pax_global_header00006660000000000000000000000064152474062340014521gustar00rootroot0000000000000052 comment=a73f27c83c669763ce7b8eb7434d64bdf5bda796 hipfort-rocm-10.0.0/000077500000000000000000000000001524740623400142105ustar00rootroot00000000000000hipfort-rocm-10.0.0/.github/000077500000000000000000000000001524740623400155505ustar00rootroot00000000000000hipfort-rocm-10.0.0/.github/CODEOWNERS000066400000000000000000000002531524740623400171430ustar00rootroot00000000000000* @amontoison # Documentation files docs/ @ROCm/rocm-documentation *.md @ROCm/rocm-documentation *.rst @ROCm/rocm-documentation .readthedocs.yaml @ROCm/rocm-documentation hipfort-rocm-10.0.0/.github/dependabot.yml000066400000000000000000000012231524740623400203760ustar00rootroot00000000000000# To get started with Dependabot version updates, you'll need to specify which # package ecosystems to update and where the package manifests are located. # Please see the documentation for all configuration options: # https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates version: 2 updates: - package-ecosystem: "pip" # See documentation for possible values directory: "/docs/sphinx" # Location of package manifests open-pull-requests-limit: 10 schedule: interval: "daily" labels: - "documentation" - "dependencies" - "ci:docs-only" reviewers: - "samjwu" hipfort-rocm-10.0.0/.gitignore000066400000000000000000000000311524740623400161720ustar00rootroot00000000000000*.o *.mod build/ /.venv hipfort-rocm-10.0.0/.readthedocs.yaml000066400000000000000000000007031524740623400174370ustar00rootroot00000000000000# Read the Docs configuration file # See https://docs.readthedocs.io/en/stable/config-file/v2.html for details version: 2 sphinx: configuration: docs/conf.py formats: [htmlzip, pdf] python: install: - requirements: docs/sphinx/requirements.txt build: os: ubuntu-24.04 tools: python: "3.10" apt_packages: - "doxygen" - "gfortran" # For pre-processing fortran sources - "graphviz" # For dot graphs in doxygen hipfort-rocm-10.0.0/CHANGELOG.md000066400000000000000000000171161524740623400160270ustar00rootroot00000000000000# Changelog for hipfort ## hipfort 0.9.0 for ROCm 10.0.0 ### Added * Regenerated all Fortran bindings against the ROCm 10.0 API. This covers the HIP runtime and every math library, and exposes the functions, enumerators, and structures added since ROCm 7.14.0. * Added `hipfort_rocrand_types`, a new module holding the rocRAND `uint4` and `rocrand_discrete_distribution_st` derived types. * Added the `hipCpuDeviceId` and `hipInvalidDeviceId` device-id constants to `hipfort_enums`. * Tutorial pages of complete, runnable Fortran programs for the HIP runtime, hipFFT, hipFFTW, hipSOLVER, rocSOLVER, hipSPARSE and rocSPARSE, a rocTX page with its supported-API table, and documentation of the rocFFT callbacks. * Experimental Fortran 2018 assumed-rank array interfaces, enabled with `-DHIPFORT_ASSUMED_RANK=ON`. Each array generic is then backed by a single `dimension(..)` overload accepting an actual of any rank; it is mutually exclusive with the classic per-rank interfaces, and only contiguous arrays may be passed. * CMake option `HIPFORT_BUILD_NVPTX` (default `ON`) that controls whether the CUDA (nvptx) backend archive is built. `-DHIPFORT_BUILD_NVPTX=OFF` skips `libhipfort-nvptx` on ROCm-only systems, halving the build time. ### Changed * hipfort no longer enables the C++ language. It is pure Fortran (C is enabled only because `hip-config.cmake` pulls in `FindThreads`), so a C++ compiler is no longer required to build it, and the bundled toolchain files no longer set `CMAKE_CXX_COMPILER`. * Each per-backend archive now contains only the symbols its backend can resolve: `libhipfort-amdgcn.a` drops `hipfort_cuda_errors` and `libhipfort-nvptx.a` drops the AMD-only `roc*` API modules. ### Fixed * Fixed several HIP derived types that had been emitted as opaque byte blobs now expose their named scalar fields (`resType`, `size`, `flags`, ...) alongside a correctly sized filler for the embedded C unions, so the layout stays exact. ## hipfort 0.8.0 for ROCm 7.14.0 ### Added * **Regenerated all Fortran bindings** against the ROCm 7.14.0 API. This covers the HIP runtime and every math library. It exposes the functions and enums added since the last release in rocBLAS, hipBLAS, rocSPARSE, hipSPARSE, rocSOLVER, hipSOLVER, rocFFT, hipFFT, rocRAND, hipRAND, and the HIP runtime, and carries the Doxygen documentation from the C headers onto the Fortran interfaces and derived-type fields. * Added Fortran interfaces to the FFTW3-compatible hipFFTW library, in new `hipfort_hipfftw` modules, plus a `hipfort::hipfftw` CMake target. * Added the `hiprandCheck` error-check helper for hipRAND status codes (`use hipfort_check`). * Added example CMake toolchain files in `cmake/toolchains`. Select one with `-DCMAKE_TOOLCHAIN_FILE` to build hipfort with a different Fortran compiler or backend. * Documented how to build hipfort applications with CMake, in the *Using hipFORT* how-to guide. It covers `find_package(hipfort)`, the exported `hipfort::*` targets, and the multiple-Fortran-toolchain install layout. * Added a *rocFFT examples* documentation page that walks through complete Fortran programs for complex-to-complex, real, multi-dimensional, batched, and out-of-place transforms, scale factors, work buffers, HIP streams, plan introspection, the compiled-kernel cache, and the version query. ### Changed * **Breaking: host scalar output arguments are now passed by reference.** Interfaces that write a single value into host memory through a pointer now take a plain `integer`/`real` scalar, instead of a `type(c_ptr), value`. This covers `hipDeviceGetAttribute`, `hipDeviceTotalMem`, `hipStreamGetDevice`, the `*_bufferSize`/`*_bufferSizeExt` queries, and the version and descriptor getters. Call them directly, for example `istat = hipDeviceGetAttribute(value, attr, dev)`, with no `C_LOC(value)`; existing code that passes `C_LOC(x)` must now pass `x`. Outputs that live on the device, such as rocSOLVER `info`, remain `type(c_ptr)` device pointers. * hipfort now installs its libraries and Fortran module files into toolchain-specific subdirectories, `lib/fortran/` and `include/fortran/`, so several Fortran toolchains can coexist. This is controlled by the new `HIPFORT_MULTITOOLCHAIN_LAYOUT` CMake option (`ON` by default). The exported `hipfort::*` targets resolve the paths automatically. ### Removed * Removed the deprecated `hipfc` compiler wrapper, the `Makefile.hipfort` include file, and the `mygpu`/`mymcpu`/`myarchgpu` GPU autodetection utilities. Build hipfort-based applications by invoking the Fortran and HIP compilers directly, and link against the exported `hipfort::*` CMake targets. * Removed the `rocblas_hgemm_kernel_name`, `rocblas_sgemm_kernel_name`, and `rocblas_dgemm_kernel_name` interfaces. The corresponding rocBLAS API functions were removed in ROCm 7.1.0. * Removed the unused legacy `lib/modules-amdgcn` modules (`hip_blas`, `rocblas_module`, `rocfft`, `rocsparse_module`, and related enum modules). ### Fixed * `hipGetDeviceProperties` now binds the `hipGetDevicePropertiesR0600` symbol, which matches the ROCm 6.0+ `hipDeviceProp_t` layout. It previously bound the legacy symbol, whose older layout produced wrong device-property field values. * Batched rocBLAS, hipBLAS, and rocSOLVER routines now pass their array of device pointers by value. The array holds device pointers and lives on the device, so it is passed directly, not by reference. * `use hipfort` now re-exports the host-register helpers (`hipHostRegister`, `hipHostGetDevicePointer`, `hipHostUnregister`); they previously required an explicit `use hipfort_hiphostregister`. ## hipfort 0.7.1 for ROCm 7.1.0 ### Added * Support for building with CMake 4.0. ### Resolved issues * Fixed a potential integer overflow issue in `hipMalloc` interfaces. ## hipfort 0.7.0 for ROCm 7.0.0 ### Added * Added documentation clarifying how hipfort is built for the NVIDIA platform. Thanks [@fluidnumerics-joe](https://github.com/fluidnumerics-joe)! ### Changed * Updated and reorganized documentation for clarity and consistency. ## hipfort 0.6.0 for ROCm 6.4.0 ### Upcoming changes * The hipfc compiler wrapper has been deprecated and will be removed in a future release. Users are encouraged to directly invoke their Fortran or HIP compilers as appropriate for each source file. ## hipfort 0.5.1 for ROCm 6.3.2 ### Added * Support for building with LLVM Flang ### Resolved issues * Fixed the exported `hipfort::hipsparse` CMake target ## hipfort 0.5.0 for ROCm 6.3.0 ### Added * Added roctx to the hipfort interfaces ### Changed * Updated the hipsolver bindings ## hipfort 0.4-0 for ROCm 6.0.1 ### Resolved issues - Included hipfort-config.cmake in the deb and rpm packages ## hipfort 0.4-0 for ROCm 6.0.0 ### Additions - Added an exported hipfort-config.cmake with the following targets: - `hipfort::hip` - `hipfort::rocblas` - `hipfort::hipblas` - `hipfort::rocfft` - `hipfort::hipfft` - `hipfort::rocsolver` - `hipfort::hipsolver` - `hipfort::rocrand` - `hipfort::hiprand` - `hipfort::rocsparse` - `hipfort::hipsparse` ## hipfort 0.4-0 for ROCm 5.7.0 ### Additions - Added `rocm_agent_enumerator` fallback for hipfc architecture autodetection ### Changes - Updated documentation to use the Sphinx toolchain and publish to ReadTheDocs - Updated `HIP_PLATFORM` from 'nvcc' to 'nvidia' ## hipfort 0.4-0 for ROCm 5.6.0 ### Additions - Added hipfc architecture autodetection for gx1101 devices ## hipfort 0.4-0 for ROCm 5.5.0 ### Fixes - Fixed hipfc architecture autodetection for gfx90a devices that were previously unrecognized hipfort-rocm-10.0.0/CMakeLists.txt000066400000000000000000000250171524740623400167550ustar00rootroot00000000000000cmake_minimum_required(VERSION 3.18..4.0 FATAL_ERROR) if(DEFINED HIPFORT_COMPILER) message(DEPRECATION "HIPFORT_COMPILER is deprecated. Use CMAKE_Fortran_COMPILER instead.") set(CMAKE_Fortran_COMPILER "${HIPFORT_COMPILER}" CACHE STRING "Fortran compiler") endif() if(DEFINED HIPFORT_AR) message(DEPRECATION "HIPFORT_AR is deprecated. Use CMAKE_AR instead.") set(CMAKE_AR "${HIPFORT_AR}" CACHE STRING "Archiving tool for static libraries") endif() if(DEFINED HIPFORT_RANLIB) message(DEPRECATION "HIPFORT_RANLIB is deprecated. Use CMAKE_RANLIB instead.") set(CMAKE_RANLIB "${HIPFORT_RANLIB}" CACHE STRING "Randomizing tool for static libraries") endif() if(DEFINED HIPFORT_COMPILER_FLAGS) message(DEPRECATION "HIPFORT_COMPILER_FLAGS is deprecated. Use CMAKE_Fortran_FLAGS instead.") set(CMAKE_Fortran_FLAGS "${HIPFORT_COMPILER_FLAGS}" CACHE STRING "Flags for the Fortran compiler and linker") endif() if(DEFINED HIPFORT_BUILD_TYPE) message(DEPRECATION "HIPFORT_BUILD_TYPE is deprecated. Use CMAKE_BUILD_TYPE instead.") set(CMAKE_BUILD_TYPE "${HIPFORT_BUILD_TYPE}" CACHE STRING "Build type to generate") endif() if(DEFINED HIPFORT_INSTALL_DIR) message(DEPRECATION "HIPFORT_INSTALL_DIR is deprecated. Use CMAKE_INSTALL_PREFIX instead.") set(CMAKE_INSTALL_PREFIX "${HIPFORT_INSTALL_DIR}" CACHE STRING "Install directory") endif() # hipfort itself is pure Fortran. C is enabled because hip-config.cmake pulls in FindThreads. PROJECT(hipfort VERSION 0.9.0 LANGUAGES Fortran C) # get compiler name get_filename_component(FCNAME ${CMAKE_Fortran_COMPILER} NAME) # setup default install directories option(HIPFORT_MULTITOOLCHAIN_LAYOUT "Install library files to toolchain-specific subdirectories" ON) if(HIPFORT_MULTITOOLCHAIN_LAYOUT) set(FORTRAN_LIBRARY_SUBDIR "fortran/${FCNAME}" CACHE STRING "Compiler-specific library symlink subdirectory") set(CMAKE_INSTALL_LIBDIR "lib/${FORTRAN_LIBRARY_SUBDIR}" CACHE STRING "Library install directory") set(CMAKE_INSTALL_INCLUDEDIR "include/${FORTRAN_LIBRARY_SUBDIR}" CACHE STRING "Mod files install directory") else() set(CMAKE_INSTALL_LIBDIR "lib" CACHE STRING "Library install directory") set(CMAKE_INSTALL_INCLUDEDIR "include" CACHE STRING "Mod files install directory") endif() include(GNUInstallDirs) # ROCm root, resolved once for every find_package/find_program below. # Precedence: -DROCM_PATH > $ROCM_PATH > hipcc on PATH > /opt/rocm. if(NOT DEFINED ROCM_PATH) if(DEFINED ENV{ROCM_PATH}) set(_rocm_path "$ENV{ROCM_PATH}") else() find_program(HIPFORT_HIPCC_EXECUTABLE NAMES hipcc hipconfig) mark_as_advanced(HIPFORT_HIPCC_EXECUTABLE) if(HIPFORT_HIPCC_EXECUTABLE) # REALPATH first: distros symlink hipcc into /usr/bin, whose parent is not ROCm. get_filename_component(_rocm_path "${HIPFORT_HIPCC_EXECUTABLE}" REALPATH) get_filename_component(_rocm_path "${_rocm_path}" DIRECTORY) get_filename_component(_rocm_path "${_rocm_path}" DIRECTORY) else() set(_rocm_path "/opt/rocm") endif() endif() set(ROCM_PATH "${_rocm_path}" CACHE PATH "ROCm installation root") unset(_rocm_path) endif() message("-- HIPFORT ------------- cmake START -------------------") message("-- Fortran Compiler: ${CMAKE_Fortran_COMPILER}") message("-- Build Type: ${CMAKE_BUILD_TYPE}") message("-- Installation Directory: ${CMAKE_INSTALL_PREFIX}") message("-- ROCm Path: ${ROCM_PATH}") message("-- hipfort Version: ${hipfort_VERSION}") message("-- HIPFORT ----------------------------------------------") set(CMAKE_Fortran_FORMAT FREE) set(CMAKE_Fortran_PREPROCESS ON) list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules") INCLUDE(FortranCInterface) FortranCInterface_VERIFY() IF(NOT FortranCInterface_VERIFIED_C) MESSAGE(FATAL_ERROR "Fortran compiler must support C Interface") ENDIF(NOT FortranCInterface_VERIFIED_C) IF(NOT CMAKE_Fortran_COMPILER_SUPPORTS_F90) MESSAGE(FATAL_ERROR "Fortran compiler does not support F90") ENDIF(NOT CMAKE_Fortran_COMPILER_SUPPORTS_F90) # Test for Fortran 08 support by using an f08-specific construct. IF(NOT DEFINED CMAKE_Fortran_COMPILER_SUPPORTS_F08) MESSAGE(CHECK_START "Checking whether ${CMAKE_Fortran_COMPILER} supports Fortran 08") INCLUDE(CheckFortranSourceCompiles) CHECK_FORTRAN_SOURCE_COMPILES(" module mod interface foo module procedure :: foo_a,foo_b end interface contains subroutine foo_a(a) use iso_c_binding integer,target,dimension(:) :: a type(c_ptr) :: a_ptr a_ptr = c_loc(a) ! gfortran < 4.9 fails here end subroutine foo_b(b) integer,pointer,dimension(:,:) :: b end end PROGRAM TESTFortran08 use mod implicit none integer :: a(5) integer,allocatable :: b(:) allocate(b,mold=a) deallocate(b) END PROGRAM TESTFortran08 " CMAKE_Fortran_COMPILER_SUPPORTS_F08) IF(CMAKE_Fortran_COMPILER_SUPPORTS_F08) MESSAGE(CHECK_PASS "yes") file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log "Determining if the Fortran compiler supports Fortran 08 passed with " "the following output:\n${OUTPUT}\n\n") set(CMAKE_Fortran_COMPILER_SUPPORTS_F08 1) ELSE(CMAKE_Fortran_COMPILER_SUPPORTS_F08) MESSAGE(CHECK_FAIL "no") file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "Determining if the Fortran compiler supports Fortran 08 failed with " "the following output:\n${OUTPUT}\n\n") set(CMAKE_Fortran_COMPILER_SUPPORTS_F08 0) ENDIF(CMAKE_Fortran_COMPILER_SUPPORTS_F08) unset(CMAKE_Fortran_COMPILER_SUPPORTS_F08 CACHE) ENDIF(NOT DEFINED CMAKE_Fortran_COMPILER_SUPPORTS_F08) # Test for Fortran 2018 support using the assumed-rank construct the generated # bindings rely on: an assumed-rank (dimension(..)) dummy passed to c_loc(). This # is exactly what the USE_ASSUMED_RANK_INTERFACES wrappers do, so it is the right # discriminator for whether HIPFORT_ASSUMED_RANK can be enabled. IF(NOT DEFINED CMAKE_Fortran_COMPILER_SUPPORTS_F18) MESSAGE(CHECK_START "Checking whether ${CMAKE_Fortran_COMPILER} supports Fortran 2018") INCLUDE(CheckFortranSourceCompiles) # NB: CHECK_FORTRAN_SOURCE_COMPILES writes the snippet to a .F file (fixed form), # so — like the Fortran 08 test above — every statement must start at column 7. CHECK_FORTRAN_SOURCE_COMPILES(" module mod18 contains function foo(x) result(p) use iso_c_binding integer(c_int),target,contiguous,dimension(..) :: x type(c_ptr) :: p p = c_loc(x) end function end module PROGRAM TESTFortran18 use mod18 use iso_c_binding implicit none integer(c_int),target :: a(5) type(c_ptr) :: p p = foo(a) END PROGRAM TESTFortran18 " CMAKE_Fortran_COMPILER_SUPPORTS_F18) IF(CMAKE_Fortran_COMPILER_SUPPORTS_F18) MESSAGE(CHECK_PASS "yes") file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log "Determining if the Fortran compiler supports Fortran 2018 passed with " "the following output:\n${OUTPUT}\n\n") set(CMAKE_Fortran_COMPILER_SUPPORTS_F18 1) ELSE(CMAKE_Fortran_COMPILER_SUPPORTS_F18) MESSAGE(CHECK_FAIL "no") file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "Determining if the Fortran compiler supports Fortran 2018 failed with " "the following output:\n${OUTPUT}\n\n") set(CMAKE_Fortran_COMPILER_SUPPORTS_F18 0) ENDIF(CMAKE_Fortran_COMPILER_SUPPORTS_F18) unset(CMAKE_Fortran_COMPILER_SUPPORTS_F18 CACHE) ENDIF(NOT DEFINED CMAKE_Fortran_COMPILER_SUPPORTS_F18) # Set compile flags for DEBUG, # RELEASE, or TESTING. INCLUDE(${CMAKE_MODULE_PATH}/SetFortranFlags.cmake) message("-- Done setting FortranFlags") message("-- CMAKE_Fortran_FLAGS_DEBUG: ${CMAKE_Fortran_FLAGS_DEBUG}") message("-- CMAKE_Fortran_FLAGS_RELEASE: ${CMAKE_Fortran_FLAGS_RELEASE}") message("-- CMAKE_Fortran_FLAGS_TESTING: ${CMAKE_Fortran_FLAGS_TESTING}") # There is an error in CMAKE with this flag for pgf90. Unset it IF(FCNAME STREQUAL "pgf90") UNSET(CMAKE_SHARED_LIBRARY_LINK_Fortran_FLAGS) ENDIF(FCNAME STREQUAL "pgf90") option(BUILD_TESTING "Build tests" OFF) # Extended tests: link each backend static archive into a shared library with # -Wl,--no-undefined and fail on any unresolved symbol. Each backend's test is # only added when all of its runtime libraries are found (see lib/CMakeLists.txt), # so this is a no-op on machines without the corresponding ROCm/CUDA stack. # Opt-in (default OFF): it needs a recent, complete ROCm or CUDA install (all math # libraries present) to be certain it passes, so it is not part of the default # test suite. option(HIPFORT_EXTENDED_TESTS "Link each backend static archive into a shared library and fail on undefined symbols (needs a recent, complete ROCm/CUDA install)" OFF) set(HIPFORT_ROCM_LIB_DIR "" CACHE PATH "Directory of the ROCm runtime libraries for the amdgcn extended shared-link test (default: /lib)") set(HIPFORT_CUDA_LIB_DIR "" CACHE PATH "Directory of the CUDA runtime libraries for the nvptx extended shared-link test (default: from find_package(CUDAToolkit))") if(BUILD_TESTING OR HIPFORT_EXTENDED_TESTS) enable_testing() endif() # Subdirectories and packaging # NOTE: rocm-cmake must be be included before # adding subdirectories. INCLUDE(${CMAKE_MODULE_PATH}/rocm-cmake.cmake) rocm_setup_version(VERSION ${VERSION}) ADD_SUBDIRECTORY(${CMAKE_SOURCE_DIR}/lib) ADD_SUBDIRECTORY(${CMAKE_SOURCE_DIR}/test) set(CPACK_DEBIAN_PACKAGE_DEPENDS "hip-runtime-amd (>= 4.5.0)") set(CPACK_RPM_PACKAGE_REQUIRES "hip-runtime-amd >= 4.5.0") # Package name changed from hipfort to hipfort-devel/dev # Backward compatibility support for old package name set(CPACK_DEBIAN_PACKAGE_PROVIDES "hipfort") set(CPACK_DEBIAN_PACKAGE_REPLACES "hipfort") set(CPACK_DEBIAN_PACKAGE_CONFLICTS "hipfort") set(CPACK_RPM_PACKAGE_PROVIDES "hipfort") set(CPACK_RPM_PACKAGE_OBSOLETES "hipfort") set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE") if(NOT CPACK_PACKAGING_INSTALL_PREFIX) set(CPACK_PACKAGING_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") endif() set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION "\${CPACK_PACKAGING_INSTALL_PREFIX}") # Prevent rpmbuild from stripping binaries, which caused issues on CentOS set(CPACK_RPM_SPEC_INSTALL_POST "/bin/true") rocm_create_package( NAME hipfort DESCRIPTION "Fortran Interface For GPU Kernel Libraries" MAINTAINER "Hipfort maintainer " HEADER_ONLY # Enabled For generating Only -devel pkg. ) message("-- HIPFORT ------------- cmake DONE --------------------") hipfort-rocm-10.0.0/LICENSE000066400000000000000000000022121524740623400152120ustar00rootroot00000000000000hipfort: FORTRAN Interfaces for GPU kernels Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. [MITx11 License] 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. hipfort-rocm-10.0.0/README.md000066400000000000000000000256101524740623400154730ustar00rootroot00000000000000# hipfort: Fortran Interface For GPU Kernel Libraries This repository contains the source and testing for hipfort. This is a FORTRAN interface library for accessing GPU Kernels. ## Documentation > [!NOTE] > The published hipfort documentation is available at [hipfort](https://rocm.docs.amd.com/projects/hipfort/en/latest/index.html) in an organized, easy-to-read format, with search and a table of contents. The documentation source files reside in the hipfort/docs folder of this repository. As with all ROCm projects, the documentation is open source. For more information, see [Contribute to ROCm documentation](https://rocm.docs.amd.com/en/latest/contribute/contributing.html). ## Build and test hipfort from source Install `git`, `cmake`, HIP, and a Fortran compiler, if not yet installed. `amdflang` (ROCm's LLVM Flang, bundled with ROCm) is the recommended default; `gfortran` (version 7.5.0 or newer) is also supported. Then build, install, and test hipfort from source with the commands below: ```shell git clone https://github.com/ROCm/hipfort.git cd hipfort cmake -S . -B build -DCMAKE_INSTALL_PREFIX=/tmp/hipfort -DHIPFORT_BUILD_NVPTX=OFF -DBUILD_TESTING=ON cmake --build build cmake --install build ctest --test-dir build ``` ### Toolchain files Example CMake toolchain files are provided in [`cmake/toolchains`](cmake/toolchains) to select the Fortran compiler and backend without setting cache variables by hand. Pass one with `-DCMAKE_TOOLCHAIN_FILE`: ```shell cmake -S . -B build -DHIPFORT_BUILD_NVPTX=OFF -DCMAKE_TOOLCHAIN_FILE=cmake/toolchains/amdflang.cmake ``` ## Fortran interfaces `hipfort` provides interfaces to the following HIP and ROCm libraries: * **HIP runtime and tooling:** HIP runtime, rocTX * **HIP math libraries (`hip*`):** hipBLAS, hipFFT, hipRAND, hipSOLVER, hipSPARSE * **FFTW3-compatible interface:** hipFFTW * **ROCm math libraries (`roc*`):** rocBLAS, rocFFT, rocRAND, rocSOLVER, rocSPARSE The APIs of the `hip*` math libraries follow their NVIDIA counterparts (cuBLAS, cuFFT, cuRAND, cuSOLVER, and cuSPARSE), whereas hipFFTW follows FFTW3. The `roc*` libraries expose AMD-specific APIs. The available interfaces depend on the Fortran compiler that is used to compile the `hipfort` modules and libraries. As the interfaces make use of the `iso_c_binding` module, the minimum requirement is a Fortran compiler that supports the Fortran 2003 standard (`f2003`). These interfaces typically require to pass `type(c_ptr)` variables and the number of bytes to memory management (e.g. `hipMalloc`) and math library routines (e.g. `hipblasDGEMM`). If your compiler understands the Fortran 2008 (`f2008`) code constructs, additional interfaces are compiled into the `hipfort` modules and libraries. These directly take Fortran (array) variables and the number of elements instead of `type(c_ptr)` variables and the number of bytes, respectively. Therefore, they reduce the chance to introduce compile-time and runtime errors into your code and makes it easier to read too. These additional interfaces are guarded by the `USE_FPOINTER_INTERFACES` preprocessor definition, which `hipfort` enables automatically once it detects Fortran 2008 support in your compiler. By convention, application and test sources that rely on them use the `.f08` file extension (see the `test/f2008` examples), while Fortran 2003 sources use `.f03`. You can override the automatic detection with the `HIPFORT_USE_FPOINTER_INTERFACES` CMake option. It defaults to `ON` when the compiler supports Fortran 2008; set `-DHIPFORT_USE_FPOINTER_INTERFACES=OFF` to build with the plain Fortran 2003 `type(c_ptr)` interfaces only. This is useful for an old compiler, or one whose Fortran 2008 support is buggy. Requesting it on a compiler without Fortran 2008 support is ignored (with a warning). **Experimental (`-DHIPFORT_ASSUMED_RANK=ON`).** By default each array generic is resolved by a set of rank-specific overloads (`rank_0`, `rank_1`, ...). With this option `hipfort` builds a single Fortran 2018 assumed-rank (`dimension(..)`) overload per routine instead. It requires a compiler with F2018 assumed-rank plus `c_loc` support, which `hipfort` probes for at configure time; if the probe fails, it warns and falls back to the per-rank Fortran 2008 interfaces instead of failing the build. It also requires `HIPFORT_USE_FPOINTER_INTERFACES` (on which the per-rank interfaces themselves depend); with that off there are no array interfaces at all, only the plain Fortran 2003 `type(c_ptr)` ones. Off by default. The assumed-rank wrapper takes the base address of the array with `c_loc`, so the actual argument must be contiguous (the dummy is declared `contiguous`). A non-contiguous section (e.g. `a(:,::2)`) would force the compiler to pass a temporary copy, so pass whole arrays or contiguous slices only. ### Example While you could write the following using the `f2003` interfaces: ```Fortran use iso_c_binding use hipfort integer :: ierr ! error code real :: a_h(5,6) ! host array type(c_ptr) :: a_d ! device array pointer ! ierr = hipMalloc(a_d,size(a_h)*4_c_size_t) ! real has 4 bytes ! append suffix '_c_size_t' to write '4' ! as 'integer(c_size_t)' ierr = hipMemcpy(a_d,c_loc(a_h),size(a_h)*4_c_size_t,hipMemcpyHostToDevice) ``` you could express the same with the `f2008` interfaces as follows: ```Fortran use hipfort integer :: ierr ! error code real :: a_h(5,6) ! host array real,pointer :: a_d(:,:) ! device array pointer ! ierr = hipMalloc(a_d,shape(a_h)) ! or hipMalloc(a_d,[5,6]) or hipMalloc(a_d,5,6) or hipMalloc(a_d,mold=a_h) ierr = hipMemcpy(a_d,a_h,size(a_h),hipMemcpyHostToDevice) ``` The `f2008` interfaces also overload `hipMalloc` similar to the Fortran 2008 `ALLOCATE` intrinsic. So you could write the whole code as shown below: ```Fortran integer :: ierr ! error code real :: a_h(5,6) ! host array real,pointer :: a_d(:,:) ! device array pointer ! ierr = hipMalloc(a_d,source=a_h) ! take shape (incl. bounds) of a_h and perform a blocking copy to device ``` In addition to `source`, there is also `dsource` in case the source is a device array. ### Supported HIP and ROCm API The current batch of HIPFORT interfaces is derived from ROCm 10.0.0. The following tables list the supported API: * [HIP](https://rocm.docs.amd.com/projects/hipfort/en/develop/doxygen/html/md_input_2supported__api__hip.html) * [hipBLAS](https://rocm.docs.amd.com/projects/hipfort/en/develop/doxygen/html/md_input_2supported__api__hipblas.html) * [hipFFT](https://rocm.docs.amd.com/projects/hipfort/en/develop/doxygen/html/md_input_2supported__api__hipfft.html) * [hipFFTW](https://rocm.docs.amd.com/projects/hipfort/en/develop/doxygen/html/md_input_2supported__api__hipfftw.html) * [hipRAND](https://rocm.docs.amd.com/projects/hipfort/en/develop/doxygen/html/md_input_2supported__api__hiprand.html) * [hipSOLVER](https://rocm.docs.amd.com/projects/hipfort/en/develop/doxygen/html/md_input_2supported__api__hipsolver.html) * [hipSPARSE](https://rocm.docs.amd.com/projects/hipfort/en/develop/doxygen/html/md_input_2supported__api__hipsparse.html) * [rocBLAS](https://rocm.docs.amd.com/projects/hipfort/en/develop/doxygen/html/md_input_2supported__api__rocblas.html) * [rocFFT](https://rocm.docs.amd.com/projects/hipfort/en/develop/doxygen/html/md_input_2supported__api__rocfft.html) * [rocRAND](https://rocm.docs.amd.com/projects/hipfort/en/develop/doxygen/html/md_input_2supported__api__rocrand.html) * [rocSOLVER](https://rocm.docs.amd.com/projects/hipfort/en/develop/doxygen/html/md_input_2supported__api__rocsolver.html) * [rocSPARSE](https://rocm.docs.amd.com/projects/hipfort/en/develop/doxygen/html/md_input_2supported__api__rocsparse.html) * [rocTX](https://rocm.docs.amd.com/projects/hipfort/en/develop/doxygen/html/md_input_2supported__api__roctx.html) You may further find it convenient to directly use the search function on [HIPFORT's documentation page](https://rocm.docs.amd.com/projects/hipfort/en/develop/) to get information on the arguments of an interface. Please [open an issue](https://github.com/ROCm/hipfort/issues) if you run into problems. ## Linking against hipfort To use hipfort in your project, invoke your Fortran and HIP compilers directly and link against the appropriate ROCm libraries. hipfort provides exported CMake targets (such as `hipfort::hip`, `hipfort::rocblas`, and `hipfort::hipblas`) to make this straightforward: ```cmake project(my_app Fortran) find_package(hipfort REQUIRED COMPONENTS hip hipblas) add_executable(my_app main.f08) target_link_libraries(my_app PRIVATE hipfort::hipblas hipfort::hip) ``` List each library you use as a `COMPONENTS` entry: a `hipfort::` target is only defined when that component is requested. The Fortran language must be enabled before `find_package(hipfort)`. ## Examples and tests The examples, which simultaneously serve as tests, are located in the `f2003` and `f2008` subdirectories of the repo's `test/` folder. Both test collections implement the same tests but require that the used Fortran compiler supports at least the respective Fortran standard. There are further subcategories per `hip*` or `roc*` library that is tested. ### Building and running the tests The tests are driven by CTest. Configure the build with `-DBUILD_TESTING=ON`, build hipfort, and run the suite with `ctest`. > **NOTE**: Running the tests requires the ROCm math libraries. The ROCm root is detected from `ROCM_PATH` or from `hipcc` on your `PATH`; override with `-DROCM_PATH=`. ```shell cmake -S. -Bbuild -DCMAKE_INSTALL_PREFIX=/tmp/hipfort -DBUILD_TESTING=ON cmake --build build ctest --test-dir build ``` To run a single test, pass its name to `ctest` via the `-R` filter, for example: ```shell ctest --test-dir build -R hipfort_test_f2008_hipblas_dgemm ``` ## Copyright, License, and Disclaimer Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. [MITx11 License] 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. hipfort-rocm-10.0.0/cmake/000077500000000000000000000000001524740623400152705ustar00rootroot00000000000000hipfort-rocm-10.0.0/cmake/Modules/000077500000000000000000000000001524740623400167005ustar00rootroot00000000000000hipfort-rocm-10.0.0/cmake/Modules/SetCompileFlag.cmake000066400000000000000000000110101524740623400225310ustar00rootroot00000000000000############################################################################# # Given a list of flags, this function will try each, one at a time, # and choose the first flag that works. If no flags work, then nothing # will be set, unless the REQUIRED key is given, in which case an error # will be given. # # Call is: # SET_COMPILE_FLAG(FLAGVAR FLAGVAL (Fortran|C|CXX) flag1 flag2...) # # For example, if you have the flag CMAKE_C_FLAGS and you want to add # warnings and want to fail if this is not possible, you might call this # function in this manner: # SET_COMPILE_FLAGS(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}" C REQUIRED # "-Wall" # GNU # "-warn all" # Intel # ) # The optin "-Wall" will be checked first, and if it works, will be # appended to the CMAKE_C_FLAGS variable. If it doesn't work, then # "-warn all" will be tried. If this doesn't work then checking will # terminate because REQUIRED was given. # # The reasong that the variable must be given twice (first as the name then # as the value in quotes) is because of the way CMAKE handles the passing # of variables in functions; it is difficult to extract a variable's # contents and assign new values to it from within a function. ############################################################################# INCLUDE(${CMAKE_ROOT}/Modules/CheckCCompilerFlag.cmake) INCLUDE(${CMAKE_ROOT}/Modules/CheckCXXCompilerFlag.cmake) FUNCTION(SET_COMPILE_FLAG FLAGVAR FLAGVAL LANG) # Do some up front setup if Fortran IF(LANG STREQUAL "Fortran") # Create a list of error messages from compilers SET(FAIL_REGEX "ignoring unknown option" # Intel "invalid argument" # Intel "unrecognized .*option" # GNU "[Uu]nknown switch" # Portland Group "ignoring unknown option" # MSVC "warning D9002" # MSVC, any lang "[Uu]nknown option" # HP "[Ww]arning: [Oo]ption" # SunPro "command option .* is not recognized" # XL ) ENDIF(LANG STREQUAL "Fortran") # Make a variable holding the flags. Filter out REQUIRED if it is there SET(FLAG_REQUIRED FALSE) SET(FLAG_FOUND FALSE) UNSET(FLAGLIST) FOREACH (var ${ARGN}) STRING(TOUPPER "${var}" UP) IF(UP STREQUAL "REQUIRED") SET(FLAG_REQUIRED TRUE) ELSE() SET(FLAGLIST ${FLAGLIST} "${var}") ENDIF(UP STREQUAL "REQUIRED") ENDFOREACH (var ${ARGN}) # Now, loop over each flag FOREACH(flag ${FLAGLIST}) UNSET(FLAG_WORKS) # Check the flag for the given language IF(LANG STREQUAL "C") CHECK_C_COMPILER_FLAG("${flag}" FLAG_WORKS) ELSEIF(LANG STREQUAL "CXX") CHECK_CXX_COMPILER_FLAG("${flag}" FLAG_WORKS) ELSEIF(LANG STREQUAL "Fortran") # There is no nice function to do this for FORTRAN, so we must manually # create a test program and check if it compiles with a given flag. SET(TESTFILE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}") SET(TESTFILE "${TESTFILE}/CMakeTmp/testFortranFlags.f90") FILE(WRITE "${TESTFILE}" " program dummyprog i = 5 end program dummyprog ") TRY_COMPILE(FLAG_WORKS ${CMAKE_BINARY_DIR} ${TESTFILE} COMPILE_DEFINITIONS "${flag}" OUTPUT_VARIABLE OUTPUT) # Check that the output message doesn't match any errors FOREACH(rx ${FAIL_REGEX}) IF("${OUTPUT}" MATCHES "${rx}") SET(FLAG_WORKS FALSE) ENDIF("${OUTPUT}" MATCHES "${rx}") ENDFOREACH(rx ${FAIL_REGEX}) ELSE() MESSAGE(FATAL_ERROR "Unknown language in SET_COMPILE_FLAGS: ${LANG}") ENDIF(LANG STREQUAL "C") # If this worked, use these flags, otherwise use other flags IF(FLAG_WORKS) # Append this flag to the end of the list that already exists SET(${FLAGVAR} "${FLAGVAL} ${flag}" CACHE STRING "Set the ${FLAGVAR} flags" FORCE) SET(FLAG_FOUND TRUE) BREAK() # We found something that works, so exit ENDIF(FLAG_WORKS) ENDFOREACH(flag ${FLAGLIST}) # Raise an error if no flag was found IF(FLAG_REQUIRED AND NOT FLAG_FOUND) MESSAGE(FATAL_ERROR "No compile flags were found") ENDIF(FLAG_REQUIRED AND NOT FLAG_FOUND) ENDFUNCTION() hipfort-rocm-10.0.0/cmake/Modules/SetFortranFlags.cmake000066400000000000000000000124061524740623400227510ustar00rootroot00000000000000###################################################### # Determine and set the Fortran compiler flags we want ###################################################### #################################################################### # Make sure that the default build type is RELEASE if not specified. #################################################################### INCLUDE(${CMAKE_MODULE_PATH}/SetCompileFlag.cmake) ######################################################### # If the compiler flags have already been set, return now ######################################################### IF(CMAKE_Fortran_FLAGS_RELEASE AND CMAKE_Fortran_FLAGS_TESTING AND CMAKE_Fortran_FLAGS_DEBUG) RETURN () ENDIF(CMAKE_Fortran_FLAGS_RELEASE AND CMAKE_Fortran_FLAGS_TESTING AND CMAKE_Fortran_FLAGS_DEBUG) ######################################################################## # Determine the appropriate flags for this compiler for each build type. # For each option type, a list of possible flags is given that work # for various compilers. The first flag that works is chosen. # If none of the flags work, nothing is added (unless the REQUIRED # flag is given in the call). This way unknown compiles are supported. ####################################################################### ##################### ### GENERAL FLAGS ### ##################### IF(NOT CMAKE_Fortran_COMPILER_ID MATCHES "Cray") option(BUILD_NATIVE "Enable optimizations that make the binaries non-portable" OFF) if(BUILD_NATIVE) # There is some bug where -march=native doesn't work on Mac IF(APPLE) SET(GNUNATIVE "-mtune=native") ELSE() SET(GNUNATIVE "-march=native") ENDIF() # Optimize for the host's architecture SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}" Fortran "-xHost" # Intel "/QxHost" # Intel Windows ${GNUNATIVE} # GNU "-ta=host" # Portland Group ) endif() ENDIF(NOT CMAKE_Fortran_COMPILER_ID MATCHES "Cray") ################### ### DEBUG FLAGS ### ################### # NOTE: debugging symbols (-g or /debug:full) are already on by default # Turn on all warnings SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}" Fortran "-warn all" # Intel "-m2" # HPE Cray "/warn:all" # Intel Windows "-Wall" # GNU # Portland Group (on by default) ) # Traceback IF(NOT CMAKE_Fortran_COMPILER_ID MATCHES "Cray") SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}" Fortran "-traceback" # Intel/Portland Group "/traceback" # Intel Windows "-fbacktrace" # GNU (gfortran) "-ftrace=full" # GNU (g95) ) ENDIF(NOT CMAKE_Fortran_COMPILER_ID MATCHES "Cray") # Check array bounds SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG}" Fortran "-check bounds" # Intel "-hbounds" # HPE Cray "/check:bounds" # Intel Windows "-fcheck=bounds" # GNU (New style) "-fbounds-check" # GNU (Old style) "-Mbounds" # Portland Group ) ##################### ### TESTING FLAGS ### ##################### # Optimizations SET(CMAKE_Fortran_FLAGS_TESTING "${CMAKE_Fortran_FLAGS_RELWITHDEBINFO}") ##################### ### RELEASE FLAGS ### ##################### # NOTE: agressive optimizations (-O3) are already turned on by default IF(NOT CMAKE_Fortran_COMPILER_ID MATCHES "Cray") # Unroll loops SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}" Fortran "-funroll-loops" # GNU "-unroll" # Intel "/unroll" # Intel Windows "-Munroll" # Portland Group ) # Inline functions SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}" Fortran "-inline" # Intel "/Qinline" # Intel Windows "-finline-functions" # GNU "-Minline" # Portland Group ) # Interprocedural (link-time) optimizations SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}" Fortran "-ipo" # Intel "/Qipo" # Intel Windows "-flto" # GNU "-Mipa" # Portland Group ) # Single-file optimizations SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}" Fortran "-ip" # Intel "/Qip" # Intel Windows ) # Vectorize code SET_COMPILE_FLAG(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE}" Fortran "-vec-report0" # Intel "/Qvec-report0" # Intel Windows "-Mvect" # Portland Group ) ENDIF(NOT CMAKE_Fortran_COMPILER_ID MATCHES "Cray") hipfort-rocm-10.0.0/cmake/Modules/SetParallelizationLibrary.cmake000066400000000000000000000024771524740623400250470ustar00rootroot00000000000000# Turns on either OpenMP or MPI # If both are requested, the other is disabled # When one is turned on, the other is turned off # If both are off, we explicitly disable them just in case IF (USE_OPENMP AND USE_MPI) MESSAGE (FATAL_ERROR "Cannot use both OpenMP and MPI") ELSEIF (USE_OPENMP) # Find OpenMP IF (NOT OpenMP_Fortran_FLAGS) FIND_PACKAGE (OpenMP_Fortran) IF (NOT OpenMP_Fortran_FLAGS) MESSAGE (FATAL_ERROR "Fortran compiler does not support OpenMP") ENDIF (NOT OpenMP_Fortran_FLAGS) ENDIF (NOT OpenMP_Fortran_FLAGS) # Turn of MPI UNSET (MPI_FOUND CACHE) UNSET (MPI_COMPILER CACHE) UNSET (MPI_LIBRARY CACHE) ELSEIF (USE_MPI) # Find MPI IF (NOT MPI_Fortran_FOUND) FIND_PACKAGE (MPI REQUIRED) ENDIF (NOT MPI_Fortran_FOUND) # Turn off OpenMP SET (OMP_NUM_PROCS 0 CACHE STRING "Number of processors OpenMP may use" FORCE) UNSET (OpenMP_C_FLAGS CACHE) UNSET (GOMP_Fortran_LINK_FLAGS CACHE) ELSE () # Turn off both OpenMP and MPI SET (OMP_NUM_PROCS 0 CACHE STRING "Number of processors OpenMP may use" FORCE) UNSET (OpenMP_Fortran_FLAGS CACHE) UNSET (GOMP_Fortran_LINK_FLAGS CACHE) UNSET (MPI_FOUND CACHE) UNSET (MPI_COMPILER CACHE) UNSET (MPI_LIBRARY CACHE) ENDIF (USE_OPENMP AND USE_MPI) hipfort-rocm-10.0.0/cmake/Modules/SetUpLAPACK.cmake000066400000000000000000000011471524740623400216210ustar00rootroot00000000000000# Find LAPACK (finds BLAS also) if not already found IF(NOT LAPACK_FOUND) ENABLE_LANGUAGE(C) # Some libraries need a C compiler to find FIND_PACKAGE(LAPACK REQUIRED) # Remember that LAPACK (and BLAS) was found. For some reason the # FindLAPACK routine doesn't place these into the CACHE. SET(BLAS_FOUND TRUE CACHE INTERNAL "BLAS was found" FORCE) SET(LAPACK_FOUND TRUE CACHE INTERNAL "LAPACK was found" FORCE) SET(BLAS_LIBRARIES ${BLAS_LIBRARIES} CACHE INTERNAL "BLAS LIBS" FORCE) SET(LAPACK_LIBRARIES ${LAPACK_LIBRARIES} CACHE INTERNAL "LAPACK LIBS" FORCE) ENDIF(NOT LAPACK_FOUND) hipfort-rocm-10.0.0/cmake/Modules/rocm-cmake.cmake000066400000000000000000000030471524740623400217240ustar00rootroot00000000000000# Find or download/install rocm-cmake project find_package(ROCmCMakeBuildTools QUIET PATHS ${ROCM_PATH}) if(NOT ROCmCMakeBuildTools_FOUND) find_package(ROCM QUIET CONFIG PATHS ${ROCM_PATH}) if(NOT ROCM_FOUND) set(rocm_cmake_tag "master" CACHE STRING "rocm-cmake tag to download") file( DOWNLOAD https://github.com/RadeonOpenCompute/rocm-cmake/archive/${rocm_cmake_tag}.zip ${CMAKE_CURRENT_BINARY_DIR}/rocm-cmake-${rocm_cmake_tag}.zip STATUS rocm_cmake_download_status LOG rocm_cmake_download_log ) list(GET rocm_cmake_download_status 0 rocm_cmake_download_error_code) if(rocm_cmake_download_error_code) message(FATAL_ERROR "Error: downloading " "https://github.com/RadeonOpenCompute/rocm-cmake/archive/${rocm_cmake_tag}.zip failed " "error_code: ${rocm_cmake_download_error_code} " "log: ${rocm_cmake_download_log} " ) endif() execute_process( COMMAND ${CMAKE_COMMAND} -E tar xzf ${CMAKE_CURRENT_BINARY_DIR}/rocm-cmake-${rocm_cmake_tag}.zip WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} RESULT_VARIABLE rocm_cmake_unpack_error_code ) if(rocm_cmake_unpack_error_code) message(FATAL_ERROR "Error: unpacking ${CMAKE_CURRENT_BINARY_DIR}/rocm-cmake-${rocm_cmake_tag}.zip failed") endif() find_package(ROCM REQUIRED CONFIG PATHS ${CMAKE_CURRENT_BINARY_DIR}/rocm-cmake-${rocm_cmake_tag}) endif() endif() include(ROCMSetupVersion) include(ROCMCreatePackage) include(ROCMInstallTargets) include(ROCMPackageConfigHelpers) include(ROCMInstallSymlinks) hipfort-rocm-10.0.0/cmake/toolchains/000077500000000000000000000000001524740623400174335ustar00rootroot00000000000000hipfort-rocm-10.0.0/cmake/toolchains/amdflang.cmake000066400000000000000000000014611524740623400222100ustar00rootroot00000000000000# AMD toolchain file for hipfort (amdflang, AMD ROCm backend). # # This is the recommended default: amdflang is the LLVM-based Fortran compiler # shipped with ROCm. # # Usage: # cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE=cmake/toolchains/amdflang.cmake # # The ROCm compilers are looked up on PATH. Set $ROCM_PATH or -DROCM_PATH= if # your install is elsewhere. set(CMAKE_Fortran_COMPILER amdflang CACHE FILEPATH "Fortran compiler") set(CMAKE_C_COMPILER amdclang CACHE FILEPATH "C compiler") # Free-form parsing and C preprocessing are enabled by hipfort itself, via # CMAKE_Fortran_FORMAT and CMAKE_Fortran_PREPROCESS in the top-level # CMakeLists.txt. CMake emits the preprocessing flag each compiler expects # (-cpp for amdflang), so there is no need to add a preprocessing or free-form # flag here. hipfort-rocm-10.0.0/cmake/toolchains/cray.cmake000066400000000000000000000020251524740623400213720ustar00rootroot00000000000000# HPE Cray toolchain file for hipfort (Cray Fortran via the ftn wrapper). # # On a Cray system, load the relevant environment modules first (for example # PrgEnv-cray and rocm), then configure with: # cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE=cmake/toolchains/cray.cmake # # The Cray compiler drivers (ftn/cc) forward to the underlying compilers and # already know about the system headers and libraries. set(CMAKE_Fortran_COMPILER ftn CACHE FILEPATH "Cray Fortran wrapper") set(CMAKE_C_COMPILER cc CACHE FILEPATH "Cray C wrapper") # cmake/Modules/SetFortranFlags.cmake already special-cases the Cray compiler, # so no extra Fortran flags are needed here. The ROCm root comes from the 'rocm' # environment module. # Free-form parsing and C preprocessing are enabled by hipfort itself, via # CMAKE_Fortran_FORMAT and CMAKE_Fortran_PREPROCESS in the top-level # CMakeLists.txt. CMake emits the preprocessing flag each compiler expects # (-eZ for the Cray compiler), so there is no need to add a preprocessing or # free-form flag here. hipfort-rocm-10.0.0/cmake/toolchains/gnu.cmake000066400000000000000000000014631524740623400212320ustar00rootroot00000000000000# GNU toolchain file for hipfort (GNU Fortran, AMD ROCm backend). # # Usage: # cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE=cmake/toolchains/gnu.cmake # # This is the default configuration used to build hipfort against ROCm. set(CMAKE_Fortran_COMPILER gfortran CACHE FILEPATH "Fortran compiler") # find_package(hip) pulls in hip-config.cmake, which needs the C language enabled. set(CMAKE_C_COMPILER gcc CACHE FILEPATH "C compiler") # ROCm root: $ROCM_PATH or hipcc on PATH; override with -DROCM_PATH=. # Free-form parsing and C preprocessing are enabled by hipfort itself, via # CMAKE_Fortran_FORMAT and CMAKE_Fortran_PREPROCESS in the top-level # CMakeLists.txt. CMake emits the preprocessing flag each compiler expects # (-cpp for gfortran), so there is no need to add a preprocessing or free-form # flag here. hipfort-rocm-10.0.0/cmake/toolchains/intel-classic.cmake000066400000000000000000000014671524740623400231770ustar00rootroot00000000000000# Classic Intel Fortran toolchain file for hipfort (ifort, AMD ROCm backend). # # Note: the classic ifort compiler is end-of-life; prefer intel.cmake (ifx) for # new setups. This file is provided for legacy environments. # # Usage: # source /opt/intel/oneapi/setvars.sh # cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE=cmake/toolchains/intel-classic.cmake set(CMAKE_Fortran_COMPILER ifort CACHE FILEPATH "Classic Intel Fortran compiler") set(CMAKE_C_COMPILER icx CACHE FILEPATH "Intel C compiler (LLVM)") # Free-form parsing and C preprocessing are enabled by hipfort itself, via # CMAKE_Fortran_FORMAT and CMAKE_Fortran_PREPROCESS in the top-level # CMakeLists.txt. CMake emits the preprocessing flag each compiler expects # (-fpp for ifort), so there is no need to add a preprocessing or free-form # flag here. hipfort-rocm-10.0.0/cmake/toolchains/intel.cmake000066400000000000000000000014121524740623400215460ustar00rootroot00000000000000# Intel oneAPI toolchain file for hipfort (ifx, AMD ROCm backend). # # Uses the LLVM-based Intel compilers (ifx/icx). For the end-of-life # classic ifort compiler, see intel-classic.cmake. # # Usage: # source /opt/intel/oneapi/setvars.sh # cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE=cmake/toolchains/intel.cmake set(CMAKE_Fortran_COMPILER ifx CACHE FILEPATH "Intel Fortran compiler (LLVM)") set(CMAKE_C_COMPILER icx CACHE FILEPATH "Intel C compiler (LLVM)") # Free-form parsing and C preprocessing are enabled by hipfort itself, via # CMAKE_Fortran_FORMAT and CMAKE_Fortran_PREPROCESS in the top-level # CMakeLists.txt. CMake emits the preprocessing flag each compiler expects # (-fpp for ifx), so there is no need to add a preprocessing or free-form # flag here. hipfort-rocm-10.0.0/cmake/toolchains/nvhpc.cmake000066400000000000000000000025121524740623400215530ustar00rootroot00000000000000# NVIDIA HPC SDK toolchain file for hipfort (nvfortran, NVIDIA/CUDA backend). # # Usage: # cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE=cmake/toolchains/nvhpc.cmake # # NOTE: this toolchain only selects the NVIDIA HPC compilers. nvfortran compiles # the hipfort sources, but hipfort's CMake currently exports usable targets # (hipfort::*) and a package config only for the AMD platform (HIP_PLATFORM=amd); # the NVIDIA/CUDA backend is not wired up yet. Set HIP_PLATFORM/ROCM_PATH below to # match your installation. set(CMAKE_Fortran_COMPILER nvfortran CACHE FILEPATH "NVIDIA Fortran compiler") set(CMAKE_C_COMPILER nvc CACHE FILEPATH "NVIDIA C compiler") # Select the NVIDIA HIP backend. Adjust the paths to your HIP/CUDA install. # set(HIP_PLATFORM nvidia CACHE STRING "HIP platform (amd or nvidia)") # set(ROCM_PATH CACHE PATH "HIP installation root") # nvfortran does not implement -march=native the way GNU does; leave the # portable defaults from cmake/Modules/SetFortranFlags.cmake in place. # Free-form parsing and C preprocessing are enabled by hipfort itself, via # CMAKE_Fortran_FORMAT and CMAKE_Fortran_PREPROCESS in the top-level # CMakeLists.txt. CMake emits the preprocessing flag each compiler expects # (-Mpreprocess for nvfortran), so there is no need to add a preprocessing or # free-form flag here. hipfort-rocm-10.0.0/docs/000077500000000000000000000000001524740623400151405ustar00rootroot00000000000000hipfort-rocm-10.0.0/docs/.gitignore000066400000000000000000000000221524740623400171220ustar00rootroot00000000000000/_build /_doxygen hipfort-rocm-10.0.0/docs/README.md000066400000000000000000000021531524740623400164200ustar00rootroot00000000000000# Building the hipFORT documentation The hipFORT documentation is built with [Sphinx](https://www.sphinx-doc.org) and [Doxygen](https://www.doxygen.nl), wired together by [rocm-docs-core](https://github.com/ROCm/rocm-docs-core). The published version lives at . ## Prerequisites * Python 3.10 or newer * `doxygen` * `gfortran` (the Fortran sources are preprocessed with it before Doxygen parses them) * `graphviz` (optional, for the type collaboration diagrams) On Ubuntu: ```shell sudo apt install doxygen gfortran graphviz ``` ## Build From the repository root, create a virtual environment, install the pinned Python dependencies, and run Sphinx: ```shell python3 -m venv .venv source .venv/bin/activate pip install -r docs/sphinx/requirements.txt sphinx-build -b html docs docs/_build/html ``` Open `docs/_build/html/index.html` in a browser. `docs/conf.py` preprocesses every `lib/hipfort/*.F90` file with `gfortran -E -cpp -P -DUSE_FPOINTER_INTERFACES -UUSE_CUDA_NAMES` into `docs/doxygen/input/`, then `rocm-docs-core` runs Doxygen and integrates the result. hipfort-rocm-10.0.0/docs/conf.py000066400000000000000000000051241524740623400164410ustar00rootroot00000000000000# Configuration file for the Sphinx documentation builder. # # This file only contains a selection of the most common options. For a full # list see the documentation: # https://www.sphinx-doc.org/en/master/usage/configuration.html import glob import os import re import shutil import subprocess from pathlib import Path from typing import Any, Dict, List from rocm_docs import ROCmDocs # Preprocess the fortran sources with gfortran, because doxygen doesn't seem # to correctly parse them, even with preprocessing turned on (and with # upper-case file names as convention) # preprocessed_out_dir has to be kept in sync with the Doxyfile's INPUT preprocessed_out_dir = Path("doxygen", "input") try: os.mkdir(preprocessed_out_dir) except FileExistsError: pass gfortran_exe = shutil.which("gfortran") if gfortran_exe is None: raise RuntimeError("Couldn't find the fortran compiler!") for filename in glob.glob("../lib/hipfort/*.[fF]90"): path = Path(filename) # -P is to disable embedding line information subprocess.check_call( [ gfortran_exe, "-E", "-cpp", "-P", "-DUSE_FPOINTER_INTERFACES", "-UUSE_CUDA_NAMES", str(path), "-o", str(preprocessed_out_dir / path.name), ] ) with open('../CMakeLists.txt', encoding='utf-8') as f: match = re.search(r'.*\bhipfort VERSION\s+\"?([0-9.]+)[^0-9.]+', f.read()) if not match: raise ValueError("HIPFORT_VERSION not found!") version_number = match[1] left_nav_title = f"hipfort {version_number} Documentation" # for PDF output on Read the Docs project = "hipfort Documentation" author = "Advanced Micro Devices, Inc." copyright = "Copyright (c) 2026 Advanced Micro Devices, Inc. All rights reserved." version = version_number release = version_number external_toc_path = "./sphinx/_toc.yml" docs_core = ROCmDocs(left_nav_title) docs_core.run_doxygen(doxygen_root="doxygen", doxygen_path="doxygen/xml") docs_core.enable_api_reference() docs_core.setup() external_projects_current_project = "hipfort" for sphinx_var in ROCmDocs.SPHINX_VARS: globals()[sphinx_var] = getattr(docs_core, sphinx_var) # rocm-docs-core might or might not have changed these yet (depending on version), # and we don't want to wipe their settings if they did if not "html_theme_options" in globals(): html_theme_options: Dict[str, Any] = {} if not "exclude_patterns" in globals(): exclude_patterns: List[str] = [] html_theme_options["show_navbar_depth"] = 2 exclude_patterns.append("doxygen/input") exclude_patterns.append("README.md") hipfort-rocm-10.0.0/docs/doxygen/000077500000000000000000000000001524740623400166155ustar00rootroot00000000000000hipfort-rocm-10.0.0/docs/doxygen/.gitignore000066400000000000000000000000131524740623400205770ustar00rootroot00000000000000/html /xml hipfort-rocm-10.0.0/docs/doxygen/Doxyfile000066400000000000000000003672201524740623400203350ustar00rootroot00000000000000# Doxyfile 1.9.8 # This file describes the settings to be used by the documentation system # doxygen (www.doxygen.org) for a project. # # All text after a double hash (##) is considered a comment and is placed in # front of the TAG it is preceding. # # All text after a single hash (#) is considered a comment and will be ignored. # The format is: # TAG = value [value, ...] # For lists, items can also be appended using: # TAG += value [value, ...] # Values that contain spaces should be placed between quotes (\" \"). # # Note: # # Use doxygen to compare the used configuration file with the template # configuration file: # doxygen -x [configFile] # Use doxygen to compare the used configuration file with the template # configuration file without replacing the environment variables or CMake type # replacement variables: # doxygen -x_noenv [configFile] #--------------------------------------------------------------------------- # Project related configuration options #--------------------------------------------------------------------------- # This tag specifies the encoding used for all characters in the configuration # file that follow. The default is UTF-8 which is also the encoding used for all # text before the first occurrence of this tag. Doxygen uses libiconv (or the # iconv built into libc) for the transcoding. See # https://www.gnu.org/software/libiconv/ for the list of possible encodings. # The default value is: UTF-8. DOXYFILE_ENCODING = UTF-8 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded by # double-quotes, unless you are using Doxywizard) that should identify the # project for which the documentation is generated. This name is used in the # title of most generated pages and in a few other places. # The default value is: My Project. PROJECT_NAME = "HIPFORT API Reference" # The PROJECT_NUMBER tag can be used to enter a project or revision number. This # could be handy for archiving the generated documentation or if some version # control system is used. PROJECT_NUMBER = # Using the PROJECT_BRIEF tag one can provide an optional one line description # for a project that appears at the top of each page and should give viewer a # quick idea about the purpose of the project. Keep the description short. PROJECT_BRIEF = "Fortran Interface for GPU kernel libraries" # With the PROJECT_LOGO tag one can specify a logo or an icon that is included # in the documentation. The maximum height of the logo should not exceed 55 # pixels and the maximum width should not exceed 200 pixels. Doxygen will copy # the logo to the output directory. PROJECT_LOGO = # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path # into which the generated documentation will be written. If a relative path is # entered, it will be relative to the location where doxygen was started. If # left blank the current directory will be used. OUTPUT_DIRECTORY = . # If the CREATE_SUBDIRS tag is set to YES then doxygen will create up to 4096 # sub-directories (in 2 levels) under the output directory of each output format # and will distribute the generated files over these directories. Enabling this # option can be useful when feeding doxygen a huge amount of source files, where # putting all generated files in the same directory would otherwise causes # performance problems for the file system. Adapt CREATE_SUBDIRS_LEVEL to # control the number of sub-directories. # The default value is: NO. CREATE_SUBDIRS = NO # Controls the number of sub-directories that will be created when # CREATE_SUBDIRS tag is set to YES. Level 0 represents 16 directories, and every # level increment doubles the number of directories, resulting in 4096 # directories at level 8 which is the default and also the maximum value. The # sub-directories are organized in 2 levels, the first level always has a fixed # number of 16 directories. # Minimum value: 0, maximum value: 8, default value: 8. # This tag requires that the tag CREATE_SUBDIRS is set to YES. CREATE_SUBDIRS_LEVEL = 8 # If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII # characters to appear in the names of generated files. If set to NO, non-ASCII # characters will be escaped, for example _xE3_x81_x84 will be used for Unicode # U+3044. # The default value is: NO. ALLOW_UNICODE_NAMES = NO # The OUTPUT_LANGUAGE tag is used to specify the language in which all # documentation generated by doxygen is written. Doxygen will use this # information to generate all constant output in the proper language. # Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Bulgarian, # Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish, Dutch, English # (United States), Esperanto, Farsi (Persian), Finnish, French, German, Greek, # Hindi, Hungarian, Indonesian, Italian, Japanese, Japanese-en (Japanese with # English messages), Korean, Korean-en (Korean with English messages), Latvian, # Lithuanian, Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, # Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, # Swedish, Turkish, Ukrainian and Vietnamese. # The default value is: English. OUTPUT_LANGUAGE = English # If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member # descriptions after the members that are listed in the file and class # documentation (similar to Javadoc). Set to NO to disable this. # The default value is: YES. BRIEF_MEMBER_DESC = YES # If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief # description of a member or function before the detailed description # # Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the # brief descriptions will be completely suppressed. # The default value is: YES. REPEAT_BRIEF = YES # This tag implements a quasi-intelligent brief description abbreviator that is # used to form the text in various listings. Each string in this list, if found # as the leading text of the brief description, will be stripped from the text # and the result, after processing the whole list, is used as the annotated # text. Otherwise, the brief description is used as-is. If left blank, the # following values are used ($name is automatically replaced with the name of # the entity):The $name class, The $name widget, The $name file, is, provides, # specifies, contains, represents, a, an and the. ABBREVIATE_BRIEF = # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then # doxygen will generate a detailed section even if there is only a brief # description. # The default value is: NO. ALWAYS_DETAILED_SEC = YES # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all # inherited members of a class in the documentation of that class as if those # members were ordinary class members. Constructors, destructors and assignment # operators of the base classes will not be shown. # The default value is: NO. INLINE_INHERITED_MEMB = YES # If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path # before files name in the file list and in the header files. If set to NO the # shortest path that makes the file name unique will be used # The default value is: YES. FULL_PATH_NAMES = NO # The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path. # Stripping is only done if one of the specified strings matches the left-hand # part of the path. The tag can be used to show relative paths in the file list. # If left blank the directory from which doxygen is run is used as the path to # strip. # # Note that you can specify absolute paths here, but also relative paths, which # will be relative from the directory where doxygen is started. # This tag requires that the tag FULL_PATH_NAMES is set to YES. STRIP_FROM_PATH = # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the # path mentioned in the documentation of a class, which tells the reader which # header file to include in order to use a class. If left blank only the name of # the header file containing the class definition is used. Otherwise one should # specify the list of include paths that are normally passed to the compiler # using the -I flag. STRIP_FROM_INC_PATH = # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but # less readable) file names. This can be useful is your file systems doesn't # support long names like on DOS, Mac, or CD-ROM. # The default value is: NO. SHORT_NAMES = NO # If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the # first line (until the first dot) of a Javadoc-style comment as the brief # description. If set to NO, the Javadoc-style will behave just like regular Qt- # style comments (thus requiring an explicit @brief command for a brief # description.) # The default value is: NO. JAVADOC_AUTOBRIEF = YES # If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line # such as # /*************** # as being the beginning of a Javadoc-style comment "banner". If set to NO, the # Javadoc-style will behave just like regular comments and it will not be # interpreted by doxygen. # The default value is: NO. JAVADOC_BANNER = YES # If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first # line (until the first dot) of a Qt-style comment as the brief description. If # set to NO, the Qt-style will behave just like regular Qt-style comments (thus # requiring an explicit \brief command for a brief description.) # The default value is: NO. QT_AUTOBRIEF = NO # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a # multi-line C++ special comment block (i.e. a block of //! or /// comments) as # a brief description. This used to be the default behavior. The new default is # to treat a multi-line C++ comment block as a detailed description. Set this # tag to YES if you prefer the old behavior instead. # # Note that setting this tag to YES also means that rational rose comments are # not recognized any more. # The default value is: NO. MULTILINE_CPP_IS_BRIEF = NO # By default Python docstrings are displayed as preformatted text and doxygen's # special commands cannot be used. By setting PYTHON_DOCSTRING to NO the # doxygen's special commands can be used and the contents of the docstring # documentation blocks is shown as doxygen documentation. # The default value is: YES. PYTHON_DOCSTRING = YES # If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the # documentation from any documented member that it re-implements. # The default value is: YES. INHERIT_DOCS = YES # If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new # page for each member. If set to NO, the documentation of a member will be part # of the file/class/namespace that contains it. # The default value is: NO. SEPARATE_MEMBER_PAGES = NO # The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen # uses this value to replace tabs by spaces in code fragments. # Minimum value: 1, maximum value: 16, default value: 4. TAB_SIZE = 4 # This tag can be used to specify a number of aliases that act as commands in # the documentation. An alias has the form: # name=value # For example adding # "sideeffect=@par Side Effects:^^" # will allow you to put the command \sideeffect (or @sideeffect) in the # documentation, which will result in a user-defined paragraph with heading # "Side Effects:". Note that you cannot put \n's in the value part of an alias # to insert newlines (in the resulting output). You can put ^^ in the value part # of an alias to insert a newline as if a physical newline was in the original # file. When you need a literal { or } or , in the value part of an alias you # have to escape them by means of a backslash (\), this can lead to conflicts # with the commands \{ and \} for these it is advised to use the version @{ and # @} or use a double escape (\\{ and \\}) ALIASES = # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources # only. Doxygen will then generate output that is more tailored for C. For # instance, some of the names that are used will be different. The list of all # members will be omitted, etc. # The default value is: NO. OPTIMIZE_OUTPUT_FOR_C = NO # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or # Python sources only. Doxygen will then generate output that is more tailored # for that language. For instance, namespaces will be presented as packages, # qualified scopes will look different, etc. # The default value is: NO. OPTIMIZE_OUTPUT_JAVA = NO # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran # sources. Doxygen will then generate output that is tailored for Fortran. # The default value is: NO. OPTIMIZE_FOR_FORTRAN = YES # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL # sources. Doxygen will then generate output that is tailored for VHDL. # The default value is: NO. OPTIMIZE_OUTPUT_VHDL = NO # Set the OPTIMIZE_OUTPUT_SLICE tag to YES if your project consists of Slice # sources only. Doxygen will then generate output that is more tailored for that # language. For instance, namespaces will be presented as modules, types will be # separated into more groups, etc. # The default value is: NO. OPTIMIZE_OUTPUT_SLICE = NO # Doxygen selects the parser to use depending on the extension of the files it # parses. With this tag you can assign which parser to use for a given # extension. Doxygen has a built-in mapping, but you can override or extend it # using this tag. The format is ext=language, where ext is a file extension, and # language is one of the parsers supported by doxygen: IDL, Java, JavaScript, # Csharp (C#), C, C++, Lex, D, PHP, md (Markdown), Objective-C, Python, Slice, # VHDL, Fortran (fixed format Fortran: FortranFixed, free formatted Fortran: # FortranFree, unknown formatted Fortran: Fortran. In the later case the parser # tries to guess whether the code is fixed or free formatted code, this is the # default for Fortran type files). For instance to make doxygen treat .inc files # as Fortran files (default is PHP), and .f files as C (default is Fortran), # use: inc=Fortran f=C. # # Note: For files without extension you can use no_extension as a placeholder. # # Note that for custom extensions you also need to set FILE_PATTERNS otherwise # the files are not read by doxygen. When specifying no_extension you should add # * to the FILE_PATTERNS. # # Note see also the list of default file extension mappings. EXTENSION_MAPPING = f=FortranFree # If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments # according to the Markdown format, which allows for more readable # documentation. See https://daringfireball.net/projects/markdown/ for details. # The output of markdown processing is further processed by doxygen, so you can # mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in # case of backward compatibilities issues. # The default value is: YES. MARKDOWN_SUPPORT = YES # When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up # to that level are automatically included in the table of contents, even if # they do not have an id attribute. # Note: This feature currently applies only to Markdown headings. # Minimum value: 0, maximum value: 99, default value: 5. # This tag requires that the tag MARKDOWN_SUPPORT is set to YES. TOC_INCLUDE_HEADINGS = 5 # The MARKDOWN_ID_STYLE tag can be used to specify the algorithm used to # generate identifiers for the Markdown headings. Note: Every identifier is # unique. # Possible values are: DOXYGEN use a fixed 'autotoc_md' string followed by a # sequence number starting at 0 and GITHUB use the lower case version of title # with any whitespace replaced by '-' and punctuation characters removed. # The default value is: DOXYGEN. # This tag requires that the tag MARKDOWN_SUPPORT is set to YES. MARKDOWN_ID_STYLE = DOXYGEN # When enabled doxygen tries to link words that correspond to documented # classes, or namespaces to their corresponding documentation. Such a link can # be prevented in individual cases by putting a % sign in front of the word or # globally by setting AUTOLINK_SUPPORT to NO. # The default value is: YES. AUTOLINK_SUPPORT = YES # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want # to include (a tag file for) the STL sources as input, then you should set this # tag to YES in order to let doxygen match functions declarations and # definitions whose arguments contain STL classes (e.g. func(std::string); # versus func(std::string) {}). This also make the inheritance and collaboration # diagrams that involve STL classes more complete and accurate. # The default value is: NO. BUILTIN_STL_SUPPORT = NO # If you use Microsoft's C++/CLI language, you should set this option to YES to # enable parsing support. # The default value is: NO. CPP_CLI_SUPPORT = NO # Set the SIP_SUPPORT tag to YES if your project consists of sip (see: # https://www.riverbankcomputing.com/software/sip/intro) sources only. Doxygen # will parse them like normal C++ but will assume all classes use public instead # of private inheritance when no explicit protection keyword is present. # The default value is: NO. SIP_SUPPORT = NO # For Microsoft's IDL there are propget and propput attributes to indicate # getter and setter methods for a property. Setting this option to YES will make # doxygen to replace the get and set methods by a property in the documentation. # This will only work if the methods are indeed getting or setting a simple # type. If this is not the case, or you want to show the methods anyway, you # should set this option to NO. # The default value is: YES. IDL_PROPERTY_SUPPORT = YES # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC # tag is set to YES then doxygen will reuse the documentation of the first # member in the group (if any) for the other members of the group. By default # all members of a group must be documented explicitly. # The default value is: NO. DISTRIBUTE_GROUP_DOC = NO # If one adds a struct or class to a group and this option is enabled, then also # any nested class or struct is added to the same group. By default this option # is disabled and one has to add nested compounds explicitly via \ingroup. # The default value is: NO. GROUP_NESTED_COMPOUNDS = NO # Set the SUBGROUPING tag to YES to allow class member groups of the same type # (for instance a group of public functions) to be put as a subgroup of that # type (e.g. under the Public Functions section). Set it to NO to prevent # subgrouping. Alternatively, this can be done per class using the # \nosubgrouping command. # The default value is: YES. SUBGROUPING = YES # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions # are shown inside the group in which they are included (e.g. using \ingroup) # instead of on a separate page (for HTML and Man pages) or section (for LaTeX # and RTF). # # Note that this feature does not work in combination with # SEPARATE_MEMBER_PAGES. # The default value is: NO. INLINE_GROUPED_CLASSES = NO # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions # with only public data fields or simple typedef fields will be shown inline in # the documentation of the scope in which they are defined (i.e. file, # namespace, or group documentation), provided this scope is documented. If set # to NO, structs, classes, and unions are shown on a separate page (for HTML and # Man pages) or section (for LaTeX and RTF). # The default value is: NO. INLINE_SIMPLE_STRUCTS = NO # When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or # enum is documented as struct, union, or enum with the name of the typedef. So # typedef struct TypeS {} TypeT, will appear in the documentation as a struct # with name TypeT. When disabled the typedef will appear as a member of a file, # namespace, or class. And the struct will be named TypeS. This can typically be # useful for C code in case the coding convention dictates that all compound # types are typedef'ed and only the typedef is referenced, never the tag name. # The default value is: NO. TYPEDEF_HIDES_STRUCT = NO # The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This # cache is used to resolve symbols given their name and scope. Since this can be # an expensive process and often the same symbol appears multiple times in the # code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small # doxygen will become slower. If the cache is too large, memory is wasted. The # cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range # is 0..9, the default is 0, corresponding to a cache size of 2^16=65536 # symbols. At the end of a run doxygen will report the cache usage and suggest # the optimal cache size from a speed point of view. # Minimum value: 0, maximum value: 9, default value: 0. LOOKUP_CACHE_SIZE = 0 # The NUM_PROC_THREADS specifies the number of threads doxygen is allowed to use # during processing. When set to 0 doxygen will based this on the number of # cores available in the system. You can set it explicitly to a value larger # than 0 to get more control over the balance between CPU load and processing # speed. At this moment only the input processing can be done using multiple # threads. Since this is still an experimental feature the default is set to 1, # which effectively disables parallel processing. Please report any issues you # encounter. Generating dot graphs in parallel is controlled by the # DOT_NUM_THREADS setting. # Minimum value: 0, maximum value: 32, default value: 1. NUM_PROC_THREADS = 1 # If the TIMESTAMP tag is set different from NO then each generated page will # contain the date or date and time when the page was generated. Setting this to # NO can help when comparing the output of multiple runs. # Possible values are: YES, NO, DATETIME and DATE. # The default value is: NO. TIMESTAMP = NO #--------------------------------------------------------------------------- # Build related configuration options #--------------------------------------------------------------------------- # If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in # documentation are documented, even if no documentation was available. Private # class members and static file members will be hidden unless the # EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES. # Note: This will also disable the warnings about undocumented members that are # normally produced when WARNINGS is set to YES. # The default value is: NO. EXTRACT_ALL = YES # If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will # be included in the documentation. # The default value is: NO. EXTRACT_PRIVATE = NO # If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual # methods of a class will be included in the documentation. # The default value is: NO. EXTRACT_PRIV_VIRTUAL = NO # If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal # scope will be included in the documentation. # The default value is: NO. EXTRACT_PACKAGE = NO # If the EXTRACT_STATIC tag is set to YES, all static members of a file will be # included in the documentation. # The default value is: NO. EXTRACT_STATIC = NO # If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined # locally in source files will be included in the documentation. If set to NO, # only classes defined in header files are included. Does not have any effect # for Java sources. # The default value is: YES. EXTRACT_LOCAL_CLASSES = YES # This flag is only useful for Objective-C code. If set to YES, local methods, # which are defined in the implementation section but not in the interface are # included in the documentation. If set to NO, only methods in the interface are # included. # The default value is: NO. EXTRACT_LOCAL_METHODS = NO # If this flag is set to YES, the members of anonymous namespaces will be # extracted and appear in the documentation as a namespace called # 'anonymous_namespace{file}', where file will be replaced with the base name of # the file that contains the anonymous namespace. By default anonymous namespace # are hidden. # The default value is: NO. EXTRACT_ANON_NSPACES = NO # If this flag is set to YES, the name of an unnamed parameter in a declaration # will be determined by the corresponding definition. By default unnamed # parameters remain unnamed in the output. # The default value is: YES. RESOLVE_UNNAMED_PARAMS = YES # If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all # undocumented members inside documented classes or files. If set to NO these # members will be included in the various overviews, but no documentation # section is generated. This option has no effect if EXTRACT_ALL is enabled. # The default value is: NO. HIDE_UNDOC_MEMBERS = NO # If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all # undocumented classes that are normally visible in the class hierarchy. If set # to NO, these classes will be included in the various overviews. This option # will also hide undocumented C++ concepts if enabled. This option has no effect # if EXTRACT_ALL is enabled. # The default value is: NO. HIDE_UNDOC_CLASSES = NO # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend # declarations. If set to NO, these declarations will be included in the # documentation. # The default value is: NO. HIDE_FRIEND_COMPOUNDS = NO # If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any # documentation blocks found inside the body of a function. If set to NO, these # blocks will be appended to the function's detailed documentation block. # The default value is: NO. HIDE_IN_BODY_DOCS = NO # The INTERNAL_DOCS tag determines if documentation that is typed after a # \internal command is included. If the tag is set to NO then the documentation # will be excluded. Set it to YES to include the internal documentation. # The default value is: NO. INTERNAL_DOCS = NO # With the correct setting of option CASE_SENSE_NAMES doxygen will better be # able to match the capabilities of the underlying filesystem. In case the # filesystem is case sensitive (i.e. it supports files in the same directory # whose names only differ in casing), the option must be set to YES to properly # deal with such files in case they appear in the input. For filesystems that # are not case sensitive the option should be set to NO to properly deal with # output files written for symbols that only differ in casing, such as for two # classes, one named CLASS and the other named Class, and to also support # references to files without having to specify the exact matching casing. On # Windows (including Cygwin) and MacOS, users should typically set this option # to NO, whereas on Linux or other Unix flavors it should typically be set to # YES. # Possible values are: SYSTEM, NO and YES. # The default value is: SYSTEM. CASE_SENSE_NAMES = YES # If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with # their full class and namespace scopes in the documentation. If set to YES, the # scope will be hidden. # The default value is: NO. HIDE_SCOPE_NAMES = NO # If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will # append additional text to a page's title, such as Class Reference. If set to # YES the compound reference will be hidden. # The default value is: NO. HIDE_COMPOUND_REFERENCE= NO # If the SHOW_HEADERFILE tag is set to YES then the documentation for a class # will show which file needs to be included to use the class. # The default value is: YES. SHOW_HEADERFILE = YES # If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of # the files that are included by a file in the documentation of that file. # The default value is: YES. SHOW_INCLUDE_FILES = YES # If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each # grouped member an include statement to the documentation, telling the reader # which file to include in order to use the member. # The default value is: NO. SHOW_GROUPED_MEMB_INC = NO # If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include # files with double quotes in the documentation rather than with sharp brackets. # The default value is: NO. FORCE_LOCAL_INCLUDES = NO # If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the # documentation for inline members. # The default value is: YES. INLINE_INFO = YES # If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the # (detailed) documentation of file and class members alphabetically by member # name. If set to NO, the members will appear in declaration order. # The default value is: YES. SORT_MEMBER_DOCS = YES # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief # descriptions of file, namespace and class members alphabetically by member # name. If set to NO, the members will appear in declaration order. Note that # this will also influence the order of the classes in the class list. # The default value is: NO. SORT_BRIEF_DOCS = NO # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the # (brief and detailed) documentation of class members so that constructors and # destructors are listed first. If set to NO the constructors will appear in the # respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS. # Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief # member documentation. # Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting # detailed member documentation. # The default value is: NO. SORT_MEMBERS_CTORS_1ST = NO # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy # of group names into alphabetical order. If set to NO the group names will # appear in their defined order. # The default value is: NO. SORT_GROUP_NAMES = NO # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by # fully-qualified names, including namespaces. If set to NO, the class list will # be sorted only by class name, not including the namespace part. # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. # Note: This option applies only to the class list, not to the alphabetical # list. # The default value is: NO. SORT_BY_SCOPE_NAME = NO # If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper # type resolution of all parameters of a function it will reject a match between # the prototype and the implementation of a member function even if there is # only one candidate or it is obvious which candidate to choose by doing a # simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still # accept a match between prototype and implementation in such cases. # The default value is: NO. STRICT_PROTO_MATCHING = NO # The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo # list. This list is created by putting \todo commands in the documentation. # The default value is: YES. GENERATE_TODOLIST = YES # The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test # list. This list is created by putting \test commands in the documentation. # The default value is: YES. GENERATE_TESTLIST = YES # The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug # list. This list is created by putting \bug commands in the documentation. # The default value is: YES. GENERATE_BUGLIST = YES # The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO) # the deprecated list. This list is created by putting \deprecated commands in # the documentation. # The default value is: YES. GENERATE_DEPRECATEDLIST= YES # The ENABLED_SECTIONS tag can be used to enable conditional documentation # sections, marked by \if ... \endif and \cond # ... \endcond blocks. ENABLED_SECTIONS = # The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the # initial value of a variable or macro / define can have for it to appear in the # documentation. If the initializer consists of more lines than specified here # it will be hidden. Use a value of 0 to hide initializers completely. The # appearance of the value of individual variables and macros / defines can be # controlled using \showinitializer or \hideinitializer command in the # documentation regardless of this setting. # Minimum value: 0, maximum value: 10000, default value: 30. MAX_INITIALIZER_LINES = 30 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated at # the bottom of the documentation of classes and structs. If set to YES, the # list will mention the files that were used to generate the documentation. # The default value is: YES. SHOW_USED_FILES = YES # Set the SHOW_FILES tag to NO to disable the generation of the Files page. This # will remove the Files entry from the Quick Index and from the Folder Tree View # (if specified). # The default value is: YES. SHOW_FILES = YES # Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces # page. This will remove the Namespaces entry from the Quick Index and from the # Folder Tree View (if specified). # The default value is: YES. SHOW_NAMESPACES = YES # The FILE_VERSION_FILTER tag can be used to specify a program or script that # doxygen should invoke to get the current version for each file (typically from # the version control system). Doxygen will invoke the program by executing (via # popen()) the command command input-file, where command is the value of the # FILE_VERSION_FILTER tag, and input-file is the name of an input file provided # by doxygen. Whatever the program writes to standard output is used as the file # version. For an example see the documentation. FILE_VERSION_FILTER = # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed # by doxygen. The layout file controls the global structure of the generated # output files in an output format independent way. To create the layout file # that represents doxygen's defaults, run doxygen with the -l option. You can # optionally specify a file name after the option, if omitted DoxygenLayout.xml # will be used as the name of the layout file. See also section "Changing the # layout of pages" for information. # # Note that if you run doxygen from a directory containing a file called # DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE # tag is left empty. LAYOUT_FILE = # The CITE_BIB_FILES tag can be used to specify one or more bib files containing # the reference definitions. This must be a list of .bib files. The .bib # extension is automatically appended if omitted. This requires the bibtex tool # to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info. # For LaTeX the style of the bibliography can be controlled using # LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the # search path. See also \cite for info how to create references. CITE_BIB_FILES = #--------------------------------------------------------------------------- # Configuration options related to warning and progress messages #--------------------------------------------------------------------------- # The QUIET tag can be used to turn on/off the messages that are generated to # standard output by doxygen. If QUIET is set to YES this implies that the # messages are off. # The default value is: NO. QUIET = NO # The WARNINGS tag can be used to turn on/off the warning messages that are # generated to standard error (stderr) by doxygen. If WARNINGS is set to YES # this implies that the warnings are on. # # Tip: Turn warnings on while writing the documentation. # The default value is: YES. WARNINGS = YES # If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate # warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag # will automatically be disabled. # The default value is: YES. WARN_IF_UNDOCUMENTED = YES # If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for # potential errors in the documentation, such as documenting some parameters in # a documented function twice, or documenting parameters that don't exist or # using markup commands wrongly. # The default value is: YES. WARN_IF_DOC_ERROR = YES # If WARN_IF_INCOMPLETE_DOC is set to YES, doxygen will warn about incomplete # function parameter documentation. If set to NO, doxygen will accept that some # parameters have no documentation without warning. # The default value is: YES. WARN_IF_INCOMPLETE_DOC = YES # This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that # are documented, but have no documentation for their parameters or return # value. If set to NO, doxygen will only warn about wrong parameter # documentation, but not about the absence of documentation. If EXTRACT_ALL is # set to YES then this flag will automatically be disabled. See also # WARN_IF_INCOMPLETE_DOC # The default value is: NO. WARN_NO_PARAMDOC = NO # If WARN_IF_UNDOC_ENUM_VAL option is set to YES, doxygen will warn about # undocumented enumeration values. If set to NO, doxygen will accept # undocumented enumeration values. If EXTRACT_ALL is set to YES then this flag # will automatically be disabled. # The default value is: NO. WARN_IF_UNDOC_ENUM_VAL = NO # If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when # a warning is encountered. If the WARN_AS_ERROR tag is set to FAIL_ON_WARNINGS # then doxygen will continue running as if WARN_AS_ERROR tag is set to NO, but # at the end of the doxygen process doxygen will return with a non-zero status. # If the WARN_AS_ERROR tag is set to FAIL_ON_WARNINGS_PRINT then doxygen behaves # like FAIL_ON_WARNINGS but in case no WARN_LOGFILE is defined doxygen will not # write the warning messages in between other messages but write them at the end # of a run, in case a WARN_LOGFILE is defined the warning messages will be # besides being in the defined file also be shown at the end of a run, unless # the WARN_LOGFILE is defined as - i.e. standard output (stdout) in that case # the behavior will remain as with the setting FAIL_ON_WARNINGS. # Possible values are: NO, YES, FAIL_ON_WARNINGS and FAIL_ON_WARNINGS_PRINT. # The default value is: NO. WARN_AS_ERROR = YES # The WARN_FORMAT tag determines the format of the warning messages that doxygen # can produce. The string should contain the $file, $line, and $text tags, which # will be replaced by the file and line number from which the warning originated # and the warning text. Optionally the format may contain $version, which will # be replaced by the version of the file (if it could be obtained via # FILE_VERSION_FILTER) # See also: WARN_LINE_FORMAT # The default value is: $file:$line: $text. WARN_FORMAT = "$file:$line: $text" # In the $text part of the WARN_FORMAT command it is possible that a reference # to a more specific place is given. To make it easier to jump to this place # (outside of doxygen) the user can define a custom "cut" / "paste" string. # Example: # WARN_LINE_FORMAT = "'vi $file +$line'" # See also: WARN_FORMAT # The default value is: at line $line of file $file. WARN_LINE_FORMAT = "at line $line of file $file" # The WARN_LOGFILE tag can be used to specify a file to which warning and error # messages should be written. If left blank the output is written to standard # error (stderr). In case the file specified cannot be opened for writing the # warning and error messages are written to standard error. When as file - is # specified the warning and error messages are written to standard output # (stdout). WARN_LOGFILE = #--------------------------------------------------------------------------- # Configuration options related to the input files #--------------------------------------------------------------------------- # The INPUT tag is used to specify the files and/or directories that contain # documented source files. You may enter file names like myfile.cpp or # directories like /usr/src/myproject. Separate the files or directories with # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING # Note: If this tag is empty the current directory is searched. INPUT = input # This tag can be used to specify the character encoding of the source files # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses # libiconv (or the iconv built into libc) for the transcoding. See the libiconv # documentation (see: # https://www.gnu.org/software/libiconv/) for the list of possible encodings. # See also: INPUT_FILE_ENCODING # The default value is: UTF-8. INPUT_ENCODING = UTF-8 # This tag can be used to specify the character encoding of the source files # that doxygen parses The INPUT_FILE_ENCODING tag can be used to specify # character encoding on a per file pattern basis. Doxygen will compare the file # name with each pattern and apply the encoding instead of the default # INPUT_ENCODING) if there is a match. The character encodings are a list of the # form: pattern=encoding (like *.php=ISO-8859-1). See cfg_input_encoding # "INPUT_ENCODING" for further information on supported encodings. INPUT_FILE_ENCODING = # If the value of the INPUT tag contains directories, you can use the # FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and # *.h) to filter out the source-files in the directories. # # Note that for custom extensions or not directly supported extensions you also # need to set EXTENSION_MAPPING for the extension otherwise the files are not # read by doxygen. # # Note the list of default checked file patterns might differ from the list of # default file extension mappings. # # If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cxxm, # *.cpp, *.cppm, *.c++, *.c++m, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, # *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp, *.h++, *.ixx, *.l, *.cs, *.d, *.php, # *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown, *.md, *.mm, *.dox (to be # provided as doxygen C comment), *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, # *.f18, *.f, *.for, *.vhd, *.vhdl, *.ucf, *.qsf and *.ice. FILE_PATTERNS = *.f \ *.f90 \ *.F90 \ *.md # The RECURSIVE tag can be used to specify whether or not subdirectories should # be searched for input files as well. # The default value is: NO. RECURSIVE = NO # The EXCLUDE tag can be used to specify files and/or directories that should be # excluded from the INPUT source files. This way you can easily exclude a # subdirectory from a directory tree whose root is specified with the INPUT tag. # # Note that relative paths are relative to the directory from which doxygen is # run. EXCLUDE = # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or # directories that are symbolic links (a Unix file system feature) are excluded # from the input. # The default value is: NO. EXCLUDE_SYMLINKS = NO # If the value of the INPUT tag contains directories, you can use the # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude # certain files from those directories. # # Note that the wildcards are matched against the file with absolute path, so to # exclude all test directories for example use the pattern */test/* EXCLUDE_PATTERNS = # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names # (namespaces, classes, functions, etc.) that should be excluded from the # output. The symbol name can be a fully qualified name, a word, or if the # wildcard * is used, a substring. Examples: ANamespace, AClass, # ANamespace::AClass, ANamespace::*Test EXCLUDE_SYMBOLS = # The EXAMPLE_PATH tag can be used to specify one or more files or directories # that contain example code fragments that are included (see the \include # command). EXAMPLE_PATH = # If the value of the EXAMPLE_PATH tag contains directories, you can use the # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and # *.h) to filter out the source-files in the directories. If left blank all # files are included. EXAMPLE_PATTERNS = * # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be # searched for input files to be used with the \include or \dontinclude commands # irrespective of the value of the RECURSIVE tag. # The default value is: NO. EXAMPLE_RECURSIVE = NO # The IMAGE_PATH tag can be used to specify one or more files or directories # that contain images that are to be included in the documentation (see the # \image command). IMAGE_PATH = # The INPUT_FILTER tag can be used to specify a program that doxygen should # invoke to filter for each input file. Doxygen will invoke the filter program # by executing (via popen()) the command: # # # # where is the value of the INPUT_FILTER tag, and is the # name of an input file. Doxygen will then use the output that the filter # program writes to standard output. If FILTER_PATTERNS is specified, this tag # will be ignored. # # Note that the filter must not add or remove lines; it is applied before the # code is scanned, but not when the output code is generated. If lines are added # or removed, the anchors will not be placed correctly. # # Note that doxygen will use the data processed and written to standard output # for further processing, therefore nothing else, like debug statements or used # commands (so in case of a Windows batch file always use @echo OFF), should be # written to standard output. # # Note that for custom extensions or not directly supported extensions you also # need to set EXTENSION_MAPPING for the extension otherwise the files are not # properly processed by doxygen. INPUT_FILTER = # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern # basis. Doxygen will compare the file name with each pattern and apply the # filter if there is a match. The filters are a list of the form: pattern=filter # (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how # filters are used. If the FILTER_PATTERNS tag is empty or if none of the # patterns match the file name, INPUT_FILTER is applied. # # Note that for custom extensions or not directly supported extensions you also # need to set EXTENSION_MAPPING for the extension otherwise the files are not # properly processed by doxygen. FILTER_PATTERNS = # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using # INPUT_FILTER) will also be used to filter the input files that are used for # producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES). # The default value is: NO. FILTER_SOURCE_FILES = NO # The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file # pattern. A pattern will override the setting for FILTER_PATTERN (if any) and # it is also possible to disable source filtering for a specific pattern using # *.ext= (so without naming a filter). # This tag requires that the tag FILTER_SOURCE_FILES is set to YES. FILTER_SOURCE_PATTERNS = # If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that # is part of the input, its contents will be placed on the main page # (index.html). This can be useful if you have a project on for instance GitHub # and want to reuse the introduction page also for the doxygen output. USE_MDFILE_AS_MAINPAGE = # The Fortran standard specifies that for fixed formatted Fortran code all # characters from position 72 are to be considered as comment. A common # extension is to allow longer lines before the automatic comment starts. The # setting FORTRAN_COMMENT_AFTER will also make it possible that longer lines can # be processed before the automatic comment starts. # Minimum value: 7, maximum value: 10000, default value: 72. FORTRAN_COMMENT_AFTER = 72 #--------------------------------------------------------------------------- # Configuration options related to source browsing #--------------------------------------------------------------------------- # If the SOURCE_BROWSER tag is set to YES then a list of source files will be # generated. Documented entities will be cross-referenced with these sources. # # Note: To get rid of all source code in the generated output, make sure that # also VERBATIM_HEADERS is set to NO. # The default value is: NO. SOURCE_BROWSER = NO # Setting the INLINE_SOURCES tag to YES will include the body of functions, # classes and enums directly into the documentation. # The default value is: NO. INLINE_SOURCES = NO # Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any # special comment blocks from generated source code fragments. Normal C, C++ and # Fortran comments will always remain visible. # The default value is: YES. STRIP_CODE_COMMENTS = YES # If the REFERENCED_BY_RELATION tag is set to YES then for each documented # entity all documented functions referencing it will be listed. # The default value is: NO. REFERENCED_BY_RELATION = NO # If the REFERENCES_RELATION tag is set to YES then for each documented function # all documented entities called/used by that function will be listed. # The default value is: NO. REFERENCES_RELATION = NO # If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set # to YES then the hyperlinks from functions in REFERENCES_RELATION and # REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will # link to the documentation. # The default value is: YES. REFERENCES_LINK_SOURCE = YES # If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the # source code will show a tooltip with additional information such as prototype, # brief description and links to the definition and documentation. Since this # will make the HTML file larger and loading of large files a bit slower, you # can opt to disable this feature. # The default value is: YES. # This tag requires that the tag SOURCE_BROWSER is set to YES. SOURCE_TOOLTIPS = YES # If the USE_HTAGS tag is set to YES then the references to source code will # point to the HTML generated by the htags(1) tool instead of doxygen built-in # source browser. The htags tool is part of GNU's global source tagging system # (see https://www.gnu.org/software/global/global.html). You will need version # 4.8.6 or higher. # # To use it do the following: # - Install the latest version of global # - Enable SOURCE_BROWSER and USE_HTAGS in the configuration file # - Make sure the INPUT points to the root of the source tree # - Run doxygen as normal # # Doxygen will invoke htags (and that will in turn invoke gtags), so these # tools must be available from the command line (i.e. in the search path). # # The result: instead of the source browser generated by doxygen, the links to # source code will now point to the output of htags. # The default value is: NO. # This tag requires that the tag SOURCE_BROWSER is set to YES. USE_HTAGS = NO # If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a # verbatim copy of the header file for each class for which an include is # specified. Set to NO to disable this. # See also: Section \class. # The default value is: YES. VERBATIM_HEADERS = YES # If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the # clang parser (see: # http://clang.llvm.org/) for more accurate parsing at the cost of reduced # performance. This can be particularly helpful with template rich C++ code for # which doxygen's built-in parser lacks the necessary type information. # Note: The availability of this option depends on whether or not doxygen was # generated with the -Duse_libclang=ON option for CMake. # The default value is: NO. CLANG_ASSISTED_PARSING = NO # If the CLANG_ASSISTED_PARSING tag is set to YES and the CLANG_ADD_INC_PATHS # tag is set to YES then doxygen will add the directory of each input to the # include path. # The default value is: YES. # This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES. CLANG_ADD_INC_PATHS = YES # If clang assisted parsing is enabled you can provide the compiler with command # line options that you would normally use when invoking the compiler. Note that # the include paths will already be set by doxygen for the files and directories # specified with INPUT and INCLUDE_PATH. # This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES. CLANG_OPTIONS = # If clang assisted parsing is enabled you can provide the clang parser with the # path to the directory containing a file called compile_commands.json. This # file is the compilation database (see: # http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html) containing the # options used when the source files were built. This is equivalent to # specifying the -p option to a clang tool, such as clang-check. These options # will then be passed to the parser. Any options specified with CLANG_OPTIONS # will be added as well. # Note: The availability of this option depends on whether or not doxygen was # generated with the -Duse_libclang=ON option for CMake. CLANG_DATABASE_PATH = #--------------------------------------------------------------------------- # Configuration options related to the alphabetical class index #--------------------------------------------------------------------------- # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all # compounds will be generated. Enable this if the project contains a lot of # classes, structs, unions or interfaces. # The default value is: YES. ALPHABETICAL_INDEX = YES # The IGNORE_PREFIX tag can be used to specify a prefix (or a list of prefixes) # that should be ignored while generating the index headers. The IGNORE_PREFIX # tag works for classes, function and member names. The entity will be placed in # the alphabetical list under the first letter of the entity name that remains # after removing the prefix. # This tag requires that the tag ALPHABETICAL_INDEX is set to YES. IGNORE_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the HTML output #--------------------------------------------------------------------------- # If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output # The default value is: YES. GENERATE_HTML = YES # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of # it. # The default directory is: html. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_OUTPUT = html # The HTML_FILE_EXTENSION tag can be used to specify the file extension for each # generated HTML page (for example: .htm, .php, .asp). # The default value is: .html. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_FILE_EXTENSION = .html # The HTML_HEADER tag can be used to specify a user-defined HTML header file for # each generated HTML page. If the tag is left blank doxygen will generate a # standard header. # # To get valid HTML the header file that includes any scripts and style sheets # that doxygen needs, which is dependent on the configuration options used (e.g. # the setting GENERATE_TREEVIEW). It is highly recommended to start with a # default header using # doxygen -w html new_header.html new_footer.html new_stylesheet.css # YourConfigFile # and then modify the file new_header.html. See also section "Doxygen usage" # for information on how to generate the default header that doxygen normally # uses. # Note: The header is subject to change so you typically have to regenerate the # default header when upgrading to a newer version of doxygen. For a description # of the possible markers and block names see the documentation. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_HEADER = ../_doxygen/header.html # The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each # generated HTML page. If the tag is left blank doxygen will generate a standard # footer. See HTML_HEADER for more information on how to generate a default # footer and what special commands can be used inside the footer. See also # section "Doxygen usage" for information on how to generate the default footer # that doxygen normally uses. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_FOOTER = ../_doxygen/footer.html # The HTML_STYLESHEET tag can be used to specify a user-defined cascading style # sheet that is used by each HTML page. It can be used to fine-tune the look of # the HTML output. If left blank doxygen will generate a default style sheet. # See also section "Doxygen usage" for information on how to generate the style # sheet that doxygen normally uses. # Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as # it is more robust and this tag (HTML_STYLESHEET) will in the future become # obsolete. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_STYLESHEET = ../_doxygen/stylesheet.css # The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined # cascading style sheets that are included after the standard style sheets # created by doxygen. Using this option one can overrule certain style aspects. # This is preferred over using HTML_STYLESHEET since it does not replace the # standard style sheet and is therefore more robust against future updates. # Doxygen will copy the style sheet files to the output directory. # Note: The order of the extra style sheet files is of importance (e.g. the last # style sheet in the list overrules the setting of the previous ones in the # list). # Note: Since the styling of scrollbars can currently not be overruled in # Webkit/Chromium, the styling will be left out of the default doxygen.css if # one or more extra stylesheets have been specified. So if scrollbar # customization is desired it has to be added explicitly. For an example see the # documentation. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_EXTRA_STYLESHEET = ../_doxygen/extra_stylesheet.css # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or # other source files which should be copied to the HTML output directory. Note # that these files will be copied to the base HTML output directory. Use the # $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these # files. In the HTML_STYLESHEET file, use the file name only. Also note that the # files will be copied as-is; there are no commands or markers available. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_EXTRA_FILES = # The HTML_COLORSTYLE tag can be used to specify if the generated HTML output # should be rendered with a dark or light theme. # Possible values are: LIGHT always generate light mode output, DARK always # generate dark mode output, AUTO_LIGHT automatically set the mode according to # the user preference, use light mode if no preference is set (the default), # AUTO_DARK automatically set the mode according to the user preference, use # dark mode if no preference is set and TOGGLE allow to user to switch between # light and dark mode via a button. # The default value is: AUTO_LIGHT. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE = AUTO_LIGHT # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen # will adjust the colors in the style sheet and background images according to # this color. Hue is specified as an angle on a color-wheel, see # https://en.wikipedia.org/wiki/Hue for more information. For instance the value # 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300 # purple, and 360 is red again. # Minimum value: 0, maximum value: 359, default value: 220. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_HUE = 220 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors # in the HTML output. For a value of 0 the output will use gray-scales only. A # value of 255 will produce the most vivid colors. # Minimum value: 0, maximum value: 255, default value: 100. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_SAT = 100 # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the # luminance component of the colors in the HTML output. Values below 100 # gradually make the output lighter, whereas values above 100 make the output # darker. The value divided by 100 is the actual gamma applied, so 80 represents # a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not # change the gamma. # Minimum value: 40, maximum value: 240, default value: 80. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_GAMMA = 80 # If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML # documentation will contain a main index with vertical navigation menus that # are dynamically created via JavaScript. If disabled, the navigation index will # consists of multiple levels of tabs that are statically embedded in every HTML # page. Disable this option to support browsers that do not have JavaScript, # like the Qt help browser. # The default value is: YES. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_DYNAMIC_MENUS = YES # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML # documentation will contain sections that can be hidden and shown after the # page has loaded. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_DYNAMIC_SECTIONS = NO # If the HTML_CODE_FOLDING tag is set to YES then classes and functions can be # dynamically folded and expanded in the generated HTML source code. # The default value is: YES. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_CODE_FOLDING = YES # With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries # shown in the various tree structured indices initially; the user can expand # and collapse entries dynamically later on. Doxygen will expand the tree to # such a level that at most the specified number of entries are visible (unless # a fully collapsed tree already exceeds this amount). So setting the number of # entries 1 will produce a full collapsed tree by default. 0 is a special value # representing an infinite number of entries and will result in a full expanded # tree by default. # Minimum value: 0, maximum value: 9999, default value: 100. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_INDEX_NUM_ENTRIES = 100 # If the GENERATE_DOCSET tag is set to YES, additional index files will be # generated that can be used as input for Apple's Xcode 3 integrated development # environment (see: # https://developer.apple.com/xcode/), introduced with OSX 10.5 (Leopard). To # create a documentation set, doxygen will generate a Makefile in the HTML # output directory. Running make will produce the docset in that directory and # running make install will install the docset in # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at # startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy # genXcode/_index.html for more information. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_DOCSET = NO # This tag determines the name of the docset feed. A documentation feed provides # an umbrella under which multiple documentation sets from a single provider # (such as a company or product suite) can be grouped. # The default value is: Doxygen generated docs. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_FEEDNAME = "Doxygen generated docs" # This tag determines the URL of the docset feed. A documentation feed provides # an umbrella under which multiple documentation sets from a single provider # (such as a company or product suite) can be grouped. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_FEEDURL = # This tag specifies a string that should uniquely identify the documentation # set bundle. This should be a reverse domain-name style string, e.g. # com.mycompany.MyDocSet. Doxygen will append .docset to the name. # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_BUNDLE_ID = org.doxygen.Project # The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify # the documentation publisher. This should be a reverse domain-name style # string, e.g. com.mycompany.MyDocSet.documentation. # The default value is: org.doxygen.Publisher. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_PUBLISHER_ID = org.doxygen.Publisher # The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher. # The default value is: Publisher. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_PUBLISHER_NAME = Publisher # If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three # additional HTML index files: index.hhp, index.hhc, and index.hhk. The # index.hhp is a project file that can be read by Microsoft's HTML Help Workshop # on Windows. In the beginning of 2021 Microsoft took the original page, with # a.o. the download links, offline the HTML help workshop was already many years # in maintenance mode). You can download the HTML help workshop from the web # archives at Installation executable (see: # http://web.archive.org/web/20160201063255/http://download.microsoft.com/downlo # ad/0/A/9/0A939EF6-E31C-430F-A3DF-DFAE7960D564/htmlhelp.exe). # # The HTML Help Workshop contains a compiler that can convert all HTML output # generated by doxygen into a single compiled HTML file (.chm). Compiled HTML # files are now used as the Windows 98 help format, and will replace the old # Windows help format (.hlp) on all Windows platforms in the future. Compressed # HTML files also contain an index, a table of contents, and you can search for # words in the documentation. The HTML workshop also contains a viewer for # compressed HTML files. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_HTMLHELP = NO # The CHM_FILE tag can be used to specify the file name of the resulting .chm # file. You can add a path in front of the file if the result should not be # written to the html output directory. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. CHM_FILE = # The HHC_LOCATION tag can be used to specify the location (absolute path # including file name) of the HTML help compiler (hhc.exe). If non-empty, # doxygen will try to run the HTML help compiler on the generated index.hhp. # The file has to be specified with full path. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. HHC_LOCATION = # The GENERATE_CHI flag controls if a separate .chi index file is generated # (YES) or that it should be included in the main .chm file (NO). # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. GENERATE_CHI = NO # The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc) # and project file content. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. CHM_INDEX_ENCODING = # The BINARY_TOC flag controls whether a binary table of contents is generated # (YES) or a normal table of contents (NO) in the .chm file. Furthermore it # enables the Previous and Next buttons. # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. BINARY_TOC = NO # The TOC_EXPAND flag can be set to YES to add extra items for group members to # the table of contents of the HTML help documentation and to the tree view. # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. TOC_EXPAND = NO # The SITEMAP_URL tag is used to specify the full URL of the place where the # generated documentation will be placed on the server by the user during the # deployment of the documentation. The generated sitemap is called sitemap.xml # and placed on the directory specified by HTML_OUTPUT. In case no SITEMAP_URL # is specified no sitemap is generated. For information about the sitemap # protocol see https://www.sitemaps.org # This tag requires that the tag GENERATE_HTML is set to YES. SITEMAP_URL = # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and # QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that # can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help # (.qch) of the generated HTML documentation. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_QHP = NO # If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify # the file name of the resulting .qch file. The path specified is relative to # the HTML output folder. # This tag requires that the tag GENERATE_QHP is set to YES. QCH_FILE = # The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help # Project output. For more information please see Qt Help Project / Namespace # (see: # https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace). # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_QHP is set to YES. QHP_NAMESPACE = org.doxygen.Project # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt # Help Project output. For more information please see Qt Help Project / Virtual # Folders (see: # https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-folders). # The default value is: doc. # This tag requires that the tag GENERATE_QHP is set to YES. QHP_VIRTUAL_FOLDER = doc # If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom # filter to add. For more information please see Qt Help Project / Custom # Filters (see: # https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_CUST_FILTER_NAME = # The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the # custom filter to add. For more information please see Qt Help Project / Custom # Filters (see: # https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_CUST_FILTER_ATTRS = # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this # project's filter section matches. Qt Help Project / Filter Attributes (see: # https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_SECT_FILTER_ATTRS = # The QHG_LOCATION tag can be used to specify the location (absolute path # including file name) of Qt's qhelpgenerator. If non-empty doxygen will try to # run qhelpgenerator on the generated .qhp file. # This tag requires that the tag GENERATE_QHP is set to YES. QHG_LOCATION = # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be # generated, together with the HTML files, they form an Eclipse help plugin. To # install this plugin and make it available under the help contents menu in # Eclipse, the contents of the directory containing the HTML and XML files needs # to be copied into the plugins directory of eclipse. The name of the directory # within the plugins directory should be the same as the ECLIPSE_DOC_ID value. # After copying Eclipse needs to be restarted before the help appears. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_ECLIPSEHELP = NO # A unique identifier for the Eclipse help plugin. When installing the plugin # the directory name containing the HTML and XML files should also have this # name. Each documentation set should have its own identifier. # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES. ECLIPSE_DOC_ID = org.doxygen.Project # If you want full control over the layout of the generated HTML pages it might # be necessary to disable the index and replace it with your own. The # DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top # of each HTML page. A value of NO enables the index and the value YES disables # it. Since the tabs in the index contain the same information as the navigation # tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. DISABLE_INDEX = NO # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index # structure should be generated to display hierarchical information. If the tag # value is set to YES, a side panel will be generated containing a tree-like # index structure (just like the one that is generated for HTML Help). For this # to work a browser that supports JavaScript, DHTML, CSS and frames is required # (i.e. any modern browser). Windows users are probably better off using the # HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can # further fine tune the look of the index (see "Fine-tuning the output"). As an # example, the default style sheet generated by doxygen has an example that # shows how to put an image at the root of the tree instead of the PROJECT_NAME. # Since the tree basically has the same information as the tab index, you could # consider setting DISABLE_INDEX to YES when enabling this option. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_TREEVIEW = NO # When both GENERATE_TREEVIEW and DISABLE_INDEX are set to YES, then the # FULL_SIDEBAR option determines if the side bar is limited to only the treeview # area (value NO) or if it should extend to the full height of the window (value # YES). Setting this to YES gives a layout similar to # https://docs.readthedocs.io with more room for contents, but less room for the # project logo, title, and description. If either GENERATE_TREEVIEW or # DISABLE_INDEX is set to NO, this option has no effect. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. FULL_SIDEBAR = NO # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that # doxygen will group on one line in the generated HTML documentation. # # Note that a value of 0 will completely suppress the enum values from appearing # in the overview section. # Minimum value: 0, maximum value: 20, default value: 4. # This tag requires that the tag GENERATE_HTML is set to YES. ENUM_VALUES_PER_LINE = 4 # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used # to set the initial width (in pixels) of the frame in which the tree is shown. # Minimum value: 0, maximum value: 1500, default value: 250. # This tag requires that the tag GENERATE_HTML is set to YES. TREEVIEW_WIDTH = 250 # If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to # external symbols imported via tag files in a separate window. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. EXT_LINKS_IN_WINDOW = NO # If the OBFUSCATE_EMAILS tag is set to YES, doxygen will obfuscate email # addresses. # The default value is: YES. # This tag requires that the tag GENERATE_HTML is set to YES. OBFUSCATE_EMAILS = YES # If the HTML_FORMULA_FORMAT option is set to svg, doxygen will use the pdf2svg # tool (see https://github.com/dawbarton/pdf2svg) or inkscape (see # https://inkscape.org) to generate formulas as SVG images instead of PNGs for # the HTML output. These images will generally look nicer at scaled resolutions. # Possible values are: png (the default) and svg (looks nicer but requires the # pdf2svg or inkscape tool). # The default value is: png. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_FORMULA_FORMAT = png # Use this tag to change the font size of LaTeX formulas included as images in # the HTML documentation. When you change the font size after a successful # doxygen run you need to manually remove any form_*.png images from the HTML # output directory to force them to be regenerated. # Minimum value: 8, maximum value: 50, default value: 10. # This tag requires that the tag GENERATE_HTML is set to YES. FORMULA_FONTSIZE = 10 # The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands # to create new LaTeX commands to be used in formulas as building blocks. See # the section "Including formulas" for details. FORMULA_MACROFILE = # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see # https://www.mathjax.org) which uses client side JavaScript for the rendering # instead of using pre-rendered bitmaps. Use this if you do not have LaTeX # installed or if you want to formulas look prettier in the HTML output. When # enabled you may also need to install MathJax separately and configure the path # to it using the MATHJAX_RELPATH option. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. USE_MATHJAX = YES # With MATHJAX_VERSION it is possible to specify the MathJax version to be used. # Note that the different versions of MathJax have different requirements with # regards to the different settings, so it is possible that also other MathJax # settings have to be changed when switching between the different MathJax # versions. # Possible values are: MathJax_2 and MathJax_3. # The default value is: MathJax_2. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_VERSION = MathJax_2 # When MathJax is enabled you can set the default output format to be used for # the MathJax output. For more details about the output format see MathJax # version 2 (see: # http://docs.mathjax.org/en/v2.7-latest/output.html) and MathJax version 3 # (see: # http://docs.mathjax.org/en/latest/web/components/output.html). # Possible values are: HTML-CSS (which is slower, but has the best # compatibility. This is the name for Mathjax version 2, for MathJax version 3 # this will be translated into chtml), NativeMML (i.e. MathML. Only supported # for NathJax 2. For MathJax version 3 chtml will be used instead.), chtml (This # is the name for Mathjax version 3, for MathJax version 2 this will be # translated into HTML-CSS) and SVG. # The default value is: HTML-CSS. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_FORMAT = HTML-CSS # When MathJax is enabled you need to specify the location relative to the HTML # output directory using the MATHJAX_RELPATH option. The destination directory # should contain the MathJax.js script. For instance, if the mathjax directory # is located at the same level as the HTML output directory, then # MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax # Content Delivery Network so you can quickly see the result without installing # MathJax. However, it is strongly recommended to install a local copy of # MathJax from https://www.mathjax.org before deployment. The default value is: # - in case of MathJax version 2: https://cdn.jsdelivr.net/npm/mathjax@2 # - in case of MathJax version 3: https://cdn.jsdelivr.net/npm/mathjax@3 # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_RELPATH = https://cdn.jsdelivr.net/npm/mathjax@2 # The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax # extension names that should be enabled during MathJax rendering. For example # for MathJax version 2 (see # https://docs.mathjax.org/en/v2.7-latest/tex.html#tex-and-latex-extensions): # MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols # For example for MathJax version 3 (see # http://docs.mathjax.org/en/latest/input/tex/extensions/index.html): # MATHJAX_EXTENSIONS = ams # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_EXTENSIONS = # The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces # of code that will be used on startup of the MathJax code. See the MathJax site # (see: # http://docs.mathjax.org/en/v2.7-latest/output.html) for more details. For an # example see the documentation. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_CODEFILE = # When the SEARCHENGINE tag is enabled doxygen will generate a search box for # the HTML output. The underlying search engine uses javascript and DHTML and # should work on any modern browser. Note that when using HTML help # (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) # there is already a search function so this one should typically be disabled. # For large projects the javascript based search engine can be slow, then # enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to # search using the keyboard; to jump to the search box use + S # (what the is depends on the OS and browser, but it is typically # , /Node, # Edge and Graph Attributes specification You need to make sure dot is able # to find the font, which can be done by putting it in a standard location or by # setting the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the # directory containing the font. Default graphviz fontsize is 14. # The default value is: fontname=Helvetica,fontsize=10. # This tag requires that the tag HAVE_DOT is set to YES. DOT_COMMON_ATTR = "fontname=Helvetica,fontsize=10" # DOT_EDGE_ATTR is concatenated with DOT_COMMON_ATTR. For elegant style you can # add 'arrowhead=open, arrowtail=open, arrowsize=0.5'. Complete documentation about # arrows shapes. # The default value is: labelfontname=Helvetica,labelfontsize=10. # This tag requires that the tag HAVE_DOT is set to YES. DOT_EDGE_ATTR = "labelfontname=Helvetica,labelfontsize=10" # DOT_NODE_ATTR is concatenated with DOT_COMMON_ATTR. For view without boxes # around nodes set 'shape=plain' or 'shape=plaintext' Shapes specification # The default value is: shape=box,height=0.2,width=0.4. # This tag requires that the tag HAVE_DOT is set to YES. DOT_NODE_ATTR = "shape=box,height=0.2,width=0.4" # You can set the path where dot can find font specified with fontname in # DOT_COMMON_ATTR and others dot attributes. # This tag requires that the tag HAVE_DOT is set to YES. DOT_FONTPATH = # If the CLASS_GRAPH tag is set to YES or GRAPH or BUILTIN then doxygen will # generate a graph for each documented class showing the direct and indirect # inheritance relations. In case the CLASS_GRAPH tag is set to YES or GRAPH and # HAVE_DOT is enabled as well, then dot will be used to draw the graph. In case # the CLASS_GRAPH tag is set to YES and HAVE_DOT is disabled or if the # CLASS_GRAPH tag is set to BUILTIN, then the built-in generator will be used. # If the CLASS_GRAPH tag is set to TEXT the direct and indirect inheritance # relations will be shown as texts / links. # Possible values are: NO, YES, TEXT, GRAPH and BUILTIN. # The default value is: YES. CLASS_GRAPH = YES # If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a # graph for each documented class showing the direct and indirect implementation # dependencies (inheritance, containment, and class references variables) of the # class with other documented classes. Explicit enabling a collaboration graph, # when COLLABORATION_GRAPH is set to NO, can be accomplished by means of the # command \collaborationgraph. Disabling a collaboration graph can be # accomplished by means of the command \hidecollaborationgraph. # The default value is: YES. # This tag requires that the tag HAVE_DOT is set to YES. COLLABORATION_GRAPH = YES # If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for # groups, showing the direct groups dependencies. Explicit enabling a group # dependency graph, when GROUP_GRAPHS is set to NO, can be accomplished by means # of the command \groupgraph. Disabling a directory graph can be accomplished by # means of the command \hidegroupgraph. See also the chapter Grouping in the # manual. # The default value is: YES. # This tag requires that the tag HAVE_DOT is set to YES. GROUP_GRAPHS = YES # If the UML_LOOK tag is set to YES, doxygen will generate inheritance and # collaboration diagrams in a style similar to the OMG's Unified Modeling # Language. # The default value is: NO. # This tag requires that the tag HAVE_DOT is set to YES. UML_LOOK = NO # If the UML_LOOK tag is enabled, the fields and methods are shown inside the # class node. If there are many fields or methods and many nodes the graph may # become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the # number of items for each type to make the size more manageable. Set this to 0 # for no limit. Note that the threshold may be exceeded by 50% before the limit # is enforced. So when you set the threshold to 10, up to 15 fields may appear, # but if the number exceeds 15, the total amount of fields shown is limited to # 10. # Minimum value: 0, maximum value: 100, default value: 10. # This tag requires that the tag UML_LOOK is set to YES. UML_LIMIT_NUM_FIELDS = 10 # If the DOT_UML_DETAILS tag is set to NO, doxygen will show attributes and # methods without types and arguments in the UML graphs. If the DOT_UML_DETAILS # tag is set to YES, doxygen will add type and arguments for attributes and # methods in the UML graphs. If the DOT_UML_DETAILS tag is set to NONE, doxygen # will not generate fields with class member information in the UML graphs. The # class diagrams will look similar to the default class diagrams but using UML # notation for the relationships. # Possible values are: NO, YES and NONE. # The default value is: NO. # This tag requires that the tag UML_LOOK is set to YES. DOT_UML_DETAILS = NO # The DOT_WRAP_THRESHOLD tag can be used to set the maximum number of characters # to display on a single line. If the actual line length exceeds this threshold # significantly it will wrapped across multiple lines. Some heuristics are apply # to avoid ugly line breaks. # Minimum value: 0, maximum value: 1000, default value: 17. # This tag requires that the tag HAVE_DOT is set to YES. DOT_WRAP_THRESHOLD = 17 # If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and # collaboration graphs will show the relations between templates and their # instances. # The default value is: NO. # This tag requires that the tag HAVE_DOT is set to YES. TEMPLATE_RELATIONS = NO # If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to # YES then doxygen will generate a graph for each documented file showing the # direct and indirect include dependencies of the file with other documented # files. Explicit enabling an include graph, when INCLUDE_GRAPH is is set to NO, # can be accomplished by means of the command \includegraph. Disabling an # include graph can be accomplished by means of the command \hideincludegraph. # The default value is: YES. # This tag requires that the tag HAVE_DOT is set to YES. INCLUDE_GRAPH = YES # If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are # set to YES then doxygen will generate a graph for each documented file showing # the direct and indirect include dependencies of the file with other documented # files. Explicit enabling an included by graph, when INCLUDED_BY_GRAPH is set # to NO, can be accomplished by means of the command \includedbygraph. Disabling # an included by graph can be accomplished by means of the command # \hideincludedbygraph. # The default value is: YES. # This tag requires that the tag HAVE_DOT is set to YES. INCLUDED_BY_GRAPH = YES # If the CALL_GRAPH tag is set to YES then doxygen will generate a call # dependency graph for every global function or class method. # # Note that enabling this option will significantly increase the time of a run. # So in most cases it will be better to enable call graphs for selected # functions only using the \callgraph command. Disabling a call graph can be # accomplished by means of the command \hidecallgraph. # The default value is: NO. # This tag requires that the tag HAVE_DOT is set to YES. CALL_GRAPH = NO # If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller # dependency graph for every global function or class method. # # Note that enabling this option will significantly increase the time of a run. # So in most cases it will be better to enable caller graphs for selected # functions only using the \callergraph command. Disabling a caller graph can be # accomplished by means of the command \hidecallergraph. # The default value is: NO. # This tag requires that the tag HAVE_DOT is set to YES. CALLER_GRAPH = NO # If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical # hierarchy of all classes instead of a textual one. # The default value is: YES. # This tag requires that the tag HAVE_DOT is set to YES. GRAPHICAL_HIERARCHY = YES # If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the # dependencies a directory has on other directories in a graphical way. The # dependency relations are determined by the #include relations between the # files in the directories. Explicit enabling a directory graph, when # DIRECTORY_GRAPH is set to NO, can be accomplished by means of the command # \directorygraph. Disabling a directory graph can be accomplished by means of # the command \hidedirectorygraph. # The default value is: YES. # This tag requires that the tag HAVE_DOT is set to YES. DIRECTORY_GRAPH = YES # The DIR_GRAPH_MAX_DEPTH tag can be used to limit the maximum number of levels # of child directories generated in directory dependency graphs by dot. # Minimum value: 1, maximum value: 25, default value: 1. # This tag requires that the tag DIRECTORY_GRAPH is set to YES. DIR_GRAPH_MAX_DEPTH = 1 # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images # generated by dot. For an explanation of the image formats see the section # output formats in the documentation of the dot tool (Graphviz (see: # https://www.graphviz.org/)). # Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order # to make the SVG files visible in IE 9+ (other browsers do not have this # requirement). # Possible values are: png, jpg, jpg:cairo, jpg:cairo:gd, jpg:gd, jpg:gd:gd, # gif, gif:cairo, gif:cairo:gd, gif:gd, gif:gd:gd, svg, png:gd, png:gd:gd, # png:cairo, png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and # png:gdiplus:gdiplus. # The default value is: png. # This tag requires that the tag HAVE_DOT is set to YES. DOT_IMAGE_FORMAT = svg # If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to # enable generation of interactive SVG images that allow zooming and panning. # # Note that this requires a modern browser other than Internet Explorer. Tested # and working are Firefox, Chrome, Safari, and Opera. # Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make # the SVG files visible. Older versions of IE do not have SVG support. # The default value is: NO. # This tag requires that the tag HAVE_DOT is set to YES. INTERACTIVE_SVG = YES # The DOT_PATH tag can be used to specify the path where the dot tool can be # found. If left blank, it is assumed the dot tool can be found in the path. # This tag requires that the tag HAVE_DOT is set to YES. DOT_PATH = # The DOTFILE_DIRS tag can be used to specify one or more directories that # contain dot files that are included in the documentation (see the \dotfile # command). # This tag requires that the tag HAVE_DOT is set to YES. DOTFILE_DIRS = # You can include diagrams made with dia in doxygen documentation. Doxygen will # then run dia to produce the diagram and insert it in the documentation. The # DIA_PATH tag allows you to specify the directory where the dia binary resides. # If left empty dia is assumed to be found in the default search path. DIA_PATH = # The DIAFILE_DIRS tag can be used to specify one or more directories that # contain dia files that are included in the documentation (see the \diafile # command). DIAFILE_DIRS = # When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the # path where java can find the plantuml.jar file or to the filename of jar file # to be used. If left blank, it is assumed PlantUML is not used or called during # a preprocessing step. Doxygen will generate a warning when it encounters a # \startuml command in this case and will not generate output for the diagram. PLANTUML_JAR_PATH = # When using plantuml, the PLANTUML_CFG_FILE tag can be used to specify a # configuration file for plantuml. PLANTUML_CFG_FILE = # When using plantuml, the specified paths are searched for files specified by # the !include statement in a plantuml block. PLANTUML_INCLUDE_PATH = # The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes # that will be shown in the graph. If the number of nodes in a graph becomes # larger than this value, doxygen will truncate the graph, which is visualized # by representing a node as a red box. Note that doxygen if the number of direct # children of the root node in a graph is already larger than # DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that # the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH. # Minimum value: 0, maximum value: 10000, default value: 50. # This tag requires that the tag HAVE_DOT is set to YES. DOT_GRAPH_MAX_NODES = 50 # The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs # generated by dot. A depth value of 3 means that only nodes reachable from the # root by following a path via at most 3 edges will be shown. Nodes that lay # further from the root node will be omitted. Note that setting this option to 1 # or 2 may greatly reduce the computation time needed for large code bases. Also # note that the size of a graph can be further restricted by # DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction. # Minimum value: 0, maximum value: 1000, default value: 0. # This tag requires that the tag HAVE_DOT is set to YES. MAX_DOT_GRAPH_DEPTH = 0 # Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output # files in one run (i.e. multiple -o and -T options on the command line). This # makes dot run faster, but since only newer versions of dot (>1.8.10) support # this, this feature is disabled by default. # The default value is: NO. # This tag requires that the tag HAVE_DOT is set to YES. DOT_MULTI_TARGETS = NO # If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page # explaining the meaning of the various boxes and arrows in the dot generated # graphs. # Note: This tag requires that UML_LOOK isn't set, i.e. the doxygen internal # graphical representation for inheritance and collaboration diagrams is used. # The default value is: YES. # This tag requires that the tag HAVE_DOT is set to YES. GENERATE_LEGEND = YES # If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate # files that are used to generate the various graphs. # # Note: This setting is not only used for dot files but also for msc temporary # files. # The default value is: YES. DOT_CLEANUP = YES # You can define message sequence charts within doxygen comments using the \msc # command. If the MSCGEN_TOOL tag is left empty (the default), then doxygen will # use a built-in version of mscgen tool to produce the charts. Alternatively, # the MSCGEN_TOOL tag can also specify the name an external tool. For instance, # specifying prog as the value, doxygen will call the tool as prog -T # -o . The external tool should support # output file formats "png", "eps", "svg", and "ismap". MSCGEN_TOOL = # The MSCFILE_DIRS tag can be used to specify one or more directories that # contain msc files that are included in the documentation (see the \mscfile # command). MSCFILE_DIRS = hipfort-rocm-10.0.0/docs/doxygen/input/000077500000000000000000000000001524740623400177545ustar00rootroot00000000000000hipfort-rocm-10.0.0/docs/doxygen/input/.gitignore000066400000000000000000000000601524740623400217400ustar00rootroot00000000000000# Pre-processed fortran sources *.f *.f90 *.F90 hipfort-rocm-10.0.0/docs/doxygen/input/mainpage.md000066400000000000000000000002341524740623400220560ustar00rootroot00000000000000# HIPFORT API Reference {#mainpage} This is the full HIPFORT API Reference. The API is organized into [modules](namespaces.html) based on the wrapped API. hipfort-rocm-10.0.0/docs/doxygen/input/supported_api_hip.md000066400000000000000000001735001524740623400240220ustar00rootroot00000000000000# HIP API Support \# | API Name | Variants ----|---------------|--------- 1 | [hipMalloc](interfacehipfort__hipmalloc_1_1hipmalloc.html "Interface documentation") | C binding 2 | [hipMallocManaged](interfacehipfort__hipmalloc_1_1hipmallocmanaged.html "Interface documentation") | C binding 3 | [hipHostMalloc](interfacehipfort__hipmalloc_1_1hiphostmalloc.html "Interface documentation") | C binding 4 | [hipFree](interfacehipfort__hipmalloc_1_1hipfree.html "Interface documentation") | C binding 5 | [hipHostFree](interfacehipfort__hipmalloc_1_1hiphostfree.html "Interface documentation") | C binding 6 | [hipMemcpy](interfacehipfort__hipmemcpy_1_1hipmemcpy.html "Interface documentation") | C binding, assumed_rank 7 | [hipMemcpyAsync](interfacehipfort__hipmemcpy_1_1hipmemcpyasync.html "Interface documentation") | C binding, assumed_rank 8 | [hipMemcpy2D](interfacehipfort__hipmemcpy_1_1hipmemcpy2d.html "Interface documentation") | C binding 9 | [hipMemcpy2DAsync](interfacehipfort__hipmemcpy_1_1hipmemcpy2dasync.html "Interface documentation") | C binding 10 | [hipHostRegister](interfacehipfort__hiphostregister_1_1hiphostregister.html "Interface documentation") | C binding 11 | [hipHostUnregister](interfacehipfort__hiphostregister_1_1hiphostunregister.html "Interface documentation") | C binding 12 | [hipHostGetDevicePointer](interfacehipfort__hiphostregister_1_1hiphostgetdevicepointer.html "Interface documentation") | C binding 13 | [hipHostGetFlags](interfacehipfort__hiphostregister_1_1hiphostgetflags.html "Interface documentation") | C binding 14 | [hipGetDeviceProperties](interfacehipfort__auxiliary_1_1hipgetdeviceproperties.html "Interface documentation") | C binding 15 | [hipCreateChannelDesc](interfacehipfort_1_1hipcreatechanneldesc.html "Interface documentation") | C binding 16 | [hipInit](interfacehipfort_1_1hipinit.html "Interface documentation") | C binding 17 | [hipDriverGetVersion](interfacehipfort_1_1hipdrivergetversion.html "Interface documentation") | C binding 18 | [hipRuntimeGetVersion](interfacehipfort_1_1hipruntimegetversion.html "Interface documentation") | C binding 19 | [hipDeviceGet](interfacehipfort_1_1hipdeviceget.html "Interface documentation") | C binding 20 | [hipDeviceComputeCapability](interfacehipfort_1_1hipdevicecomputecapability.html "Interface documentation") | C binding 21 | [hipDeviceGetName](interfacehipfort_1_1hipdevicegetname.html "Interface documentation") | C binding 22 | [hipDeviceGetUuid](interfacehipfort_1_1hipdevicegetuuid.html "Interface documentation") | C binding 23 | [hipDeviceGetP2PAttribute](interfacehipfort_1_1hipdevicegetp2pattribute.html "Interface documentation") | C binding 24 | [hipDeviceGetPCIBusId](interfacehipfort_1_1hipdevicegetpcibusid.html "Interface documentation") | C binding 25 | [hipDeviceGetByPCIBusId](interfacehipfort_1_1hipdevicegetbypcibusid.html "Interface documentation") | C binding 26 | [hipDeviceTotalMem](interfacehipfort_1_1hipdevicetotalmem.html "Interface documentation") | C binding 27 | [hipDeviceSynchronize](interfacehipfort_1_1hipdevicesynchronize.html "Interface documentation") | C binding 28 | [hipDeviceReset](interfacehipfort_1_1hipdevicereset.html "Interface documentation") | C binding 29 | [hipSetDevice](interfacehipfort_1_1hipsetdevice.html "Interface documentation") | C binding 30 | [hipSetValidDevices](interfacehipfort_1_1hipsetvaliddevices.html "Interface documentation") | C binding 31 | [hipGetDevice](interfacehipfort_1_1hipgetdevice.html "Interface documentation") | C binding 32 | [hipGetDeviceCount](interfacehipfort_1_1hipgetdevicecount.html "Interface documentation") | C binding 33 | [hipDeviceGetAttribute](interfacehipfort_1_1hipdevicegetattribute.html "Interface documentation") | C binding 34 | [hipDeviceGetDefaultMemPool](interfacehipfort_1_1hipdevicegetdefaultmempool.html "Interface documentation") | C binding 35 | [hipDeviceSetMemPool](interfacehipfort_1_1hipdevicesetmempool.html "Interface documentation") | C binding 36 | [hipDeviceGetMemPool](interfacehipfort_1_1hipdevicegetmempool.html "Interface documentation") | C binding 37 | [hipDeviceGetTexture1DLinearMaxWidth](interfacehipfort_1_1hipdevicegettexture1dlinearmaxwidth.html "Interface documentation") | C binding 38 | [hipDeviceSetCacheConfig](interfacehipfort_1_1hipdevicesetcacheconfig.html "Interface documentation") | C binding 39 | [hipDeviceGetCacheConfig](interfacehipfort_1_1hipdevicegetcacheconfig.html "Interface documentation") | C binding 40 | [hipDeviceGetLimit](interfacehipfort_1_1hipdevicegetlimit.html "Interface documentation") | C binding 41 | [hipDeviceSetLimit](interfacehipfort_1_1hipdevicesetlimit.html "Interface documentation") | C binding 42 | [hipDeviceGetSharedMemConfig](interfacehipfort_1_1hipdevicegetsharedmemconfig.html "Interface documentation") | C binding 43 | [hipGetDeviceFlags](interfacehipfort_1_1hipgetdeviceflags.html "Interface documentation") | C binding 44 | [hipDeviceSetSharedMemConfig](interfacehipfort_1_1hipdevicesetsharedmemconfig.html "Interface documentation") | C binding 45 | [hipSetDeviceFlags](interfacehipfort_1_1hipsetdeviceflags.html "Interface documentation") | C binding 46 | [hipChooseDeviceR0600](interfacehipfort_1_1hipchoosedevicer0600.html "Interface documentation") | C binding 47 | [hipExtGetLinkTypeAndHopCount](interfacehipfort_1_1hipextgetlinktypeandhopcount.html "Interface documentation") | C binding 48 | [hipIpcGetMemHandle](interfacehipfort_1_1hipipcgetmemhandle.html "Interface documentation") | C binding 49 | [hipIpcOpenMemHandle](interfacehipfort_1_1hipipcopenmemhandle.html "Interface documentation") | C binding 50 | [hipIpcCloseMemHandle](interfacehipfort_1_1hipipcclosememhandle.html "Interface documentation") | C binding 51 | [hipIpcGetEventHandle](interfacehipfort_1_1hipipcgeteventhandle.html "Interface documentation") | C binding 52 | [hipIpcOpenEventHandle](interfacehipfort_1_1hipipcopeneventhandle.html "Interface documentation") | C binding 53 | [hipFuncSetAttribute](interfacehipfort_1_1hipfuncsetattribute.html "Interface documentation") | C binding 54 | [hipKernelSetAttribute](interfacehipfort_1_1hipkernelsetattribute.html "Interface documentation") | C binding 55 | [hipKernelGetFunction](interfacehipfort_1_1hipkernelgetfunction.html "Interface documentation") | C binding 56 | [hipFuncSetCacheConfig](interfacehipfort_1_1hipfuncsetcacheconfig.html "Interface documentation") | C binding 57 | [hipFuncSetSharedMemConfig](interfacehipfort_1_1hipfuncsetsharedmemconfig.html "Interface documentation") | C binding 58 | [hipGetLastError](interfacehipfort_1_1hipgetlasterror.html "Interface documentation") | C binding 59 | [hipExtGetLastError](interfacehipfort_1_1hipextgetlasterror.html "Interface documentation") | C binding 60 | [hipPeekAtLastError](interfacehipfort_1_1hippeekatlasterror.html "Interface documentation") | C binding 61 | [hipGetErrorName](interfacehipfort_1_1hipgeterrorname.html "Interface documentation") | C binding 62 | [hipGetErrorString](interfacehipfort_1_1hipgeterrorstring.html "Interface documentation") | C binding 63 | [hipDrvGetErrorName](interfacehipfort_1_1hipdrvgeterrorname.html "Interface documentation") | C binding 64 | [hipDrvGetErrorString](interfacehipfort_1_1hipdrvgeterrorstring.html "Interface documentation") | C binding 65 | [hipStreamCreate](interfacehipfort_1_1hipstreamcreate.html "Interface documentation") | C binding 66 | [hipStreamCreateWithFlags](interfacehipfort_1_1hipstreamcreatewithflags.html "Interface documentation") | C binding 67 | [hipStreamCreateWithPriority](interfacehipfort_1_1hipstreamcreatewithpriority.html "Interface documentation") | C binding 68 | [hipDeviceGetStreamPriorityRange](interfacehipfort_1_1hipdevicegetstreampriorityrange.html "Interface documentation") | C binding 69 | [hipStreamDestroy](interfacehipfort_1_1hipstreamdestroy.html "Interface documentation") | C binding 70 | [hipStreamQuery](interfacehipfort_1_1hipstreamquery.html "Interface documentation") | C binding 71 | [hipStreamSynchronize](interfacehipfort_1_1hipstreamsynchronize.html "Interface documentation") | C binding 72 | [hipStreamWaitEvent](interfacehipfort_1_1hipstreamwaitevent.html "Interface documentation") | C binding 73 | [hipStreamGetFlags](interfacehipfort_1_1hipstreamgetflags.html "Interface documentation") | C binding 74 | [hipStreamGetId](interfacehipfort_1_1hipstreamgetid.html "Interface documentation") | C binding 75 | [hipStreamGetPriority](interfacehipfort_1_1hipstreamgetpriority.html "Interface documentation") | C binding 76 | [hipStreamGetDevice](interfacehipfort_1_1hipstreamgetdevice.html "Interface documentation") | C binding 77 | [hipExtStreamCreateWithCUMask](interfacehipfort_1_1hipextstreamcreatewithcumask.html "Interface documentation") | C binding 78 | [hipExtStreamGetCUMask](interfacehipfort_1_1hipextstreamgetcumask.html "Interface documentation") | C binding 79 | [hipStreamAddCallback](interfacehipfort_1_1hipstreamaddcallback.html "Interface documentation") | C binding 80 | [hipStreamSetAttribute](interfacehipfort_1_1hipstreamsetattribute.html "Interface documentation") | C binding 81 | [hipStreamGetAttribute](interfacehipfort_1_1hipstreamgetattribute.html "Interface documentation") | C binding 82 | [hipStreamCopyAttributes](interfacehipfort_1_1hipstreamcopyattributes.html "Interface documentation") | C binding 83 | [hipStreamWaitValue32](interfacehipfort_1_1hipstreamwaitvalue32.html "Interface documentation") | C binding 84 | [hipStreamWaitValue64](interfacehipfort_1_1hipstreamwaitvalue64.html "Interface documentation") | C binding 85 | [hipStreamWriteValue32](interfacehipfort_1_1hipstreamwritevalue32.html "Interface documentation") | C binding 86 | [hipStreamWriteValue64](interfacehipfort_1_1hipstreamwritevalue64.html "Interface documentation") | C binding 87 | [hipStreamBatchMemOp](interfacehipfort_1_1hipstreambatchmemop.html "Interface documentation") | C binding 88 | [hipGraphAddBatchMemOpNode](interfacehipfort_1_1hipgraphaddbatchmemopnode.html "Interface documentation") | C binding 89 | [hipGraphBatchMemOpNodeGetParams](interfacehipfort_1_1hipgraphbatchmemopnodegetparams.html "Interface documentation") | C binding 90 | [hipGraphBatchMemOpNodeSetParams](interfacehipfort_1_1hipgraphbatchmemopnodesetparams.html "Interface documentation") | C binding 91 | [hipGraphExecBatchMemOpNodeSetParams](interfacehipfort_1_1hipgraphexecbatchmemopnodesetparams.html "Interface documentation") | C binding 92 | [hipEventCreateWithFlags](interfacehipfort_1_1hipeventcreatewithflags.html "Interface documentation") | C binding 93 | [hipEventCreate](interfacehipfort_1_1hipeventcreate.html "Interface documentation") | C binding 94 | [hipEventRecordWithFlags](interfacehipfort_1_1hipeventrecordwithflags.html "Interface documentation") | C binding 95 | [hipEventRecord](interfacehipfort_1_1hipeventrecord.html "Interface documentation") | C binding 96 | [hipEventDestroy](interfacehipfort_1_1hipeventdestroy.html "Interface documentation") | C binding 97 | [hipEventSynchronize](interfacehipfort_1_1hipeventsynchronize.html "Interface documentation") | C binding 98 | [hipEventElapsedTime](interfacehipfort_1_1hipeventelapsedtime.html "Interface documentation") | C binding 99 | [hipEventQuery](interfacehipfort_1_1hipeventquery.html "Interface documentation") | C binding 100 | [hipPointerSetAttribute](interfacehipfort_1_1hippointersetattribute.html "Interface documentation") | C binding 101 | [hipPointerGetAttributes](interfacehipfort_1_1hippointergetattributes.html "Interface documentation") | C binding 102 | [hipPointerGetAttribute](interfacehipfort_1_1hippointergetattribute.html "Interface documentation") | C binding 103 | [hipDrvPointerGetAttributes](interfacehipfort_1_1hipdrvpointergetattributes.html "Interface documentation") | C binding 104 | [hipImportExternalSemaphore](interfacehipfort_1_1hipimportexternalsemaphore.html "Interface documentation") | C binding 105 | [hipSignalExternalSemaphoresAsync](interfacehipfort_1_1hipsignalexternalsemaphoresasync.html "Interface documentation") | C binding 106 | [hipWaitExternalSemaphoresAsync](interfacehipfort_1_1hipwaitexternalsemaphoresasync.html "Interface documentation") | C binding 107 | [hipDestroyExternalSemaphore](interfacehipfort_1_1hipdestroyexternalsemaphore.html "Interface documentation") | C binding 108 | [hipImportExternalMemory](interfacehipfort_1_1hipimportexternalmemory.html "Interface documentation") | C binding 109 | [hipExternalMemoryGetMappedBuffer](interfacehipfort_1_1hipexternalmemorygetmappedbuffer.html "Interface documentation") | C binding 110 | [hipDestroyExternalMemory](interfacehipfort_1_1hipdestroyexternalmemory.html "Interface documentation") | C binding 111 | [hipExternalMemoryGetMappedMipmappedArray](interfacehipfort_1_1hipexternalmemorygetmappedmipmappedarray.html "Interface documentation") | C binding 112 | [hipExtMallocWithFlags](interfacehipfort_1_1hipextmallocwithflags.html "Interface documentation") | C binding 113 | [hipMallocHost](interfacehipfort_1_1hipmallochost.html "Interface documentation") | C binding 114 | [hipMemAllocHost](interfacehipfort_1_1hipmemallochost.html "Interface documentation") | C binding 115 | [hipMemPrefetchAsync](interfacehipfort_1_1hipmemprefetchasync.html "Interface documentation") | C binding 116 | [hipMemPrefetchAsync_v2](interfacehipfort_1_1hipmemprefetchasync__v2.html "Interface documentation") | C binding 117 | [hipMemPrefetchBatchAsync](interfacehipfort_1_1hipmemprefetchbatchasync.html "Interface documentation") | C binding 118 | [hipMemDiscardBatchAsync](interfacehipfort_1_1hipmemdiscardbatchasync.html "Interface documentation") | C binding 119 | [hipDrvMemDiscardBatchAsync](interfacehipfort_1_1hipdrvmemdiscardbatchasync.html "Interface documentation") | C binding 120 | [hipMemDiscardAndPrefetchBatchAsync](interfacehipfort_1_1hipmemdiscardandprefetchbatchasync.html "Interface documentation") | C binding 121 | [hipDrvMemDiscardAndPrefetchBatchAsync](interfacehipfort_1_1hipdrvmemdiscardandprefetchbatchasync.html "Interface documentation") | C binding 122 | [hipMemAdvise](interfacehipfort_1_1hipmemadvise.html "Interface documentation") | C binding 123 | [hipMemAdvise_v2](interfacehipfort_1_1hipmemadvise__v2.html "Interface documentation") | C binding 124 | [hipMemRangeGetAttribute](interfacehipfort_1_1hipmemrangegetattribute.html "Interface documentation") | C binding 125 | [hipMemRangeGetAttributes](interfacehipfort_1_1hipmemrangegetattributes.html "Interface documentation") | C binding 126 | [hipStreamAttachMemAsync](interfacehipfort_1_1hipstreamattachmemasync.html "Interface documentation") | C binding 127 | [hipMallocAsync](interfacehipfort_1_1hipmallocasync.html "Interface documentation") | C binding 128 | [hipFreeAsync](interfacehipfort_1_1hipfreeasync.html "Interface documentation") | C binding 129 | [hipMemPoolTrimTo](interfacehipfort_1_1hipmempooltrimto.html "Interface documentation") | C binding 130 | [hipMemPoolSetAttribute](interfacehipfort_1_1hipmempoolsetattribute.html "Interface documentation") | C binding 131 | [hipMemPoolGetAttribute](interfacehipfort_1_1hipmempoolgetattribute.html "Interface documentation") | C binding 132 | [hipMemPoolSetAccess](interfacehipfort_1_1hipmempoolsetaccess.html "Interface documentation") | C binding 133 | [hipMemPoolGetAccess](interfacehipfort_1_1hipmempoolgetaccess.html "Interface documentation") | C binding 134 | [hipMemPoolCreate](interfacehipfort_1_1hipmempoolcreate.html "Interface documentation") | C binding 135 | [hipMemPoolDestroy](interfacehipfort_1_1hipmempooldestroy.html "Interface documentation") | C binding 136 | [hipMallocFromPoolAsync](interfacehipfort_1_1hipmallocfrompoolasync.html "Interface documentation") | C binding 137 | [hipMemPoolExportToShareableHandle](interfacehipfort_1_1hipmempoolexporttoshareablehandle.html "Interface documentation") | C binding 138 | [hipMemPoolImportFromShareableHandle](interfacehipfort_1_1hipmempoolimportfromshareablehandle.html "Interface documentation") | C binding 139 | [hipMemPoolExportPointer](interfacehipfort_1_1hipmempoolexportpointer.html "Interface documentation") | C binding 140 | [hipMemPoolImportPointer](interfacehipfort_1_1hipmempoolimportpointer.html "Interface documentation") | C binding 141 | [hipMemSetMemPool](interfacehipfort_1_1hipmemsetmempool.html "Interface documentation") | C binding 142 | [hipMemGetMemPool](interfacehipfort_1_1hipmemgetmempool.html "Interface documentation") | C binding 143 | [hipMemGetDefaultMemPool](interfacehipfort_1_1hipmemgetdefaultmempool.html "Interface documentation") | C binding 144 | [hipHostAlloc](interfacehipfort_1_1hiphostalloc.html "Interface documentation") | C binding 145 | [hipMallocPitch](interfacehipfort_1_1hipmallocpitch.html "Interface documentation") | C binding 146 | [hipMemAllocPitch](interfacehipfort_1_1hipmemallocpitch.html "Interface documentation") | C binding 147 | [hipFreeHost](interfacehipfort_1_1hipfreehost.html "Interface documentation") | C binding 148 | [hipMemcpyWithStream](interfacehipfort_1_1hipmemcpywithstream.html "Interface documentation") | C binding 149 | [hipMemcpyHtoD](interfacehipfort_1_1hipmemcpyhtod.html "Interface documentation") | C binding 150 | [hipMemcpyDtoH](interfacehipfort_1_1hipmemcpydtoh.html "Interface documentation") | C binding 151 | [hipMemcpyDtoD](interfacehipfort_1_1hipmemcpydtod.html "Interface documentation") | C binding 152 | [hipMemcpyAtoD](interfacehipfort_1_1hipmemcpyatod.html "Interface documentation") | C binding 153 | [hipMemcpyDtoA](interfacehipfort_1_1hipmemcpydtoa.html "Interface documentation") | C binding 154 | [hipMemcpyAtoA](interfacehipfort_1_1hipmemcpyatoa.html "Interface documentation") | C binding 155 | [hipMemcpyHtoDAsync](interfacehipfort_1_1hipmemcpyhtodasync.html "Interface documentation") | C binding 156 | [hipMemcpyDtoHAsync](interfacehipfort_1_1hipmemcpydtohasync.html "Interface documentation") | C binding 157 | [hipMemcpyDtoDAsync](interfacehipfort_1_1hipmemcpydtodasync.html "Interface documentation") | C binding 158 | [hipMemcpyAtoHAsync](interfacehipfort_1_1hipmemcpyatohasync.html "Interface documentation") | C binding 159 | [hipMemcpyHtoAAsync](interfacehipfort_1_1hipmemcpyhtoaasync.html "Interface documentation") | C binding 160 | [hipModuleGetGlobal](interfacehipfort_1_1hipmodulegetglobal.html "Interface documentation") | C binding 161 | [hipGetSymbolAddress](interfacehipfort_1_1hipgetsymboladdress.html "Interface documentation") | C binding 162 | [hipGetSymbolSize](interfacehipfort_1_1hipgetsymbolsize.html "Interface documentation") | C binding 163 | [hipGetProcAddress](interfacehipfort_1_1hipgetprocaddress.html "Interface documentation") | C binding 164 | [hipMemcpyToSymbol](interfacehipfort_1_1hipmemcpytosymbol.html "Interface documentation") | C binding 165 | [hipMemcpyToSymbolAsync](interfacehipfort_1_1hipmemcpytosymbolasync.html "Interface documentation") | C binding 166 | [hipMemcpyFromSymbol](interfacehipfort_1_1hipmemcpyfromsymbol.html "Interface documentation") | C binding 167 | [hipMemcpyFromSymbolAsync](interfacehipfort_1_1hipmemcpyfromsymbolasync.html "Interface documentation") | C binding 168 | [hipMemset](interfacehipfort_1_1hipmemset.html "Interface documentation") | C binding 169 | [hipMemsetD8](interfacehipfort_1_1hipmemsetd8.html "Interface documentation") | C binding 170 | [hipMemsetD8Async](interfacehipfort_1_1hipmemsetd8async.html "Interface documentation") | C binding 171 | [hipMemsetD16](interfacehipfort_1_1hipmemsetd16.html "Interface documentation") | C binding 172 | [hipMemsetD16Async](interfacehipfort_1_1hipmemsetd16async.html "Interface documentation") | C binding 173 | [hipMemsetD32](interfacehipfort_1_1hipmemsetd32.html "Interface documentation") | C binding 174 | [hipMemsetAsync](interfacehipfort_1_1hipmemsetasync.html "Interface documentation") | C binding 175 | [hipMemsetD32Async](interfacehipfort_1_1hipmemsetd32async.html "Interface documentation") | C binding 176 | [hipMemset2D](interfacehipfort_1_1hipmemset2d.html "Interface documentation") | C binding 177 | [hipMemset2DAsync](interfacehipfort_1_1hipmemset2dasync.html "Interface documentation") | C binding 178 | [hipMemset3D](interfacehipfort_1_1hipmemset3d.html "Interface documentation") | C binding 179 | [hipMemset3DAsync](interfacehipfort_1_1hipmemset3dasync.html "Interface documentation") | C binding 180 | [hipMemsetD2D8](interfacehipfort_1_1hipmemsetd2d8.html "Interface documentation") | C binding 181 | [hipMemsetD2D8Async](interfacehipfort_1_1hipmemsetd2d8async.html "Interface documentation") | C binding 182 | [hipMemsetD2D16](interfacehipfort_1_1hipmemsetd2d16.html "Interface documentation") | C binding 183 | [hipMemsetD2D16Async](interfacehipfort_1_1hipmemsetd2d16async.html "Interface documentation") | C binding 184 | [hipMemsetD2D32](interfacehipfort_1_1hipmemsetd2d32.html "Interface documentation") | C binding 185 | [hipMemsetD2D32Async](interfacehipfort_1_1hipmemsetd2d32async.html "Interface documentation") | C binding 186 | [hipMemGetInfo](interfacehipfort_1_1hipmemgetinfo.html "Interface documentation") | C binding 187 | [hipMemPtrGetInfo](interfacehipfort_1_1hipmemptrgetinfo.html "Interface documentation") | C binding 188 | [hipMallocArray](interfacehipfort_1_1hipmallocarray.html "Interface documentation") | C binding 189 | [hipArrayCreate](interfacehipfort_1_1hiparraycreate.html "Interface documentation") | C binding 190 | [hipArrayDestroy](interfacehipfort_1_1hiparraydestroy.html "Interface documentation") | C binding 191 | [hipArray3DCreate](interfacehipfort_1_1hiparray3dcreate.html "Interface documentation") | C binding 192 | [hipMalloc3D](interfacehipfort_1_1hipmalloc3d.html "Interface documentation") | C binding 193 | [hipFreeArray](interfacehipfort_1_1hipfreearray.html "Interface documentation") | C binding 194 | [hipMalloc3DArray](interfacehipfort_1_1hipmalloc3darray.html "Interface documentation") | C binding 195 | [hipArrayGetInfo](interfacehipfort_1_1hiparraygetinfo.html "Interface documentation") | C binding 196 | [hipArrayGetDescriptor](interfacehipfort_1_1hiparraygetdescriptor.html "Interface documentation") | C binding 197 | [hipArray3DGetDescriptor](interfacehipfort_1_1hiparray3dgetdescriptor.html "Interface documentation") | C binding 198 | [hipMemcpyParam2D](interfacehipfort_1_1hipmemcpyparam2d.html "Interface documentation") | C binding 199 | [hipMemcpyParam2DAsync](interfacehipfort_1_1hipmemcpyparam2dasync.html "Interface documentation") | C binding 200 | [hipMemcpy2DToArray](interfacehipfort_1_1hipmemcpy2dtoarray.html "Interface documentation") | C binding 201 | [hipMemcpy2DToArrayAsync](interfacehipfort_1_1hipmemcpy2dtoarrayasync.html "Interface documentation") | C binding 202 | [hipMemcpy2DArrayToArray](interfacehipfort_1_1hipmemcpy2darraytoarray.html "Interface documentation") | C binding 203 | [hipMemcpyToArray](interfacehipfort_1_1hipmemcpytoarray.html "Interface documentation") | C binding 204 | [hipMemcpyFromArray](interfacehipfort_1_1hipmemcpyfromarray.html "Interface documentation") | C binding 205 | [hipMemcpy2DFromArray](interfacehipfort_1_1hipmemcpy2dfromarray.html "Interface documentation") | C binding 206 | [hipMemcpy2DFromArrayAsync](interfacehipfort_1_1hipmemcpy2dfromarrayasync.html "Interface documentation") | C binding 207 | [hipMemcpyAtoH](interfacehipfort_1_1hipmemcpyatoh.html "Interface documentation") | C binding 208 | [hipMemcpyHtoA](interfacehipfort_1_1hipmemcpyhtoa.html "Interface documentation") | C binding 209 | [hipMemcpy3D](interfacehipfort_1_1hipmemcpy3d.html "Interface documentation") | C binding 210 | [hipMemcpy3DAsync](interfacehipfort_1_1hipmemcpy3dasync.html "Interface documentation") | C binding 211 | [hipDrvMemcpy3D](interfacehipfort_1_1hipdrvmemcpy3d.html "Interface documentation") | C binding 212 | [hipDrvMemcpy3DAsync](interfacehipfort_1_1hipdrvmemcpy3dasync.html "Interface documentation") | C binding 213 | [hipMemGetAddressRange](interfacehipfort_1_1hipmemgetaddressrange.html "Interface documentation") | C binding 214 | [hipMemcpyBatchAsync](interfacehipfort_1_1hipmemcpybatchasync.html "Interface documentation") | C binding 215 | [hipMemcpy3DBatchAsync](interfacehipfort_1_1hipmemcpy3dbatchasync.html "Interface documentation") | C binding 216 | [hipMemcpy3DPeer](interfacehipfort_1_1hipmemcpy3dpeer.html "Interface documentation") | C binding 217 | [hipMemcpy3DPeerAsync](interfacehipfort_1_1hipmemcpy3dpeerasync.html "Interface documentation") | C binding 218 | [hipMipmappedArrayGetMemoryRequirements](interfacehipfort_1_1hipmipmappedarraygetmemoryrequirements.html "Interface documentation") | C binding 219 | [hipDeviceCanAccessPeer](interfacehipfort_1_1hipdevicecanaccesspeer.html "Interface documentation") | C binding 220 | [hipDeviceEnablePeerAccess](interfacehipfort_1_1hipdeviceenablepeeraccess.html "Interface documentation") | C binding 221 | [hipDeviceDisablePeerAccess](interfacehipfort_1_1hipdevicedisablepeeraccess.html "Interface documentation") | C binding 222 | [hipMemcpyPeer](interfacehipfort_1_1hipmemcpypeer.html "Interface documentation") | C binding 223 | [hipMemcpyPeerAsync](interfacehipfort_1_1hipmemcpypeerasync.html "Interface documentation") | C binding 224 | [hipDeviceGetDevResource](interfacehipfort_1_1hipdevicegetdevresource.html "Interface documentation") | C binding 225 | [hipDevSmResourceSplitByCount](interfacehipfort_1_1hipdevsmresourcesplitbycount.html "Interface documentation") | C binding 226 | [hipDevSmResourceSplit](interfacehipfort_1_1hipdevsmresourcesplit.html "Interface documentation") | C binding 227 | [hipDevResourceGenerateDesc](interfacehipfort_1_1hipdevresourcegeneratedesc.html "Interface documentation") | C binding 228 | [hipGreenCtxCreate](interfacehipfort_1_1hipgreenctxcreate.html "Interface documentation") | C binding 229 | [hipExecutionCtxDestroy](interfacehipfort_1_1hipexecutionctxdestroy.html "Interface documentation") | C binding 230 | [hipDeviceGetExecutionCtx](interfacehipfort_1_1hipdevicegetexecutionctx.html "Interface documentation") | C binding 231 | [hipExecutionCtxStreamCreate](interfacehipfort_1_1hipexecutionctxstreamcreate.html "Interface documentation") | C binding 232 | [hipExecutionCtxGetDevResource](interfacehipfort_1_1hipexecutionctxgetdevresource.html "Interface documentation") | C binding 233 | [hipExecutionCtxGetDevice](interfacehipfort_1_1hipexecutionctxgetdevice.html "Interface documentation") | C binding 234 | [hipExecutionCtxGetId](interfacehipfort_1_1hipexecutionctxgetid.html "Interface documentation") | C binding 235 | [hipStreamGetDevResource](interfacehipfort_1_1hipstreamgetdevresource.html "Interface documentation") | C binding 236 | [hipExecutionCtxRecordEvent](interfacehipfort_1_1hipexecutionctxrecordevent.html "Interface documentation") | C binding 237 | [hipExecutionCtxSynchronize](interfacehipfort_1_1hipexecutionctxsynchronize.html "Interface documentation") | C binding 238 | [hipExecutionCtxWaitEvent](interfacehipfort_1_1hipexecutionctxwaitevent.html "Interface documentation") | C binding 239 | [hipCtxCreate](interfacehipfort_1_1hipctxcreate.html "Interface documentation") | C binding 240 | [hipCtxDestroy](interfacehipfort_1_1hipctxdestroy.html "Interface documentation") | C binding 241 | [hipCtxPopCurrent](interfacehipfort_1_1hipctxpopcurrent.html "Interface documentation") | C binding 242 | [hipCtxPushCurrent](interfacehipfort_1_1hipctxpushcurrent.html "Interface documentation") | C binding 243 | [hipCtxSetCurrent](interfacehipfort_1_1hipctxsetcurrent.html "Interface documentation") | C binding 244 | [hipCtxGetCurrent](interfacehipfort_1_1hipctxgetcurrent.html "Interface documentation") | C binding 245 | [hipCtxGetDevice](interfacehipfort_1_1hipctxgetdevice.html "Interface documentation") | C binding 246 | [hipCtxGetApiVersion](interfacehipfort_1_1hipctxgetapiversion.html "Interface documentation") | C binding 247 | [hipCtxGetCacheConfig](interfacehipfort_1_1hipctxgetcacheconfig.html "Interface documentation") | C binding 248 | [hipCtxSetCacheConfig](interfacehipfort_1_1hipctxsetcacheconfig.html "Interface documentation") | C binding 249 | [hipCtxSetSharedMemConfig](interfacehipfort_1_1hipctxsetsharedmemconfig.html "Interface documentation") | C binding 250 | [hipCtxGetSharedMemConfig](interfacehipfort_1_1hipctxgetsharedmemconfig.html "Interface documentation") | C binding 251 | [hipCtxSynchronize](interfacehipfort_1_1hipctxsynchronize.html "Interface documentation") | C binding 252 | [hipCtxGetFlags](interfacehipfort_1_1hipctxgetflags.html "Interface documentation") | C binding 253 | [hipCtxEnablePeerAccess](interfacehipfort_1_1hipctxenablepeeraccess.html "Interface documentation") | C binding 254 | [hipCtxDisablePeerAccess](interfacehipfort_1_1hipctxdisablepeeraccess.html "Interface documentation") | C binding 255 | [hipDevicePrimaryCtxGetState](interfacehipfort_1_1hipdeviceprimaryctxgetstate.html "Interface documentation") | C binding 256 | [hipDevicePrimaryCtxRelease](interfacehipfort_1_1hipdeviceprimaryctxrelease.html "Interface documentation") | C binding 257 | [hipDevicePrimaryCtxRetain](interfacehipfort_1_1hipdeviceprimaryctxretain.html "Interface documentation") | C binding 258 | [hipDevicePrimaryCtxReset](interfacehipfort_1_1hipdeviceprimaryctxreset.html "Interface documentation") | C binding 259 | [hipDevicePrimaryCtxSetFlags](interfacehipfort_1_1hipdeviceprimaryctxsetflags.html "Interface documentation") | C binding 260 | [hipModuleLoadFatBinary](interfacehipfort_1_1hipmoduleloadfatbinary.html "Interface documentation") | C binding 261 | [hipModuleLoad](interfacehipfort_1_1hipmoduleload.html "Interface documentation") | C binding 262 | [hipModuleUnload](interfacehipfort_1_1hipmoduleunload.html "Interface documentation") | C binding 263 | [hipModuleGetFunction](interfacehipfort_1_1hipmodulegetfunction.html "Interface documentation") | C binding 264 | [hipModuleGetFunctionCount](interfacehipfort_1_1hipmodulegetfunctioncount.html "Interface documentation") | C binding 265 | [hipKernelGetAttribute](interfacehipfort_1_1hipkernelgetattribute.html "Interface documentation") | C binding 266 | [hipLibraryLoadData](interfacehipfort_1_1hiplibraryloaddata.html "Interface documentation") | C binding 267 | [hipLibraryLoadFromFile](interfacehipfort_1_1hiplibraryloadfromfile.html "Interface documentation") | C binding 268 | [hipLibraryUnload](interfacehipfort_1_1hiplibraryunload.html "Interface documentation") | C binding 269 | [hipLibraryGetKernel](interfacehipfort_1_1hiplibrarygetkernel.html "Interface documentation") | C binding 270 | [hipLibraryGetKernelCount](interfacehipfort_1_1hiplibrarygetkernelcount.html "Interface documentation") | C binding 271 | [hipLibraryGetGlobal](interfacehipfort_1_1hiplibrarygetglobal.html "Interface documentation") | C binding 272 | [hipLibraryGetManaged](interfacehipfort_1_1hiplibrarygetmanaged.html "Interface documentation") | C binding 273 | [hipLibraryEnumerateKernels](interfacehipfort_1_1hiplibraryenumeratekernels.html "Interface documentation") | C binding 274 | [hipKernelGetLibrary](interfacehipfort_1_1hipkernelgetlibrary.html "Interface documentation") | C binding 275 | [hipKernelGetName](interfacehipfort_1_1hipkernelgetname.html "Interface documentation") | C binding 276 | [hipKernelGetParamInfo](interfacehipfort_1_1hipkernelgetparaminfo.html "Interface documentation") | C binding 277 | [hipFuncGetAttributes](interfacehipfort_1_1hipfuncgetattributes.html "Interface documentation") | C binding 278 | [hipFuncGetAttribute](interfacehipfort_1_1hipfuncgetattribute.html "Interface documentation") | C binding 279 | [hipGetFuncBySymbol](interfacehipfort_1_1hipgetfuncbysymbol.html "Interface documentation") | C binding 280 | [hipGetDriverEntryPoint](interfacehipfort_1_1hipgetdriverentrypoint.html "Interface documentation") | C binding 281 | [hipModuleGetTexRef](interfacehipfort_1_1hipmodulegettexref.html "Interface documentation") | C binding 282 | [hipModuleLoadData](interfacehipfort_1_1hipmoduleloaddata.html "Interface documentation") | C binding 283 | [hipModuleLoadDataEx](interfacehipfort_1_1hipmoduleloaddataex.html "Interface documentation") | C binding 284 | [hipLinkAddData](interfacehipfort_1_1hiplinkadddata.html "Interface documentation") | C binding 285 | [hipLinkAddFile](interfacehipfort_1_1hiplinkaddfile.html "Interface documentation") | C binding 286 | [hipLinkComplete](interfacehipfort_1_1hiplinkcomplete.html "Interface documentation") | C binding 287 | [hipLinkCreate](interfacehipfort_1_1hiplinkcreate.html "Interface documentation") | C binding 288 | [hipLinkDestroy](interfacehipfort_1_1hiplinkdestroy.html "Interface documentation") | C binding 289 | [hipModuleLaunchKernel](interfacehipfort_1_1hipmodulelaunchkernel.html "Interface documentation") | C binding 290 | [hipModuleLaunchCooperativeKernel](interfacehipfort_1_1hipmodulelaunchcooperativekernel.html "Interface documentation") | C binding 291 | [hipModuleLaunchCooperativeKernelMultiDevice](interfacehipfort_1_1hipmodulelaunchcooperativekernelmultidevice.html "Interface documentation") | C binding 292 | [hipLaunchCooperativeKernel](interfacehipfort_1_1hiplaunchcooperativekernel.html "Interface documentation") | C binding 293 | [hipLaunchCooperativeKernelMultiDevice](interfacehipfort_1_1hiplaunchcooperativekernelmultidevice.html "Interface documentation") | C binding 294 | [hipExtLaunchMultiKernelMultiDevice](interfacehipfort_1_1hipextlaunchmultikernelmultidevice.html "Interface documentation") | C binding 295 | [hipLaunchKernelExC](interfacehipfort_1_1hiplaunchkernelexc.html "Interface documentation") | C binding 296 | [hipDrvLaunchKernelEx](interfacehipfort_1_1hipdrvlaunchkernelex.html "Interface documentation") | C binding 297 | [hipMemGetHandleForAddressRange](interfacehipfort_1_1hipmemgethandleforaddressrange.html "Interface documentation") | C binding 298 | [hipModuleOccupancyMaxPotentialBlockSize](interfacehipfort_1_1hipmoduleoccupancymaxpotentialblocksize.html "Interface documentation") | C binding 299 | [hipModuleOccupancyMaxPotentialBlockSizeWithFlags](interfacehipfort_1_1hipmoduleoccupancymaxpotentialblocksizewithflags.html "Interface documentation") | C binding 300 | [hipModuleOccupancyMaxActiveBlocksPerMultiprocessor](interfacehipfort_1_1hipmoduleoccupancymaxactiveblockspermultiprocessor.html "Interface documentation") | C binding 301 | [hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags](interfacehipfort_1_1hipmoduleoccupancymaxactiveblockspermultiprocessorwithflags.html "Interface documentation") | C binding 302 | [hipOccupancyMaxActiveBlocksPerMultiprocessor](interfacehipfort_1_1hipoccupancymaxactiveblockspermultiprocessor.html "Interface documentation") | C binding 303 | [hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags](interfacehipfort_1_1hipoccupancymaxactiveblockspermultiprocessorwithflags.html "Interface documentation") | C binding 304 | [hipOccupancyMaxPotentialBlockSize](interfacehipfort_1_1hipoccupancymaxpotentialblocksize.html "Interface documentation") | C binding 305 | [hipOccupancyAvailableDynamicSMemPerBlock](interfacehipfort_1_1hipoccupancyavailabledynamicsmemperblock.html "Interface documentation") | C binding 306 | [hipOccupancyMaxActiveClusters](interfacehipfort_1_1hipoccupancymaxactiveclusters.html "Interface documentation") | C binding 307 | [hipOccupancyMaxPotentialClusterSize](interfacehipfort_1_1hipoccupancymaxpotentialclustersize.html "Interface documentation") | C binding 308 | [hipProfilerStart](interfacehipfort_1_1hipprofilerstart.html "Interface documentation") | C binding 309 | [hipProfilerStop](interfacehipfort_1_1hipprofilerstop.html "Interface documentation") | C binding 310 | [hipConfigureCall](interfacehipfort_1_1hipconfigurecall.html "Interface documentation") | C binding 311 | [hipSetupArgument](interfacehipfort_1_1hipsetupargument.html "Interface documentation") | C binding 312 | [hipLaunchByPtr](interfacehipfort_1_1hiplaunchbyptr.html "Interface documentation") | C binding 313 | [hipLaunchKernel](interfacehipfort_1_1hiplaunchkernel.html "Interface documentation") | C binding 314 | [hipLaunchHostFunc](interfacehipfort_1_1hiplaunchhostfunc.html "Interface documentation") | C binding 315 | [hipDrvMemcpy2DUnaligned](interfacehipfort_1_1hipdrvmemcpy2dunaligned.html "Interface documentation") | C binding 316 | [hipExtLaunchKernel](interfacehipfort_1_1hipextlaunchkernel.html "Interface documentation") | C binding 317 | [hipCreateTextureObject](interfacehipfort_1_1hipcreatetextureobject.html "Interface documentation") | C binding 318 | [hipDestroyTextureObject](interfacehipfort_1_1hipdestroytextureobject.html "Interface documentation") | C binding 319 | [hipGetChannelDesc](interfacehipfort_1_1hipgetchanneldesc.html "Interface documentation") | C binding 320 | [hipGetTextureObjectResourceDesc](interfacehipfort_1_1hipgettextureobjectresourcedesc.html "Interface documentation") | C binding 321 | [hipGetTextureObjectResourceViewDesc](interfacehipfort_1_1hipgettextureobjectresourceviewdesc.html "Interface documentation") | C binding 322 | [hipGetTextureObjectTextureDesc](interfacehipfort_1_1hipgettextureobjecttexturedesc.html "Interface documentation") | C binding 323 | [hipTexObjectCreate](interfacehipfort_1_1hiptexobjectcreate.html "Interface documentation") | C binding 324 | [hipTexObjectDestroy](interfacehipfort_1_1hiptexobjectdestroy.html "Interface documentation") | C binding 325 | [hipTexObjectGetResourceDesc](interfacehipfort_1_1hiptexobjectgetresourcedesc.html "Interface documentation") | C binding 326 | [hipTexObjectGetResourceViewDesc](interfacehipfort_1_1hiptexobjectgetresourceviewdesc.html "Interface documentation") | C binding 327 | [hipTexObjectGetTextureDesc](interfacehipfort_1_1hiptexobjectgettexturedesc.html "Interface documentation") | C binding 328 | [hipMallocMipmappedArray](interfacehipfort_1_1hipmallocmipmappedarray.html "Interface documentation") | C binding 329 | [hipFreeMipmappedArray](interfacehipfort_1_1hipfreemipmappedarray.html "Interface documentation") | C binding 330 | [hipGetMipmappedArrayLevel](interfacehipfort_1_1hipgetmipmappedarraylevel.html "Interface documentation") | C binding 331 | [hipMipmappedArrayCreate](interfacehipfort_1_1hipmipmappedarraycreate.html "Interface documentation") | C binding 332 | [hipMipmappedArrayDestroy](interfacehipfort_1_1hipmipmappedarraydestroy.html "Interface documentation") | C binding 333 | [hipMipmappedArrayGetLevel](interfacehipfort_1_1hipmipmappedarraygetlevel.html "Interface documentation") | C binding 334 | [hipBindTextureToMipmappedArray](interfacehipfort_1_1hipbindtexturetomipmappedarray.html "Interface documentation") | C binding 335 | [hipGetTextureReference](interfacehipfort_1_1hipgettexturereference.html "Interface documentation") | C binding 336 | [hipTexRefGetBorderColor](interfacehipfort_1_1hiptexrefgetbordercolor.html "Interface documentation") | C binding 337 | [hipTexRefGetArray](interfacehipfort_1_1hiptexrefgetarray.html "Interface documentation") | C binding 338 | [hipTexRefSetAddressMode](interfacehipfort_1_1hiptexrefsetaddressmode.html "Interface documentation") | C binding 339 | [hipTexRefSetArray](interfacehipfort_1_1hiptexrefsetarray.html "Interface documentation") | C binding 340 | [hipTexRefSetFilterMode](interfacehipfort_1_1hiptexrefsetfiltermode.html "Interface documentation") | C binding 341 | [hipTexRefSetFlags](interfacehipfort_1_1hiptexrefsetflags.html "Interface documentation") | C binding 342 | [hipTexRefSetFormat](interfacehipfort_1_1hiptexrefsetformat.html "Interface documentation") | C binding 343 | [hipBindTexture](interfacehipfort_1_1hipbindtexture.html "Interface documentation") | C binding 344 | [hipBindTexture2D](interfacehipfort_1_1hipbindtexture2d.html "Interface documentation") | C binding 345 | [hipBindTextureToArray](interfacehipfort_1_1hipbindtexturetoarray.html "Interface documentation") | C binding 346 | [hipGetTextureAlignmentOffset](interfacehipfort_1_1hipgettexturealignmentoffset.html "Interface documentation") | C binding 347 | [hipUnbindTexture](interfacehipfort_1_1hipunbindtexture.html "Interface documentation") | C binding 348 | [hipTexRefGetAddress](interfacehipfort_1_1hiptexrefgetaddress.html "Interface documentation") | C binding 349 | [hipTexRefGetAddressMode](interfacehipfort_1_1hiptexrefgetaddressmode.html "Interface documentation") | C binding 350 | [hipTexRefGetFilterMode](interfacehipfort_1_1hiptexrefgetfiltermode.html "Interface documentation") | C binding 351 | [hipTexRefGetFlags](interfacehipfort_1_1hiptexrefgetflags.html "Interface documentation") | C binding 352 | [hipTexRefGetFormat](interfacehipfort_1_1hiptexrefgetformat.html "Interface documentation") | C binding 353 | [hipTexRefGetMaxAnisotropy](interfacehipfort_1_1hiptexrefgetmaxanisotropy.html "Interface documentation") | C binding 354 | [hipTexRefGetMipmapFilterMode](interfacehipfort_1_1hiptexrefgetmipmapfiltermode.html "Interface documentation") | C binding 355 | [hipTexRefGetMipmapLevelBias](interfacehipfort_1_1hiptexrefgetmipmaplevelbias.html "Interface documentation") | C binding 356 | [hipTexRefGetMipmapLevelClamp](interfacehipfort_1_1hiptexrefgetmipmaplevelclamp.html "Interface documentation") | C binding 357 | [hipTexRefGetMipMappedArray](interfacehipfort_1_1hiptexrefgetmipmappedarray.html "Interface documentation") | C binding 358 | [hipTexRefSetAddress](interfacehipfort_1_1hiptexrefsetaddress.html "Interface documentation") | C binding 359 | [hipTexRefSetAddress2D](interfacehipfort_1_1hiptexrefsetaddress2d.html "Interface documentation") | C binding 360 | [hipTexRefSetMaxAnisotropy](interfacehipfort_1_1hiptexrefsetmaxanisotropy.html "Interface documentation") | C binding 361 | [hipTexRefSetBorderColor](interfacehipfort_1_1hiptexrefsetbordercolor.html "Interface documentation") | C binding 362 | [hipTexRefSetMipmapFilterMode](interfacehipfort_1_1hiptexrefsetmipmapfiltermode.html "Interface documentation") | C binding 363 | [hipTexRefSetMipmapLevelBias](interfacehipfort_1_1hiptexrefsetmipmaplevelbias.html "Interface documentation") | C binding 364 | [hipTexRefSetMipmapLevelClamp](interfacehipfort_1_1hiptexrefsetmipmaplevelclamp.html "Interface documentation") | C binding 365 | [hipTexRefSetMipmappedArray](interfacehipfort_1_1hiptexrefsetmipmappedarray.html "Interface documentation") | C binding 366 | [hipApiName](interfacehipfort_1_1hipapiname.html "Interface documentation") | C binding 367 | [hipKernelNameRef](interfacehipfort_1_1hipkernelnameref.html "Interface documentation") | C binding 368 | [hipKernelNameRefByPtr](interfacehipfort_1_1hipkernelnamerefbyptr.html "Interface documentation") | C binding 369 | [hipGetStreamDeviceId](interfacehipfort_1_1hipgetstreamdeviceid.html "Interface documentation") | C binding 370 | [hipStreamBeginCapture](interfacehipfort_1_1hipstreambegincapture.html "Interface documentation") | C binding 371 | [hipStreamBeginCaptureToGraph](interfacehipfort_1_1hipstreambegincapturetograph.html "Interface documentation") | C binding 372 | [hipStreamEndCapture](interfacehipfort_1_1hipstreamendcapture.html "Interface documentation") | C binding 373 | [hipStreamGetCaptureInfo](interfacehipfort_1_1hipstreamgetcaptureinfo.html "Interface documentation") | C binding 374 | [hipStreamGetCaptureInfo_v2](interfacehipfort_1_1hipstreamgetcaptureinfo__v2.html "Interface documentation") | C binding 375 | [hipStreamIsCapturing](interfacehipfort_1_1hipstreamiscapturing.html "Interface documentation") | C binding 376 | [hipStreamUpdateCaptureDependencies](interfacehipfort_1_1hipstreamupdatecapturedependencies.html "Interface documentation") | C binding 377 | [hipThreadExchangeStreamCaptureMode](interfacehipfort_1_1hipthreadexchangestreamcapturemode.html "Interface documentation") | C binding 378 | [hipGraphCreate](interfacehipfort_1_1hipgraphcreate.html "Interface documentation") | C binding 379 | [hipGraphDestroy](interfacehipfort_1_1hipgraphdestroy.html "Interface documentation") | C binding 380 | [hipGraphAddDependencies](interfacehipfort_1_1hipgraphadddependencies.html "Interface documentation") | C binding 381 | [hipGraphRemoveDependencies](interfacehipfort_1_1hipgraphremovedependencies.html "Interface documentation") | C binding 382 | [hipGraphGetEdges](interfacehipfort_1_1hipgraphgetedges.html "Interface documentation") | C binding 383 | [hipGraphGetNodes](interfacehipfort_1_1hipgraphgetnodes.html "Interface documentation") | C binding 384 | [hipGraphGetRootNodes](interfacehipfort_1_1hipgraphgetrootnodes.html "Interface documentation") | C binding 385 | [hipGraphNodeGetDependencies](interfacehipfort_1_1hipgraphnodegetdependencies.html "Interface documentation") | C binding 386 | [hipGraphNodeGetDependentNodes](interfacehipfort_1_1hipgraphnodegetdependentnodes.html "Interface documentation") | C binding 387 | [hipGraphNodeGetType](interfacehipfort_1_1hipgraphnodegettype.html "Interface documentation") | C binding 388 | [hipGraphDestroyNode](interfacehipfort_1_1hipgraphdestroynode.html "Interface documentation") | C binding 389 | [hipGraphClone](interfacehipfort_1_1hipgraphclone.html "Interface documentation") | C binding 390 | [hipGraphNodeFindInClone](interfacehipfort_1_1hipgraphnodefindinclone.html "Interface documentation") | C binding 391 | [hipGraphInstantiate](interfacehipfort_1_1hipgraphinstantiate.html "Interface documentation") | C binding 392 | [hipGraphInstantiateWithFlags](interfacehipfort_1_1hipgraphinstantiatewithflags.html "Interface documentation") | C binding 393 | [hipGraphInstantiateWithParams](interfacehipfort_1_1hipgraphinstantiatewithparams.html "Interface documentation") | C binding 394 | [hipGraphLaunch](interfacehipfort_1_1hipgraphlaunch.html "Interface documentation") | C binding 395 | [hipGraphUpload](interfacehipfort_1_1hipgraphupload.html "Interface documentation") | C binding 396 | [hipGraphAddNode](interfacehipfort_1_1hipgraphaddnode.html "Interface documentation") | C binding 397 | [hipGraphExecGetFlags](interfacehipfort_1_1hipgraphexecgetflags.html "Interface documentation") | C binding 398 | [hipGraphNodeSetParams](interfacehipfort_1_1hipgraphnodesetparams.html "Interface documentation") | C binding 399 | [hipGraphExecNodeSetParams](interfacehipfort_1_1hipgraphexecnodesetparams.html "Interface documentation") | C binding 400 | [hipGraphExecDestroy](interfacehipfort_1_1hipgraphexecdestroy.html "Interface documentation") | C binding 401 | [hipGraphExecUpdate](interfacehipfort_1_1hipgraphexecupdate.html "Interface documentation") | C binding 402 | [hipGraphAddKernelNode](interfacehipfort_1_1hipgraphaddkernelnode.html "Interface documentation") | C binding 403 | [hipGraphKernelNodeGetParams](interfacehipfort_1_1hipgraphkernelnodegetparams.html "Interface documentation") | C binding 404 | [hipGraphKernelNodeSetParams](interfacehipfort_1_1hipgraphkernelnodesetparams.html "Interface documentation") | C binding 405 | [hipGraphExecKernelNodeSetParams](interfacehipfort_1_1hipgraphexeckernelnodesetparams.html "Interface documentation") | C binding 406 | [hipDrvGraphAddMemcpyNode](interfacehipfort_1_1hipdrvgraphaddmemcpynode.html "Interface documentation") | C binding 407 | [hipGraphAddMemcpyNode](interfacehipfort_1_1hipgraphaddmemcpynode.html "Interface documentation") | C binding 408 | [hipGraphMemcpyNodeGetParams](interfacehipfort_1_1hipgraphmemcpynodegetparams.html "Interface documentation") | C binding 409 | [hipGraphMemcpyNodeSetParams](interfacehipfort_1_1hipgraphmemcpynodesetparams.html "Interface documentation") | C binding 410 | [hipGraphKernelNodeSetAttribute](interfacehipfort_1_1hipgraphkernelnodesetattribute.html "Interface documentation") | C binding 411 | [hipGraphKernelNodeGetAttribute](interfacehipfort_1_1hipgraphkernelnodegetattribute.html "Interface documentation") | C binding 412 | [hipGraphExecMemcpyNodeSetParams](interfacehipfort_1_1hipgraphexecmemcpynodesetparams.html "Interface documentation") | C binding 413 | [hipGraphAddMemcpyNode1D](interfacehipfort_1_1hipgraphaddmemcpynode1d.html "Interface documentation") | C binding 414 | [hipGraphMemcpyNodeSetParams1D](interfacehipfort_1_1hipgraphmemcpynodesetparams1d.html "Interface documentation") | C binding 415 | [hipGraphExecMemcpyNodeSetParams1D](interfacehipfort_1_1hipgraphexecmemcpynodesetparams1d.html "Interface documentation") | C binding 416 | [hipGraphAddMemcpyNodeFromSymbol](interfacehipfort_1_1hipgraphaddmemcpynodefromsymbol.html "Interface documentation") | C binding 417 | [hipGraphMemcpyNodeSetParamsFromSymbol](interfacehipfort_1_1hipgraphmemcpynodesetparamsfromsymbol.html "Interface documentation") | C binding 418 | [hipGraphExecMemcpyNodeSetParamsFromSymbol](interfacehipfort_1_1hipgraphexecmemcpynodesetparamsfromsymbol.html "Interface documentation") | C binding 419 | [hipGraphAddMemcpyNodeToSymbol](interfacehipfort_1_1hipgraphaddmemcpynodetosymbol.html "Interface documentation") | C binding 420 | [hipGraphMemcpyNodeSetParamsToSymbol](interfacehipfort_1_1hipgraphmemcpynodesetparamstosymbol.html "Interface documentation") | C binding 421 | [hipGraphExecMemcpyNodeSetParamsToSymbol](interfacehipfort_1_1hipgraphexecmemcpynodesetparamstosymbol.html "Interface documentation") | C binding 422 | [hipGraphAddMemsetNode](interfacehipfort_1_1hipgraphaddmemsetnode.html "Interface documentation") | C binding 423 | [hipGraphMemsetNodeGetParams](interfacehipfort_1_1hipgraphmemsetnodegetparams.html "Interface documentation") | C binding 424 | [hipGraphMemsetNodeSetParams](interfacehipfort_1_1hipgraphmemsetnodesetparams.html "Interface documentation") | C binding 425 | [hipGraphExecMemsetNodeSetParams](interfacehipfort_1_1hipgraphexecmemsetnodesetparams.html "Interface documentation") | C binding 426 | [hipGraphAddHostNode](interfacehipfort_1_1hipgraphaddhostnode.html "Interface documentation") | C binding 427 | [hipGraphHostNodeGetParams](interfacehipfort_1_1hipgraphhostnodegetparams.html "Interface documentation") | C binding 428 | [hipGraphHostNodeSetParams](interfacehipfort_1_1hipgraphhostnodesetparams.html "Interface documentation") | C binding 429 | [hipGraphExecHostNodeSetParams](interfacehipfort_1_1hipgraphexechostnodesetparams.html "Interface documentation") | C binding 430 | [hipGraphAddChildGraphNode](interfacehipfort_1_1hipgraphaddchildgraphnode.html "Interface documentation") | C binding 431 | [hipGraphChildGraphNodeGetGraph](interfacehipfort_1_1hipgraphchildgraphnodegetgraph.html "Interface documentation") | C binding 432 | [hipGraphExecChildGraphNodeSetParams](interfacehipfort_1_1hipgraphexecchildgraphnodesetparams.html "Interface documentation") | C binding 433 | [hipGraphAddEmptyNode](interfacehipfort_1_1hipgraphaddemptynode.html "Interface documentation") | C binding 434 | [hipGraphAddEventRecordNode](interfacehipfort_1_1hipgraphaddeventrecordnode.html "Interface documentation") | C binding 435 | [hipGraphEventRecordNodeGetEvent](interfacehipfort_1_1hipgrapheventrecordnodegetevent.html "Interface documentation") | C binding 436 | [hipGraphEventRecordNodeSetEvent](interfacehipfort_1_1hipgrapheventrecordnodesetevent.html "Interface documentation") | C binding 437 | [hipGraphExecEventRecordNodeSetEvent](interfacehipfort_1_1hipgraphexeceventrecordnodesetevent.html "Interface documentation") | C binding 438 | [hipGraphAddEventWaitNode](interfacehipfort_1_1hipgraphaddeventwaitnode.html "Interface documentation") | C binding 439 | [hipGraphEventWaitNodeGetEvent](interfacehipfort_1_1hipgrapheventwaitnodegetevent.html "Interface documentation") | C binding 440 | [hipGraphEventWaitNodeSetEvent](interfacehipfort_1_1hipgrapheventwaitnodesetevent.html "Interface documentation") | C binding 441 | [hipGraphExecEventWaitNodeSetEvent](interfacehipfort_1_1hipgraphexeceventwaitnodesetevent.html "Interface documentation") | C binding 442 | [hipGraphAddMemAllocNode](interfacehipfort_1_1hipgraphaddmemallocnode.html "Interface documentation") | C binding 443 | [hipGraphMemAllocNodeGetParams](interfacehipfort_1_1hipgraphmemallocnodegetparams.html "Interface documentation") | C binding 444 | [hipGraphAddMemFreeNode](interfacehipfort_1_1hipgraphaddmemfreenode.html "Interface documentation") | C binding 445 | [hipGraphMemFreeNodeGetParams](interfacehipfort_1_1hipgraphmemfreenodegetparams.html "Interface documentation") | C binding 446 | [hipDeviceGetGraphMemAttribute](interfacehipfort_1_1hipdevicegetgraphmemattribute.html "Interface documentation") | C binding 447 | [hipDeviceSetGraphMemAttribute](interfacehipfort_1_1hipdevicesetgraphmemattribute.html "Interface documentation") | C binding 448 | [hipDeviceGraphMemTrim](interfacehipfort_1_1hipdevicegraphmemtrim.html "Interface documentation") | C binding 449 | [hipUserObjectCreate](interfacehipfort_1_1hipuserobjectcreate.html "Interface documentation") | C binding 450 | [hipUserObjectRelease](interfacehipfort_1_1hipuserobjectrelease.html "Interface documentation") | C binding 451 | [hipUserObjectRetain](interfacehipfort_1_1hipuserobjectretain.html "Interface documentation") | C binding 452 | [hipGraphRetainUserObject](interfacehipfort_1_1hipgraphretainuserobject.html "Interface documentation") | C binding 453 | [hipGraphReleaseUserObject](interfacehipfort_1_1hipgraphreleaseuserobject.html "Interface documentation") | C binding 454 | [hipGraphDebugDotPrint](interfacehipfort_1_1hipgraphdebugdotprint.html "Interface documentation") | C binding 455 | [hipGraphKernelNodeCopyAttributes](interfacehipfort_1_1hipgraphkernelnodecopyattributes.html "Interface documentation") | C binding 456 | [hipGraphNodeSetEnabled](interfacehipfort_1_1hipgraphnodesetenabled.html "Interface documentation") | C binding 457 | [hipGraphNodeGetEnabled](interfacehipfort_1_1hipgraphnodegetenabled.html "Interface documentation") | C binding 458 | [hipGraphAddExternalSemaphoresWaitNode](interfacehipfort_1_1hipgraphaddexternalsemaphoreswaitnode.html "Interface documentation") | C binding 459 | [hipGraphAddExternalSemaphoresSignalNode](interfacehipfort_1_1hipgraphaddexternalsemaphoressignalnode.html "Interface documentation") | C binding 460 | [hipGraphExternalSemaphoresSignalNodeSetParams](interfacehipfort_1_1hipgraphexternalsemaphoressignalnodesetparams.html "Interface documentation") | C binding 461 | [hipGraphExternalSemaphoresWaitNodeSetParams](interfacehipfort_1_1hipgraphexternalsemaphoreswaitnodesetparams.html "Interface documentation") | C binding 462 | [hipGraphExternalSemaphoresSignalNodeGetParams](interfacehipfort_1_1hipgraphexternalsemaphoressignalnodegetparams.html "Interface documentation") | C binding 463 | [hipGraphExternalSemaphoresWaitNodeGetParams](interfacehipfort_1_1hipgraphexternalsemaphoreswaitnodegetparams.html "Interface documentation") | C binding 464 | [hipGraphExecExternalSemaphoresSignalNodeSetParams](interfacehipfort_1_1hipgraphexecexternalsemaphoressignalnodesetparams.html "Interface documentation") | C binding 465 | [hipGraphExecExternalSemaphoresWaitNodeSetParams](interfacehipfort_1_1hipgraphexecexternalsemaphoreswaitnodesetparams.html "Interface documentation") | C binding 466 | [hipDrvGraphMemcpyNodeGetParams](interfacehipfort_1_1hipdrvgraphmemcpynodegetparams.html "Interface documentation") | C binding 467 | [hipDrvGraphMemcpyNodeSetParams](interfacehipfort_1_1hipdrvgraphmemcpynodesetparams.html "Interface documentation") | C binding 468 | [hipDrvGraphAddMemsetNode](interfacehipfort_1_1hipdrvgraphaddmemsetnode.html "Interface documentation") | C binding 469 | [hipDrvGraphAddMemFreeNode](interfacehipfort_1_1hipdrvgraphaddmemfreenode.html "Interface documentation") | C binding 470 | [hipDrvGraphExecMemcpyNodeSetParams](interfacehipfort_1_1hipdrvgraphexecmemcpynodesetparams.html "Interface documentation") | C binding 471 | [hipDrvGraphExecMemsetNodeSetParams](interfacehipfort_1_1hipdrvgraphexecmemsetnodesetparams.html "Interface documentation") | C binding 472 | [hipMemAddressFree](interfacehipfort_1_1hipmemaddressfree.html "Interface documentation") | C binding 473 | [hipMemAddressReserve](interfacehipfort_1_1hipmemaddressreserve.html "Interface documentation") | C binding 474 | [hipMemCreate](interfacehipfort_1_1hipmemcreate.html "Interface documentation") | C binding 475 | [hipMemExportToShareableHandle](interfacehipfort_1_1hipmemexporttoshareablehandle.html "Interface documentation") | C binding 476 | [hipMemGetAccess](interfacehipfort_1_1hipmemgetaccess.html "Interface documentation") | C binding 477 | [hipMemGetAllocationGranularity](interfacehipfort_1_1hipmemgetallocationgranularity.html "Interface documentation") | C binding 478 | [hipMemGetAllocationPropertiesFromHandle](interfacehipfort_1_1hipmemgetallocationpropertiesfromhandle.html "Interface documentation") | C binding 479 | [hipMemImportFromShareableHandle](interfacehipfort_1_1hipmemimportfromshareablehandle.html "Interface documentation") | C binding 480 | [hipMemMap](interfacehipfort_1_1hipmemmap.html "Interface documentation") | C binding 481 | [hipMemMapArrayAsync](interfacehipfort_1_1hipmemmaparrayasync.html "Interface documentation") | C binding 482 | [hipMemRelease](interfacehipfort_1_1hipmemrelease.html "Interface documentation") | C binding 483 | [hipMemRetainAllocationHandle](interfacehipfort_1_1hipmemretainallocationhandle.html "Interface documentation") | C binding 484 | [hipMemSetAccess](interfacehipfort_1_1hipmemsetaccess.html "Interface documentation") | C binding 485 | [hipMemUnmap](interfacehipfort_1_1hipmemunmap.html "Interface documentation") | C binding 486 | [hipGraphicsMapResources](interfacehipfort_1_1hipgraphicsmapresources.html "Interface documentation") | C binding 487 | [hipGraphicsSubResourceGetMappedArray](interfacehipfort_1_1hipgraphicssubresourcegetmappedarray.html "Interface documentation") | C binding 488 | [hipGraphicsResourceGetMappedPointer](interfacehipfort_1_1hipgraphicsresourcegetmappedpointer.html "Interface documentation") | C binding 489 | [hipGraphicsUnmapResources](interfacehipfort_1_1hipgraphicsunmapresources.html "Interface documentation") | C binding 490 | [hipGraphicsUnregisterResource](interfacehipfort_1_1hipgraphicsunregisterresource.html "Interface documentation") | C binding 491 | [hipCreateSurfaceObject](interfacehipfort_1_1hipcreatesurfaceobject.html "Interface documentation") | C binding 492 | [hipDestroySurfaceObject](interfacehipfort_1_1hipdestroysurfaceobject.html "Interface documentation") | C binding 493 | [hipExtEnableLogging](interfacehipfort_1_1hipextenablelogging.html "Interface documentation") | C binding 494 | [hipExtDisableLogging](interfacehipfort_1_1hipextdisablelogging.html "Interface documentation") | C binding 495 | [hipExtSetLoggingParams](interfacehipfort_1_1hipextsetloggingparams.html "Interface documentation") | C binding 496 | [hipMemcpy_spt](interfacehipfort_1_1hipmemcpy__spt.html "Interface documentation") | C binding 497 | [hipMemcpyToSymbol_spt](interfacehipfort_1_1hipmemcpytosymbol__spt.html "Interface documentation") | C binding 498 | [hipMemcpyFromSymbol_spt](interfacehipfort_1_1hipmemcpyfromsymbol__spt.html "Interface documentation") | C binding 499 | [hipMemcpy2D_spt](interfacehipfort_1_1hipmemcpy2d__spt.html "Interface documentation") | C binding 500 | [hipMemcpy2DFromArray_spt](interfacehipfort_1_1hipmemcpy2dfromarray__spt.html "Interface documentation") | C binding 501 | [hipMemcpy3D_spt](interfacehipfort_1_1hipmemcpy3d__spt.html "Interface documentation") | C binding 502 | [hipMemset_spt](interfacehipfort_1_1hipmemset__spt.html "Interface documentation") | C binding 503 | [hipMemsetAsync_spt](interfacehipfort_1_1hipmemsetasync__spt.html "Interface documentation") | C binding 504 | [hipMemset2D_spt](interfacehipfort_1_1hipmemset2d__spt.html "Interface documentation") | C binding 505 | [hipMemset2DAsync_spt](interfacehipfort_1_1hipmemset2dasync__spt.html "Interface documentation") | C binding 506 | [hipMemset3DAsync_spt](interfacehipfort_1_1hipmemset3dasync__spt.html "Interface documentation") | C binding 507 | [hipMemset3D_spt](interfacehipfort_1_1hipmemset3d__spt.html "Interface documentation") | C binding 508 | [hipMemcpyAsync_spt](interfacehipfort_1_1hipmemcpyasync__spt.html "Interface documentation") | C binding 509 | [hipMemcpy3DAsync_spt](interfacehipfort_1_1hipmemcpy3dasync__spt.html "Interface documentation") | C binding 510 | [hipMemcpy2DAsync_spt](interfacehipfort_1_1hipmemcpy2dasync__spt.html "Interface documentation") | C binding 511 | [hipMemcpyFromSymbolAsync_spt](interfacehipfort_1_1hipmemcpyfromsymbolasync__spt.html "Interface documentation") | C binding 512 | [hipMemcpyToSymbolAsync_spt](interfacehipfort_1_1hipmemcpytosymbolasync__spt.html "Interface documentation") | C binding 513 | [hipMemcpyFromArray_spt](interfacehipfort_1_1hipmemcpyfromarray__spt.html "Interface documentation") | C binding 514 | [hipMemcpy2DToArray_spt](interfacehipfort_1_1hipmemcpy2dtoarray__spt.html "Interface documentation") | C binding 515 | [hipMemcpy2DFromArrayAsync_spt](interfacehipfort_1_1hipmemcpy2dfromarrayasync__spt.html "Interface documentation") | C binding 516 | [hipMemcpy2DToArrayAsync_spt](interfacehipfort_1_1hipmemcpy2dtoarrayasync__spt.html "Interface documentation") | C binding 517 | [hipStreamQuery_spt](interfacehipfort_1_1hipstreamquery__spt.html "Interface documentation") | C binding 518 | [hipStreamSynchronize_spt](interfacehipfort_1_1hipstreamsynchronize__spt.html "Interface documentation") | C binding 519 | [hipStreamGetPriority_spt](interfacehipfort_1_1hipstreamgetpriority__spt.html "Interface documentation") | C binding 520 | [hipStreamWaitEvent_spt](interfacehipfort_1_1hipstreamwaitevent__spt.html "Interface documentation") | C binding 521 | [hipStreamGetFlags_spt](interfacehipfort_1_1hipstreamgetflags__spt.html "Interface documentation") | C binding 522 | [hipStreamAddCallback_spt](interfacehipfort_1_1hipstreamaddcallback__spt.html "Interface documentation") | C binding 523 | [hipEventRecord_spt](interfacehipfort_1_1hipeventrecord__spt.html "Interface documentation") | C binding 524 | [hipLaunchCooperativeKernel_spt](interfacehipfort_1_1hiplaunchcooperativekernel__spt.html "Interface documentation") | C binding 525 | [hipLaunchKernel_spt](interfacehipfort_1_1hiplaunchkernel__spt.html "Interface documentation") | C binding 526 | [hipGraphLaunch_spt](interfacehipfort_1_1hipgraphlaunch__spt.html "Interface documentation") | C binding 527 | [hipStreamBeginCapture_spt](interfacehipfort_1_1hipstreambegincapture__spt.html "Interface documentation") | C binding 528 | [hipStreamEndCapture_spt](interfacehipfort_1_1hipstreamendcapture__spt.html "Interface documentation") | C binding 529 | [hipStreamIsCapturing_spt](interfacehipfort_1_1hipstreamiscapturing__spt.html "Interface documentation") | C binding 530 | [hipStreamGetCaptureInfo_spt](interfacehipfort_1_1hipstreamgetcaptureinfo__spt.html "Interface documentation") | C binding 531 | [hipStreamGetCaptureInfo_v2_spt](interfacehipfort_1_1hipstreamgetcaptureinfo__v2__spt.html "Interface documentation") | C binding 532 | [hipLaunchHostFunc_spt](interfacehipfort_1_1hiplaunchhostfunc__spt.html "Interface documentation") | C binding 533 | [hipGetDriverEntryPoint_spt](interfacehipfort_1_1hipgetdriverentrypoint__spt.html "Interface documentation") | C binding 534 | [hipGetProcAddress_spt](interfacehipfort_1_1hipgetprocaddress__spt.html "Interface documentation") | C binding 535 | [hipChooseDevice](interfacehipfort_1_1hipchoosedevice.html "Interface documentation") | C binding hipfort-rocm-10.0.0/docs/doxygen/input/supported_api_hipblas.md000066400000000000000000004765341524740623400247010ustar00rootroot00000000000000# hipBLAS API support \# | API Name | Variants ----|---------------|--------- 1 | [hipblasCreate](interfacehipfort__hipblas_1_1hipblascreate.html "Interface documentation") | C binding 2 | [hipblasDestroy](interfacehipfort__hipblas_1_1hipblasdestroy.html "Interface documentation") | C binding 3 | [hipblasGetVersion](interfacehipfort__hipblas_1_1hipblasgetversion.html "Interface documentation") | C binding 4 | [hipblasGetProperty](interfacehipfort__hipblas_1_1hipblasgetproperty.html "Interface documentation") | C binding 5 | [hipblasSetStream](interfacehipfort__hipblas_1_1hipblassetstream.html "Interface documentation") | C binding 6 | [hipblasGetStream](interfacehipfort__hipblas_1_1hipblasgetstream.html "Interface documentation") | C binding 7 | [hipblasSetPointerMode](interfacehipfort__hipblas_1_1hipblassetpointermode.html "Interface documentation") | C binding 8 | [hipblasGetPointerMode](interfacehipfort__hipblas_1_1hipblasgetpointermode.html "Interface documentation") | C binding 9 | [hipblasSetMathMode](interfacehipfort__hipblas_1_1hipblassetmathmode.html "Interface documentation") | C binding 10 | [hipblasGetMathMode](interfacehipfort__hipblas_1_1hipblasgetmathmode.html "Interface documentation") | C binding 11 | [hipblasSetWorkspace](interfacehipfort__hipblas_1_1hipblassetworkspace.html "Interface documentation") | C binding 12 | [hipblasSetAtomicsMode](interfacehipfort__hipblas_1_1hipblassetatomicsmode.html "Interface documentation") | C binding 13 | [hipblasGetAtomicsMode](interfacehipfort__hipblas_1_1hipblasgetatomicsmode.html "Interface documentation") | C binding 14 | [hipblasSetBatchAlphaStride](interfacehipfort__hipblas_1_1hipblassetbatchalphastride.html "Interface documentation") | C binding 15 | [hipblasGetBatchAlphaStride](interfacehipfort__hipblas_1_1hipblasgetbatchalphastride.html "Interface documentation") | C binding 16 | [hipblasSetBatchBetaStride](interfacehipfort__hipblas_1_1hipblassetbatchbetastride.html "Interface documentation") | C binding 17 | [hipblasGetBatchBetaStride](interfacehipfort__hipblas_1_1hipblasgetbatchbetastride.html "Interface documentation") | C binding 18 | [hipblasIsamax](interfacehipfort__hipblas_1_1hipblasisamax.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 19 | [hipblasIdamax](interfacehipfort__hipblas_1_1hipblasidamax.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 20 | [hipblasIcamax](interfacehipfort__hipblas_1_1hipblasicamax.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 21 | [hipblasIzamax](interfacehipfort__hipblas_1_1hipblasizamax.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 22 | [hipblasIsamax_64](interfacehipfort__hipblas_1_1hipblasisamax__64.html "Interface documentation") | C binding 23 | [hipblasIdamax_64](interfacehipfort__hipblas_1_1hipblasidamax__64.html "Interface documentation") | C binding 24 | [hipblasIcamax_64](interfacehipfort__hipblas_1_1hipblasicamax__64.html "Interface documentation") | C binding 25 | [hipblasIzamax_64](interfacehipfort__hipblas_1_1hipblasizamax__64.html "Interface documentation") | C binding 26 | [hipblasIsamaxBatched](interfacehipfort__hipblas_1_1hipblasisamaxbatched.html "Interface documentation") | C binding 27 | [hipblasIdamaxBatched](interfacehipfort__hipblas_1_1hipblasidamaxbatched.html "Interface documentation") | C binding 28 | [hipblasIcamaxBatched](interfacehipfort__hipblas_1_1hipblasicamaxbatched.html "Interface documentation") | C binding 29 | [hipblasIzamaxBatched](interfacehipfort__hipblas_1_1hipblasizamaxbatched.html "Interface documentation") | C binding 30 | [hipblasIsamaxBatched_64](interfacehipfort__hipblas_1_1hipblasisamaxbatched__64.html "Interface documentation") | C binding 31 | [hipblasIdamaxBatched_64](interfacehipfort__hipblas_1_1hipblasidamaxbatched__64.html "Interface documentation") | C binding 32 | [hipblasIcamaxBatched_64](interfacehipfort__hipblas_1_1hipblasicamaxbatched__64.html "Interface documentation") | C binding 33 | [hipblasIzamaxBatched_64](interfacehipfort__hipblas_1_1hipblasizamaxbatched__64.html "Interface documentation") | C binding 34 | [hipblasIsamaxStridedBatched](interfacehipfort__hipblas_1_1hipblasisamaxstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 35 | [hipblasIdamaxStridedBatched](interfacehipfort__hipblas_1_1hipblasidamaxstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 36 | [hipblasIcamaxStridedBatched](interfacehipfort__hipblas_1_1hipblasicamaxstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 37 | [hipblasIzamaxStridedBatched](interfacehipfort__hipblas_1_1hipblasizamaxstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 38 | [hipblasIsamaxStridedBatched_64](interfacehipfort__hipblas_1_1hipblasisamaxstridedbatched__64.html "Interface documentation") | C binding 39 | [hipblasIdamaxStridedBatched_64](interfacehipfort__hipblas_1_1hipblasidamaxstridedbatched__64.html "Interface documentation") | C binding 40 | [hipblasIcamaxStridedBatched_64](interfacehipfort__hipblas_1_1hipblasicamaxstridedbatched__64.html "Interface documentation") | C binding 41 | [hipblasIzamaxStridedBatched_64](interfacehipfort__hipblas_1_1hipblasizamaxstridedbatched__64.html "Interface documentation") | C binding 42 | [hipblasIsamin](interfacehipfort__hipblas_1_1hipblasisamin.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 43 | [hipblasIdamin](interfacehipfort__hipblas_1_1hipblasidamin.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 44 | [hipblasIcamin](interfacehipfort__hipblas_1_1hipblasicamin.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 45 | [hipblasIzamin](interfacehipfort__hipblas_1_1hipblasizamin.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 46 | [hipblasIsamin_64](interfacehipfort__hipblas_1_1hipblasisamin__64.html "Interface documentation") | C binding 47 | [hipblasIdamin_64](interfacehipfort__hipblas_1_1hipblasidamin__64.html "Interface documentation") | C binding 48 | [hipblasIcamin_64](interfacehipfort__hipblas_1_1hipblasicamin__64.html "Interface documentation") | C binding 49 | [hipblasIzamin_64](interfacehipfort__hipblas_1_1hipblasizamin__64.html "Interface documentation") | C binding 50 | [hipblasIsaminBatched](interfacehipfort__hipblas_1_1hipblasisaminbatched.html "Interface documentation") | C binding 51 | [hipblasIdaminBatched](interfacehipfort__hipblas_1_1hipblasidaminbatched.html "Interface documentation") | C binding 52 | [hipblasIcaminBatched](interfacehipfort__hipblas_1_1hipblasicaminbatched.html "Interface documentation") | C binding 53 | [hipblasIzaminBatched](interfacehipfort__hipblas_1_1hipblasizaminbatched.html "Interface documentation") | C binding 54 | [hipblasIsaminBatched_64](interfacehipfort__hipblas_1_1hipblasisaminbatched__64.html "Interface documentation") | C binding 55 | [hipblasIdaminBatched_64](interfacehipfort__hipblas_1_1hipblasidaminbatched__64.html "Interface documentation") | C binding 56 | [hipblasIcaminBatched_64](interfacehipfort__hipblas_1_1hipblasicaminbatched__64.html "Interface documentation") | C binding 57 | [hipblasIzaminBatched_64](interfacehipfort__hipblas_1_1hipblasizaminbatched__64.html "Interface documentation") | C binding 58 | [hipblasIsaminStridedBatched](interfacehipfort__hipblas_1_1hipblasisaminstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 59 | [hipblasIdaminStridedBatched](interfacehipfort__hipblas_1_1hipblasidaminstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 60 | [hipblasIcaminStridedBatched](interfacehipfort__hipblas_1_1hipblasicaminstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 61 | [hipblasIzaminStridedBatched](interfacehipfort__hipblas_1_1hipblasizaminstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 62 | [hipblasIsaminStridedBatched_64](interfacehipfort__hipblas_1_1hipblasisaminstridedbatched__64.html "Interface documentation") | C binding 63 | [hipblasIdaminStridedBatched_64](interfacehipfort__hipblas_1_1hipblasidaminstridedbatched__64.html "Interface documentation") | C binding 64 | [hipblasIcaminStridedBatched_64](interfacehipfort__hipblas_1_1hipblasicaminstridedbatched__64.html "Interface documentation") | C binding 65 | [hipblasIzaminStridedBatched_64](interfacehipfort__hipblas_1_1hipblasizaminstridedbatched__64.html "Interface documentation") | C binding 66 | [hipblasSasum](interfacehipfort__hipblas_1_1hipblassasum.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 67 | [hipblasDasum](interfacehipfort__hipblas_1_1hipblasdasum.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 68 | [hipblasScasum](interfacehipfort__hipblas_1_1hipblasscasum.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 69 | [hipblasDzasum](interfacehipfort__hipblas_1_1hipblasdzasum.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 70 | [hipblasSasum_64](interfacehipfort__hipblas_1_1hipblassasum__64.html "Interface documentation") | C binding 71 | [hipblasDasum_64](interfacehipfort__hipblas_1_1hipblasdasum__64.html "Interface documentation") | C binding 72 | [hipblasScasum_64](interfacehipfort__hipblas_1_1hipblasscasum__64.html "Interface documentation") | C binding 73 | [hipblasDzasum_64](interfacehipfort__hipblas_1_1hipblasdzasum__64.html "Interface documentation") | C binding 74 | [hipblasSasumBatched](interfacehipfort__hipblas_1_1hipblassasumbatched.html "Interface documentation") | C binding 75 | [hipblasDasumBatched](interfacehipfort__hipblas_1_1hipblasdasumbatched.html "Interface documentation") | C binding 76 | [hipblasScasumBatched](interfacehipfort__hipblas_1_1hipblasscasumbatched.html "Interface documentation") | C binding 77 | [hipblasDzasumBatched](interfacehipfort__hipblas_1_1hipblasdzasumbatched.html "Interface documentation") | C binding 78 | [hipblasSasumBatched_64](interfacehipfort__hipblas_1_1hipblassasumbatched__64.html "Interface documentation") | C binding 79 | [hipblasDasumBatched_64](interfacehipfort__hipblas_1_1hipblasdasumbatched__64.html "Interface documentation") | C binding 80 | [hipblasScasumBatched_64](interfacehipfort__hipblas_1_1hipblasscasumbatched__64.html "Interface documentation") | C binding 81 | [hipblasDzasumBatched_64](interfacehipfort__hipblas_1_1hipblasdzasumbatched__64.html "Interface documentation") | C binding 82 | [hipblasSasumStridedBatched](interfacehipfort__hipblas_1_1hipblassasumstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 83 | [hipblasDasumStridedBatched](interfacehipfort__hipblas_1_1hipblasdasumstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 84 | [hipblasScasumStridedBatched](interfacehipfort__hipblas_1_1hipblasscasumstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 85 | [hipblasDzasumStridedBatched](interfacehipfort__hipblas_1_1hipblasdzasumstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 86 | [hipblasSasumStridedBatched_64](interfacehipfort__hipblas_1_1hipblassasumstridedbatched__64.html "Interface documentation") | C binding 87 | [hipblasDasumStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdasumstridedbatched__64.html "Interface documentation") | C binding 88 | [hipblasScasumStridedBatched_64](interfacehipfort__hipblas_1_1hipblasscasumstridedbatched__64.html "Interface documentation") | C binding 89 | [hipblasDzasumStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdzasumstridedbatched__64.html "Interface documentation") | C binding 90 | [hipblasHaxpy](interfacehipfort__hipblas_1_1hipblashaxpy.html "Interface documentation") | C binding 91 | [hipblasSaxpy](interfacehipfort__hipblas_1_1hipblassaxpy.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 92 | [hipblasDaxpy](interfacehipfort__hipblas_1_1hipblasdaxpy.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 93 | [hipblasCaxpy](interfacehipfort__hipblas_1_1hipblascaxpy.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 94 | [hipblasZaxpy](interfacehipfort__hipblas_1_1hipblaszaxpy.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 95 | [hipblasHaxpy_64](interfacehipfort__hipblas_1_1hipblashaxpy__64.html "Interface documentation") | C binding 96 | [hipblasSaxpy_64](interfacehipfort__hipblas_1_1hipblassaxpy__64.html "Interface documentation") | C binding 97 | [hipblasDaxpy_64](interfacehipfort__hipblas_1_1hipblasdaxpy__64.html "Interface documentation") | C binding 98 | [hipblasCaxpy_64](interfacehipfort__hipblas_1_1hipblascaxpy__64.html "Interface documentation") | C binding 99 | [hipblasZaxpy_64](interfacehipfort__hipblas_1_1hipblaszaxpy__64.html "Interface documentation") | C binding 100 | [hipblasHaxpyBatched](interfacehipfort__hipblas_1_1hipblashaxpybatched.html "Interface documentation") | C binding 101 | [hipblasSaxpyBatched](interfacehipfort__hipblas_1_1hipblassaxpybatched.html "Interface documentation") | C binding 102 | [hipblasDaxpyBatched](interfacehipfort__hipblas_1_1hipblasdaxpybatched.html "Interface documentation") | C binding 103 | [hipblasCaxpyBatched](interfacehipfort__hipblas_1_1hipblascaxpybatched.html "Interface documentation") | C binding 104 | [hipblasZaxpyBatched](interfacehipfort__hipblas_1_1hipblaszaxpybatched.html "Interface documentation") | C binding 105 | [hipblasHaxpyBatched_64](interfacehipfort__hipblas_1_1hipblashaxpybatched__64.html "Interface documentation") | C binding 106 | [hipblasSaxpyBatched_64](interfacehipfort__hipblas_1_1hipblassaxpybatched__64.html "Interface documentation") | C binding 107 | [hipblasDaxpyBatched_64](interfacehipfort__hipblas_1_1hipblasdaxpybatched__64.html "Interface documentation") | C binding 108 | [hipblasCaxpyBatched_64](interfacehipfort__hipblas_1_1hipblascaxpybatched__64.html "Interface documentation") | C binding 109 | [hipblasZaxpyBatched_64](interfacehipfort__hipblas_1_1hipblaszaxpybatched__64.html "Interface documentation") | C binding 110 | [hipblasHaxpyStridedBatched](interfacehipfort__hipblas_1_1hipblashaxpystridedbatched.html "Interface documentation") | C binding 111 | [hipblasSaxpyStridedBatched](interfacehipfort__hipblas_1_1hipblassaxpystridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 112 | [hipblasDaxpyStridedBatched](interfacehipfort__hipblas_1_1hipblasdaxpystridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 113 | [hipblasCaxpyStridedBatched](interfacehipfort__hipblas_1_1hipblascaxpystridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 114 | [hipblasZaxpyStridedBatched](interfacehipfort__hipblas_1_1hipblaszaxpystridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 115 | [hipblasHaxpyStridedBatched_64](interfacehipfort__hipblas_1_1hipblashaxpystridedbatched__64.html "Interface documentation") | C binding 116 | [hipblasSaxpyStridedBatched_64](interfacehipfort__hipblas_1_1hipblassaxpystridedbatched__64.html "Interface documentation") | C binding 117 | [hipblasDaxpyStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdaxpystridedbatched__64.html "Interface documentation") | C binding 118 | [hipblasCaxpyStridedBatched_64](interfacehipfort__hipblas_1_1hipblascaxpystridedbatched__64.html "Interface documentation") | C binding 119 | [hipblasZaxpyStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszaxpystridedbatched__64.html "Interface documentation") | C binding 120 | [hipblasScopy](interfacehipfort__hipblas_1_1hipblasscopy.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 121 | [hipblasDcopy](interfacehipfort__hipblas_1_1hipblasdcopy.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 122 | [hipblasCcopy](interfacehipfort__hipblas_1_1hipblasccopy.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 123 | [hipblasZcopy](interfacehipfort__hipblas_1_1hipblaszcopy.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 124 | [hipblasScopy_64](interfacehipfort__hipblas_1_1hipblasscopy__64.html "Interface documentation") | C binding 125 | [hipblasDcopy_64](interfacehipfort__hipblas_1_1hipblasdcopy__64.html "Interface documentation") | C binding 126 | [hipblasCcopy_64](interfacehipfort__hipblas_1_1hipblasccopy__64.html "Interface documentation") | C binding 127 | [hipblasZcopy_64](interfacehipfort__hipblas_1_1hipblaszcopy__64.html "Interface documentation") | C binding 128 | [hipblasScopyBatched](interfacehipfort__hipblas_1_1hipblasscopybatched.html "Interface documentation") | C binding 129 | [hipblasDcopyBatched](interfacehipfort__hipblas_1_1hipblasdcopybatched.html "Interface documentation") | C binding 130 | [hipblasCcopyBatched](interfacehipfort__hipblas_1_1hipblasccopybatched.html "Interface documentation") | C binding 131 | [hipblasZcopyBatched](interfacehipfort__hipblas_1_1hipblaszcopybatched.html "Interface documentation") | C binding 132 | [hipblasScopyBatched_64](interfacehipfort__hipblas_1_1hipblasscopybatched__64.html "Interface documentation") | C binding 133 | [hipblasDcopyBatched_64](interfacehipfort__hipblas_1_1hipblasdcopybatched__64.html "Interface documentation") | C binding 134 | [hipblasCcopyBatched_64](interfacehipfort__hipblas_1_1hipblasccopybatched__64.html "Interface documentation") | C binding 135 | [hipblasZcopyBatched_64](interfacehipfort__hipblas_1_1hipblaszcopybatched__64.html "Interface documentation") | C binding 136 | [hipblasScopyStridedBatched](interfacehipfort__hipblas_1_1hipblasscopystridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 137 | [hipblasDcopyStridedBatched](interfacehipfort__hipblas_1_1hipblasdcopystridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 138 | [hipblasCcopyStridedBatched](interfacehipfort__hipblas_1_1hipblasccopystridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 139 | [hipblasZcopyStridedBatched](interfacehipfort__hipblas_1_1hipblaszcopystridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 140 | [hipblasScopyStridedBatched_64](interfacehipfort__hipblas_1_1hipblasscopystridedbatched__64.html "Interface documentation") | C binding 141 | [hipblasDcopyStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdcopystridedbatched__64.html "Interface documentation") | C binding 142 | [hipblasCcopyStridedBatched_64](interfacehipfort__hipblas_1_1hipblasccopystridedbatched__64.html "Interface documentation") | C binding 143 | [hipblasZcopyStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszcopystridedbatched__64.html "Interface documentation") | C binding 144 | [hipblasHdot](interfacehipfort__hipblas_1_1hipblashdot.html "Interface documentation") | C binding 145 | [hipblasBfdot](interfacehipfort__hipblas_1_1hipblasbfdot.html "Interface documentation") | C binding 146 | [hipblasSdot](interfacehipfort__hipblas_1_1hipblassdot.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 147 | [hipblasDdot](interfacehipfort__hipblas_1_1hipblasddot.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 148 | [hipblasCdotc](interfacehipfort__hipblas_1_1hipblascdotc.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 149 | [hipblasCdotu](interfacehipfort__hipblas_1_1hipblascdotu.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 150 | [hipblasZdotc](interfacehipfort__hipblas_1_1hipblaszdotc.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 151 | [hipblasZdotu](interfacehipfort__hipblas_1_1hipblaszdotu.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 152 | [hipblasHdot_64](interfacehipfort__hipblas_1_1hipblashdot__64.html "Interface documentation") | C binding 153 | [hipblasBfdot_64](interfacehipfort__hipblas_1_1hipblasbfdot__64.html "Interface documentation") | C binding 154 | [hipblasSdot_64](interfacehipfort__hipblas_1_1hipblassdot__64.html "Interface documentation") | C binding 155 | [hipblasDdot_64](interfacehipfort__hipblas_1_1hipblasddot__64.html "Interface documentation") | C binding 156 | [hipblasCdotc_64](interfacehipfort__hipblas_1_1hipblascdotc__64.html "Interface documentation") | C binding 157 | [hipblasCdotu_64](interfacehipfort__hipblas_1_1hipblascdotu__64.html "Interface documentation") | C binding 158 | [hipblasZdotc_64](interfacehipfort__hipblas_1_1hipblaszdotc__64.html "Interface documentation") | C binding 159 | [hipblasZdotu_64](interfacehipfort__hipblas_1_1hipblaszdotu__64.html "Interface documentation") | C binding 160 | [hipblasHdotBatched](interfacehipfort__hipblas_1_1hipblashdotbatched.html "Interface documentation") | C binding 161 | [hipblasBfdotBatched](interfacehipfort__hipblas_1_1hipblasbfdotbatched.html "Interface documentation") | C binding 162 | [hipblasSdotBatched](interfacehipfort__hipblas_1_1hipblassdotbatched.html "Interface documentation") | C binding 163 | [hipblasDdotBatched](interfacehipfort__hipblas_1_1hipblasddotbatched.html "Interface documentation") | C binding 164 | [hipblasCdotcBatched](interfacehipfort__hipblas_1_1hipblascdotcbatched.html "Interface documentation") | C binding 165 | [hipblasCdotuBatched](interfacehipfort__hipblas_1_1hipblascdotubatched.html "Interface documentation") | C binding 166 | [hipblasZdotcBatched](interfacehipfort__hipblas_1_1hipblaszdotcbatched.html "Interface documentation") | C binding 167 | [hipblasZdotuBatched](interfacehipfort__hipblas_1_1hipblaszdotubatched.html "Interface documentation") | C binding 168 | [hipblasHdotBatched_64](interfacehipfort__hipblas_1_1hipblashdotbatched__64.html "Interface documentation") | C binding 169 | [hipblasBfdotBatched_64](interfacehipfort__hipblas_1_1hipblasbfdotbatched__64.html "Interface documentation") | C binding 170 | [hipblasSdotBatched_64](interfacehipfort__hipblas_1_1hipblassdotbatched__64.html "Interface documentation") | C binding 171 | [hipblasDdotBatched_64](interfacehipfort__hipblas_1_1hipblasddotbatched__64.html "Interface documentation") | C binding 172 | [hipblasCdotcBatched_64](interfacehipfort__hipblas_1_1hipblascdotcbatched__64.html "Interface documentation") | C binding 173 | [hipblasCdotuBatched_64](interfacehipfort__hipblas_1_1hipblascdotubatched__64.html "Interface documentation") | C binding 174 | [hipblasZdotcBatched_64](interfacehipfort__hipblas_1_1hipblaszdotcbatched__64.html "Interface documentation") | C binding 175 | [hipblasZdotuBatched_64](interfacehipfort__hipblas_1_1hipblaszdotubatched__64.html "Interface documentation") | C binding 176 | [hipblasHdotStridedBatched](interfacehipfort__hipblas_1_1hipblashdotstridedbatched.html "Interface documentation") | C binding 177 | [hipblasBfdotStridedBatched](interfacehipfort__hipblas_1_1hipblasbfdotstridedbatched.html "Interface documentation") | C binding 178 | [hipblasSdotStridedBatched](interfacehipfort__hipblas_1_1hipblassdotstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 179 | [hipblasDdotStridedBatched](interfacehipfort__hipblas_1_1hipblasddotstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 180 | [hipblasCdotcStridedBatched](interfacehipfort__hipblas_1_1hipblascdotcstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 181 | [hipblasCdotuStridedBatched](interfacehipfort__hipblas_1_1hipblascdotustridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 182 | [hipblasZdotcStridedBatched](interfacehipfort__hipblas_1_1hipblaszdotcstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 183 | [hipblasZdotuStridedBatched](interfacehipfort__hipblas_1_1hipblaszdotustridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 184 | [hipblasHdotStridedBatched_64](interfacehipfort__hipblas_1_1hipblashdotstridedbatched__64.html "Interface documentation") | C binding 185 | [hipblasBfdotStridedBatched_64](interfacehipfort__hipblas_1_1hipblasbfdotstridedbatched__64.html "Interface documentation") | C binding 186 | [hipblasSdotStridedBatched_64](interfacehipfort__hipblas_1_1hipblassdotstridedbatched__64.html "Interface documentation") | C binding 187 | [hipblasDdotStridedBatched_64](interfacehipfort__hipblas_1_1hipblasddotstridedbatched__64.html "Interface documentation") | C binding 188 | [hipblasCdotcStridedBatched_64](interfacehipfort__hipblas_1_1hipblascdotcstridedbatched__64.html "Interface documentation") | C binding 189 | [hipblasCdotuStridedBatched_64](interfacehipfort__hipblas_1_1hipblascdotustridedbatched__64.html "Interface documentation") | C binding 190 | [hipblasZdotcStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszdotcstridedbatched__64.html "Interface documentation") | C binding 191 | [hipblasZdotuStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszdotustridedbatched__64.html "Interface documentation") | C binding 192 | [hipblasSnrm2](interfacehipfort__hipblas_1_1hipblassnrm2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 193 | [hipblasDnrm2](interfacehipfort__hipblas_1_1hipblasdnrm2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 194 | [hipblasScnrm2](interfacehipfort__hipblas_1_1hipblasscnrm2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 195 | [hipblasDznrm2](interfacehipfort__hipblas_1_1hipblasdznrm2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 196 | [hipblasSnrm2_64](interfacehipfort__hipblas_1_1hipblassnrm2__64.html "Interface documentation") | C binding 197 | [hipblasDnrm2_64](interfacehipfort__hipblas_1_1hipblasdnrm2__64.html "Interface documentation") | C binding 198 | [hipblasScnrm2_64](interfacehipfort__hipblas_1_1hipblasscnrm2__64.html "Interface documentation") | C binding 199 | [hipblasDznrm2_64](interfacehipfort__hipblas_1_1hipblasdznrm2__64.html "Interface documentation") | C binding 200 | [hipblasSnrm2Batched](interfacehipfort__hipblas_1_1hipblassnrm2batched.html "Interface documentation") | C binding 201 | [hipblasDnrm2Batched](interfacehipfort__hipblas_1_1hipblasdnrm2batched.html "Interface documentation") | C binding 202 | [hipblasScnrm2Batched](interfacehipfort__hipblas_1_1hipblasscnrm2batched.html "Interface documentation") | C binding 203 | [hipblasDznrm2Batched](interfacehipfort__hipblas_1_1hipblasdznrm2batched.html "Interface documentation") | C binding 204 | [hipblasSnrm2Batched_64](interfacehipfort__hipblas_1_1hipblassnrm2batched__64.html "Interface documentation") | C binding 205 | [hipblasDnrm2Batched_64](interfacehipfort__hipblas_1_1hipblasdnrm2batched__64.html "Interface documentation") | C binding 206 | [hipblasScnrm2Batched_64](interfacehipfort__hipblas_1_1hipblasscnrm2batched__64.html "Interface documentation") | C binding 207 | [hipblasDznrm2Batched_64](interfacehipfort__hipblas_1_1hipblasdznrm2batched__64.html "Interface documentation") | C binding 208 | [hipblasSnrm2StridedBatched](interfacehipfort__hipblas_1_1hipblassnrm2stridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 209 | [hipblasDnrm2StridedBatched](interfacehipfort__hipblas_1_1hipblasdnrm2stridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 210 | [hipblasScnrm2StridedBatched](interfacehipfort__hipblas_1_1hipblasscnrm2stridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 211 | [hipblasDznrm2StridedBatched](interfacehipfort__hipblas_1_1hipblasdznrm2stridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 212 | [hipblasSnrm2StridedBatched_64](interfacehipfort__hipblas_1_1hipblassnrm2stridedbatched__64.html "Interface documentation") | C binding 213 | [hipblasDnrm2StridedBatched_64](interfacehipfort__hipblas_1_1hipblasdnrm2stridedbatched__64.html "Interface documentation") | C binding 214 | [hipblasScnrm2StridedBatched_64](interfacehipfort__hipblas_1_1hipblasscnrm2stridedbatched__64.html "Interface documentation") | C binding 215 | [hipblasDznrm2StridedBatched_64](interfacehipfort__hipblas_1_1hipblasdznrm2stridedbatched__64.html "Interface documentation") | C binding 216 | [hipblasSrot](interfacehipfort__hipblas_1_1hipblassrot.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 217 | [hipblasDrot](interfacehipfort__hipblas_1_1hipblasdrot.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 218 | [hipblasCrot](interfacehipfort__hipblas_1_1hipblascrot.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 219 | [hipblasCsrot](interfacehipfort__hipblas_1_1hipblascsrot.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 220 | [hipblasZrot](interfacehipfort__hipblas_1_1hipblaszrot.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 221 | [hipblasZdrot](interfacehipfort__hipblas_1_1hipblaszdrot.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 222 | [hipblasSrot_64](interfacehipfort__hipblas_1_1hipblassrot__64.html "Interface documentation") | C binding 223 | [hipblasDrot_64](interfacehipfort__hipblas_1_1hipblasdrot__64.html "Interface documentation") | C binding 224 | [hipblasCrot_64](interfacehipfort__hipblas_1_1hipblascrot__64.html "Interface documentation") | C binding 225 | [hipblasCsrot_64](interfacehipfort__hipblas_1_1hipblascsrot__64.html "Interface documentation") | C binding 226 | [hipblasZrot_64](interfacehipfort__hipblas_1_1hipblaszrot__64.html "Interface documentation") | C binding 227 | [hipblasZdrot_64](interfacehipfort__hipblas_1_1hipblaszdrot__64.html "Interface documentation") | C binding 228 | [hipblasSrotBatched](interfacehipfort__hipblas_1_1hipblassrotbatched.html "Interface documentation") | C binding 229 | [hipblasDrotBatched](interfacehipfort__hipblas_1_1hipblasdrotbatched.html "Interface documentation") | C binding 230 | [hipblasCrotBatched](interfacehipfort__hipblas_1_1hipblascrotbatched.html "Interface documentation") | C binding 231 | [hipblasCsrotBatched](interfacehipfort__hipblas_1_1hipblascsrotbatched.html "Interface documentation") | C binding 232 | [hipblasZrotBatched](interfacehipfort__hipblas_1_1hipblaszrotbatched.html "Interface documentation") | C binding 233 | [hipblasZdrotBatched](interfacehipfort__hipblas_1_1hipblaszdrotbatched.html "Interface documentation") | C binding 234 | [hipblasSrotBatched_64](interfacehipfort__hipblas_1_1hipblassrotbatched__64.html "Interface documentation") | C binding 235 | [hipblasDrotBatched_64](interfacehipfort__hipblas_1_1hipblasdrotbatched__64.html "Interface documentation") | C binding 236 | [hipblasCrotBatched_64](interfacehipfort__hipblas_1_1hipblascrotbatched__64.html "Interface documentation") | C binding 237 | [hipblasCsrotBatched_64](interfacehipfort__hipblas_1_1hipblascsrotbatched__64.html "Interface documentation") | C binding 238 | [hipblasZrotBatched_64](interfacehipfort__hipblas_1_1hipblaszrotbatched__64.html "Interface documentation") | C binding 239 | [hipblasZdrotBatched_64](interfacehipfort__hipblas_1_1hipblaszdrotbatched__64.html "Interface documentation") | C binding 240 | [hipblasSrotStridedBatched](interfacehipfort__hipblas_1_1hipblassrotstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 241 | [hipblasDrotStridedBatched](interfacehipfort__hipblas_1_1hipblasdrotstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 242 | [hipblasCrotStridedBatched](interfacehipfort__hipblas_1_1hipblascrotstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 243 | [hipblasCsrotStridedBatched](interfacehipfort__hipblas_1_1hipblascsrotstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 244 | [hipblasZrotStridedBatched](interfacehipfort__hipblas_1_1hipblaszrotstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 245 | [hipblasZdrotStridedBatched](interfacehipfort__hipblas_1_1hipblaszdrotstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 246 | [hipblasSrotStridedBatched_64](interfacehipfort__hipblas_1_1hipblassrotstridedbatched__64.html "Interface documentation") | C binding 247 | [hipblasDrotStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdrotstridedbatched__64.html "Interface documentation") | C binding 248 | [hipblasCrotStridedBatched_64](interfacehipfort__hipblas_1_1hipblascrotstridedbatched__64.html "Interface documentation") | C binding 249 | [hipblasCsrotStridedBatched_64](interfacehipfort__hipblas_1_1hipblascsrotstridedbatched__64.html "Interface documentation") | C binding 250 | [hipblasZrotStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszrotstridedbatched__64.html "Interface documentation") | C binding 251 | [hipblasZdrotStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszdrotstridedbatched__64.html "Interface documentation") | C binding 252 | [hipblasSrotg](interfacehipfort__hipblas_1_1hipblassrotg.html "Interface documentation") | C binding 253 | [hipblasDrotg](interfacehipfort__hipblas_1_1hipblasdrotg.html "Interface documentation") | C binding 254 | [hipblasCrotg](interfacehipfort__hipblas_1_1hipblascrotg.html "Interface documentation") | C binding 255 | [hipblasZrotg](interfacehipfort__hipblas_1_1hipblaszrotg.html "Interface documentation") | C binding 256 | [hipblasSrotg_64](interfacehipfort__hipblas_1_1hipblassrotg__64.html "Interface documentation") | C binding 257 | [hipblasDrotg_64](interfacehipfort__hipblas_1_1hipblasdrotg__64.html "Interface documentation") | C binding 258 | [hipblasCrotg_64](interfacehipfort__hipblas_1_1hipblascrotg__64.html "Interface documentation") | C binding 259 | [hipblasZrotg_64](interfacehipfort__hipblas_1_1hipblaszrotg__64.html "Interface documentation") | C binding 260 | [hipblasSrotgBatched](interfacehipfort__hipblas_1_1hipblassrotgbatched.html "Interface documentation") | C binding 261 | [hipblasDrotgBatched](interfacehipfort__hipblas_1_1hipblasdrotgbatched.html "Interface documentation") | C binding 262 | [hipblasCrotgBatched](interfacehipfort__hipblas_1_1hipblascrotgbatched.html "Interface documentation") | C binding 263 | [hipblasZrotgBatched](interfacehipfort__hipblas_1_1hipblaszrotgbatched.html "Interface documentation") | C binding 264 | [hipblasSrotgBatched_64](interfacehipfort__hipblas_1_1hipblassrotgbatched__64.html "Interface documentation") | C binding 265 | [hipblasDrotgBatched_64](interfacehipfort__hipblas_1_1hipblasdrotgbatched__64.html "Interface documentation") | C binding 266 | [hipblasCrotgBatched_64](interfacehipfort__hipblas_1_1hipblascrotgbatched__64.html "Interface documentation") | C binding 267 | [hipblasZrotgBatched_64](interfacehipfort__hipblas_1_1hipblaszrotgbatched__64.html "Interface documentation") | C binding 268 | [hipblasSrotgStridedBatched](interfacehipfort__hipblas_1_1hipblassrotgstridedbatched.html "Interface documentation") | C binding 269 | [hipblasDrotgStridedBatched](interfacehipfort__hipblas_1_1hipblasdrotgstridedbatched.html "Interface documentation") | C binding 270 | [hipblasCrotgStridedBatched](interfacehipfort__hipblas_1_1hipblascrotgstridedbatched.html "Interface documentation") | C binding 271 | [hipblasZrotgStridedBatched](interfacehipfort__hipblas_1_1hipblaszrotgstridedbatched.html "Interface documentation") | C binding 272 | [hipblasSrotgStridedBatched_64](interfacehipfort__hipblas_1_1hipblassrotgstridedbatched__64.html "Interface documentation") | C binding 273 | [hipblasDrotgStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdrotgstridedbatched__64.html "Interface documentation") | C binding 274 | [hipblasCrotgStridedBatched_64](interfacehipfort__hipblas_1_1hipblascrotgstridedbatched__64.html "Interface documentation") | C binding 275 | [hipblasZrotgStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszrotgstridedbatched__64.html "Interface documentation") | C binding 276 | [hipblasSrotm](interfacehipfort__hipblas_1_1hipblassrotm.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 277 | [hipblasDrotm](interfacehipfort__hipblas_1_1hipblasdrotm.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 278 | [hipblasSrotm_64](interfacehipfort__hipblas_1_1hipblassrotm__64.html "Interface documentation") | C binding 279 | [hipblasDrotm_64](interfacehipfort__hipblas_1_1hipblasdrotm__64.html "Interface documentation") | C binding 280 | [hipblasSrotmBatched](interfacehipfort__hipblas_1_1hipblassrotmbatched.html "Interface documentation") | C binding 281 | [hipblasDrotmBatched](interfacehipfort__hipblas_1_1hipblasdrotmbatched.html "Interface documentation") | C binding 282 | [hipblasSrotmBatched_64](interfacehipfort__hipblas_1_1hipblassrotmbatched__64.html "Interface documentation") | C binding 283 | [hipblasDrotmBatched_64](interfacehipfort__hipblas_1_1hipblasdrotmbatched__64.html "Interface documentation") | C binding 284 | [hipblasSrotmStridedBatched](interfacehipfort__hipblas_1_1hipblassrotmstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 285 | [hipblasDrotmStridedBatched](interfacehipfort__hipblas_1_1hipblasdrotmstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 286 | [hipblasSrotmStridedBatched_64](interfacehipfort__hipblas_1_1hipblassrotmstridedbatched__64.html "Interface documentation") | C binding 287 | [hipblasDrotmStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdrotmstridedbatched__64.html "Interface documentation") | C binding 288 | [hipblasSrotmg](interfacehipfort__hipblas_1_1hipblassrotmg.html "Interface documentation") | C binding 289 | [hipblasDrotmg](interfacehipfort__hipblas_1_1hipblasdrotmg.html "Interface documentation") | C binding 290 | [hipblasSrotmg_64](interfacehipfort__hipblas_1_1hipblassrotmg__64.html "Interface documentation") | C binding 291 | [hipblasDrotmg_64](interfacehipfort__hipblas_1_1hipblasdrotmg__64.html "Interface documentation") | C binding 292 | [hipblasSrotmgBatched](interfacehipfort__hipblas_1_1hipblassrotmgbatched.html "Interface documentation") | C binding 293 | [hipblasDrotmgBatched](interfacehipfort__hipblas_1_1hipblasdrotmgbatched.html "Interface documentation") | C binding 294 | [hipblasSrotmgBatched_64](interfacehipfort__hipblas_1_1hipblassrotmgbatched__64.html "Interface documentation") | C binding 295 | [hipblasDrotmgBatched_64](interfacehipfort__hipblas_1_1hipblasdrotmgbatched__64.html "Interface documentation") | C binding 296 | [hipblasSrotmgStridedBatched](interfacehipfort__hipblas_1_1hipblassrotmgstridedbatched.html "Interface documentation") | C binding 297 | [hipblasDrotmgStridedBatched](interfacehipfort__hipblas_1_1hipblasdrotmgstridedbatched.html "Interface documentation") | C binding 298 | [hipblasSrotmgStridedBatched_64](interfacehipfort__hipblas_1_1hipblassrotmgstridedbatched__64.html "Interface documentation") | C binding 299 | [hipblasDrotmgStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdrotmgstridedbatched__64.html "Interface documentation") | C binding 300 | [hipblasSscal](interfacehipfort__hipblas_1_1hipblassscal.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 301 | [hipblasDscal](interfacehipfort__hipblas_1_1hipblasdscal.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 302 | [hipblasCscal](interfacehipfort__hipblas_1_1hipblascscal.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 303 | [hipblasCsscal](interfacehipfort__hipblas_1_1hipblascsscal.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 304 | [hipblasZscal](interfacehipfort__hipblas_1_1hipblaszscal.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 305 | [hipblasZdscal](interfacehipfort__hipblas_1_1hipblaszdscal.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 306 | [hipblasSscal_64](interfacehipfort__hipblas_1_1hipblassscal__64.html "Interface documentation") | C binding 307 | [hipblasDscal_64](interfacehipfort__hipblas_1_1hipblasdscal__64.html "Interface documentation") | C binding 308 | [hipblasCscal_64](interfacehipfort__hipblas_1_1hipblascscal__64.html "Interface documentation") | C binding 309 | [hipblasCsscal_64](interfacehipfort__hipblas_1_1hipblascsscal__64.html "Interface documentation") | C binding 310 | [hipblasZscal_64](interfacehipfort__hipblas_1_1hipblaszscal__64.html "Interface documentation") | C binding 311 | [hipblasZdscal_64](interfacehipfort__hipblas_1_1hipblaszdscal__64.html "Interface documentation") | C binding 312 | [hipblasSscalBatched](interfacehipfort__hipblas_1_1hipblassscalbatched.html "Interface documentation") | C binding 313 | [hipblasDscalBatched](interfacehipfort__hipblas_1_1hipblasdscalbatched.html "Interface documentation") | C binding 314 | [hipblasCscalBatched](interfacehipfort__hipblas_1_1hipblascscalbatched.html "Interface documentation") | C binding 315 | [hipblasZscalBatched](interfacehipfort__hipblas_1_1hipblaszscalbatched.html "Interface documentation") | C binding 316 | [hipblasCsscalBatched](interfacehipfort__hipblas_1_1hipblascsscalbatched.html "Interface documentation") | C binding 317 | [hipblasZdscalBatched](interfacehipfort__hipblas_1_1hipblaszdscalbatched.html "Interface documentation") | C binding 318 | [hipblasSscalBatched_64](interfacehipfort__hipblas_1_1hipblassscalbatched__64.html "Interface documentation") | C binding 319 | [hipblasDscalBatched_64](interfacehipfort__hipblas_1_1hipblasdscalbatched__64.html "Interface documentation") | C binding 320 | [hipblasCscalBatched_64](interfacehipfort__hipblas_1_1hipblascscalbatched__64.html "Interface documentation") | C binding 321 | [hipblasZscalBatched_64](interfacehipfort__hipblas_1_1hipblaszscalbatched__64.html "Interface documentation") | C binding 322 | [hipblasCsscalBatched_64](interfacehipfort__hipblas_1_1hipblascsscalbatched__64.html "Interface documentation") | C binding 323 | [hipblasZdscalBatched_64](interfacehipfort__hipblas_1_1hipblaszdscalbatched__64.html "Interface documentation") | C binding 324 | [hipblasSscalStridedBatched](interfacehipfort__hipblas_1_1hipblassscalstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 325 | [hipblasDscalStridedBatched](interfacehipfort__hipblas_1_1hipblasdscalstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 326 | [hipblasCscalStridedBatched](interfacehipfort__hipblas_1_1hipblascscalstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 327 | [hipblasZscalStridedBatched](interfacehipfort__hipblas_1_1hipblaszscalstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 328 | [hipblasCsscalStridedBatched](interfacehipfort__hipblas_1_1hipblascsscalstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 329 | [hipblasZdscalStridedBatched](interfacehipfort__hipblas_1_1hipblaszdscalstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 330 | [hipblasSscalStridedBatched_64](interfacehipfort__hipblas_1_1hipblassscalstridedbatched__64.html "Interface documentation") | C binding 331 | [hipblasDscalStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdscalstridedbatched__64.html "Interface documentation") | C binding 332 | [hipblasCscalStridedBatched_64](interfacehipfort__hipblas_1_1hipblascscalstridedbatched__64.html "Interface documentation") | C binding 333 | [hipblasZscalStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszscalstridedbatched__64.html "Interface documentation") | C binding 334 | [hipblasCsscalStridedBatched_64](interfacehipfort__hipblas_1_1hipblascsscalstridedbatched__64.html "Interface documentation") | C binding 335 | [hipblasZdscalStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszdscalstridedbatched__64.html "Interface documentation") | C binding 336 | [hipblasSswap](interfacehipfort__hipblas_1_1hipblassswap.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 337 | [hipblasDswap](interfacehipfort__hipblas_1_1hipblasdswap.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 338 | [hipblasCswap](interfacehipfort__hipblas_1_1hipblascswap.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 339 | [hipblasZswap](interfacehipfort__hipblas_1_1hipblaszswap.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 340 | [hipblasSswap_64](interfacehipfort__hipblas_1_1hipblassswap__64.html "Interface documentation") | C binding 341 | [hipblasDswap_64](interfacehipfort__hipblas_1_1hipblasdswap__64.html "Interface documentation") | C binding 342 | [hipblasCswap_64](interfacehipfort__hipblas_1_1hipblascswap__64.html "Interface documentation") | C binding 343 | [hipblasZswap_64](interfacehipfort__hipblas_1_1hipblaszswap__64.html "Interface documentation") | C binding 344 | [hipblasSswapBatched](interfacehipfort__hipblas_1_1hipblassswapbatched.html "Interface documentation") | C binding 345 | [hipblasDswapBatched](interfacehipfort__hipblas_1_1hipblasdswapbatched.html "Interface documentation") | C binding 346 | [hipblasCswapBatched](interfacehipfort__hipblas_1_1hipblascswapbatched.html "Interface documentation") | C binding 347 | [hipblasZswapBatched](interfacehipfort__hipblas_1_1hipblaszswapbatched.html "Interface documentation") | C binding 348 | [hipblasSswapBatched_64](interfacehipfort__hipblas_1_1hipblassswapbatched__64.html "Interface documentation") | C binding 349 | [hipblasDswapBatched_64](interfacehipfort__hipblas_1_1hipblasdswapbatched__64.html "Interface documentation") | C binding 350 | [hipblasCswapBatched_64](interfacehipfort__hipblas_1_1hipblascswapbatched__64.html "Interface documentation") | C binding 351 | [hipblasZswapBatched_64](interfacehipfort__hipblas_1_1hipblaszswapbatched__64.html "Interface documentation") | C binding 352 | [hipblasSswapStridedBatched](interfacehipfort__hipblas_1_1hipblassswapstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 353 | [hipblasDswapStridedBatched](interfacehipfort__hipblas_1_1hipblasdswapstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 354 | [hipblasCswapStridedBatched](interfacehipfort__hipblas_1_1hipblascswapstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 355 | [hipblasZswapStridedBatched](interfacehipfort__hipblas_1_1hipblaszswapstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 356 | [hipblasSswapStridedBatched_64](interfacehipfort__hipblas_1_1hipblassswapstridedbatched__64.html "Interface documentation") | C binding 357 | [hipblasDswapStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdswapstridedbatched__64.html "Interface documentation") | C binding 358 | [hipblasCswapStridedBatched_64](interfacehipfort__hipblas_1_1hipblascswapstridedbatched__64.html "Interface documentation") | C binding 359 | [hipblasZswapStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszswapstridedbatched__64.html "Interface documentation") | C binding 360 | [hipblasSgbmv](interfacehipfort__hipblas_1_1hipblassgbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 361 | [hipblasDgbmv](interfacehipfort__hipblas_1_1hipblasdgbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 362 | [hipblasCgbmv](interfacehipfort__hipblas_1_1hipblascgbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 363 | [hipblasZgbmv](interfacehipfort__hipblas_1_1hipblaszgbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 364 | [hipblasSgbmv_64](interfacehipfort__hipblas_1_1hipblassgbmv__64.html "Interface documentation") | C binding 365 | [hipblasDgbmv_64](interfacehipfort__hipblas_1_1hipblasdgbmv__64.html "Interface documentation") | C binding 366 | [hipblasCgbmv_64](interfacehipfort__hipblas_1_1hipblascgbmv__64.html "Interface documentation") | C binding 367 | [hipblasZgbmv_64](interfacehipfort__hipblas_1_1hipblaszgbmv__64.html "Interface documentation") | C binding 368 | [hipblasSgbmvBatched](interfacehipfort__hipblas_1_1hipblassgbmvbatched.html "Interface documentation") | C binding 369 | [hipblasDgbmvBatched](interfacehipfort__hipblas_1_1hipblasdgbmvbatched.html "Interface documentation") | C binding 370 | [hipblasCgbmvBatched](interfacehipfort__hipblas_1_1hipblascgbmvbatched.html "Interface documentation") | C binding 371 | [hipblasZgbmvBatched](interfacehipfort__hipblas_1_1hipblaszgbmvbatched.html "Interface documentation") | C binding 372 | [hipblasSgbmvBatched_64](interfacehipfort__hipblas_1_1hipblassgbmvbatched__64.html "Interface documentation") | C binding 373 | [hipblasDgbmvBatched_64](interfacehipfort__hipblas_1_1hipblasdgbmvbatched__64.html "Interface documentation") | C binding 374 | [hipblasCgbmvBatched_64](interfacehipfort__hipblas_1_1hipblascgbmvbatched__64.html "Interface documentation") | C binding 375 | [hipblasZgbmvBatched_64](interfacehipfort__hipblas_1_1hipblaszgbmvbatched__64.html "Interface documentation") | C binding 376 | [hipblasSgbmvStridedBatched](interfacehipfort__hipblas_1_1hipblassgbmvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 377 | [hipblasDgbmvStridedBatched](interfacehipfort__hipblas_1_1hipblasdgbmvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 378 | [hipblasCgbmvStridedBatched](interfacehipfort__hipblas_1_1hipblascgbmvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 379 | [hipblasZgbmvStridedBatched](interfacehipfort__hipblas_1_1hipblaszgbmvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 380 | [hipblasSgbmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblassgbmvstridedbatched__64.html "Interface documentation") | C binding 381 | [hipblasDgbmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdgbmvstridedbatched__64.html "Interface documentation") | C binding 382 | [hipblasCgbmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblascgbmvstridedbatched__64.html "Interface documentation") | C binding 383 | [hipblasZgbmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszgbmvstridedbatched__64.html "Interface documentation") | C binding 384 | [hipblasSgemv](interfacehipfort__hipblas_1_1hipblassgemv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 385 | [hipblasDgemv](interfacehipfort__hipblas_1_1hipblasdgemv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 386 | [hipblasCgemv](interfacehipfort__hipblas_1_1hipblascgemv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 387 | [hipblasZgemv](interfacehipfort__hipblas_1_1hipblaszgemv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 388 | [hipblasSgemv_64](interfacehipfort__hipblas_1_1hipblassgemv__64.html "Interface documentation") | C binding 389 | [hipblasDgemv_64](interfacehipfort__hipblas_1_1hipblasdgemv__64.html "Interface documentation") | C binding 390 | [hipblasCgemv_64](interfacehipfort__hipblas_1_1hipblascgemv__64.html "Interface documentation") | C binding 391 | [hipblasZgemv_64](interfacehipfort__hipblas_1_1hipblaszgemv__64.html "Interface documentation") | C binding 392 | [hipblasSgemvBatched](interfacehipfort__hipblas_1_1hipblassgemvbatched.html "Interface documentation") | C binding 393 | [hipblasDgemvBatched](interfacehipfort__hipblas_1_1hipblasdgemvbatched.html "Interface documentation") | C binding 394 | [hipblasCgemvBatched](interfacehipfort__hipblas_1_1hipblascgemvbatched.html "Interface documentation") | C binding 395 | [hipblasZgemvBatched](interfacehipfort__hipblas_1_1hipblaszgemvbatched.html "Interface documentation") | C binding 396 | [hipblasSgemvBatched_64](interfacehipfort__hipblas_1_1hipblassgemvbatched__64.html "Interface documentation") | C binding 397 | [hipblasDgemvBatched_64](interfacehipfort__hipblas_1_1hipblasdgemvbatched__64.html "Interface documentation") | C binding 398 | [hipblasCgemvBatched_64](interfacehipfort__hipblas_1_1hipblascgemvbatched__64.html "Interface documentation") | C binding 399 | [hipblasZgemvBatched_64](interfacehipfort__hipblas_1_1hipblaszgemvbatched__64.html "Interface documentation") | C binding 400 | [hipblasSgemvStridedBatched](interfacehipfort__hipblas_1_1hipblassgemvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 401 | [hipblasDgemvStridedBatched](interfacehipfort__hipblas_1_1hipblasdgemvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 402 | [hipblasCgemvStridedBatched](interfacehipfort__hipblas_1_1hipblascgemvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 403 | [hipblasZgemvStridedBatched](interfacehipfort__hipblas_1_1hipblaszgemvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 404 | [hipblasSgemvStridedBatched_64](interfacehipfort__hipblas_1_1hipblassgemvstridedbatched__64.html "Interface documentation") | C binding 405 | [hipblasDgemvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdgemvstridedbatched__64.html "Interface documentation") | C binding 406 | [hipblasCgemvStridedBatched_64](interfacehipfort__hipblas_1_1hipblascgemvstridedbatched__64.html "Interface documentation") | C binding 407 | [hipblasZgemvStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszgemvstridedbatched__64.html "Interface documentation") | C binding 408 | [hipblasSger](interfacehipfort__hipblas_1_1hipblassger.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 409 | [hipblasDger](interfacehipfort__hipblas_1_1hipblasdger.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 410 | [hipblasCgeru](interfacehipfort__hipblas_1_1hipblascgeru.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 411 | [hipblasCgerc](interfacehipfort__hipblas_1_1hipblascgerc.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 412 | [hipblasZgeru](interfacehipfort__hipblas_1_1hipblaszgeru.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 413 | [hipblasZgerc](interfacehipfort__hipblas_1_1hipblaszgerc.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 414 | [hipblasSger_64](interfacehipfort__hipblas_1_1hipblassger__64.html "Interface documentation") | C binding 415 | [hipblasDger_64](interfacehipfort__hipblas_1_1hipblasdger__64.html "Interface documentation") | C binding 416 | [hipblasCgeru_64](interfacehipfort__hipblas_1_1hipblascgeru__64.html "Interface documentation") | C binding 417 | [hipblasCgerc_64](interfacehipfort__hipblas_1_1hipblascgerc__64.html "Interface documentation") | C binding 418 | [hipblasZgeru_64](interfacehipfort__hipblas_1_1hipblaszgeru__64.html "Interface documentation") | C binding 419 | [hipblasZgerc_64](interfacehipfort__hipblas_1_1hipblaszgerc__64.html "Interface documentation") | C binding 420 | [hipblasSgerBatched](interfacehipfort__hipblas_1_1hipblassgerbatched.html "Interface documentation") | C binding 421 | [hipblasDgerBatched](interfacehipfort__hipblas_1_1hipblasdgerbatched.html "Interface documentation") | C binding 422 | [hipblasCgeruBatched](interfacehipfort__hipblas_1_1hipblascgerubatched.html "Interface documentation") | C binding 423 | [hipblasCgercBatched](interfacehipfort__hipblas_1_1hipblascgercbatched.html "Interface documentation") | C binding 424 | [hipblasZgeruBatched](interfacehipfort__hipblas_1_1hipblaszgerubatched.html "Interface documentation") | C binding 425 | [hipblasZgercBatched](interfacehipfort__hipblas_1_1hipblaszgercbatched.html "Interface documentation") | C binding 426 | [hipblasSgerBatched_64](interfacehipfort__hipblas_1_1hipblassgerbatched__64.html "Interface documentation") | C binding 427 | [hipblasDgerBatched_64](interfacehipfort__hipblas_1_1hipblasdgerbatched__64.html "Interface documentation") | C binding 428 | [hipblasCgeruBatched_64](interfacehipfort__hipblas_1_1hipblascgerubatched__64.html "Interface documentation") | C binding 429 | [hipblasCgercBatched_64](interfacehipfort__hipblas_1_1hipblascgercbatched__64.html "Interface documentation") | C binding 430 | [hipblasZgeruBatched_64](interfacehipfort__hipblas_1_1hipblaszgerubatched__64.html "Interface documentation") | C binding 431 | [hipblasZgercBatched_64](interfacehipfort__hipblas_1_1hipblaszgercbatched__64.html "Interface documentation") | C binding 432 | [hipblasSgerStridedBatched](interfacehipfort__hipblas_1_1hipblassgerstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 433 | [hipblasDgerStridedBatched](interfacehipfort__hipblas_1_1hipblasdgerstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 434 | [hipblasCgeruStridedBatched](interfacehipfort__hipblas_1_1hipblascgerustridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 435 | [hipblasCgercStridedBatched](interfacehipfort__hipblas_1_1hipblascgercstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 436 | [hipblasZgeruStridedBatched](interfacehipfort__hipblas_1_1hipblaszgerustridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 437 | [hipblasZgercStridedBatched](interfacehipfort__hipblas_1_1hipblaszgercstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 438 | [hipblasSgerStridedBatched_64](interfacehipfort__hipblas_1_1hipblassgerstridedbatched__64.html "Interface documentation") | C binding 439 | [hipblasDgerStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdgerstridedbatched__64.html "Interface documentation") | C binding 440 | [hipblasCgeruStridedBatched_64](interfacehipfort__hipblas_1_1hipblascgerustridedbatched__64.html "Interface documentation") | C binding 441 | [hipblasCgercStridedBatched_64](interfacehipfort__hipblas_1_1hipblascgercstridedbatched__64.html "Interface documentation") | C binding 442 | [hipblasZgeruStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszgerustridedbatched__64.html "Interface documentation") | C binding 443 | [hipblasZgercStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszgercstridedbatched__64.html "Interface documentation") | C binding 444 | [hipblasChbmv](interfacehipfort__hipblas_1_1hipblaschbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 445 | [hipblasZhbmv](interfacehipfort__hipblas_1_1hipblaszhbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 446 | [hipblasChbmv_64](interfacehipfort__hipblas_1_1hipblaschbmv__64.html "Interface documentation") | C binding 447 | [hipblasZhbmv_64](interfacehipfort__hipblas_1_1hipblaszhbmv__64.html "Interface documentation") | C binding 448 | [hipblasChbmvBatched](interfacehipfort__hipblas_1_1hipblaschbmvbatched.html "Interface documentation") | C binding 449 | [hipblasZhbmvBatched](interfacehipfort__hipblas_1_1hipblaszhbmvbatched.html "Interface documentation") | C binding 450 | [hipblasChbmvBatched_64](interfacehipfort__hipblas_1_1hipblaschbmvbatched__64.html "Interface documentation") | C binding 451 | [hipblasZhbmvBatched_64](interfacehipfort__hipblas_1_1hipblaszhbmvbatched__64.html "Interface documentation") | C binding 452 | [hipblasChbmvStridedBatched](interfacehipfort__hipblas_1_1hipblaschbmvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 453 | [hipblasZhbmvStridedBatched](interfacehipfort__hipblas_1_1hipblaszhbmvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 454 | [hipblasChbmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblaschbmvstridedbatched__64.html "Interface documentation") | C binding 455 | [hipblasZhbmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszhbmvstridedbatched__64.html "Interface documentation") | C binding 456 | [hipblasChemv](interfacehipfort__hipblas_1_1hipblaschemv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 457 | [hipblasZhemv](interfacehipfort__hipblas_1_1hipblaszhemv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 458 | [hipblasChemv_64](interfacehipfort__hipblas_1_1hipblaschemv__64.html "Interface documentation") | C binding 459 | [hipblasZhemv_64](interfacehipfort__hipblas_1_1hipblaszhemv__64.html "Interface documentation") | C binding 460 | [hipblasChemvBatched](interfacehipfort__hipblas_1_1hipblaschemvbatched.html "Interface documentation") | C binding 461 | [hipblasZhemvBatched](interfacehipfort__hipblas_1_1hipblaszhemvbatched.html "Interface documentation") | C binding 462 | [hipblasChemvBatched_64](interfacehipfort__hipblas_1_1hipblaschemvbatched__64.html "Interface documentation") | C binding 463 | [hipblasZhemvBatched_64](interfacehipfort__hipblas_1_1hipblaszhemvbatched__64.html "Interface documentation") | C binding 464 | [hipblasChemvStridedBatched](interfacehipfort__hipblas_1_1hipblaschemvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 465 | [hipblasZhemvStridedBatched](interfacehipfort__hipblas_1_1hipblaszhemvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 466 | [hipblasChemvStridedBatched_64](interfacehipfort__hipblas_1_1hipblaschemvstridedbatched__64.html "Interface documentation") | C binding 467 | [hipblasZhemvStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszhemvstridedbatched__64.html "Interface documentation") | C binding 468 | [hipblasCher](interfacehipfort__hipblas_1_1hipblascher.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 469 | [hipblasZher](interfacehipfort__hipblas_1_1hipblaszher.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 470 | [hipblasCher_64](interfacehipfort__hipblas_1_1hipblascher__64.html "Interface documentation") | C binding 471 | [hipblasZher_64](interfacehipfort__hipblas_1_1hipblaszher__64.html "Interface documentation") | C binding 472 | [hipblasCherBatched](interfacehipfort__hipblas_1_1hipblascherbatched.html "Interface documentation") | C binding 473 | [hipblasZherBatched](interfacehipfort__hipblas_1_1hipblaszherbatched.html "Interface documentation") | C binding 474 | [hipblasCherBatched_64](interfacehipfort__hipblas_1_1hipblascherbatched__64.html "Interface documentation") | C binding 475 | [hipblasZherBatched_64](interfacehipfort__hipblas_1_1hipblaszherbatched__64.html "Interface documentation") | C binding 476 | [hipblasCherStridedBatched](interfacehipfort__hipblas_1_1hipblascherstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 477 | [hipblasZherStridedBatched](interfacehipfort__hipblas_1_1hipblaszherstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 478 | [hipblasCherStridedBatched_64](interfacehipfort__hipblas_1_1hipblascherstridedbatched__64.html "Interface documentation") | C binding 479 | [hipblasZherStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszherstridedbatched__64.html "Interface documentation") | C binding 480 | [hipblasCher2](interfacehipfort__hipblas_1_1hipblascher2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 481 | [hipblasZher2](interfacehipfort__hipblas_1_1hipblaszher2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 482 | [hipblasCher2_64](interfacehipfort__hipblas_1_1hipblascher2__64.html "Interface documentation") | C binding 483 | [hipblasZher2_64](interfacehipfort__hipblas_1_1hipblaszher2__64.html "Interface documentation") | C binding 484 | [hipblasCher2Batched](interfacehipfort__hipblas_1_1hipblascher2batched.html "Interface documentation") | C binding 485 | [hipblasZher2Batched](interfacehipfort__hipblas_1_1hipblaszher2batched.html "Interface documentation") | C binding 486 | [hipblasCher2Batched_64](interfacehipfort__hipblas_1_1hipblascher2batched__64.html "Interface documentation") | C binding 487 | [hipblasZher2Batched_64](interfacehipfort__hipblas_1_1hipblaszher2batched__64.html "Interface documentation") | C binding 488 | [hipblasCher2StridedBatched](interfacehipfort__hipblas_1_1hipblascher2stridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 489 | [hipblasZher2StridedBatched](interfacehipfort__hipblas_1_1hipblaszher2stridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 490 | [hipblasCher2StridedBatched_64](interfacehipfort__hipblas_1_1hipblascher2stridedbatched__64.html "Interface documentation") | C binding 491 | [hipblasZher2StridedBatched_64](interfacehipfort__hipblas_1_1hipblaszher2stridedbatched__64.html "Interface documentation") | C binding 492 | [hipblasChpmv](interfacehipfort__hipblas_1_1hipblaschpmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 493 | [hipblasZhpmv](interfacehipfort__hipblas_1_1hipblaszhpmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 494 | [hipblasChpmv_64](interfacehipfort__hipblas_1_1hipblaschpmv__64.html "Interface documentation") | C binding 495 | [hipblasZhpmv_64](interfacehipfort__hipblas_1_1hipblaszhpmv__64.html "Interface documentation") | C binding 496 | [hipblasChpmvBatched](interfacehipfort__hipblas_1_1hipblaschpmvbatched.html "Interface documentation") | C binding 497 | [hipblasZhpmvBatched](interfacehipfort__hipblas_1_1hipblaszhpmvbatched.html "Interface documentation") | C binding 498 | [hipblasChpmvBatched_64](interfacehipfort__hipblas_1_1hipblaschpmvbatched__64.html "Interface documentation") | C binding 499 | [hipblasZhpmvBatched_64](interfacehipfort__hipblas_1_1hipblaszhpmvbatched__64.html "Interface documentation") | C binding 500 | [hipblasChpmvStridedBatched](interfacehipfort__hipblas_1_1hipblaschpmvstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 501 | [hipblasZhpmvStridedBatched](interfacehipfort__hipblas_1_1hipblaszhpmvstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 502 | [hipblasChpmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblaschpmvstridedbatched__64.html "Interface documentation") | C binding 503 | [hipblasZhpmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszhpmvstridedbatched__64.html "Interface documentation") | C binding 504 | [hipblasChpr](interfacehipfort__hipblas_1_1hipblaschpr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 505 | [hipblasZhpr](interfacehipfort__hipblas_1_1hipblaszhpr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 506 | [hipblasChpr_64](interfacehipfort__hipblas_1_1hipblaschpr__64.html "Interface documentation") | C binding 507 | [hipblasZhpr_64](interfacehipfort__hipblas_1_1hipblaszhpr__64.html "Interface documentation") | C binding 508 | [hipblasChprBatched](interfacehipfort__hipblas_1_1hipblaschprbatched.html "Interface documentation") | C binding 509 | [hipblasZhprBatched](interfacehipfort__hipblas_1_1hipblaszhprbatched.html "Interface documentation") | C binding 510 | [hipblasChprBatched_64](interfacehipfort__hipblas_1_1hipblaschprbatched__64.html "Interface documentation") | C binding 511 | [hipblasZhprBatched_64](interfacehipfort__hipblas_1_1hipblaszhprbatched__64.html "Interface documentation") | C binding 512 | [hipblasChprStridedBatched](interfacehipfort__hipblas_1_1hipblaschprstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 513 | [hipblasZhprStridedBatched](interfacehipfort__hipblas_1_1hipblaszhprstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 514 | [hipblasChprStridedBatched_64](interfacehipfort__hipblas_1_1hipblaschprstridedbatched__64.html "Interface documentation") | C binding 515 | [hipblasZhprStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszhprstridedbatched__64.html "Interface documentation") | C binding 516 | [hipblasChpr2](interfacehipfort__hipblas_1_1hipblaschpr2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 517 | [hipblasZhpr2](interfacehipfort__hipblas_1_1hipblaszhpr2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 518 | [hipblasChpr2_64](interfacehipfort__hipblas_1_1hipblaschpr2__64.html "Interface documentation") | C binding 519 | [hipblasZhpr2_64](interfacehipfort__hipblas_1_1hipblaszhpr2__64.html "Interface documentation") | C binding 520 | [hipblasChpr2Batched](interfacehipfort__hipblas_1_1hipblaschpr2batched.html "Interface documentation") | C binding 521 | [hipblasZhpr2Batched](interfacehipfort__hipblas_1_1hipblaszhpr2batched.html "Interface documentation") | C binding 522 | [hipblasChpr2Batched_64](interfacehipfort__hipblas_1_1hipblaschpr2batched__64.html "Interface documentation") | C binding 523 | [hipblasZhpr2Batched_64](interfacehipfort__hipblas_1_1hipblaszhpr2batched__64.html "Interface documentation") | C binding 524 | [hipblasChpr2StridedBatched](interfacehipfort__hipblas_1_1hipblaschpr2stridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 525 | [hipblasZhpr2StridedBatched](interfacehipfort__hipblas_1_1hipblaszhpr2stridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 526 | [hipblasChpr2StridedBatched_64](interfacehipfort__hipblas_1_1hipblaschpr2stridedbatched__64.html "Interface documentation") | C binding 527 | [hipblasZhpr2StridedBatched_64](interfacehipfort__hipblas_1_1hipblaszhpr2stridedbatched__64.html "Interface documentation") | C binding 528 | [hipblasSsbmv](interfacehipfort__hipblas_1_1hipblasssbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 529 | [hipblasDsbmv](interfacehipfort__hipblas_1_1hipblasdsbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 530 | [hipblasSsbmv_64](interfacehipfort__hipblas_1_1hipblasssbmv__64.html "Interface documentation") | C binding 531 | [hipblasDsbmv_64](interfacehipfort__hipblas_1_1hipblasdsbmv__64.html "Interface documentation") | C binding 532 | [hipblasSsbmvBatched](interfacehipfort__hipblas_1_1hipblasssbmvbatched.html "Interface documentation") | C binding 533 | [hipblasDsbmvBatched](interfacehipfort__hipblas_1_1hipblasdsbmvbatched.html "Interface documentation") | C binding 534 | [hipblasSsbmvBatched_64](interfacehipfort__hipblas_1_1hipblasssbmvbatched__64.html "Interface documentation") | C binding 535 | [hipblasDsbmvBatched_64](interfacehipfort__hipblas_1_1hipblasdsbmvbatched__64.html "Interface documentation") | C binding 536 | [hipblasSsbmvStridedBatched](interfacehipfort__hipblas_1_1hipblasssbmvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 537 | [hipblasDsbmvStridedBatched](interfacehipfort__hipblas_1_1hipblasdsbmvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 538 | [hipblasSsbmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasssbmvstridedbatched__64.html "Interface documentation") | C binding 539 | [hipblasDsbmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdsbmvstridedbatched__64.html "Interface documentation") | C binding 540 | [hipblasSspmv](interfacehipfort__hipblas_1_1hipblassspmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 541 | [hipblasDspmv](interfacehipfort__hipblas_1_1hipblasdspmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 542 | [hipblasSspmv_64](interfacehipfort__hipblas_1_1hipblassspmv__64.html "Interface documentation") | C binding 543 | [hipblasDspmv_64](interfacehipfort__hipblas_1_1hipblasdspmv__64.html "Interface documentation") | C binding 544 | [hipblasSspmvBatched](interfacehipfort__hipblas_1_1hipblassspmvbatched.html "Interface documentation") | C binding 545 | [hipblasDspmvBatched](interfacehipfort__hipblas_1_1hipblasdspmvbatched.html "Interface documentation") | C binding 546 | [hipblasSspmvBatched_64](interfacehipfort__hipblas_1_1hipblassspmvbatched__64.html "Interface documentation") | C binding 547 | [hipblasDspmvBatched_64](interfacehipfort__hipblas_1_1hipblasdspmvbatched__64.html "Interface documentation") | C binding 548 | [hipblasSspmvStridedBatched](interfacehipfort__hipblas_1_1hipblassspmvstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 549 | [hipblasDspmvStridedBatched](interfacehipfort__hipblas_1_1hipblasdspmvstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 550 | [hipblasSspmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblassspmvstridedbatched__64.html "Interface documentation") | C binding 551 | [hipblasDspmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdspmvstridedbatched__64.html "Interface documentation") | C binding 552 | [hipblasSspr](interfacehipfort__hipblas_1_1hipblassspr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 553 | [hipblasDspr](interfacehipfort__hipblas_1_1hipblasdspr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 554 | [hipblasCspr](interfacehipfort__hipblas_1_1hipblascspr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 555 | [hipblasZspr](interfacehipfort__hipblas_1_1hipblaszspr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 556 | [hipblasSspr_64](interfacehipfort__hipblas_1_1hipblassspr__64.html "Interface documentation") | C binding 557 | [hipblasDspr_64](interfacehipfort__hipblas_1_1hipblasdspr__64.html "Interface documentation") | C binding 558 | [hipblasCspr_64](interfacehipfort__hipblas_1_1hipblascspr__64.html "Interface documentation") | C binding 559 | [hipblasZspr_64](interfacehipfort__hipblas_1_1hipblaszspr__64.html "Interface documentation") | C binding 560 | [hipblasSsprBatched](interfacehipfort__hipblas_1_1hipblasssprbatched.html "Interface documentation") | C binding 561 | [hipblasDsprBatched](interfacehipfort__hipblas_1_1hipblasdsprbatched.html "Interface documentation") | C binding 562 | [hipblasCsprBatched](interfacehipfort__hipblas_1_1hipblascsprbatched.html "Interface documentation") | C binding 563 | [hipblasZsprBatched](interfacehipfort__hipblas_1_1hipblaszsprbatched.html "Interface documentation") | C binding 564 | [hipblasSsprBatched_64](interfacehipfort__hipblas_1_1hipblasssprbatched__64.html "Interface documentation") | C binding 565 | [hipblasDsprBatched_64](interfacehipfort__hipblas_1_1hipblasdsprbatched__64.html "Interface documentation") | C binding 566 | [hipblasCsprBatched_64](interfacehipfort__hipblas_1_1hipblascsprbatched__64.html "Interface documentation") | C binding 567 | [hipblasZsprBatched_64](interfacehipfort__hipblas_1_1hipblaszsprbatched__64.html "Interface documentation") | C binding 568 | [hipblasSsprStridedBatched](interfacehipfort__hipblas_1_1hipblasssprstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 569 | [hipblasDsprStridedBatched](interfacehipfort__hipblas_1_1hipblasdsprstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 570 | [hipblasCsprStridedBatched](interfacehipfort__hipblas_1_1hipblascsprstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 571 | [hipblasZsprStridedBatched](interfacehipfort__hipblas_1_1hipblaszsprstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 572 | [hipblasSsprStridedBatched_64](interfacehipfort__hipblas_1_1hipblasssprstridedbatched__64.html "Interface documentation") | C binding 573 | [hipblasDsprStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdsprstridedbatched__64.html "Interface documentation") | C binding 574 | [hipblasCsprStridedBatched_64](interfacehipfort__hipblas_1_1hipblascsprstridedbatched__64.html "Interface documentation") | C binding 575 | [hipblasZsprStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszsprstridedbatched__64.html "Interface documentation") | C binding 576 | [hipblasSspr2](interfacehipfort__hipblas_1_1hipblassspr2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 577 | [hipblasDspr2](interfacehipfort__hipblas_1_1hipblasdspr2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 578 | [hipblasSspr2_64](interfacehipfort__hipblas_1_1hipblassspr2__64.html "Interface documentation") | C binding 579 | [hipblasDspr2_64](interfacehipfort__hipblas_1_1hipblasdspr2__64.html "Interface documentation") | C binding 580 | [hipblasSspr2Batched](interfacehipfort__hipblas_1_1hipblassspr2batched.html "Interface documentation") | C binding 581 | [hipblasDspr2Batched](interfacehipfort__hipblas_1_1hipblasdspr2batched.html "Interface documentation") | C binding 582 | [hipblasSspr2Batched_64](interfacehipfort__hipblas_1_1hipblassspr2batched__64.html "Interface documentation") | C binding 583 | [hipblasDspr2Batched_64](interfacehipfort__hipblas_1_1hipblasdspr2batched__64.html "Interface documentation") | C binding 584 | [hipblasSspr2StridedBatched](interfacehipfort__hipblas_1_1hipblassspr2stridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 585 | [hipblasDspr2StridedBatched](interfacehipfort__hipblas_1_1hipblasdspr2stridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 586 | [hipblasSspr2StridedBatched_64](interfacehipfort__hipblas_1_1hipblassspr2stridedbatched__64.html "Interface documentation") | C binding 587 | [hipblasDspr2StridedBatched_64](interfacehipfort__hipblas_1_1hipblasdspr2stridedbatched__64.html "Interface documentation") | C binding 588 | [hipblasSsymv](interfacehipfort__hipblas_1_1hipblasssymv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 589 | [hipblasDsymv](interfacehipfort__hipblas_1_1hipblasdsymv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 590 | [hipblasCsymv](interfacehipfort__hipblas_1_1hipblascsymv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 591 | [hipblasZsymv](interfacehipfort__hipblas_1_1hipblaszsymv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 592 | [hipblasSsymv_64](interfacehipfort__hipblas_1_1hipblasssymv__64.html "Interface documentation") | C binding 593 | [hipblasDsymv_64](interfacehipfort__hipblas_1_1hipblasdsymv__64.html "Interface documentation") | C binding 594 | [hipblasCsymv_64](interfacehipfort__hipblas_1_1hipblascsymv__64.html "Interface documentation") | C binding 595 | [hipblasZsymv_64](interfacehipfort__hipblas_1_1hipblaszsymv__64.html "Interface documentation") | C binding 596 | [hipblasSsymvBatched](interfacehipfort__hipblas_1_1hipblasssymvbatched.html "Interface documentation") | C binding 597 | [hipblasDsymvBatched](interfacehipfort__hipblas_1_1hipblasdsymvbatched.html "Interface documentation") | C binding 598 | [hipblasCsymvBatched](interfacehipfort__hipblas_1_1hipblascsymvbatched.html "Interface documentation") | C binding 599 | [hipblasZsymvBatched](interfacehipfort__hipblas_1_1hipblaszsymvbatched.html "Interface documentation") | C binding 600 | [hipblasSsymvBatched_64](interfacehipfort__hipblas_1_1hipblasssymvbatched__64.html "Interface documentation") | C binding 601 | [hipblasDsymvBatched_64](interfacehipfort__hipblas_1_1hipblasdsymvbatched__64.html "Interface documentation") | C binding 602 | [hipblasCsymvBatched_64](interfacehipfort__hipblas_1_1hipblascsymvbatched__64.html "Interface documentation") | C binding 603 | [hipblasZsymvBatched_64](interfacehipfort__hipblas_1_1hipblaszsymvbatched__64.html "Interface documentation") | C binding 604 | [hipblasSsymvStridedBatched](interfacehipfort__hipblas_1_1hipblasssymvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 605 | [hipblasDsymvStridedBatched](interfacehipfort__hipblas_1_1hipblasdsymvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 606 | [hipblasCsymvStridedBatched](interfacehipfort__hipblas_1_1hipblascsymvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 607 | [hipblasZsymvStridedBatched](interfacehipfort__hipblas_1_1hipblaszsymvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 608 | [hipblasSsymvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasssymvstridedbatched__64.html "Interface documentation") | C binding 609 | [hipblasDsymvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdsymvstridedbatched__64.html "Interface documentation") | C binding 610 | [hipblasCsymvStridedBatched_64](interfacehipfort__hipblas_1_1hipblascsymvstridedbatched__64.html "Interface documentation") | C binding 611 | [hipblasZsymvStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszsymvstridedbatched__64.html "Interface documentation") | C binding 612 | [hipblasSsyr](interfacehipfort__hipblas_1_1hipblasssyr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 613 | [hipblasDsyr](interfacehipfort__hipblas_1_1hipblasdsyr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 614 | [hipblasCsyr](interfacehipfort__hipblas_1_1hipblascsyr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 615 | [hipblasZsyr](interfacehipfort__hipblas_1_1hipblaszsyr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 616 | [hipblasSsyr_64](interfacehipfort__hipblas_1_1hipblasssyr__64.html "Interface documentation") | C binding 617 | [hipblasDsyr_64](interfacehipfort__hipblas_1_1hipblasdsyr__64.html "Interface documentation") | C binding 618 | [hipblasCsyr_64](interfacehipfort__hipblas_1_1hipblascsyr__64.html "Interface documentation") | C binding 619 | [hipblasZsyr_64](interfacehipfort__hipblas_1_1hipblaszsyr__64.html "Interface documentation") | C binding 620 | [hipblasSsyrBatched](interfacehipfort__hipblas_1_1hipblasssyrbatched.html "Interface documentation") | C binding 621 | [hipblasDsyrBatched](interfacehipfort__hipblas_1_1hipblasdsyrbatched.html "Interface documentation") | C binding 622 | [hipblasCsyrBatched](interfacehipfort__hipblas_1_1hipblascsyrbatched.html "Interface documentation") | C binding 623 | [hipblasZsyrBatched](interfacehipfort__hipblas_1_1hipblaszsyrbatched.html "Interface documentation") | C binding 624 | [hipblasSsyrBatched_64](interfacehipfort__hipblas_1_1hipblasssyrbatched__64.html "Interface documentation") | C binding 625 | [hipblasDsyrBatched_64](interfacehipfort__hipblas_1_1hipblasdsyrbatched__64.html "Interface documentation") | C binding 626 | [hipblasCsyrBatched_64](interfacehipfort__hipblas_1_1hipblascsyrbatched__64.html "Interface documentation") | C binding 627 | [hipblasZsyrBatched_64](interfacehipfort__hipblas_1_1hipblaszsyrbatched__64.html "Interface documentation") | C binding 628 | [hipblasSsyrStridedBatched](interfacehipfort__hipblas_1_1hipblasssyrstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 629 | [hipblasDsyrStridedBatched](interfacehipfort__hipblas_1_1hipblasdsyrstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 630 | [hipblasCsyrStridedBatched](interfacehipfort__hipblas_1_1hipblascsyrstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 631 | [hipblasZsyrStridedBatched](interfacehipfort__hipblas_1_1hipblaszsyrstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 632 | [hipblasSsyrStridedBatched_64](interfacehipfort__hipblas_1_1hipblasssyrstridedbatched__64.html "Interface documentation") | C binding 633 | [hipblasDsyrStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdsyrstridedbatched__64.html "Interface documentation") | C binding 634 | [hipblasCsyrStridedBatched_64](interfacehipfort__hipblas_1_1hipblascsyrstridedbatched__64.html "Interface documentation") | C binding 635 | [hipblasZsyrStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszsyrstridedbatched__64.html "Interface documentation") | C binding 636 | [hipblasSsyr2](interfacehipfort__hipblas_1_1hipblasssyr2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 637 | [hipblasDsyr2](interfacehipfort__hipblas_1_1hipblasdsyr2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 638 | [hipblasCsyr2](interfacehipfort__hipblas_1_1hipblascsyr2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 639 | [hipblasZsyr2](interfacehipfort__hipblas_1_1hipblaszsyr2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 640 | [hipblasSsyr2_64](interfacehipfort__hipblas_1_1hipblasssyr2__64.html "Interface documentation") | C binding 641 | [hipblasDsyr2_64](interfacehipfort__hipblas_1_1hipblasdsyr2__64.html "Interface documentation") | C binding 642 | [hipblasCsyr2_64](interfacehipfort__hipblas_1_1hipblascsyr2__64.html "Interface documentation") | C binding 643 | [hipblasZsyr2_64](interfacehipfort__hipblas_1_1hipblaszsyr2__64.html "Interface documentation") | C binding 644 | [hipblasSsyr2Batched](interfacehipfort__hipblas_1_1hipblasssyr2batched.html "Interface documentation") | C binding 645 | [hipblasDsyr2Batched](interfacehipfort__hipblas_1_1hipblasdsyr2batched.html "Interface documentation") | C binding 646 | [hipblasCsyr2Batched](interfacehipfort__hipblas_1_1hipblascsyr2batched.html "Interface documentation") | C binding 647 | [hipblasZsyr2Batched](interfacehipfort__hipblas_1_1hipblaszsyr2batched.html "Interface documentation") | C binding 648 | [hipblasSsyr2Batched_64](interfacehipfort__hipblas_1_1hipblasssyr2batched__64.html "Interface documentation") | C binding 649 | [hipblasDsyr2Batched_64](interfacehipfort__hipblas_1_1hipblasdsyr2batched__64.html "Interface documentation") | C binding 650 | [hipblasCsyr2Batched_64](interfacehipfort__hipblas_1_1hipblascsyr2batched__64.html "Interface documentation") | C binding 651 | [hipblasZsyr2Batched_64](interfacehipfort__hipblas_1_1hipblaszsyr2batched__64.html "Interface documentation") | C binding 652 | [hipblasSsyr2StridedBatched](interfacehipfort__hipblas_1_1hipblasssyr2stridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 653 | [hipblasDsyr2StridedBatched](interfacehipfort__hipblas_1_1hipblasdsyr2stridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 654 | [hipblasCsyr2StridedBatched](interfacehipfort__hipblas_1_1hipblascsyr2stridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 655 | [hipblasZsyr2StridedBatched](interfacehipfort__hipblas_1_1hipblaszsyr2stridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 656 | [hipblasSsyr2StridedBatched_64](interfacehipfort__hipblas_1_1hipblasssyr2stridedbatched__64.html "Interface documentation") | C binding 657 | [hipblasDsyr2StridedBatched_64](interfacehipfort__hipblas_1_1hipblasdsyr2stridedbatched__64.html "Interface documentation") | C binding 658 | [hipblasCsyr2StridedBatched_64](interfacehipfort__hipblas_1_1hipblascsyr2stridedbatched__64.html "Interface documentation") | C binding 659 | [hipblasZsyr2StridedBatched_64](interfacehipfort__hipblas_1_1hipblaszsyr2stridedbatched__64.html "Interface documentation") | C binding 660 | [hipblasStbmv](interfacehipfort__hipblas_1_1hipblasstbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 661 | [hipblasDtbmv](interfacehipfort__hipblas_1_1hipblasdtbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 662 | [hipblasCtbmv](interfacehipfort__hipblas_1_1hipblasctbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 663 | [hipblasZtbmv](interfacehipfort__hipblas_1_1hipblasztbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 664 | [hipblasStbmv_64](interfacehipfort__hipblas_1_1hipblasstbmv__64.html "Interface documentation") | C binding 665 | [hipblasDtbmv_64](interfacehipfort__hipblas_1_1hipblasdtbmv__64.html "Interface documentation") | C binding 666 | [hipblasCtbmv_64](interfacehipfort__hipblas_1_1hipblasctbmv__64.html "Interface documentation") | C binding 667 | [hipblasZtbmv_64](interfacehipfort__hipblas_1_1hipblasztbmv__64.html "Interface documentation") | C binding 668 | [hipblasStbmvBatched](interfacehipfort__hipblas_1_1hipblasstbmvbatched.html "Interface documentation") | C binding 669 | [hipblasDtbmvBatched](interfacehipfort__hipblas_1_1hipblasdtbmvbatched.html "Interface documentation") | C binding 670 | [hipblasCtbmvBatched](interfacehipfort__hipblas_1_1hipblasctbmvbatched.html "Interface documentation") | C binding 671 | [hipblasZtbmvBatched](interfacehipfort__hipblas_1_1hipblasztbmvbatched.html "Interface documentation") | C binding 672 | [hipblasStbmvBatched_64](interfacehipfort__hipblas_1_1hipblasstbmvbatched__64.html "Interface documentation") | C binding 673 | [hipblasDtbmvBatched_64](interfacehipfort__hipblas_1_1hipblasdtbmvbatched__64.html "Interface documentation") | C binding 674 | [hipblasCtbmvBatched_64](interfacehipfort__hipblas_1_1hipblasctbmvbatched__64.html "Interface documentation") | C binding 675 | [hipblasZtbmvBatched_64](interfacehipfort__hipblas_1_1hipblasztbmvbatched__64.html "Interface documentation") | C binding 676 | [hipblasStbmvStridedBatched](interfacehipfort__hipblas_1_1hipblasstbmvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 677 | [hipblasDtbmvStridedBatched](interfacehipfort__hipblas_1_1hipblasdtbmvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 678 | [hipblasCtbmvStridedBatched](interfacehipfort__hipblas_1_1hipblasctbmvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 679 | [hipblasZtbmvStridedBatched](interfacehipfort__hipblas_1_1hipblasztbmvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 680 | [hipblasStbmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasstbmvstridedbatched__64.html "Interface documentation") | C binding 681 | [hipblasDtbmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdtbmvstridedbatched__64.html "Interface documentation") | C binding 682 | [hipblasCtbmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasctbmvstridedbatched__64.html "Interface documentation") | C binding 683 | [hipblasZtbmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasztbmvstridedbatched__64.html "Interface documentation") | C binding 684 | [hipblasStbsv](interfacehipfort__hipblas_1_1hipblasstbsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 685 | [hipblasDtbsv](interfacehipfort__hipblas_1_1hipblasdtbsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 686 | [hipblasCtbsv](interfacehipfort__hipblas_1_1hipblasctbsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 687 | [hipblasZtbsv](interfacehipfort__hipblas_1_1hipblasztbsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 688 | [hipblasStbsv_64](interfacehipfort__hipblas_1_1hipblasstbsv__64.html "Interface documentation") | C binding 689 | [hipblasDtbsv_64](interfacehipfort__hipblas_1_1hipblasdtbsv__64.html "Interface documentation") | C binding 690 | [hipblasCtbsv_64](interfacehipfort__hipblas_1_1hipblasctbsv__64.html "Interface documentation") | C binding 691 | [hipblasZtbsv_64](interfacehipfort__hipblas_1_1hipblasztbsv__64.html "Interface documentation") | C binding 692 | [hipblasStbsvBatched](interfacehipfort__hipblas_1_1hipblasstbsvbatched.html "Interface documentation") | C binding 693 | [hipblasDtbsvBatched](interfacehipfort__hipblas_1_1hipblasdtbsvbatched.html "Interface documentation") | C binding 694 | [hipblasCtbsvBatched](interfacehipfort__hipblas_1_1hipblasctbsvbatched.html "Interface documentation") | C binding 695 | [hipblasZtbsvBatched](interfacehipfort__hipblas_1_1hipblasztbsvbatched.html "Interface documentation") | C binding 696 | [hipblasStbsvBatched_64](interfacehipfort__hipblas_1_1hipblasstbsvbatched__64.html "Interface documentation") | C binding 697 | [hipblasDtbsvBatched_64](interfacehipfort__hipblas_1_1hipblasdtbsvbatched__64.html "Interface documentation") | C binding 698 | [hipblasCtbsvBatched_64](interfacehipfort__hipblas_1_1hipblasctbsvbatched__64.html "Interface documentation") | C binding 699 | [hipblasZtbsvBatched_64](interfacehipfort__hipblas_1_1hipblasztbsvbatched__64.html "Interface documentation") | C binding 700 | [hipblasStbsvStridedBatched](interfacehipfort__hipblas_1_1hipblasstbsvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 701 | [hipblasDtbsvStridedBatched](interfacehipfort__hipblas_1_1hipblasdtbsvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 702 | [hipblasCtbsvStridedBatched](interfacehipfort__hipblas_1_1hipblasctbsvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 703 | [hipblasZtbsvStridedBatched](interfacehipfort__hipblas_1_1hipblasztbsvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 704 | [hipblasStbsvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasstbsvstridedbatched__64.html "Interface documentation") | C binding 705 | [hipblasDtbsvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdtbsvstridedbatched__64.html "Interface documentation") | C binding 706 | [hipblasCtbsvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasctbsvstridedbatched__64.html "Interface documentation") | C binding 707 | [hipblasZtbsvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasztbsvstridedbatched__64.html "Interface documentation") | C binding 708 | [hipblasStpmv](interfacehipfort__hipblas_1_1hipblasstpmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 709 | [hipblasDtpmv](interfacehipfort__hipblas_1_1hipblasdtpmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 710 | [hipblasCtpmv](interfacehipfort__hipblas_1_1hipblasctpmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 711 | [hipblasZtpmv](interfacehipfort__hipblas_1_1hipblasztpmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 712 | [hipblasStpmv_64](interfacehipfort__hipblas_1_1hipblasstpmv__64.html "Interface documentation") | C binding 713 | [hipblasDtpmv_64](interfacehipfort__hipblas_1_1hipblasdtpmv__64.html "Interface documentation") | C binding 714 | [hipblasCtpmv_64](interfacehipfort__hipblas_1_1hipblasctpmv__64.html "Interface documentation") | C binding 715 | [hipblasZtpmv_64](interfacehipfort__hipblas_1_1hipblasztpmv__64.html "Interface documentation") | C binding 716 | [hipblasStpmvBatched](interfacehipfort__hipblas_1_1hipblasstpmvbatched.html "Interface documentation") | C binding 717 | [hipblasDtpmvBatched](interfacehipfort__hipblas_1_1hipblasdtpmvbatched.html "Interface documentation") | C binding 718 | [hipblasCtpmvBatched](interfacehipfort__hipblas_1_1hipblasctpmvbatched.html "Interface documentation") | C binding 719 | [hipblasZtpmvBatched](interfacehipfort__hipblas_1_1hipblasztpmvbatched.html "Interface documentation") | C binding 720 | [hipblasStpmvBatched_64](interfacehipfort__hipblas_1_1hipblasstpmvbatched__64.html "Interface documentation") | C binding 721 | [hipblasDtpmvBatched_64](interfacehipfort__hipblas_1_1hipblasdtpmvbatched__64.html "Interface documentation") | C binding 722 | [hipblasCtpmvBatched_64](interfacehipfort__hipblas_1_1hipblasctpmvbatched__64.html "Interface documentation") | C binding 723 | [hipblasZtpmvBatched_64](interfacehipfort__hipblas_1_1hipblasztpmvbatched__64.html "Interface documentation") | C binding 724 | [hipblasStpmvStridedBatched](interfacehipfort__hipblas_1_1hipblasstpmvstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 725 | [hipblasDtpmvStridedBatched](interfacehipfort__hipblas_1_1hipblasdtpmvstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 726 | [hipblasCtpmvStridedBatched](interfacehipfort__hipblas_1_1hipblasctpmvstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 727 | [hipblasZtpmvStridedBatched](interfacehipfort__hipblas_1_1hipblasztpmvstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 728 | [hipblasStpmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasstpmvstridedbatched__64.html "Interface documentation") | C binding 729 | [hipblasDtpmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdtpmvstridedbatched__64.html "Interface documentation") | C binding 730 | [hipblasCtpmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasctpmvstridedbatched__64.html "Interface documentation") | C binding 731 | [hipblasZtpmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasztpmvstridedbatched__64.html "Interface documentation") | C binding 732 | [hipblasStpsv](interfacehipfort__hipblas_1_1hipblasstpsv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 733 | [hipblasDtpsv](interfacehipfort__hipblas_1_1hipblasdtpsv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 734 | [hipblasCtpsv](interfacehipfort__hipblas_1_1hipblasctpsv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 735 | [hipblasZtpsv](interfacehipfort__hipblas_1_1hipblasztpsv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 736 | [hipblasStpsv_64](interfacehipfort__hipblas_1_1hipblasstpsv__64.html "Interface documentation") | C binding 737 | [hipblasDtpsv_64](interfacehipfort__hipblas_1_1hipblasdtpsv__64.html "Interface documentation") | C binding 738 | [hipblasCtpsv_64](interfacehipfort__hipblas_1_1hipblasctpsv__64.html "Interface documentation") | C binding 739 | [hipblasZtpsv_64](interfacehipfort__hipblas_1_1hipblasztpsv__64.html "Interface documentation") | C binding 740 | [hipblasStpsvBatched](interfacehipfort__hipblas_1_1hipblasstpsvbatched.html "Interface documentation") | C binding 741 | [hipblasDtpsvBatched](interfacehipfort__hipblas_1_1hipblasdtpsvbatched.html "Interface documentation") | C binding 742 | [hipblasCtpsvBatched](interfacehipfort__hipblas_1_1hipblasctpsvbatched.html "Interface documentation") | C binding 743 | [hipblasZtpsvBatched](interfacehipfort__hipblas_1_1hipblasztpsvbatched.html "Interface documentation") | C binding 744 | [hipblasStpsvBatched_64](interfacehipfort__hipblas_1_1hipblasstpsvbatched__64.html "Interface documentation") | C binding 745 | [hipblasDtpsvBatched_64](interfacehipfort__hipblas_1_1hipblasdtpsvbatched__64.html "Interface documentation") | C binding 746 | [hipblasCtpsvBatched_64](interfacehipfort__hipblas_1_1hipblasctpsvbatched__64.html "Interface documentation") | C binding 747 | [hipblasZtpsvBatched_64](interfacehipfort__hipblas_1_1hipblasztpsvbatched__64.html "Interface documentation") | C binding 748 | [hipblasStpsvStridedBatched](interfacehipfort__hipblas_1_1hipblasstpsvstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 749 | [hipblasDtpsvStridedBatched](interfacehipfort__hipblas_1_1hipblasdtpsvstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 750 | [hipblasCtpsvStridedBatched](interfacehipfort__hipblas_1_1hipblasctpsvstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 751 | [hipblasZtpsvStridedBatched](interfacehipfort__hipblas_1_1hipblasztpsvstridedbatched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 752 | [hipblasStpsvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasstpsvstridedbatched__64.html "Interface documentation") | C binding 753 | [hipblasDtpsvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdtpsvstridedbatched__64.html "Interface documentation") | C binding 754 | [hipblasCtpsvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasctpsvstridedbatched__64.html "Interface documentation") | C binding 755 | [hipblasZtpsvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasztpsvstridedbatched__64.html "Interface documentation") | C binding 756 | [hipblasStrmv](interfacehipfort__hipblas_1_1hipblasstrmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 757 | [hipblasDtrmv](interfacehipfort__hipblas_1_1hipblasdtrmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 758 | [hipblasCtrmv](interfacehipfort__hipblas_1_1hipblasctrmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 759 | [hipblasZtrmv](interfacehipfort__hipblas_1_1hipblasztrmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 760 | [hipblasStrmv_64](interfacehipfort__hipblas_1_1hipblasstrmv__64.html "Interface documentation") | C binding 761 | [hipblasDtrmv_64](interfacehipfort__hipblas_1_1hipblasdtrmv__64.html "Interface documentation") | C binding 762 | [hipblasCtrmv_64](interfacehipfort__hipblas_1_1hipblasctrmv__64.html "Interface documentation") | C binding 763 | [hipblasZtrmv_64](interfacehipfort__hipblas_1_1hipblasztrmv__64.html "Interface documentation") | C binding 764 | [hipblasStrmvBatched](interfacehipfort__hipblas_1_1hipblasstrmvbatched.html "Interface documentation") | C binding 765 | [hipblasDtrmvBatched](interfacehipfort__hipblas_1_1hipblasdtrmvbatched.html "Interface documentation") | C binding 766 | [hipblasCtrmvBatched](interfacehipfort__hipblas_1_1hipblasctrmvbatched.html "Interface documentation") | C binding 767 | [hipblasZtrmvBatched](interfacehipfort__hipblas_1_1hipblasztrmvbatched.html "Interface documentation") | C binding 768 | [hipblasStrmvBatched_64](interfacehipfort__hipblas_1_1hipblasstrmvbatched__64.html "Interface documentation") | C binding 769 | [hipblasDtrmvBatched_64](interfacehipfort__hipblas_1_1hipblasdtrmvbatched__64.html "Interface documentation") | C binding 770 | [hipblasCtrmvBatched_64](interfacehipfort__hipblas_1_1hipblasctrmvbatched__64.html "Interface documentation") | C binding 771 | [hipblasZtrmvBatched_64](interfacehipfort__hipblas_1_1hipblasztrmvbatched__64.html "Interface documentation") | C binding 772 | [hipblasStrmvStridedBatched](interfacehipfort__hipblas_1_1hipblasstrmvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 773 | [hipblasDtrmvStridedBatched](interfacehipfort__hipblas_1_1hipblasdtrmvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 774 | [hipblasCtrmvStridedBatched](interfacehipfort__hipblas_1_1hipblasctrmvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 775 | [hipblasZtrmvStridedBatched](interfacehipfort__hipblas_1_1hipblasztrmvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 776 | [hipblasStrmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasstrmvstridedbatched__64.html "Interface documentation") | C binding 777 | [hipblasDtrmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdtrmvstridedbatched__64.html "Interface documentation") | C binding 778 | [hipblasCtrmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasctrmvstridedbatched__64.html "Interface documentation") | C binding 779 | [hipblasZtrmvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasztrmvstridedbatched__64.html "Interface documentation") | C binding 780 | [hipblasStrsv](interfacehipfort__hipblas_1_1hipblasstrsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 781 | [hipblasDtrsv](interfacehipfort__hipblas_1_1hipblasdtrsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 782 | [hipblasCtrsv](interfacehipfort__hipblas_1_1hipblasctrsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 783 | [hipblasZtrsv](interfacehipfort__hipblas_1_1hipblasztrsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 784 | [hipblasStrsv_64](interfacehipfort__hipblas_1_1hipblasstrsv__64.html "Interface documentation") | C binding 785 | [hipblasDtrsv_64](interfacehipfort__hipblas_1_1hipblasdtrsv__64.html "Interface documentation") | C binding 786 | [hipblasCtrsv_64](interfacehipfort__hipblas_1_1hipblasctrsv__64.html "Interface documentation") | C binding 787 | [hipblasZtrsv_64](interfacehipfort__hipblas_1_1hipblasztrsv__64.html "Interface documentation") | C binding 788 | [hipblasStrsvBatched](interfacehipfort__hipblas_1_1hipblasstrsvbatched.html "Interface documentation") | C binding 789 | [hipblasDtrsvBatched](interfacehipfort__hipblas_1_1hipblasdtrsvbatched.html "Interface documentation") | C binding 790 | [hipblasCtrsvBatched](interfacehipfort__hipblas_1_1hipblasctrsvbatched.html "Interface documentation") | C binding 791 | [hipblasZtrsvBatched](interfacehipfort__hipblas_1_1hipblasztrsvbatched.html "Interface documentation") | C binding 792 | [hipblasStrsvBatched_64](interfacehipfort__hipblas_1_1hipblasstrsvbatched__64.html "Interface documentation") | C binding 793 | [hipblasDtrsvBatched_64](interfacehipfort__hipblas_1_1hipblasdtrsvbatched__64.html "Interface documentation") | C binding 794 | [hipblasCtrsvBatched_64](interfacehipfort__hipblas_1_1hipblasctrsvbatched__64.html "Interface documentation") | C binding 795 | [hipblasZtrsvBatched_64](interfacehipfort__hipblas_1_1hipblasztrsvbatched__64.html "Interface documentation") | C binding 796 | [hipblasStrsvStridedBatched](interfacehipfort__hipblas_1_1hipblasstrsvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 797 | [hipblasDtrsvStridedBatched](interfacehipfort__hipblas_1_1hipblasdtrsvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 798 | [hipblasCtrsvStridedBatched](interfacehipfort__hipblas_1_1hipblasctrsvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 799 | [hipblasZtrsvStridedBatched](interfacehipfort__hipblas_1_1hipblasztrsvstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 800 | [hipblasStrsvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasstrsvstridedbatched__64.html "Interface documentation") | C binding 801 | [hipblasDtrsvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdtrsvstridedbatched__64.html "Interface documentation") | C binding 802 | [hipblasCtrsvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasctrsvstridedbatched__64.html "Interface documentation") | C binding 803 | [hipblasZtrsvStridedBatched_64](interfacehipfort__hipblas_1_1hipblasztrsvstridedbatched__64.html "Interface documentation") | C binding 804 | [hipblasHgemm](interfacehipfort__hipblas_1_1hipblashgemm.html "Interface documentation") | C binding 805 | [hipblasSgemm](interfacehipfort__hipblas_1_1hipblassgemm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 806 | [hipblasDgemm](interfacehipfort__hipblas_1_1hipblasdgemm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 807 | [hipblasCgemm](interfacehipfort__hipblas_1_1hipblascgemm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 808 | [hipblasZgemm](interfacehipfort__hipblas_1_1hipblaszgemm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 809 | [hipblasHgemm_64](interfacehipfort__hipblas_1_1hipblashgemm__64.html "Interface documentation") | C binding 810 | [hipblasSgemm_64](interfacehipfort__hipblas_1_1hipblassgemm__64.html "Interface documentation") | C binding 811 | [hipblasDgemm_64](interfacehipfort__hipblas_1_1hipblasdgemm__64.html "Interface documentation") | C binding 812 | [hipblasCgemm_64](interfacehipfort__hipblas_1_1hipblascgemm__64.html "Interface documentation") | C binding 813 | [hipblasZgemm_64](interfacehipfort__hipblas_1_1hipblaszgemm__64.html "Interface documentation") | C binding 814 | [hipblasHgemmBatched](interfacehipfort__hipblas_1_1hipblashgemmbatched.html "Interface documentation") | C binding 815 | [hipblasSgemmBatched](interfacehipfort__hipblas_1_1hipblassgemmbatched.html "Interface documentation") | C binding 816 | [hipblasDgemmBatched](interfacehipfort__hipblas_1_1hipblasdgemmbatched.html "Interface documentation") | C binding 817 | [hipblasCgemmBatched](interfacehipfort__hipblas_1_1hipblascgemmbatched.html "Interface documentation") | C binding 818 | [hipblasZgemmBatched](interfacehipfort__hipblas_1_1hipblaszgemmbatched.html "Interface documentation") | C binding 819 | [hipblasHgemmBatched_64](interfacehipfort__hipblas_1_1hipblashgemmbatched__64.html "Interface documentation") | C binding 820 | [hipblasSgemmBatched_64](interfacehipfort__hipblas_1_1hipblassgemmbatched__64.html "Interface documentation") | C binding 821 | [hipblasDgemmBatched_64](interfacehipfort__hipblas_1_1hipblasdgemmbatched__64.html "Interface documentation") | C binding 822 | [hipblasCgemmBatched_64](interfacehipfort__hipblas_1_1hipblascgemmbatched__64.html "Interface documentation") | C binding 823 | [hipblasZgemmBatched_64](interfacehipfort__hipblas_1_1hipblaszgemmbatched__64.html "Interface documentation") | C binding 824 | [hipblasHgemmStridedBatched](interfacehipfort__hipblas_1_1hipblashgemmstridedbatched.html "Interface documentation") | C binding 825 | [hipblasSgemmStridedBatched](interfacehipfort__hipblas_1_1hipblassgemmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 826 | [hipblasDgemmStridedBatched](interfacehipfort__hipblas_1_1hipblasdgemmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 827 | [hipblasCgemmStridedBatched](interfacehipfort__hipblas_1_1hipblascgemmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 828 | [hipblasZgemmStridedBatched](interfacehipfort__hipblas_1_1hipblaszgemmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 829 | [hipblasHgemmStridedBatched_64](interfacehipfort__hipblas_1_1hipblashgemmstridedbatched__64.html "Interface documentation") | C binding 830 | [hipblasSgemmStridedBatched_64](interfacehipfort__hipblas_1_1hipblassgemmstridedbatched__64.html "Interface documentation") | C binding 831 | [hipblasDgemmStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdgemmstridedbatched__64.html "Interface documentation") | C binding 832 | [hipblasCgemmStridedBatched_64](interfacehipfort__hipblas_1_1hipblascgemmstridedbatched__64.html "Interface documentation") | C binding 833 | [hipblasZgemmStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszgemmstridedbatched__64.html "Interface documentation") | C binding 834 | [hipblasCherk](interfacehipfort__hipblas_1_1hipblascherk.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 835 | [hipblasZherk](interfacehipfort__hipblas_1_1hipblaszherk.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 836 | [hipblasCherk_64](interfacehipfort__hipblas_1_1hipblascherk__64.html "Interface documentation") | C binding 837 | [hipblasZherk_64](interfacehipfort__hipblas_1_1hipblaszherk__64.html "Interface documentation") | C binding 838 | [hipblasCherkBatched](interfacehipfort__hipblas_1_1hipblascherkbatched.html "Interface documentation") | C binding 839 | [hipblasZherkBatched](interfacehipfort__hipblas_1_1hipblaszherkbatched.html "Interface documentation") | C binding 840 | [hipblasCherkBatched_64](interfacehipfort__hipblas_1_1hipblascherkbatched__64.html "Interface documentation") | C binding 841 | [hipblasZherkBatched_64](interfacehipfort__hipblas_1_1hipblaszherkbatched__64.html "Interface documentation") | C binding 842 | [hipblasCherkStridedBatched](interfacehipfort__hipblas_1_1hipblascherkstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 843 | [hipblasZherkStridedBatched](interfacehipfort__hipblas_1_1hipblaszherkstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 844 | [hipblasCherkStridedBatched_64](interfacehipfort__hipblas_1_1hipblascherkstridedbatched__64.html "Interface documentation") | C binding 845 | [hipblasZherkStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszherkstridedbatched__64.html "Interface documentation") | C binding 846 | [hipblasCherkx](interfacehipfort__hipblas_1_1hipblascherkx.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 847 | [hipblasZherkx](interfacehipfort__hipblas_1_1hipblaszherkx.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 848 | [hipblasCherkx_64](interfacehipfort__hipblas_1_1hipblascherkx__64.html "Interface documentation") | C binding 849 | [hipblasZherkx_64](interfacehipfort__hipblas_1_1hipblaszherkx__64.html "Interface documentation") | C binding 850 | [hipblasCherkxBatched](interfacehipfort__hipblas_1_1hipblascherkxbatched.html "Interface documentation") | C binding 851 | [hipblasZherkxBatched](interfacehipfort__hipblas_1_1hipblaszherkxbatched.html "Interface documentation") | C binding 852 | [hipblasCherkxBatched_64](interfacehipfort__hipblas_1_1hipblascherkxbatched__64.html "Interface documentation") | C binding 853 | [hipblasZherkxBatched_64](interfacehipfort__hipblas_1_1hipblaszherkxbatched__64.html "Interface documentation") | C binding 854 | [hipblasCherkxStridedBatched](interfacehipfort__hipblas_1_1hipblascherkxstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 855 | [hipblasZherkxStridedBatched](interfacehipfort__hipblas_1_1hipblaszherkxstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 856 | [hipblasCherkxStridedBatched_64](interfacehipfort__hipblas_1_1hipblascherkxstridedbatched__64.html "Interface documentation") | C binding 857 | [hipblasZherkxStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszherkxstridedbatched__64.html "Interface documentation") | C binding 858 | [hipblasCher2k](interfacehipfort__hipblas_1_1hipblascher2k.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 859 | [hipblasZher2k](interfacehipfort__hipblas_1_1hipblaszher2k.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 860 | [hipblasCher2k_64](interfacehipfort__hipblas_1_1hipblascher2k__64.html "Interface documentation") | C binding 861 | [hipblasZher2k_64](interfacehipfort__hipblas_1_1hipblaszher2k__64.html "Interface documentation") | C binding 862 | [hipblasCher2kBatched](interfacehipfort__hipblas_1_1hipblascher2kbatched.html "Interface documentation") | C binding 863 | [hipblasZher2kBatched](interfacehipfort__hipblas_1_1hipblaszher2kbatched.html "Interface documentation") | C binding 864 | [hipblasCher2kBatched_64](interfacehipfort__hipblas_1_1hipblascher2kbatched__64.html "Interface documentation") | C binding 865 | [hipblasZher2kBatched_64](interfacehipfort__hipblas_1_1hipblaszher2kbatched__64.html "Interface documentation") | C binding 866 | [hipblasCher2kStridedBatched](interfacehipfort__hipblas_1_1hipblascher2kstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 867 | [hipblasZher2kStridedBatched](interfacehipfort__hipblas_1_1hipblaszher2kstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 868 | [hipblasCher2kStridedBatched_64](interfacehipfort__hipblas_1_1hipblascher2kstridedbatched__64.html "Interface documentation") | C binding 869 | [hipblasZher2kStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszher2kstridedbatched__64.html "Interface documentation") | C binding 870 | [hipblasSsymm](interfacehipfort__hipblas_1_1hipblasssymm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 871 | [hipblasDsymm](interfacehipfort__hipblas_1_1hipblasdsymm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 872 | [hipblasCsymm](interfacehipfort__hipblas_1_1hipblascsymm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 873 | [hipblasZsymm](interfacehipfort__hipblas_1_1hipblaszsymm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 874 | [hipblasSsymm_64](interfacehipfort__hipblas_1_1hipblasssymm__64.html "Interface documentation") | C binding 875 | [hipblasDsymm_64](interfacehipfort__hipblas_1_1hipblasdsymm__64.html "Interface documentation") | C binding 876 | [hipblasCsymm_64](interfacehipfort__hipblas_1_1hipblascsymm__64.html "Interface documentation") | C binding 877 | [hipblasZsymm_64](interfacehipfort__hipblas_1_1hipblaszsymm__64.html "Interface documentation") | C binding 878 | [hipblasSsymmBatched](interfacehipfort__hipblas_1_1hipblasssymmbatched.html "Interface documentation") | C binding 879 | [hipblasDsymmBatched](interfacehipfort__hipblas_1_1hipblasdsymmbatched.html "Interface documentation") | C binding 880 | [hipblasCsymmBatched](interfacehipfort__hipblas_1_1hipblascsymmbatched.html "Interface documentation") | C binding 881 | [hipblasZsymmBatched](interfacehipfort__hipblas_1_1hipblaszsymmbatched.html "Interface documentation") | C binding 882 | [hipblasSsymmBatched_64](interfacehipfort__hipblas_1_1hipblasssymmbatched__64.html "Interface documentation") | C binding 883 | [hipblasDsymmBatched_64](interfacehipfort__hipblas_1_1hipblasdsymmbatched__64.html "Interface documentation") | C binding 884 | [hipblasCsymmBatched_64](interfacehipfort__hipblas_1_1hipblascsymmbatched__64.html "Interface documentation") | C binding 885 | [hipblasZsymmBatched_64](interfacehipfort__hipblas_1_1hipblaszsymmbatched__64.html "Interface documentation") | C binding 886 | [hipblasSsymmStridedBatched](interfacehipfort__hipblas_1_1hipblasssymmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 887 | [hipblasDsymmStridedBatched](interfacehipfort__hipblas_1_1hipblasdsymmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 888 | [hipblasCsymmStridedBatched](interfacehipfort__hipblas_1_1hipblascsymmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 889 | [hipblasZsymmStridedBatched](interfacehipfort__hipblas_1_1hipblaszsymmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 890 | [hipblasSsymmStridedBatched_64](interfacehipfort__hipblas_1_1hipblasssymmstridedbatched__64.html "Interface documentation") | C binding 891 | [hipblasDsymmStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdsymmstridedbatched__64.html "Interface documentation") | C binding 892 | [hipblasCsymmStridedBatched_64](interfacehipfort__hipblas_1_1hipblascsymmstridedbatched__64.html "Interface documentation") | C binding 893 | [hipblasZsymmStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszsymmstridedbatched__64.html "Interface documentation") | C binding 894 | [hipblasSsyrk](interfacehipfort__hipblas_1_1hipblasssyrk.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 895 | [hipblasDsyrk](interfacehipfort__hipblas_1_1hipblasdsyrk.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 896 | [hipblasCsyrk](interfacehipfort__hipblas_1_1hipblascsyrk.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 897 | [hipblasZsyrk](interfacehipfort__hipblas_1_1hipblaszsyrk.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 898 | [hipblasSsyrk_64](interfacehipfort__hipblas_1_1hipblasssyrk__64.html "Interface documentation") | C binding 899 | [hipblasDsyrk_64](interfacehipfort__hipblas_1_1hipblasdsyrk__64.html "Interface documentation") | C binding 900 | [hipblasCsyrk_64](interfacehipfort__hipblas_1_1hipblascsyrk__64.html "Interface documentation") | C binding 901 | [hipblasZsyrk_64](interfacehipfort__hipblas_1_1hipblaszsyrk__64.html "Interface documentation") | C binding 902 | [hipblasSsyrkBatched](interfacehipfort__hipblas_1_1hipblasssyrkbatched.html "Interface documentation") | C binding 903 | [hipblasDsyrkBatched](interfacehipfort__hipblas_1_1hipblasdsyrkbatched.html "Interface documentation") | C binding 904 | [hipblasCsyrkBatched](interfacehipfort__hipblas_1_1hipblascsyrkbatched.html "Interface documentation") | C binding 905 | [hipblasZsyrkBatched](interfacehipfort__hipblas_1_1hipblaszsyrkbatched.html "Interface documentation") | C binding 906 | [hipblasSsyrkBatched_64](interfacehipfort__hipblas_1_1hipblasssyrkbatched__64.html "Interface documentation") | C binding 907 | [hipblasDsyrkBatched_64](interfacehipfort__hipblas_1_1hipblasdsyrkbatched__64.html "Interface documentation") | C binding 908 | [hipblasCsyrkBatched_64](interfacehipfort__hipblas_1_1hipblascsyrkbatched__64.html "Interface documentation") | C binding 909 | [hipblasZsyrkBatched_64](interfacehipfort__hipblas_1_1hipblaszsyrkbatched__64.html "Interface documentation") | C binding 910 | [hipblasSsyrkStridedBatched](interfacehipfort__hipblas_1_1hipblasssyrkstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 911 | [hipblasDsyrkStridedBatched](interfacehipfort__hipblas_1_1hipblasdsyrkstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 912 | [hipblasCsyrkStridedBatched](interfacehipfort__hipblas_1_1hipblascsyrkstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 913 | [hipblasZsyrkStridedBatched](interfacehipfort__hipblas_1_1hipblaszsyrkstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 914 | [hipblasSsyrkStridedBatched_64](interfacehipfort__hipblas_1_1hipblasssyrkstridedbatched__64.html "Interface documentation") | C binding 915 | [hipblasDsyrkStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdsyrkstridedbatched__64.html "Interface documentation") | C binding 916 | [hipblasCsyrkStridedBatched_64](interfacehipfort__hipblas_1_1hipblascsyrkstridedbatched__64.html "Interface documentation") | C binding 917 | [hipblasZsyrkStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszsyrkstridedbatched__64.html "Interface documentation") | C binding 918 | [hipblasSsyr2k](interfacehipfort__hipblas_1_1hipblasssyr2k.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 919 | [hipblasDsyr2k](interfacehipfort__hipblas_1_1hipblasdsyr2k.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 920 | [hipblasCsyr2k](interfacehipfort__hipblas_1_1hipblascsyr2k.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 921 | [hipblasZsyr2k](interfacehipfort__hipblas_1_1hipblaszsyr2k.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 922 | [hipblasSsyr2k_64](interfacehipfort__hipblas_1_1hipblasssyr2k__64.html "Interface documentation") | C binding 923 | [hipblasDsyr2k_64](interfacehipfort__hipblas_1_1hipblasdsyr2k__64.html "Interface documentation") | C binding 924 | [hipblasCsyr2k_64](interfacehipfort__hipblas_1_1hipblascsyr2k__64.html "Interface documentation") | C binding 925 | [hipblasZsyr2k_64](interfacehipfort__hipblas_1_1hipblaszsyr2k__64.html "Interface documentation") | C binding 926 | [hipblasSsyr2kBatched](interfacehipfort__hipblas_1_1hipblasssyr2kbatched.html "Interface documentation") | C binding 927 | [hipblasDsyr2kBatched](interfacehipfort__hipblas_1_1hipblasdsyr2kbatched.html "Interface documentation") | C binding 928 | [hipblasCsyr2kBatched](interfacehipfort__hipblas_1_1hipblascsyr2kbatched.html "Interface documentation") | C binding 929 | [hipblasZsyr2kBatched](interfacehipfort__hipblas_1_1hipblaszsyr2kbatched.html "Interface documentation") | C binding 930 | [hipblasSsyr2kBatched_64](interfacehipfort__hipblas_1_1hipblasssyr2kbatched__64.html "Interface documentation") | C binding 931 | [hipblasDsyr2kBatched_64](interfacehipfort__hipblas_1_1hipblasdsyr2kbatched__64.html "Interface documentation") | C binding 932 | [hipblasCsyr2kBatched_64](interfacehipfort__hipblas_1_1hipblascsyr2kbatched__64.html "Interface documentation") | C binding 933 | [hipblasZsyr2kBatched_64](interfacehipfort__hipblas_1_1hipblaszsyr2kbatched__64.html "Interface documentation") | C binding 934 | [hipblasSsyr2kStridedBatched](interfacehipfort__hipblas_1_1hipblasssyr2kstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 935 | [hipblasDsyr2kStridedBatched](interfacehipfort__hipblas_1_1hipblasdsyr2kstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 936 | [hipblasCsyr2kStridedBatched](interfacehipfort__hipblas_1_1hipblascsyr2kstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 937 | [hipblasZsyr2kStridedBatched](interfacehipfort__hipblas_1_1hipblaszsyr2kstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 938 | [hipblasSsyr2kStridedBatched_64](interfacehipfort__hipblas_1_1hipblasssyr2kstridedbatched__64.html "Interface documentation") | C binding 939 | [hipblasDsyr2kStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdsyr2kstridedbatched__64.html "Interface documentation") | C binding 940 | [hipblasCsyr2kStridedBatched_64](interfacehipfort__hipblas_1_1hipblascsyr2kstridedbatched__64.html "Interface documentation") | C binding 941 | [hipblasZsyr2kStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszsyr2kstridedbatched__64.html "Interface documentation") | C binding 942 | [hipblasSsyrkx](interfacehipfort__hipblas_1_1hipblasssyrkx.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 943 | [hipblasDsyrkx](interfacehipfort__hipblas_1_1hipblasdsyrkx.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 944 | [hipblasCsyrkx](interfacehipfort__hipblas_1_1hipblascsyrkx.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 945 | [hipblasZsyrkx](interfacehipfort__hipblas_1_1hipblaszsyrkx.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 946 | [hipblasSsyrkx_64](interfacehipfort__hipblas_1_1hipblasssyrkx__64.html "Interface documentation") | C binding 947 | [hipblasDsyrkx_64](interfacehipfort__hipblas_1_1hipblasdsyrkx__64.html "Interface documentation") | C binding 948 | [hipblasCsyrkx_64](interfacehipfort__hipblas_1_1hipblascsyrkx__64.html "Interface documentation") | C binding 949 | [hipblasZsyrkx_64](interfacehipfort__hipblas_1_1hipblaszsyrkx__64.html "Interface documentation") | C binding 950 | [hipblasSsyrkxBatched](interfacehipfort__hipblas_1_1hipblasssyrkxbatched.html "Interface documentation") | C binding 951 | [hipblasDsyrkxBatched](interfacehipfort__hipblas_1_1hipblasdsyrkxbatched.html "Interface documentation") | C binding 952 | [hipblasCsyrkxBatched](interfacehipfort__hipblas_1_1hipblascsyrkxbatched.html "Interface documentation") | C binding 953 | [hipblasZsyrkxBatched](interfacehipfort__hipblas_1_1hipblaszsyrkxbatched.html "Interface documentation") | C binding 954 | [hipblasSsyrkxBatched_64](interfacehipfort__hipblas_1_1hipblasssyrkxbatched__64.html "Interface documentation") | C binding 955 | [hipblasDsyrkxBatched_64](interfacehipfort__hipblas_1_1hipblasdsyrkxbatched__64.html "Interface documentation") | C binding 956 | [hipblasCsyrkxBatched_64](interfacehipfort__hipblas_1_1hipblascsyrkxbatched__64.html "Interface documentation") | C binding 957 | [hipblasZsyrkxBatched_64](interfacehipfort__hipblas_1_1hipblaszsyrkxbatched__64.html "Interface documentation") | C binding 958 | [hipblasSsyrkxStridedBatched](interfacehipfort__hipblas_1_1hipblasssyrkxstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 959 | [hipblasDsyrkxStridedBatched](interfacehipfort__hipblas_1_1hipblasdsyrkxstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 960 | [hipblasCsyrkxStridedBatched](interfacehipfort__hipblas_1_1hipblascsyrkxstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 961 | [hipblasZsyrkxStridedBatched](interfacehipfort__hipblas_1_1hipblaszsyrkxstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 962 | [hipblasSsyrkxStridedBatched_64](interfacehipfort__hipblas_1_1hipblasssyrkxstridedbatched__64.html "Interface documentation") | C binding 963 | [hipblasDsyrkxStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdsyrkxstridedbatched__64.html "Interface documentation") | C binding 964 | [hipblasCsyrkxStridedBatched_64](interfacehipfort__hipblas_1_1hipblascsyrkxstridedbatched__64.html "Interface documentation") | C binding 965 | [hipblasZsyrkxStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszsyrkxstridedbatched__64.html "Interface documentation") | C binding 966 | [hipblasSgeam](interfacehipfort__hipblas_1_1hipblassgeam.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 967 | [hipblasDgeam](interfacehipfort__hipblas_1_1hipblasdgeam.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 968 | [hipblasCgeam](interfacehipfort__hipblas_1_1hipblascgeam.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 969 | [hipblasZgeam](interfacehipfort__hipblas_1_1hipblaszgeam.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 970 | [hipblasSgeam_64](interfacehipfort__hipblas_1_1hipblassgeam__64.html "Interface documentation") | C binding 971 | [hipblasDgeam_64](interfacehipfort__hipblas_1_1hipblasdgeam__64.html "Interface documentation") | C binding 972 | [hipblasCgeam_64](interfacehipfort__hipblas_1_1hipblascgeam__64.html "Interface documentation") | C binding 973 | [hipblasZgeam_64](interfacehipfort__hipblas_1_1hipblaszgeam__64.html "Interface documentation") | C binding 974 | [hipblasSgeamBatched](interfacehipfort__hipblas_1_1hipblassgeambatched.html "Interface documentation") | C binding 975 | [hipblasDgeamBatched](interfacehipfort__hipblas_1_1hipblasdgeambatched.html "Interface documentation") | C binding 976 | [hipblasCgeamBatched](interfacehipfort__hipblas_1_1hipblascgeambatched.html "Interface documentation") | C binding 977 | [hipblasZgeamBatched](interfacehipfort__hipblas_1_1hipblaszgeambatched.html "Interface documentation") | C binding 978 | [hipblasSgeamBatched_64](interfacehipfort__hipblas_1_1hipblassgeambatched__64.html "Interface documentation") | C binding 979 | [hipblasDgeamBatched_64](interfacehipfort__hipblas_1_1hipblasdgeambatched__64.html "Interface documentation") | C binding 980 | [hipblasCgeamBatched_64](interfacehipfort__hipblas_1_1hipblascgeambatched__64.html "Interface documentation") | C binding 981 | [hipblasZgeamBatched_64](interfacehipfort__hipblas_1_1hipblaszgeambatched__64.html "Interface documentation") | C binding 982 | [hipblasSgeamStridedBatched](interfacehipfort__hipblas_1_1hipblassgeamstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 983 | [hipblasDgeamStridedBatched](interfacehipfort__hipblas_1_1hipblasdgeamstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 984 | [hipblasCgeamStridedBatched](interfacehipfort__hipblas_1_1hipblascgeamstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 985 | [hipblasZgeamStridedBatched](interfacehipfort__hipblas_1_1hipblaszgeamstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 986 | [hipblasSgeamStridedBatched_64](interfacehipfort__hipblas_1_1hipblassgeamstridedbatched__64.html "Interface documentation") | C binding 987 | [hipblasDgeamStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdgeamstridedbatched__64.html "Interface documentation") | C binding 988 | [hipblasCgeamStridedBatched_64](interfacehipfort__hipblas_1_1hipblascgeamstridedbatched__64.html "Interface documentation") | C binding 989 | [hipblasZgeamStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszgeamstridedbatched__64.html "Interface documentation") | C binding 990 | [hipblasChemm](interfacehipfort__hipblas_1_1hipblaschemm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 991 | [hipblasZhemm](interfacehipfort__hipblas_1_1hipblaszhemm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 992 | [hipblasChemm_64](interfacehipfort__hipblas_1_1hipblaschemm__64.html "Interface documentation") | C binding 993 | [hipblasZhemm_64](interfacehipfort__hipblas_1_1hipblaszhemm__64.html "Interface documentation") | C binding 994 | [hipblasChemmBatched](interfacehipfort__hipblas_1_1hipblaschemmbatched.html "Interface documentation") | C binding 995 | [hipblasZhemmBatched](interfacehipfort__hipblas_1_1hipblaszhemmbatched.html "Interface documentation") | C binding 996 | [hipblasChemmBatched_64](interfacehipfort__hipblas_1_1hipblaschemmbatched__64.html "Interface documentation") | C binding 997 | [hipblasZhemmBatched_64](interfacehipfort__hipblas_1_1hipblaszhemmbatched__64.html "Interface documentation") | C binding 998 | [hipblasChemmStridedBatched](interfacehipfort__hipblas_1_1hipblaschemmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 999 | [hipblasZhemmStridedBatched](interfacehipfort__hipblas_1_1hipblaszhemmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1000 | [hipblasChemmStridedBatched_64](interfacehipfort__hipblas_1_1hipblaschemmstridedbatched__64.html "Interface documentation") | C binding 1001 | [hipblasZhemmStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszhemmstridedbatched__64.html "Interface documentation") | C binding 1002 | [hipblasStrmm](interfacehipfort__hipblas_1_1hipblasstrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1003 | [hipblasDtrmm](interfacehipfort__hipblas_1_1hipblasdtrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1004 | [hipblasCtrmm](interfacehipfort__hipblas_1_1hipblasctrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1005 | [hipblasZtrmm](interfacehipfort__hipblas_1_1hipblasztrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1006 | [hipblasStrmm_64](interfacehipfort__hipblas_1_1hipblasstrmm__64.html "Interface documentation") | C binding 1007 | [hipblasDtrmm_64](interfacehipfort__hipblas_1_1hipblasdtrmm__64.html "Interface documentation") | C binding 1008 | [hipblasCtrmm_64](interfacehipfort__hipblas_1_1hipblasctrmm__64.html "Interface documentation") | C binding 1009 | [hipblasZtrmm_64](interfacehipfort__hipblas_1_1hipblasztrmm__64.html "Interface documentation") | C binding 1010 | [hipblasStrmmBatched](interfacehipfort__hipblas_1_1hipblasstrmmbatched.html "Interface documentation") | C binding 1011 | [hipblasDtrmmBatched](interfacehipfort__hipblas_1_1hipblasdtrmmbatched.html "Interface documentation") | C binding 1012 | [hipblasCtrmmBatched](interfacehipfort__hipblas_1_1hipblasctrmmbatched.html "Interface documentation") | C binding 1013 | [hipblasZtrmmBatched](interfacehipfort__hipblas_1_1hipblasztrmmbatched.html "Interface documentation") | C binding 1014 | [hipblasStrmmBatched_64](interfacehipfort__hipblas_1_1hipblasstrmmbatched__64.html "Interface documentation") | C binding 1015 | [hipblasDtrmmBatched_64](interfacehipfort__hipblas_1_1hipblasdtrmmbatched__64.html "Interface documentation") | C binding 1016 | [hipblasCtrmmBatched_64](interfacehipfort__hipblas_1_1hipblasctrmmbatched__64.html "Interface documentation") | C binding 1017 | [hipblasZtrmmBatched_64](interfacehipfort__hipblas_1_1hipblasztrmmbatched__64.html "Interface documentation") | C binding 1018 | [hipblasStrmmStridedBatched](interfacehipfort__hipblas_1_1hipblasstrmmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1019 | [hipblasDtrmmStridedBatched](interfacehipfort__hipblas_1_1hipblasdtrmmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1020 | [hipblasCtrmmStridedBatched](interfacehipfort__hipblas_1_1hipblasctrmmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1021 | [hipblasZtrmmStridedBatched](interfacehipfort__hipblas_1_1hipblasztrmmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1022 | [hipblasStrmmStridedBatched_64](interfacehipfort__hipblas_1_1hipblasstrmmstridedbatched__64.html "Interface documentation") | C binding 1023 | [hipblasDtrmmStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdtrmmstridedbatched__64.html "Interface documentation") | C binding 1024 | [hipblasCtrmmStridedBatched_64](interfacehipfort__hipblas_1_1hipblasctrmmstridedbatched__64.html "Interface documentation") | C binding 1025 | [hipblasZtrmmStridedBatched_64](interfacehipfort__hipblas_1_1hipblasztrmmstridedbatched__64.html "Interface documentation") | C binding 1026 | [hipblasStrsm](interfacehipfort__hipblas_1_1hipblasstrsm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1027 | [hipblasDtrsm](interfacehipfort__hipblas_1_1hipblasdtrsm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1028 | [hipblasCtrsm](interfacehipfort__hipblas_1_1hipblasctrsm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1029 | [hipblasZtrsm](interfacehipfort__hipblas_1_1hipblasztrsm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1030 | [hipblasStrsm_64](interfacehipfort__hipblas_1_1hipblasstrsm__64.html "Interface documentation") | C binding 1031 | [hipblasDtrsm_64](interfacehipfort__hipblas_1_1hipblasdtrsm__64.html "Interface documentation") | C binding 1032 | [hipblasCtrsm_64](interfacehipfort__hipblas_1_1hipblasctrsm__64.html "Interface documentation") | C binding 1033 | [hipblasZtrsm_64](interfacehipfort__hipblas_1_1hipblasztrsm__64.html "Interface documentation") | C binding 1034 | [hipblasStrsmBatched](interfacehipfort__hipblas_1_1hipblasstrsmbatched.html "Interface documentation") | C binding 1035 | [hipblasDtrsmBatched](interfacehipfort__hipblas_1_1hipblasdtrsmbatched.html "Interface documentation") | C binding 1036 | [hipblasCtrsmBatched](interfacehipfort__hipblas_1_1hipblasctrsmbatched.html "Interface documentation") | C binding 1037 | [hipblasZtrsmBatched](interfacehipfort__hipblas_1_1hipblasztrsmbatched.html "Interface documentation") | C binding 1038 | [hipblasStrsmBatched_64](interfacehipfort__hipblas_1_1hipblasstrsmbatched__64.html "Interface documentation") | C binding 1039 | [hipblasDtrsmBatched_64](interfacehipfort__hipblas_1_1hipblasdtrsmbatched__64.html "Interface documentation") | C binding 1040 | [hipblasCtrsmBatched_64](interfacehipfort__hipblas_1_1hipblasctrsmbatched__64.html "Interface documentation") | C binding 1041 | [hipblasZtrsmBatched_64](interfacehipfort__hipblas_1_1hipblasztrsmbatched__64.html "Interface documentation") | C binding 1042 | [hipblasStrsmStridedBatched](interfacehipfort__hipblas_1_1hipblasstrsmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1043 | [hipblasDtrsmStridedBatched](interfacehipfort__hipblas_1_1hipblasdtrsmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1044 | [hipblasCtrsmStridedBatched](interfacehipfort__hipblas_1_1hipblasctrsmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1045 | [hipblasZtrsmStridedBatched](interfacehipfort__hipblas_1_1hipblasztrsmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1046 | [hipblasStrsmStridedBatched_64](interfacehipfort__hipblas_1_1hipblasstrsmstridedbatched__64.html "Interface documentation") | C binding 1047 | [hipblasDtrsmStridedBatched_64](interfacehipfort__hipblas_1_1hipblasdtrsmstridedbatched__64.html "Interface documentation") | C binding 1048 | [hipblasCtrsmStridedBatched_64](interfacehipfort__hipblas_1_1hipblasctrsmstridedbatched__64.html "Interface documentation") | C binding 1049 | [hipblasZtrsmStridedBatched_64](interfacehipfort__hipblas_1_1hipblasztrsmstridedbatched__64.html "Interface documentation") | C binding 1050 | [hipblasStrtri](interfacehipfort__hipblas_1_1hipblasstrtri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1051 | [hipblasDtrtri](interfacehipfort__hipblas_1_1hipblasdtrtri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1052 | [hipblasCtrtri](interfacehipfort__hipblas_1_1hipblasctrtri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1053 | [hipblasZtrtri](interfacehipfort__hipblas_1_1hipblasztrtri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1054 | [hipblasStrtriBatched](interfacehipfort__hipblas_1_1hipblasstrtribatched.html "Interface documentation") | C binding 1055 | [hipblasDtrtriBatched](interfacehipfort__hipblas_1_1hipblasdtrtribatched.html "Interface documentation") | C binding 1056 | [hipblasCtrtriBatched](interfacehipfort__hipblas_1_1hipblasctrtribatched.html "Interface documentation") | C binding 1057 | [hipblasZtrtriBatched](interfacehipfort__hipblas_1_1hipblasztrtribatched.html "Interface documentation") | C binding 1058 | [hipblasStrtriStridedBatched](interfacehipfort__hipblas_1_1hipblasstrtristridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1059 | [hipblasDtrtriStridedBatched](interfacehipfort__hipblas_1_1hipblasdtrtristridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1060 | [hipblasCtrtriStridedBatched](interfacehipfort__hipblas_1_1hipblasctrtristridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1061 | [hipblasZtrtriStridedBatched](interfacehipfort__hipblas_1_1hipblasztrtristridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1062 | [hipblasSdgmm](interfacehipfort__hipblas_1_1hipblassdgmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1063 | [hipblasDdgmm](interfacehipfort__hipblas_1_1hipblasddgmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1064 | [hipblasCdgmm](interfacehipfort__hipblas_1_1hipblascdgmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1065 | [hipblasZdgmm](interfacehipfort__hipblas_1_1hipblaszdgmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1066 | [hipblasSdgmm_64](interfacehipfort__hipblas_1_1hipblassdgmm__64.html "Interface documentation") | C binding 1067 | [hipblasDdgmm_64](interfacehipfort__hipblas_1_1hipblasddgmm__64.html "Interface documentation") | C binding 1068 | [hipblasCdgmm_64](interfacehipfort__hipblas_1_1hipblascdgmm__64.html "Interface documentation") | C binding 1069 | [hipblasZdgmm_64](interfacehipfort__hipblas_1_1hipblaszdgmm__64.html "Interface documentation") | C binding 1070 | [hipblasSdgmmBatched](interfacehipfort__hipblas_1_1hipblassdgmmbatched.html "Interface documentation") | C binding 1071 | [hipblasDdgmmBatched](interfacehipfort__hipblas_1_1hipblasddgmmbatched.html "Interface documentation") | C binding 1072 | [hipblasCdgmmBatched](interfacehipfort__hipblas_1_1hipblascdgmmbatched.html "Interface documentation") | C binding 1073 | [hipblasZdgmmBatched](interfacehipfort__hipblas_1_1hipblaszdgmmbatched.html "Interface documentation") | C binding 1074 | [hipblasSdgmmBatched_64](interfacehipfort__hipblas_1_1hipblassdgmmbatched__64.html "Interface documentation") | C binding 1075 | [hipblasDdgmmBatched_64](interfacehipfort__hipblas_1_1hipblasddgmmbatched__64.html "Interface documentation") | C binding 1076 | [hipblasCdgmmBatched_64](interfacehipfort__hipblas_1_1hipblascdgmmbatched__64.html "Interface documentation") | C binding 1077 | [hipblasZdgmmBatched_64](interfacehipfort__hipblas_1_1hipblaszdgmmbatched__64.html "Interface documentation") | C binding 1078 | [hipblasSdgmmStridedBatched](interfacehipfort__hipblas_1_1hipblassdgmmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1079 | [hipblasDdgmmStridedBatched](interfacehipfort__hipblas_1_1hipblasddgmmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1080 | [hipblasCdgmmStridedBatched](interfacehipfort__hipblas_1_1hipblascdgmmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1081 | [hipblasZdgmmStridedBatched](interfacehipfort__hipblas_1_1hipblaszdgmmstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1082 | [hipblasSdgmmStridedBatched_64](interfacehipfort__hipblas_1_1hipblassdgmmstridedbatched__64.html "Interface documentation") | C binding 1083 | [hipblasDdgmmStridedBatched_64](interfacehipfort__hipblas_1_1hipblasddgmmstridedbatched__64.html "Interface documentation") | C binding 1084 | [hipblasCdgmmStridedBatched_64](interfacehipfort__hipblas_1_1hipblascdgmmstridedbatched__64.html "Interface documentation") | C binding 1085 | [hipblasZdgmmStridedBatched_64](interfacehipfort__hipblas_1_1hipblaszdgmmstridedbatched__64.html "Interface documentation") | C binding 1086 | [hipblasSgetrf](interfacehipfort__hipblas_1_1hipblassgetrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1087 | [hipblasDgetrf](interfacehipfort__hipblas_1_1hipblasdgetrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1088 | [hipblasCgetrf](interfacehipfort__hipblas_1_1hipblascgetrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1089 | [hipblasZgetrf](interfacehipfort__hipblas_1_1hipblaszgetrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1090 | [hipblasSgetrfBatched](interfacehipfort__hipblas_1_1hipblassgetrfbatched.html "Interface documentation") | C binding 1091 | [hipblasDgetrfBatched](interfacehipfort__hipblas_1_1hipblasdgetrfbatched.html "Interface documentation") | C binding 1092 | [hipblasCgetrfBatched](interfacehipfort__hipblas_1_1hipblascgetrfbatched.html "Interface documentation") | C binding 1093 | [hipblasZgetrfBatched](interfacehipfort__hipblas_1_1hipblaszgetrfbatched.html "Interface documentation") | C binding 1094 | [hipblasSgetrfStridedBatched](interfacehipfort__hipblas_1_1hipblassgetrfstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1095 | [hipblasDgetrfStridedBatched](interfacehipfort__hipblas_1_1hipblasdgetrfstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1096 | [hipblasCgetrfStridedBatched](interfacehipfort__hipblas_1_1hipblascgetrfstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1097 | [hipblasZgetrfStridedBatched](interfacehipfort__hipblas_1_1hipblaszgetrfstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1098 | [hipblasSgetrs](interfacehipfort__hipblas_1_1hipblassgetrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1099 | [hipblasDgetrs](interfacehipfort__hipblas_1_1hipblasdgetrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1100 | [hipblasCgetrs](interfacehipfort__hipblas_1_1hipblascgetrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1101 | [hipblasZgetrs](interfacehipfort__hipblas_1_1hipblaszgetrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1102 | [hipblasSgetrsBatched](interfacehipfort__hipblas_1_1hipblassgetrsbatched.html "Interface documentation") | C binding 1103 | [hipblasDgetrsBatched](interfacehipfort__hipblas_1_1hipblasdgetrsbatched.html "Interface documentation") | C binding 1104 | [hipblasCgetrsBatched](interfacehipfort__hipblas_1_1hipblascgetrsbatched.html "Interface documentation") | C binding 1105 | [hipblasZgetrsBatched](interfacehipfort__hipblas_1_1hipblaszgetrsbatched.html "Interface documentation") | C binding 1106 | [hipblasSgetrsStridedBatched](interfacehipfort__hipblas_1_1hipblassgetrsstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1107 | [hipblasDgetrsStridedBatched](interfacehipfort__hipblas_1_1hipblasdgetrsstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1108 | [hipblasCgetrsStridedBatched](interfacehipfort__hipblas_1_1hipblascgetrsstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1109 | [hipblasZgetrsStridedBatched](interfacehipfort__hipblas_1_1hipblaszgetrsstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1110 | [hipblasSgetriBatched](interfacehipfort__hipblas_1_1hipblassgetribatched.html "Interface documentation") | C binding 1111 | [hipblasDgetriBatched](interfacehipfort__hipblas_1_1hipblasdgetribatched.html "Interface documentation") | C binding 1112 | [hipblasCgetriBatched](interfacehipfort__hipblas_1_1hipblascgetribatched.html "Interface documentation") | C binding 1113 | [hipblasZgetriBatched](interfacehipfort__hipblas_1_1hipblaszgetribatched.html "Interface documentation") | C binding 1114 | [hipblasSgels](interfacehipfort__hipblas_1_1hipblassgels.html "Interface documentation") | C binding 1115 | [hipblasDgels](interfacehipfort__hipblas_1_1hipblasdgels.html "Interface documentation") | C binding 1116 | [hipblasCgels](interfacehipfort__hipblas_1_1hipblascgels.html "Interface documentation") | C binding 1117 | [hipblasZgels](interfacehipfort__hipblas_1_1hipblaszgels.html "Interface documentation") | C binding 1118 | [hipblasSgelsBatched](interfacehipfort__hipblas_1_1hipblassgelsbatched.html "Interface documentation") | C binding 1119 | [hipblasDgelsBatched](interfacehipfort__hipblas_1_1hipblasdgelsbatched.html "Interface documentation") | C binding 1120 | [hipblasCgelsBatched](interfacehipfort__hipblas_1_1hipblascgelsbatched.html "Interface documentation") | C binding 1121 | [hipblasZgelsBatched](interfacehipfort__hipblas_1_1hipblaszgelsbatched.html "Interface documentation") | C binding 1122 | [hipblasSgelsStridedBatched](interfacehipfort__hipblas_1_1hipblassgelsstridedbatched.html "Interface documentation") | C binding 1123 | [hipblasDgelsStridedBatched](interfacehipfort__hipblas_1_1hipblasdgelsstridedbatched.html "Interface documentation") | C binding 1124 | [hipblasCgelsStridedBatched](interfacehipfort__hipblas_1_1hipblascgelsstridedbatched.html "Interface documentation") | C binding 1125 | [hipblasZgelsStridedBatched](interfacehipfort__hipblas_1_1hipblaszgelsstridedbatched.html "Interface documentation") | C binding 1126 | [hipblasSgeqrf](interfacehipfort__hipblas_1_1hipblassgeqrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1127 | [hipblasDgeqrf](interfacehipfort__hipblas_1_1hipblasdgeqrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1128 | [hipblasCgeqrf](interfacehipfort__hipblas_1_1hipblascgeqrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1129 | [hipblasZgeqrf](interfacehipfort__hipblas_1_1hipblaszgeqrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1130 | [hipblasSgeqrfBatched](interfacehipfort__hipblas_1_1hipblassgeqrfbatched.html "Interface documentation") | C binding 1131 | [hipblasDgeqrfBatched](interfacehipfort__hipblas_1_1hipblasdgeqrfbatched.html "Interface documentation") | C binding 1132 | [hipblasCgeqrfBatched](interfacehipfort__hipblas_1_1hipblascgeqrfbatched.html "Interface documentation") | C binding 1133 | [hipblasZgeqrfBatched](interfacehipfort__hipblas_1_1hipblaszgeqrfbatched.html "Interface documentation") | C binding 1134 | [hipblasSgeqrfStridedBatched](interfacehipfort__hipblas_1_1hipblassgeqrfstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1135 | [hipblasDgeqrfStridedBatched](interfacehipfort__hipblas_1_1hipblasdgeqrfstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1136 | [hipblasCgeqrfStridedBatched](interfacehipfort__hipblas_1_1hipblascgeqrfstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1137 | [hipblasZgeqrfStridedBatched](interfacehipfort__hipblas_1_1hipblaszgeqrfstridedbatched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1138 | [hipblasGemmEx](interfacehipfort__hipblas_1_1hipblasgemmex.html "Interface documentation") | C binding 1139 | [hipblasGemmExWithFlags](interfacehipfort__hipblas_1_1hipblasgemmexwithflags.html "Interface documentation") | C binding 1140 | [hipblasGemmEx_64](interfacehipfort__hipblas_1_1hipblasgemmex__64.html "Interface documentation") | C binding 1141 | [hipblasGemmExWithFlags_64](interfacehipfort__hipblas_1_1hipblasgemmexwithflags__64.html "Interface documentation") | C binding 1142 | [hipblasGemmBatchedEx](interfacehipfort__hipblas_1_1hipblasgemmbatchedex.html "Interface documentation") | C binding 1143 | [hipblasGemmBatchedExWithFlags](interfacehipfort__hipblas_1_1hipblasgemmbatchedexwithflags.html "Interface documentation") | C binding 1144 | [hipblasGemmBatchedEx_64](interfacehipfort__hipblas_1_1hipblasgemmbatchedex__64.html "Interface documentation") | C binding 1145 | [hipblasGemmBatchedExWithFlags_64](interfacehipfort__hipblas_1_1hipblasgemmbatchedexwithflags__64.html "Interface documentation") | C binding 1146 | [hipblasGemmStridedBatchedEx](interfacehipfort__hipblas_1_1hipblasgemmstridedbatchedex.html "Interface documentation") | C binding 1147 | [hipblasGemmStridedBatchedExWithFlags](interfacehipfort__hipblas_1_1hipblasgemmstridedbatchedexwithflags.html "Interface documentation") | C binding 1148 | [hipblasGemmStridedBatchedEx_64](interfacehipfort__hipblas_1_1hipblasgemmstridedbatchedex__64.html "Interface documentation") | C binding 1149 | [hipblasGemmStridedBatchedExWithFlags_64](interfacehipfort__hipblas_1_1hipblasgemmstridedbatchedexwithflags__64.html "Interface documentation") | C binding 1150 | [hipblasSyrkEx](interfacehipfort__hipblas_1_1hipblassyrkex.html "Interface documentation") | C binding 1151 | [hipblasTrsmEx](interfacehipfort__hipblas_1_1hipblastrsmex.html "Interface documentation") | C binding 1152 | [hipblasHerkEx](interfacehipfort__hipblas_1_1hipblasherkex.html "Interface documentation") | C binding 1153 | [hipblasTrsmBatchedEx](interfacehipfort__hipblas_1_1hipblastrsmbatchedex.html "Interface documentation") | C binding 1154 | [hipblasTrsmStridedBatchedEx](interfacehipfort__hipblas_1_1hipblastrsmstridedbatchedex.html "Interface documentation") | C binding 1155 | [hipblasAxpyEx](interfacehipfort__hipblas_1_1hipblasaxpyex.html "Interface documentation") | C binding 1156 | [hipblasAxpyEx_64](interfacehipfort__hipblas_1_1hipblasaxpyex__64.html "Interface documentation") | C binding 1157 | [hipblasAxpyBatchedEx](interfacehipfort__hipblas_1_1hipblasaxpybatchedex.html "Interface documentation") | C binding 1158 | [hipblasAxpyBatchedEx_64](interfacehipfort__hipblas_1_1hipblasaxpybatchedex__64.html "Interface documentation") | C binding 1159 | [hipblasAxpyStridedBatchedEx](interfacehipfort__hipblas_1_1hipblasaxpystridedbatchedex.html "Interface documentation") | C binding 1160 | [hipblasAxpyStridedBatchedEx_64](interfacehipfort__hipblas_1_1hipblasaxpystridedbatchedex__64.html "Interface documentation") | C binding 1161 | [hipblasDotEx](interfacehipfort__hipblas_1_1hipblasdotex.html "Interface documentation") | C binding 1162 | [hipblasDotcEx](interfacehipfort__hipblas_1_1hipblasdotcex.html "Interface documentation") | C binding 1163 | [hipblasDotEx_64](interfacehipfort__hipblas_1_1hipblasdotex__64.html "Interface documentation") | C binding 1164 | [hipblasDotcEx_64](interfacehipfort__hipblas_1_1hipblasdotcex__64.html "Interface documentation") | C binding 1165 | [hipblasDotBatchedEx](interfacehipfort__hipblas_1_1hipblasdotbatchedex.html "Interface documentation") | C binding 1166 | [hipblasDotcBatchedEx](interfacehipfort__hipblas_1_1hipblasdotcbatchedex.html "Interface documentation") | C binding 1167 | [hipblasDotBatchedEx_64](interfacehipfort__hipblas_1_1hipblasdotbatchedex__64.html "Interface documentation") | C binding 1168 | [hipblasDotcBatchedEx_64](interfacehipfort__hipblas_1_1hipblasdotcbatchedex__64.html "Interface documentation") | C binding 1169 | [hipblasDotStridedBatchedEx](interfacehipfort__hipblas_1_1hipblasdotstridedbatchedex.html "Interface documentation") | C binding 1170 | [hipblasDotcStridedBatchedEx](interfacehipfort__hipblas_1_1hipblasdotcstridedbatchedex.html "Interface documentation") | C binding 1171 | [hipblasDotStridedBatchedEx_64](interfacehipfort__hipblas_1_1hipblasdotstridedbatchedex__64.html "Interface documentation") | C binding 1172 | [hipblasDotcStridedBatchedEx_64](interfacehipfort__hipblas_1_1hipblasdotcstridedbatchedex__64.html "Interface documentation") | C binding 1173 | [hipblasNrm2Ex](interfacehipfort__hipblas_1_1hipblasnrm2ex.html "Interface documentation") | C binding 1174 | [hipblasNrm2Ex_64](interfacehipfort__hipblas_1_1hipblasnrm2ex__64.html "Interface documentation") | C binding 1175 | [hipblasNrm2BatchedEx](interfacehipfort__hipblas_1_1hipblasnrm2batchedex.html "Interface documentation") | C binding 1176 | [hipblasNrm2BatchedEx_64](interfacehipfort__hipblas_1_1hipblasnrm2batchedex__64.html "Interface documentation") | C binding 1177 | [hipblasNrm2StridedBatchedEx](interfacehipfort__hipblas_1_1hipblasnrm2stridedbatchedex.html "Interface documentation") | C binding 1178 | [hipblasNrm2StridedBatchedEx_64](interfacehipfort__hipblas_1_1hipblasnrm2stridedbatchedex__64.html "Interface documentation") | C binding 1179 | [hipblasRotEx](interfacehipfort__hipblas_1_1hipblasrotex.html "Interface documentation") | C binding 1180 | [hipblasRotEx_64](interfacehipfort__hipblas_1_1hipblasrotex__64.html "Interface documentation") | C binding 1181 | [hipblasRotBatchedEx](interfacehipfort__hipblas_1_1hipblasrotbatchedex.html "Interface documentation") | C binding 1182 | [hipblasRotBatchedEx_64](interfacehipfort__hipblas_1_1hipblasrotbatchedex__64.html "Interface documentation") | C binding 1183 | [hipblasRotStridedBatchedEx](interfacehipfort__hipblas_1_1hipblasrotstridedbatchedex.html "Interface documentation") | C binding 1184 | [hipblasRotStridedBatchedEx_64](interfacehipfort__hipblas_1_1hipblasrotstridedbatchedex__64.html "Interface documentation") | C binding 1185 | [hipblasScalEx](interfacehipfort__hipblas_1_1hipblasscalex.html "Interface documentation") | C binding 1186 | [hipblasScalEx_64](interfacehipfort__hipblas_1_1hipblasscalex__64.html "Interface documentation") | C binding 1187 | [hipblasScalBatchedEx](interfacehipfort__hipblas_1_1hipblasscalbatchedex.html "Interface documentation") | C binding 1188 | [hipblasScalBatchedEx_64](interfacehipfort__hipblas_1_1hipblasscalbatchedex__64.html "Interface documentation") | C binding 1189 | [hipblasScalStridedBatchedEx](interfacehipfort__hipblas_1_1hipblasscalstridedbatchedex.html "Interface documentation") | C binding 1190 | [hipblasScalStridedBatchedEx_64](interfacehipfort__hipblas_1_1hipblasscalstridedbatchedex__64.html "Interface documentation") | C binding 1191 | [hipblasStatusToString](interfacehipfort__hipblas_1_1hipblasstatustostring.html "Interface documentation") | C binding 1192 | [hipblasSetVector](interfacehipfort__hipblas_1_1hipblassetvector.html "Interface documentation") | C binding, full_rank, rank_0, assumed_rank 1193 | [hipblasGetVector](interfacehipfort__hipblas_1_1hipblasgetvector.html "Interface documentation") | C binding, full_rank, rank_0, assumed_rank 1194 | [hipblasSetMatrix](interfacehipfort__hipblas_1_1hipblassetmatrix.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1195 | [hipblasGetMatrix](interfacehipfort__hipblas_1_1hipblasgetmatrix.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1196 | [hipblasSetVectorAsync](interfacehipfort__hipblas_1_1hipblassetvectorasync.html "Interface documentation") | C binding, full_rank, rank_0, assumed_rank 1197 | [hipblasGetVectorAsync](interfacehipfort__hipblas_1_1hipblasgetvectorasync.html "Interface documentation") | C binding, full_rank, rank_0, assumed_rank 1198 | [hipblasSetMatrixAsync](interfacehipfort__hipblas_1_1hipblassetmatrixasync.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1199 | [hipblasGetMatrixAsync](interfacehipfort__hipblas_1_1hipblasgetmatrixasync.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank hipfort-rocm-10.0.0/docs/doxygen/input/supported_api_hipfft.md000066400000000000000000000102321524740623400245120ustar00rootroot00000000000000# hipFFT API Support \# | API Name | Variants ----|---------------|--------- 1 | [hipfftPlan1d](interfacehipfort__hipfft_1_1hipfftplan1d.html "Interface documentation") | C binding 2 | [hipfftPlan2d](interfacehipfort__hipfft_1_1hipfftplan2d.html "Interface documentation") | C binding 3 | [hipfftPlan3d](interfacehipfort__hipfft_1_1hipfftplan3d.html "Interface documentation") | C binding 4 | [hipfftPlanMany](interfacehipfort__hipfft_1_1hipfftplanmany.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 5 | [hipfftCreate](interfacehipfort__hipfft_1_1hipfftcreate.html "Interface documentation") | C binding 6 | [hipfftExtPlanScaleFactor](interfacehipfort__hipfft_1_1hipfftextplanscalefactor.html "Interface documentation") | C binding 7 | [hipfftMakePlan1d](interfacehipfort__hipfft_1_1hipfftmakeplan1d.html "Interface documentation") | C binding 8 | [hipfftMakePlan2d](interfacehipfort__hipfft_1_1hipfftmakeplan2d.html "Interface documentation") | C binding 9 | [hipfftMakePlan3d](interfacehipfort__hipfft_1_1hipfftmakeplan3d.html "Interface documentation") | C binding 10 | [hipfftMakePlanMany](interfacehipfort__hipfft_1_1hipfftmakeplanmany.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 11 | [hipfftMakePlanMany64](interfacehipfort__hipfft_1_1hipfftmakeplanmany64.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 12 | [hipfftEstimate1d](interfacehipfort__hipfft_1_1hipfftestimate1d.html "Interface documentation") | C binding 13 | [hipfftEstimate2d](interfacehipfort__hipfft_1_1hipfftestimate2d.html "Interface documentation") | C binding 14 | [hipfftEstimate3d](interfacehipfort__hipfft_1_1hipfftestimate3d.html "Interface documentation") | C binding 15 | [hipfftEstimateMany](interfacehipfort__hipfft_1_1hipfftestimatemany.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 16 | [hipfftGetSize1d](interfacehipfort__hipfft_1_1hipfftgetsize1d.html "Interface documentation") | C binding 17 | [hipfftGetSize2d](interfacehipfort__hipfft_1_1hipfftgetsize2d.html "Interface documentation") | C binding 18 | [hipfftGetSize3d](interfacehipfort__hipfft_1_1hipfftgetsize3d.html "Interface documentation") | C binding 19 | [hipfftGetSizeMany](interfacehipfort__hipfft_1_1hipfftgetsizemany.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 20 | [hipfftGetSizeMany64](interfacehipfort__hipfft_1_1hipfftgetsizemany64.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 21 | [hipfftGetSize](interfacehipfort__hipfft_1_1hipfftgetsize.html "Interface documentation") | C binding 22 | [hipfftSetAutoAllocation](interfacehipfort__hipfft_1_1hipfftsetautoallocation.html "Interface documentation") | C binding 23 | [hipfftSetWorkArea](interfacehipfort__hipfft_1_1hipfftsetworkarea.html "Interface documentation") | C binding 24 | [hipfftExecC2C](interfacehipfort__hipfft_1_1hipfftexecc2c.html "Interface documentation") | C binding, rank_0, rank_1, rank_2, rank_3, assumed_rank 25 | [hipfftExecR2C](interfacehipfort__hipfft_1_1hipfftexecr2c.html "Interface documentation") | C binding, rank_0, rank_1, rank_2, rank_3, assumed_rank 26 | [hipfftExecC2R](interfacehipfort__hipfft_1_1hipfftexecc2r.html "Interface documentation") | C binding, rank_0, rank_1, rank_2, rank_3, assumed_rank 27 | [hipfftExecZ2Z](interfacehipfort__hipfft_1_1hipfftexecz2z.html "Interface documentation") | C binding, rank_0, rank_1, rank_2, rank_3, assumed_rank 28 | [hipfftExecD2Z](interfacehipfort__hipfft_1_1hipfftexecd2z.html "Interface documentation") | C binding, rank_0, rank_1, rank_2, rank_3, assumed_rank 29 | [hipfftExecZ2D](interfacehipfort__hipfft_1_1hipfftexecz2d.html "Interface documentation") | C binding, rank_0, rank_1, rank_2, rank_3, assumed_rank 30 | [hipfftSetStream](interfacehipfort__hipfft_1_1hipfftsetstream.html "Interface documentation") | C binding 31 | [hipfftDestroy](interfacehipfort__hipfft_1_1hipfftdestroy.html "Interface documentation") | C binding 32 | [hipfftGetVersion](interfacehipfort__hipfft_1_1hipfftgetversion.html "Interface documentation") | C binding 33 | [hipfftGetProperty](interfacehipfort__hipfft_1_1hipfftgetproperty.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank hipfort-rocm-10.0.0/docs/doxygen/input/supported_api_hipfftw.md000066400000000000000000000205001524740623400247000ustar00rootroot00000000000000# hipFFTW API Support \# | API Name | Variants ----|---------------|--------- 1 | [fftw_malloc](interfacehipfort__hipfftw_1_1fftw__malloc.html "Interface documentation") | C binding 2 | [fftwf_malloc](interfacehipfort__hipfftw_1_1fftwf__malloc.html "Interface documentation") | C binding 3 | [fftw_alloc_real](interfacehipfort__hipfftw_1_1fftw__alloc__real.html "Interface documentation") | C binding 4 | [fftwf_alloc_real](interfacehipfort__hipfftw_1_1fftwf__alloc__real.html "Interface documentation") | C binding 5 | [fftw_alloc_complex](interfacehipfort__hipfftw_1_1fftw__alloc__complex.html "Interface documentation") | C binding 6 | [fftwf_alloc_complex](interfacehipfort__hipfftw_1_1fftwf__alloc__complex.html "Interface documentation") | C binding 7 | [fftw_free](interfacehipfort__hipfftw_1_1fftw__free.html "Interface documentation") | C binding 8 | [fftwf_free](interfacehipfort__hipfftw_1_1fftwf__free.html "Interface documentation") | C binding 9 | [fftw_plan_dft_1d](interfacehipfort__hipfftw_1_1fftw__plan__dft__1d.html "Interface documentation") | C binding 10 | [fftwf_plan_dft_1d](interfacehipfort__hipfftw_1_1fftwf__plan__dft__1d.html "Interface documentation") | C binding 11 | [fftw_plan_dft_2d](interfacehipfort__hipfftw_1_1fftw__plan__dft__2d.html "Interface documentation") | C binding 12 | [fftwf_plan_dft_2d](interfacehipfort__hipfftw_1_1fftwf__plan__dft__2d.html "Interface documentation") | C binding 13 | [fftw_plan_dft_3d](interfacehipfort__hipfftw_1_1fftw__plan__dft__3d.html "Interface documentation") | C binding 14 | [fftwf_plan_dft_3d](interfacehipfort__hipfftw_1_1fftwf__plan__dft__3d.html "Interface documentation") | C binding 15 | [fftw_plan_dft](interfacehipfort__hipfftw_1_1fftw__plan__dft.html "Interface documentation") | C binding 16 | [fftwf_plan_dft](interfacehipfort__hipfftw_1_1fftwf__plan__dft.html "Interface documentation") | C binding 17 | [fftw_plan_dft_r2c_1d](interfacehipfort__hipfftw_1_1fftw__plan__dft__r2c__1d.html "Interface documentation") | C binding 18 | [fftwf_plan_dft_r2c_1d](interfacehipfort__hipfftw_1_1fftwf__plan__dft__r2c__1d.html "Interface documentation") | C binding 19 | [fftw_plan_dft_r2c_2d](interfacehipfort__hipfftw_1_1fftw__plan__dft__r2c__2d.html "Interface documentation") | C binding 20 | [fftwf_plan_dft_r2c_2d](interfacehipfort__hipfftw_1_1fftwf__plan__dft__r2c__2d.html "Interface documentation") | C binding 21 | [fftw_plan_dft_r2c_3d](interfacehipfort__hipfftw_1_1fftw__plan__dft__r2c__3d.html "Interface documentation") | C binding 22 | [fftwf_plan_dft_r2c_3d](interfacehipfort__hipfftw_1_1fftwf__plan__dft__r2c__3d.html "Interface documentation") | C binding 23 | [fftw_plan_dft_r2c](interfacehipfort__hipfftw_1_1fftw__plan__dft__r2c.html "Interface documentation") | C binding 24 | [fftwf_plan_dft_r2c](interfacehipfort__hipfftw_1_1fftwf__plan__dft__r2c.html "Interface documentation") | C binding 25 | [fftw_plan_dft_c2r_1d](interfacehipfort__hipfftw_1_1fftw__plan__dft__c2r__1d.html "Interface documentation") | C binding 26 | [fftwf_plan_dft_c2r_1d](interfacehipfort__hipfftw_1_1fftwf__plan__dft__c2r__1d.html "Interface documentation") | C binding 27 | [fftw_plan_dft_c2r_2d](interfacehipfort__hipfftw_1_1fftw__plan__dft__c2r__2d.html "Interface documentation") | C binding 28 | [fftwf_plan_dft_c2r_2d](interfacehipfort__hipfftw_1_1fftwf__plan__dft__c2r__2d.html "Interface documentation") | C binding 29 | [fftw_plan_dft_c2r_3d](interfacehipfort__hipfftw_1_1fftw__plan__dft__c2r__3d.html "Interface documentation") | C binding 30 | [fftwf_plan_dft_c2r_3d](interfacehipfort__hipfftw_1_1fftwf__plan__dft__c2r__3d.html "Interface documentation") | C binding 31 | [fftw_plan_dft_c2r](interfacehipfort__hipfftw_1_1fftw__plan__dft__c2r.html "Interface documentation") | C binding 32 | [fftwf_plan_dft_c2r](interfacehipfort__hipfftw_1_1fftwf__plan__dft__c2r.html "Interface documentation") | C binding 33 | [fftw_plan_many_dft](interfacehipfort__hipfftw_1_1fftw__plan__many__dft.html "Interface documentation") | C binding 34 | [fftwf_plan_many_dft](interfacehipfort__hipfftw_1_1fftwf__plan__many__dft.html "Interface documentation") | C binding 35 | [fftw_plan_many_dft_r2c](interfacehipfort__hipfftw_1_1fftw__plan__many__dft__r2c.html "Interface documentation") | C binding 36 | [fftwf_plan_many_dft_r2c](interfacehipfort__hipfftw_1_1fftwf__plan__many__dft__r2c.html "Interface documentation") | C binding 37 | [fftw_plan_many_dft_c2r](interfacehipfort__hipfftw_1_1fftw__plan__many__dft__c2r.html "Interface documentation") | C binding 38 | [fftwf_plan_many_dft_c2r](interfacehipfort__hipfftw_1_1fftwf__plan__many__dft__c2r.html "Interface documentation") | C binding 39 | [fftw_plan_guru_dft](interfacehipfort__hipfftw_1_1fftw__plan__guru__dft.html "Interface documentation") | C binding 40 | [fftwf_plan_guru_dft](interfacehipfort__hipfftw_1_1fftwf__plan__guru__dft.html "Interface documentation") | C binding 41 | [fftw_plan_guru_dft_r2c](interfacehipfort__hipfftw_1_1fftw__plan__guru__dft__r2c.html "Interface documentation") | C binding 42 | [fftwf_plan_guru_dft_r2c](interfacehipfort__hipfftw_1_1fftwf__plan__guru__dft__r2c.html "Interface documentation") | C binding 43 | [fftw_plan_guru_dft_c2r](interfacehipfort__hipfftw_1_1fftw__plan__guru__dft__c2r.html "Interface documentation") | C binding 44 | [fftwf_plan_guru_dft_c2r](interfacehipfort__hipfftw_1_1fftwf__plan__guru__dft__c2r.html "Interface documentation") | C binding 45 | [fftw_plan_guru64_dft](interfacehipfort__hipfftw_1_1fftw__plan__guru64__dft.html "Interface documentation") | C binding 46 | [fftwf_plan_guru64_dft](interfacehipfort__hipfftw_1_1fftwf__plan__guru64__dft.html "Interface documentation") | C binding 47 | [fftw_plan_guru64_dft_r2c](interfacehipfort__hipfftw_1_1fftw__plan__guru64__dft__r2c.html "Interface documentation") | C binding 48 | [fftwf_plan_guru64_dft_r2c](interfacehipfort__hipfftw_1_1fftwf__plan__guru64__dft__r2c.html "Interface documentation") | C binding 49 | [fftw_plan_guru64_dft_c2r](interfacehipfort__hipfftw_1_1fftw__plan__guru64__dft__c2r.html "Interface documentation") | C binding 50 | [fftwf_plan_guru64_dft_c2r](interfacehipfort__hipfftw_1_1fftwf__plan__guru64__dft__c2r.html "Interface documentation") | C binding 51 | [fftw_execute](interfacehipfort__hipfftw_1_1fftw__execute.html "Interface documentation") | C binding 52 | [fftwf_execute](interfacehipfort__hipfftw_1_1fftwf__execute.html "Interface documentation") | C binding 53 | [fftw_execute_dft](interfacehipfort__hipfftw_1_1fftw__execute__dft.html "Interface documentation") | C binding 54 | [fftwf_execute_dft](interfacehipfort__hipfftw_1_1fftwf__execute__dft.html "Interface documentation") | C binding 55 | [fftw_execute_dft_r2c](interfacehipfort__hipfftw_1_1fftw__execute__dft__r2c.html "Interface documentation") | C binding 56 | [fftwf_execute_dft_r2c](interfacehipfort__hipfftw_1_1fftwf__execute__dft__r2c.html "Interface documentation") | C binding 57 | [fftw_execute_dft_c2r](interfacehipfort__hipfftw_1_1fftw__execute__dft__c2r.html "Interface documentation") | C binding 58 | [fftwf_execute_dft_c2r](interfacehipfort__hipfftw_1_1fftwf__execute__dft__c2r.html "Interface documentation") | C binding 59 | [fftw_destroy_plan](interfacehipfort__hipfftw_1_1fftw__destroy__plan.html "Interface documentation") | C binding 60 | [fftwf_destroy_plan](interfacehipfort__hipfftw_1_1fftwf__destroy__plan.html "Interface documentation") | C binding 61 | [fftw_print_plan](interfacehipfort__hipfftw_1_1fftw__print__plan.html "Interface documentation") | C binding 62 | [fftwf_print_plan](interfacehipfort__hipfftw_1_1fftwf__print__plan.html "Interface documentation") | C binding 63 | [fftw_set_timelimit](interfacehipfort__hipfftw_1_1fftw__set__timelimit.html "Interface documentation") | C binding 64 | [fftwf_set_timelimit](interfacehipfort__hipfftw_1_1fftwf__set__timelimit.html "Interface documentation") | C binding 65 | [fftw_cost](interfacehipfort__hipfftw_1_1fftw__cost.html "Interface documentation") | C binding 66 | [fftwf_cost](interfacehipfort__hipfftw_1_1fftwf__cost.html "Interface documentation") | C binding 67 | [fftw_flops](interfacehipfort__hipfftw_1_1fftw__flops.html "Interface documentation") | C binding 68 | [fftwf_flops](interfacehipfort__hipfftw_1_1fftwf__flops.html "Interface documentation") | C binding 69 | [fftw_cleanup](interfacehipfort__hipfftw_1_1fftw__cleanup.html "Interface documentation") | C binding 70 | [fftwf_cleanup](interfacehipfort__hipfftw_1_1fftwf__cleanup.html "Interface documentation") | C binding hipfort-rocm-10.0.0/docs/doxygen/input/supported_api_hiprand.md000066400000000000000000000103221524740623400246570ustar00rootroot00000000000000# hipRAND API Support \# | API Name | Variants ----|---------------|--------- 1 | [hiprandCreateGenerator](interfacehipfort__hiprand_1_1hiprandcreategenerator.html "Interface documentation") | C binding 2 | [hiprandCreateGeneratorHost](interfacehipfort__hiprand_1_1hiprandcreategeneratorhost.html "Interface documentation") | C binding 3 | [hiprandDestroyGenerator](interfacehipfort__hiprand_1_1hipranddestroygenerator.html "Interface documentation") | C binding 4 | [hiprandGenerate](interfacehipfort__hiprand_1_1hiprandgenerate.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 5 | [hiprandGenerateChar](interfacehipfort__hiprand_1_1hiprandgeneratechar.html "Interface documentation") | C binding 6 | [hiprandGenerateShort](interfacehipfort__hiprand_1_1hiprandgenerateshort.html "Interface documentation") | C binding 7 | [hiprandGenerateLongLong](interfacehipfort__hiprand_1_1hiprandgeneratelonglong.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 8 | [hiprandGenerateUniform](interfacehipfort__hiprand_1_1hiprandgenerateuniform.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 9 | [hiprandGenerateUniformDouble](interfacehipfort__hiprand_1_1hiprandgenerateuniformdouble.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 10 | [hiprandGenerateUniformHalf](interfacehipfort__hiprand_1_1hiprandgenerateuniformhalf.html "Interface documentation") | C binding 11 | [hiprandGenerateNormal](interfacehipfort__hiprand_1_1hiprandgeneratenormal.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 12 | [hiprandGenerateNormalDouble](interfacehipfort__hiprand_1_1hiprandgeneratenormaldouble.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 13 | [hiprandGenerateNormalHalf](interfacehipfort__hiprand_1_1hiprandgeneratenormalhalf.html "Interface documentation") | C binding 14 | [hiprandGenerateLogNormal](interfacehipfort__hiprand_1_1hiprandgeneratelognormal.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 15 | [hiprandGenerateLogNormalDouble](interfacehipfort__hiprand_1_1hiprandgeneratelognormaldouble.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 16 | [hiprandGenerateLogNormalHalf](interfacehipfort__hiprand_1_1hiprandgeneratelognormalhalf.html "Interface documentation") | C binding 17 | [hiprandGeneratePoisson](interfacehipfort__hiprand_1_1hiprandgeneratepoisson.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 18 | [hiprandGenerateSeeds](interfacehipfort__hiprand_1_1hiprandgenerateseeds.html "Interface documentation") | C binding 19 | [hiprandSetStream](interfacehipfort__hiprand_1_1hiprandsetstream.html "Interface documentation") | C binding 20 | [hiprandSetPseudoRandomGeneratorSeed](interfacehipfort__hiprand_1_1hiprandsetpseudorandomgeneratorseed.html "Interface documentation") | C binding 21 | [hiprandSetGeneratorOffset](interfacehipfort__hiprand_1_1hiprandsetgeneratoroffset.html "Interface documentation") | C binding 22 | [hiprandSetGeneratorOrdering](interfacehipfort__hiprand_1_1hiprandsetgeneratorordering.html "Interface documentation") | C binding 23 | [hiprandSetQuasiRandomGeneratorDimensions](interfacehipfort__hiprand_1_1hiprandsetquasirandomgeneratordimensions.html "Interface documentation") | C binding 24 | [hiprandGetVersion](interfacehipfort__hiprand_1_1hiprandgetversion.html "Interface documentation") | C binding 25 | [hiprandCreatePoissonDistribution](interfacehipfort__hiprand_1_1hiprandcreatepoissondistribution.html "Interface documentation") | C binding 26 | [hiprandDestroyDistribution](interfacehipfort__hiprand_1_1hipranddestroydistribution.html "Interface documentation") | C binding 27 | [hiprandGetDirectionVectors32](interfacehipfort__hiprand_1_1hiprandgetdirectionvectors32.html "Interface documentation") | C binding 28 | [hiprandGetDirectionVectors64](interfacehipfort__hiprand_1_1hiprandgetdirectionvectors64.html "Interface documentation") | C binding 29 | [hiprandGetScrambleConstants32](interfacehipfort__hiprand_1_1hiprandgetscrambleconstants32.html "Interface documentation") | C binding 30 | [hiprandGetScrambleConstants64](interfacehipfort__hiprand_1_1hiprandgetscrambleconstants64.html "Interface documentation") | C binding hipfort-rocm-10.0.0/docs/doxygen/input/supported_api_hipsolver.md000066400000000000000000002236711524740623400252620ustar00rootroot00000000000000# hipSOLVER API support \# | API Name | Variants ----|---------------|--------- 1 | [hipsolverCreate](interfacehipfort__hipsolver_1_1hipsolvercreate.html "Interface documentation") | C binding 2 | [hipsolverDestroy](interfacehipfort__hipsolver_1_1hipsolverdestroy.html "Interface documentation") | C binding 3 | [hipsolverSetStream](interfacehipfort__hipsolver_1_1hipsolversetstream.html "Interface documentation") | C binding 4 | [hipsolverGetStream](interfacehipfort__hipsolver_1_1hipsolvergetstream.html "Interface documentation") | C binding 5 | [hipsolverSetDeterministicMode](interfacehipfort__hipsolver_1_1hipsolversetdeterministicmode.html "Interface documentation") | C binding 6 | [hipsolverGetDeterministicMode](interfacehipfort__hipsolver_1_1hipsolvergetdeterministicmode.html "Interface documentation") | C binding 7 | [hipsolverCreateGesvdjInfo](interfacehipfort__hipsolver_1_1hipsolvercreategesvdjinfo.html "Interface documentation") | C binding 8 | [hipsolverDestroyGesvdjInfo](interfacehipfort__hipsolver_1_1hipsolverdestroygesvdjinfo.html "Interface documentation") | C binding 9 | [hipsolverXgesvdjSetMaxSweeps](interfacehipfort__hipsolver_1_1hipsolverxgesvdjsetmaxsweeps.html "Interface documentation") | C binding 10 | [hipsolverXgesvdjSetSortEig](interfacehipfort__hipsolver_1_1hipsolverxgesvdjsetsorteig.html "Interface documentation") | C binding 11 | [hipsolverXgesvdjSetTolerance](interfacehipfort__hipsolver_1_1hipsolverxgesvdjsettolerance.html "Interface documentation") | C binding 12 | [hipsolverXgesvdjGetResidual](interfacehipfort__hipsolver_1_1hipsolverxgesvdjgetresidual.html "Interface documentation") | C binding 13 | [hipsolverXgesvdjGetSweeps](interfacehipfort__hipsolver_1_1hipsolverxgesvdjgetsweeps.html "Interface documentation") | C binding 14 | [hipsolverCreateSyevjInfo](interfacehipfort__hipsolver_1_1hipsolvercreatesyevjinfo.html "Interface documentation") | C binding 15 | [hipsolverDestroySyevjInfo](interfacehipfort__hipsolver_1_1hipsolverdestroysyevjinfo.html "Interface documentation") | C binding 16 | [hipsolverXsyevjSetMaxSweeps](interfacehipfort__hipsolver_1_1hipsolverxsyevjsetmaxsweeps.html "Interface documentation") | C binding 17 | [hipsolverXsyevjSetSortEig](interfacehipfort__hipsolver_1_1hipsolverxsyevjsetsorteig.html "Interface documentation") | C binding 18 | [hipsolverXsyevjSetTolerance](interfacehipfort__hipsolver_1_1hipsolverxsyevjsettolerance.html "Interface documentation") | C binding 19 | [hipsolverXsyevjGetResidual](interfacehipfort__hipsolver_1_1hipsolverxsyevjgetresidual.html "Interface documentation") | C binding 20 | [hipsolverXsyevjGetSweeps](interfacehipfort__hipsolver_1_1hipsolverxsyevjgetsweeps.html "Interface documentation") | C binding 21 | [hipsolverSorgbr_bufferSize](interfacehipfort__hipsolver_1_1hipsolversorgbr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 22 | [hipsolverDorgbr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdorgbr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 23 | [hipsolverCungbr_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercungbr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 24 | [hipsolverZungbr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzungbr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 25 | [hipsolverSorgbr](interfacehipfort__hipsolver_1_1hipsolversorgbr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 26 | [hipsolverDorgbr](interfacehipfort__hipsolver_1_1hipsolverdorgbr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 27 | [hipsolverCungbr](interfacehipfort__hipsolver_1_1hipsolvercungbr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 28 | [hipsolverZungbr](interfacehipfort__hipsolver_1_1hipsolverzungbr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 29 | [hipsolverSorgqr_bufferSize](interfacehipfort__hipsolver_1_1hipsolversorgqr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 30 | [hipsolverDorgqr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdorgqr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 31 | [hipsolverCungqr_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercungqr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 32 | [hipsolverZungqr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzungqr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 33 | [hipsolverSorgqr](interfacehipfort__hipsolver_1_1hipsolversorgqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 34 | [hipsolverDorgqr](interfacehipfort__hipsolver_1_1hipsolverdorgqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 35 | [hipsolverCungqr](interfacehipfort__hipsolver_1_1hipsolvercungqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 36 | [hipsolverZungqr](interfacehipfort__hipsolver_1_1hipsolverzungqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 37 | [hipsolverSorgtr_bufferSize](interfacehipfort__hipsolver_1_1hipsolversorgtr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 38 | [hipsolverDorgtr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdorgtr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 39 | [hipsolverCungtr_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercungtr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 40 | [hipsolverZungtr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzungtr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 41 | [hipsolverSorgtr](interfacehipfort__hipsolver_1_1hipsolversorgtr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 42 | [hipsolverDorgtr](interfacehipfort__hipsolver_1_1hipsolverdorgtr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 43 | [hipsolverCungtr](interfacehipfort__hipsolver_1_1hipsolvercungtr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 44 | [hipsolverZungtr](interfacehipfort__hipsolver_1_1hipsolverzungtr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 45 | [hipsolverSormqr_bufferSize](interfacehipfort__hipsolver_1_1hipsolversormqr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 46 | [hipsolverDormqr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdormqr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 47 | [hipsolverCunmqr_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercunmqr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 48 | [hipsolverZunmqr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzunmqr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 49 | [hipsolverSormqr](interfacehipfort__hipsolver_1_1hipsolversormqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 50 | [hipsolverDormqr](interfacehipfort__hipsolver_1_1hipsolverdormqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 51 | [hipsolverCunmqr](interfacehipfort__hipsolver_1_1hipsolvercunmqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 52 | [hipsolverZunmqr](interfacehipfort__hipsolver_1_1hipsolverzunmqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 53 | [hipsolverSormtr_bufferSize](interfacehipfort__hipsolver_1_1hipsolversormtr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 54 | [hipsolverDormtr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdormtr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 55 | [hipsolverCunmtr_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercunmtr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 56 | [hipsolverZunmtr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzunmtr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 57 | [hipsolverSormtr](interfacehipfort__hipsolver_1_1hipsolversormtr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 58 | [hipsolverDormtr](interfacehipfort__hipsolver_1_1hipsolverdormtr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 59 | [hipsolverCunmtr](interfacehipfort__hipsolver_1_1hipsolvercunmtr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 60 | [hipsolverZunmtr](interfacehipfort__hipsolver_1_1hipsolverzunmtr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 61 | [hipsolverSgebrd_bufferSize](interfacehipfort__hipsolver_1_1hipsolversgebrd__buffersize.html "Interface documentation") | C binding 62 | [hipsolverDgebrd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdgebrd__buffersize.html "Interface documentation") | C binding 63 | [hipsolverCgebrd_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercgebrd__buffersize.html "Interface documentation") | C binding 64 | [hipsolverZgebrd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzgebrd__buffersize.html "Interface documentation") | C binding 65 | [hipsolverSgebrd](interfacehipfort__hipsolver_1_1hipsolversgebrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 66 | [hipsolverDgebrd](interfacehipfort__hipsolver_1_1hipsolverdgebrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 67 | [hipsolverCgebrd](interfacehipfort__hipsolver_1_1hipsolvercgebrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 68 | [hipsolverZgebrd](interfacehipfort__hipsolver_1_1hipsolverzgebrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 69 | [hipsolverSSgels_bufferSize](interfacehipfort__hipsolver_1_1hipsolverssgels__buffersize.html "Interface documentation") | C binding 70 | [hipsolverDDgels_bufferSize](interfacehipfort__hipsolver_1_1hipsolverddgels__buffersize.html "Interface documentation") | C binding 71 | [hipsolverCCgels_bufferSize](interfacehipfort__hipsolver_1_1hipsolverccgels__buffersize.html "Interface documentation") | C binding 72 | [hipsolverZZgels_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzzgels__buffersize.html "Interface documentation") | C binding 73 | [hipsolverSSgels](interfacehipfort__hipsolver_1_1hipsolverssgels.html "Interface documentation") | C binding 74 | [hipsolverDDgels](interfacehipfort__hipsolver_1_1hipsolverddgels.html "Interface documentation") | C binding 75 | [hipsolverCCgels](interfacehipfort__hipsolver_1_1hipsolverccgels.html "Interface documentation") | C binding 76 | [hipsolverZZgels](interfacehipfort__hipsolver_1_1hipsolverzzgels.html "Interface documentation") | C binding 77 | [hipsolverSgeqrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolversgeqrf__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 78 | [hipsolverDgeqrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdgeqrf__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 79 | [hipsolverCgeqrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercgeqrf__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 80 | [hipsolverZgeqrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzgeqrf__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 81 | [hipsolverSgeqrf](interfacehipfort__hipsolver_1_1hipsolversgeqrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 82 | [hipsolverDgeqrf](interfacehipfort__hipsolver_1_1hipsolverdgeqrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 83 | [hipsolverCgeqrf](interfacehipfort__hipsolver_1_1hipsolvercgeqrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 84 | [hipsolverZgeqrf](interfacehipfort__hipsolver_1_1hipsolverzgeqrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 85 | [hipsolverSSgesv_bufferSize](interfacehipfort__hipsolver_1_1hipsolverssgesv__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 86 | [hipsolverDDgesv_bufferSize](interfacehipfort__hipsolver_1_1hipsolverddgesv__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 87 | [hipsolverCCgesv_bufferSize](interfacehipfort__hipsolver_1_1hipsolverccgesv__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 88 | [hipsolverZZgesv_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzzgesv__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 89 | [hipsolverSSgesv](interfacehipfort__hipsolver_1_1hipsolverssgesv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 90 | [hipsolverDDgesv](interfacehipfort__hipsolver_1_1hipsolverddgesv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 91 | [hipsolverCCgesv](interfacehipfort__hipsolver_1_1hipsolverccgesv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 92 | [hipsolverZZgesv](interfacehipfort__hipsolver_1_1hipsolverzzgesv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 93 | [hipsolverSgesvd_bufferSize](interfacehipfort__hipsolver_1_1hipsolversgesvd__buffersize.html "Interface documentation") | C binding 94 | [hipsolverDgesvd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdgesvd__buffersize.html "Interface documentation") | C binding 95 | [hipsolverCgesvd_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercgesvd__buffersize.html "Interface documentation") | C binding 96 | [hipsolverZgesvd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzgesvd__buffersize.html "Interface documentation") | C binding 97 | [hipsolverSgesvd](interfacehipfort__hipsolver_1_1hipsolversgesvd.html "Interface documentation") | C binding 98 | [hipsolverDgesvd](interfacehipfort__hipsolver_1_1hipsolverdgesvd.html "Interface documentation") | C binding 99 | [hipsolverCgesvd](interfacehipfort__hipsolver_1_1hipsolvercgesvd.html "Interface documentation") | C binding 100 | [hipsolverZgesvd](interfacehipfort__hipsolver_1_1hipsolverzgesvd.html "Interface documentation") | C binding 101 | [hipsolverSgesvdj_bufferSize](interfacehipfort__hipsolver_1_1hipsolversgesvdj__buffersize.html "Interface documentation") | C binding 102 | [hipsolverDgesvdj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdgesvdj__buffersize.html "Interface documentation") | C binding 103 | [hipsolverCgesvdj_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercgesvdj__buffersize.html "Interface documentation") | C binding 104 | [hipsolverZgesvdj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzgesvdj__buffersize.html "Interface documentation") | C binding 105 | [hipsolverSgesvdj](interfacehipfort__hipsolver_1_1hipsolversgesvdj.html "Interface documentation") | C binding 106 | [hipsolverDgesvdj](interfacehipfort__hipsolver_1_1hipsolverdgesvdj.html "Interface documentation") | C binding 107 | [hipsolverCgesvdj](interfacehipfort__hipsolver_1_1hipsolvercgesvdj.html "Interface documentation") | C binding 108 | [hipsolverZgesvdj](interfacehipfort__hipsolver_1_1hipsolverzgesvdj.html "Interface documentation") | C binding 109 | [hipsolverSgesvdjBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolversgesvdjbatched__buffersize.html "Interface documentation") | C binding 110 | [hipsolverDgesvdjBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdgesvdjbatched__buffersize.html "Interface documentation") | C binding 111 | [hipsolverCgesvdjBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercgesvdjbatched__buffersize.html "Interface documentation") | C binding 112 | [hipsolverZgesvdjBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzgesvdjbatched__buffersize.html "Interface documentation") | C binding 113 | [hipsolverSgesvdjBatched](interfacehipfort__hipsolver_1_1hipsolversgesvdjbatched.html "Interface documentation") | C binding 114 | [hipsolverDgesvdjBatched](interfacehipfort__hipsolver_1_1hipsolverdgesvdjbatched.html "Interface documentation") | C binding 115 | [hipsolverCgesvdjBatched](interfacehipfort__hipsolver_1_1hipsolvercgesvdjbatched.html "Interface documentation") | C binding 116 | [hipsolverZgesvdjBatched](interfacehipfort__hipsolver_1_1hipsolverzgesvdjbatched.html "Interface documentation") | C binding 117 | [hipsolverSgetrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolversgetrf__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 118 | [hipsolverDgetrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdgetrf__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 119 | [hipsolverCgetrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercgetrf__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 120 | [hipsolverZgetrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzgetrf__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 121 | [hipsolverSgetrf](interfacehipfort__hipsolver_1_1hipsolversgetrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 122 | [hipsolverDgetrf](interfacehipfort__hipsolver_1_1hipsolverdgetrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 123 | [hipsolverCgetrf](interfacehipfort__hipsolver_1_1hipsolvercgetrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 124 | [hipsolverZgetrf](interfacehipfort__hipsolver_1_1hipsolverzgetrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 125 | [hipsolverSgetrs_bufferSize](interfacehipfort__hipsolver_1_1hipsolversgetrs__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 126 | [hipsolverDgetrs_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdgetrs__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 127 | [hipsolverCgetrs_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercgetrs__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 128 | [hipsolverZgetrs_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzgetrs__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 129 | [hipsolverSgetrs](interfacehipfort__hipsolver_1_1hipsolversgetrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 130 | [hipsolverDgetrs](interfacehipfort__hipsolver_1_1hipsolverdgetrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 131 | [hipsolverCgetrs](interfacehipfort__hipsolver_1_1hipsolvercgetrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 132 | [hipsolverZgetrs](interfacehipfort__hipsolver_1_1hipsolverzgetrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 133 | [hipsolverSpotrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverspotrf__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 134 | [hipsolverDpotrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdpotrf__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 135 | [hipsolverCpotrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercpotrf__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 136 | [hipsolverZpotrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzpotrf__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 137 | [hipsolverSpotrf](interfacehipfort__hipsolver_1_1hipsolverspotrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 138 | [hipsolverDpotrf](interfacehipfort__hipsolver_1_1hipsolverdpotrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 139 | [hipsolverCpotrf](interfacehipfort__hipsolver_1_1hipsolvercpotrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 140 | [hipsolverZpotrf](interfacehipfort__hipsolver_1_1hipsolverzpotrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 141 | [hipsolverSpotrfBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverspotrfbatched__buffersize.html "Interface documentation") | C binding 142 | [hipsolverDpotrfBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdpotrfbatched__buffersize.html "Interface documentation") | C binding 143 | [hipsolverCpotrfBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercpotrfbatched__buffersize.html "Interface documentation") | C binding 144 | [hipsolverZpotrfBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzpotrfbatched__buffersize.html "Interface documentation") | C binding 145 | [hipsolverSpotrfBatched](interfacehipfort__hipsolver_1_1hipsolverspotrfbatched.html "Interface documentation") | C binding 146 | [hipsolverDpotrfBatched](interfacehipfort__hipsolver_1_1hipsolverdpotrfbatched.html "Interface documentation") | C binding 147 | [hipsolverCpotrfBatched](interfacehipfort__hipsolver_1_1hipsolvercpotrfbatched.html "Interface documentation") | C binding 148 | [hipsolverZpotrfBatched](interfacehipfort__hipsolver_1_1hipsolverzpotrfbatched.html "Interface documentation") | C binding 149 | [hipsolverSpotri_bufferSize](interfacehipfort__hipsolver_1_1hipsolverspotri__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 150 | [hipsolverDpotri_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdpotri__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 151 | [hipsolverCpotri_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercpotri__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 152 | [hipsolverZpotri_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzpotri__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 153 | [hipsolverSpotri](interfacehipfort__hipsolver_1_1hipsolverspotri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 154 | [hipsolverDpotri](interfacehipfort__hipsolver_1_1hipsolverdpotri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 155 | [hipsolverCpotri](interfacehipfort__hipsolver_1_1hipsolvercpotri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 156 | [hipsolverZpotri](interfacehipfort__hipsolver_1_1hipsolverzpotri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 157 | [hipsolverSpotrs_bufferSize](interfacehipfort__hipsolver_1_1hipsolverspotrs__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 158 | [hipsolverDpotrs_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdpotrs__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 159 | [hipsolverCpotrs_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercpotrs__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 160 | [hipsolverZpotrs_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzpotrs__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 161 | [hipsolverSpotrs](interfacehipfort__hipsolver_1_1hipsolverspotrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 162 | [hipsolverDpotrs](interfacehipfort__hipsolver_1_1hipsolverdpotrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 163 | [hipsolverCpotrs](interfacehipfort__hipsolver_1_1hipsolvercpotrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 164 | [hipsolverZpotrs](interfacehipfort__hipsolver_1_1hipsolverzpotrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 165 | [hipsolverSpotrsBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverspotrsbatched__buffersize.html "Interface documentation") | C binding 166 | [hipsolverDpotrsBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdpotrsbatched__buffersize.html "Interface documentation") | C binding 167 | [hipsolverCpotrsBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercpotrsbatched__buffersize.html "Interface documentation") | C binding 168 | [hipsolverZpotrsBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzpotrsbatched__buffersize.html "Interface documentation") | C binding 169 | [hipsolverSpotrsBatched](interfacehipfort__hipsolver_1_1hipsolverspotrsbatched.html "Interface documentation") | C binding 170 | [hipsolverDpotrsBatched](interfacehipfort__hipsolver_1_1hipsolverdpotrsbatched.html "Interface documentation") | C binding 171 | [hipsolverCpotrsBatched](interfacehipfort__hipsolver_1_1hipsolvercpotrsbatched.html "Interface documentation") | C binding 172 | [hipsolverZpotrsBatched](interfacehipfort__hipsolver_1_1hipsolverzpotrsbatched.html "Interface documentation") | C binding 173 | [hipsolverSsyevd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverssyevd__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 174 | [hipsolverDsyevd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdsyevd__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 175 | [hipsolverCheevd_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercheevd__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 176 | [hipsolverZheevd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzheevd__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 177 | [hipsolverSsyevd](interfacehipfort__hipsolver_1_1hipsolverssyevd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 178 | [hipsolverDsyevd](interfacehipfort__hipsolver_1_1hipsolverdsyevd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 179 | [hipsolverCheevd](interfacehipfort__hipsolver_1_1hipsolvercheevd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 180 | [hipsolverZheevd](interfacehipfort__hipsolver_1_1hipsolverzheevd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 181 | [hipsolverSsyevdx_bufferSize](interfacehipfort__hipsolver_1_1hipsolverssyevdx__buffersize.html "Interface documentation") | C binding 182 | [hipsolverDsyevdx_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdsyevdx__buffersize.html "Interface documentation") | C binding 183 | [hipsolverCheevdx_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercheevdx__buffersize.html "Interface documentation") | C binding 184 | [hipsolverZheevdx_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzheevdx__buffersize.html "Interface documentation") | C binding 185 | [hipsolverSsyevdx](interfacehipfort__hipsolver_1_1hipsolverssyevdx.html "Interface documentation") | C binding 186 | [hipsolverDsyevdx](interfacehipfort__hipsolver_1_1hipsolverdsyevdx.html "Interface documentation") | C binding 187 | [hipsolverCheevdx](interfacehipfort__hipsolver_1_1hipsolvercheevdx.html "Interface documentation") | C binding 188 | [hipsolverZheevdx](interfacehipfort__hipsolver_1_1hipsolverzheevdx.html "Interface documentation") | C binding 189 | [hipsolverSsyevj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverssyevj__buffersize.html "Interface documentation") | C binding 190 | [hipsolverDsyevj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdsyevj__buffersize.html "Interface documentation") | C binding 191 | [hipsolverCheevj_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercheevj__buffersize.html "Interface documentation") | C binding 192 | [hipsolverZheevj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzheevj__buffersize.html "Interface documentation") | C binding 193 | [hipsolverSsyevj](interfacehipfort__hipsolver_1_1hipsolverssyevj.html "Interface documentation") | C binding 194 | [hipsolverDsyevj](interfacehipfort__hipsolver_1_1hipsolverdsyevj.html "Interface documentation") | C binding 195 | [hipsolverCheevj](interfacehipfort__hipsolver_1_1hipsolvercheevj.html "Interface documentation") | C binding 196 | [hipsolverZheevj](interfacehipfort__hipsolver_1_1hipsolverzheevj.html "Interface documentation") | C binding 197 | [hipsolverSsyevjBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverssyevjbatched__buffersize.html "Interface documentation") | C binding 198 | [hipsolverDsyevjBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdsyevjbatched__buffersize.html "Interface documentation") | C binding 199 | [hipsolverCheevjBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercheevjbatched__buffersize.html "Interface documentation") | C binding 200 | [hipsolverZheevjBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzheevjbatched__buffersize.html "Interface documentation") | C binding 201 | [hipsolverSsyevjBatched](interfacehipfort__hipsolver_1_1hipsolverssyevjbatched.html "Interface documentation") | C binding 202 | [hipsolverDsyevjBatched](interfacehipfort__hipsolver_1_1hipsolverdsyevjbatched.html "Interface documentation") | C binding 203 | [hipsolverCheevjBatched](interfacehipfort__hipsolver_1_1hipsolvercheevjbatched.html "Interface documentation") | C binding 204 | [hipsolverZheevjBatched](interfacehipfort__hipsolver_1_1hipsolverzheevjbatched.html "Interface documentation") | C binding 205 | [hipsolverSsygvd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverssygvd__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 206 | [hipsolverDsygvd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdsygvd__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 207 | [hipsolverChegvd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverchegvd__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 208 | [hipsolverZhegvd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzhegvd__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 209 | [hipsolverSsygvd](interfacehipfort__hipsolver_1_1hipsolverssygvd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 210 | [hipsolverDsygvd](interfacehipfort__hipsolver_1_1hipsolverdsygvd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 211 | [hipsolverChegvd](interfacehipfort__hipsolver_1_1hipsolverchegvd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 212 | [hipsolverZhegvd](interfacehipfort__hipsolver_1_1hipsolverzhegvd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 213 | [hipsolverSsygvdx_bufferSize](interfacehipfort__hipsolver_1_1hipsolverssygvdx__buffersize.html "Interface documentation") | C binding 214 | [hipsolverDsygvdx_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdsygvdx__buffersize.html "Interface documentation") | C binding 215 | [hipsolverChegvdx_bufferSize](interfacehipfort__hipsolver_1_1hipsolverchegvdx__buffersize.html "Interface documentation") | C binding 216 | [hipsolverZhegvdx_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzhegvdx__buffersize.html "Interface documentation") | C binding 217 | [hipsolverSsygvdx](interfacehipfort__hipsolver_1_1hipsolverssygvdx.html "Interface documentation") | C binding 218 | [hipsolverDsygvdx](interfacehipfort__hipsolver_1_1hipsolverdsygvdx.html "Interface documentation") | C binding 219 | [hipsolverChegvdx](interfacehipfort__hipsolver_1_1hipsolverchegvdx.html "Interface documentation") | C binding 220 | [hipsolverZhegvdx](interfacehipfort__hipsolver_1_1hipsolverzhegvdx.html "Interface documentation") | C binding 221 | [hipsolverSsygvj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverssygvj__buffersize.html "Interface documentation") | C binding 222 | [hipsolverDsygvj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdsygvj__buffersize.html "Interface documentation") | C binding 223 | [hipsolverChegvj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverchegvj__buffersize.html "Interface documentation") | C binding 224 | [hipsolverZhegvj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzhegvj__buffersize.html "Interface documentation") | C binding 225 | [hipsolverSsygvj](interfacehipfort__hipsolver_1_1hipsolverssygvj.html "Interface documentation") | C binding 226 | [hipsolverDsygvj](interfacehipfort__hipsolver_1_1hipsolverdsygvj.html "Interface documentation") | C binding 227 | [hipsolverChegvj](interfacehipfort__hipsolver_1_1hipsolverchegvj.html "Interface documentation") | C binding 228 | [hipsolverZhegvj](interfacehipfort__hipsolver_1_1hipsolverzhegvj.html "Interface documentation") | C binding 229 | [hipsolverSsytrd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverssytrd__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 230 | [hipsolverDsytrd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdsytrd__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 231 | [hipsolverChetrd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverchetrd__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 232 | [hipsolverZhetrd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzhetrd__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 233 | [hipsolverSsytrd](interfacehipfort__hipsolver_1_1hipsolverssytrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 234 | [hipsolverDsytrd](interfacehipfort__hipsolver_1_1hipsolverdsytrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 235 | [hipsolverChetrd](interfacehipfort__hipsolver_1_1hipsolverchetrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 236 | [hipsolverZhetrd](interfacehipfort__hipsolver_1_1hipsolverzhetrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 237 | [hipsolverSsytrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverssytrf__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 238 | [hipsolverDsytrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdsytrf__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 239 | [hipsolverCsytrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolvercsytrf__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 240 | [hipsolverZsytrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverzsytrf__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 241 | [hipsolverSsytrf](interfacehipfort__hipsolver_1_1hipsolverssytrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 242 | [hipsolverDsytrf](interfacehipfort__hipsolver_1_1hipsolverdsytrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 243 | [hipsolverCsytrf](interfacehipfort__hipsolver_1_1hipsolvercsytrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 244 | [hipsolverZsytrf](interfacehipfort__hipsolver_1_1hipsolverzsytrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 245 | [hipsolverDnCreate](interfacehipfort__hipsolver_1_1hipsolverdncreate.html "Interface documentation") | C binding 246 | [hipsolverDnDestroy](interfacehipfort__hipsolver_1_1hipsolverdndestroy.html "Interface documentation") | C binding 247 | [hipsolverDnSetStream](interfacehipfort__hipsolver_1_1hipsolverdnsetstream.html "Interface documentation") | C binding 248 | [hipsolverDnGetStream](interfacehipfort__hipsolver_1_1hipsolverdngetstream.html "Interface documentation") | C binding 249 | [hipsolverDnSetDeterministicMode](interfacehipfort__hipsolver_1_1hipsolverdnsetdeterministicmode.html "Interface documentation") | C binding 250 | [hipsolverDnGetDeterministicMode](interfacehipfort__hipsolver_1_1hipsolverdngetdeterministicmode.html "Interface documentation") | C binding 251 | [hipsolverDnCreateGesvdjInfo](interfacehipfort__hipsolver_1_1hipsolverdncreategesvdjinfo.html "Interface documentation") | C binding 252 | [hipsolverDnDestroyGesvdjInfo](interfacehipfort__hipsolver_1_1hipsolverdndestroygesvdjinfo.html "Interface documentation") | C binding 253 | [hipsolverDnXgesvdjSetMaxSweeps](interfacehipfort__hipsolver_1_1hipsolverdnxgesvdjsetmaxsweeps.html "Interface documentation") | C binding 254 | [hipsolverDnXgesvdjSetSortEig](interfacehipfort__hipsolver_1_1hipsolverdnxgesvdjsetsorteig.html "Interface documentation") | C binding 255 | [hipsolverDnXgesvdjSetTolerance](interfacehipfort__hipsolver_1_1hipsolverdnxgesvdjsettolerance.html "Interface documentation") | C binding 256 | [hipsolverDnXgesvdjGetResidual](interfacehipfort__hipsolver_1_1hipsolverdnxgesvdjgetresidual.html "Interface documentation") | C binding 257 | [hipsolverDnXgesvdjGetSweeps](interfacehipfort__hipsolver_1_1hipsolverdnxgesvdjgetsweeps.html "Interface documentation") | C binding 258 | [hipsolverDnCreateSyevjInfo](interfacehipfort__hipsolver_1_1hipsolverdncreatesyevjinfo.html "Interface documentation") | C binding 259 | [hipsolverDnDestroySyevjInfo](interfacehipfort__hipsolver_1_1hipsolverdndestroysyevjinfo.html "Interface documentation") | C binding 260 | [hipsolverDnXsyevjSetMaxSweeps](interfacehipfort__hipsolver_1_1hipsolverdnxsyevjsetmaxsweeps.html "Interface documentation") | C binding 261 | [hipsolverDnXsyevjSetSortEig](interfacehipfort__hipsolver_1_1hipsolverdnxsyevjsetsorteig.html "Interface documentation") | C binding 262 | [hipsolverDnXsyevjSetTolerance](interfacehipfort__hipsolver_1_1hipsolverdnxsyevjsettolerance.html "Interface documentation") | C binding 263 | [hipsolverDnXsyevjGetResidual](interfacehipfort__hipsolver_1_1hipsolverdnxsyevjgetresidual.html "Interface documentation") | C binding 264 | [hipsolverDnXsyevjGetSweeps](interfacehipfort__hipsolver_1_1hipsolverdnxsyevjgetsweeps.html "Interface documentation") | C binding 265 | [hipsolverDnSorgbr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnsorgbr__buffersize.html "Interface documentation") | C binding 266 | [hipsolverDnDorgbr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndorgbr__buffersize.html "Interface documentation") | C binding 267 | [hipsolverDnCungbr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdncungbr__buffersize.html "Interface documentation") | C binding 268 | [hipsolverDnZungbr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzungbr__buffersize.html "Interface documentation") | C binding 269 | [hipsolverDnSorgbr](interfacehipfort__hipsolver_1_1hipsolverdnsorgbr.html "Interface documentation") | C binding 270 | [hipsolverDnDorgbr](interfacehipfort__hipsolver_1_1hipsolverdndorgbr.html "Interface documentation") | C binding 271 | [hipsolverDnCungbr](interfacehipfort__hipsolver_1_1hipsolverdncungbr.html "Interface documentation") | C binding 272 | [hipsolverDnZungbr](interfacehipfort__hipsolver_1_1hipsolverdnzungbr.html "Interface documentation") | C binding 273 | [hipsolverDnSorgqr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnsorgqr__buffersize.html "Interface documentation") | C binding 274 | [hipsolverDnDorgqr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndorgqr__buffersize.html "Interface documentation") | C binding 275 | [hipsolverDnCungqr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdncungqr__buffersize.html "Interface documentation") | C binding 276 | [hipsolverDnZungqr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzungqr__buffersize.html "Interface documentation") | C binding 277 | [hipsolverDnSorgqr](interfacehipfort__hipsolver_1_1hipsolverdnsorgqr.html "Interface documentation") | C binding 278 | [hipsolverDnDorgqr](interfacehipfort__hipsolver_1_1hipsolverdndorgqr.html "Interface documentation") | C binding 279 | [hipsolverDnCungqr](interfacehipfort__hipsolver_1_1hipsolverdncungqr.html "Interface documentation") | C binding 280 | [hipsolverDnZungqr](interfacehipfort__hipsolver_1_1hipsolverdnzungqr.html "Interface documentation") | C binding 281 | [hipsolverDnSorgtr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnsorgtr__buffersize.html "Interface documentation") | C binding 282 | [hipsolverDnDorgtr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndorgtr__buffersize.html "Interface documentation") | C binding 283 | [hipsolverDnCungtr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdncungtr__buffersize.html "Interface documentation") | C binding 284 | [hipsolverDnZungtr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzungtr__buffersize.html "Interface documentation") | C binding 285 | [hipsolverDnSorgtr](interfacehipfort__hipsolver_1_1hipsolverdnsorgtr.html "Interface documentation") | C binding 286 | [hipsolverDnDorgtr](interfacehipfort__hipsolver_1_1hipsolverdndorgtr.html "Interface documentation") | C binding 287 | [hipsolverDnCungtr](interfacehipfort__hipsolver_1_1hipsolverdncungtr.html "Interface documentation") | C binding 288 | [hipsolverDnZungtr](interfacehipfort__hipsolver_1_1hipsolverdnzungtr.html "Interface documentation") | C binding 289 | [hipsolverDnSormqr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnsormqr__buffersize.html "Interface documentation") | C binding 290 | [hipsolverDnDormqr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndormqr__buffersize.html "Interface documentation") | C binding 291 | [hipsolverDnCunmqr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdncunmqr__buffersize.html "Interface documentation") | C binding 292 | [hipsolverDnZunmqr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzunmqr__buffersize.html "Interface documentation") | C binding 293 | [hipsolverDnSormqr](interfacehipfort__hipsolver_1_1hipsolverdnsormqr.html "Interface documentation") | C binding 294 | [hipsolverDnDormqr](interfacehipfort__hipsolver_1_1hipsolverdndormqr.html "Interface documentation") | C binding 295 | [hipsolverDnCunmqr](interfacehipfort__hipsolver_1_1hipsolverdncunmqr.html "Interface documentation") | C binding 296 | [hipsolverDnZunmqr](interfacehipfort__hipsolver_1_1hipsolverdnzunmqr.html "Interface documentation") | C binding 297 | [hipsolverDnSormtr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnsormtr__buffersize.html "Interface documentation") | C binding 298 | [hipsolverDnDormtr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndormtr__buffersize.html "Interface documentation") | C binding 299 | [hipsolverDnCunmtr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdncunmtr__buffersize.html "Interface documentation") | C binding 300 | [hipsolverDnZunmtr_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzunmtr__buffersize.html "Interface documentation") | C binding 301 | [hipsolverDnSormtr](interfacehipfort__hipsolver_1_1hipsolverdnsormtr.html "Interface documentation") | C binding 302 | [hipsolverDnDormtr](interfacehipfort__hipsolver_1_1hipsolverdndormtr.html "Interface documentation") | C binding 303 | [hipsolverDnCunmtr](interfacehipfort__hipsolver_1_1hipsolverdncunmtr.html "Interface documentation") | C binding 304 | [hipsolverDnZunmtr](interfacehipfort__hipsolver_1_1hipsolverdnzunmtr.html "Interface documentation") | C binding 305 | [hipsolverDnSgebrd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnsgebrd__buffersize.html "Interface documentation") | C binding 306 | [hipsolverDnDgebrd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndgebrd__buffersize.html "Interface documentation") | C binding 307 | [hipsolverDnCgebrd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdncgebrd__buffersize.html "Interface documentation") | C binding 308 | [hipsolverDnZgebrd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzgebrd__buffersize.html "Interface documentation") | C binding 309 | [hipsolverDnSgebrd](interfacehipfort__hipsolver_1_1hipsolverdnsgebrd.html "Interface documentation") | C binding 310 | [hipsolverDnDgebrd](interfacehipfort__hipsolver_1_1hipsolverdndgebrd.html "Interface documentation") | C binding 311 | [hipsolverDnCgebrd](interfacehipfort__hipsolver_1_1hipsolverdncgebrd.html "Interface documentation") | C binding 312 | [hipsolverDnZgebrd](interfacehipfort__hipsolver_1_1hipsolverdnzgebrd.html "Interface documentation") | C binding 313 | [hipsolverDnSSgels_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnssgels__buffersize.html "Interface documentation") | C binding 314 | [hipsolverDnDDgels_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnddgels__buffersize.html "Interface documentation") | C binding 315 | [hipsolverDnCCgels_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnccgels__buffersize.html "Interface documentation") | C binding 316 | [hipsolverDnZZgels_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzzgels__buffersize.html "Interface documentation") | C binding 317 | [hipsolverDnSSgels](interfacehipfort__hipsolver_1_1hipsolverdnssgels.html "Interface documentation") | C binding 318 | [hipsolverDnDDgels](interfacehipfort__hipsolver_1_1hipsolverdnddgels.html "Interface documentation") | C binding 319 | [hipsolverDnCCgels](interfacehipfort__hipsolver_1_1hipsolverdnccgels.html "Interface documentation") | C binding 320 | [hipsolverDnZZgels](interfacehipfort__hipsolver_1_1hipsolverdnzzgels.html "Interface documentation") | C binding 321 | [hipsolverDnSgeqrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnsgeqrf__buffersize.html "Interface documentation") | C binding 322 | [hipsolverDnDgeqrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndgeqrf__buffersize.html "Interface documentation") | C binding 323 | [hipsolverDnCgeqrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdncgeqrf__buffersize.html "Interface documentation") | C binding 324 | [hipsolverDnZgeqrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzgeqrf__buffersize.html "Interface documentation") | C binding 325 | [hipsolverDnSgeqrf](interfacehipfort__hipsolver_1_1hipsolverdnsgeqrf.html "Interface documentation") | C binding 326 | [hipsolverDnDgeqrf](interfacehipfort__hipsolver_1_1hipsolverdndgeqrf.html "Interface documentation") | C binding 327 | [hipsolverDnCgeqrf](interfacehipfort__hipsolver_1_1hipsolverdncgeqrf.html "Interface documentation") | C binding 328 | [hipsolverDnZgeqrf](interfacehipfort__hipsolver_1_1hipsolverdnzgeqrf.html "Interface documentation") | C binding 329 | [hipsolverDnSSgesv_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnssgesv__buffersize.html "Interface documentation") | C binding 330 | [hipsolverDnDDgesv_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnddgesv__buffersize.html "Interface documentation") | C binding 331 | [hipsolverDnCCgesv_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnccgesv__buffersize.html "Interface documentation") | C binding 332 | [hipsolverDnZZgesv_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzzgesv__buffersize.html "Interface documentation") | C binding 333 | [hipsolverDnSSgesv](interfacehipfort__hipsolver_1_1hipsolverdnssgesv.html "Interface documentation") | C binding 334 | [hipsolverDnDDgesv](interfacehipfort__hipsolver_1_1hipsolverdnddgesv.html "Interface documentation") | C binding 335 | [hipsolverDnCCgesv](interfacehipfort__hipsolver_1_1hipsolverdnccgesv.html "Interface documentation") | C binding 336 | [hipsolverDnZZgesv](interfacehipfort__hipsolver_1_1hipsolverdnzzgesv.html "Interface documentation") | C binding 337 | [hipsolverDnSgesvd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnsgesvd__buffersize.html "Interface documentation") | C binding 338 | [hipsolverDnDgesvd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndgesvd__buffersize.html "Interface documentation") | C binding 339 | [hipsolverDnCgesvd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdncgesvd__buffersize.html "Interface documentation") | C binding 340 | [hipsolverDnZgesvd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzgesvd__buffersize.html "Interface documentation") | C binding 341 | [hipsolverDnSgesvd](interfacehipfort__hipsolver_1_1hipsolverdnsgesvd.html "Interface documentation") | C binding 342 | [hipsolverDnDgesvd](interfacehipfort__hipsolver_1_1hipsolverdndgesvd.html "Interface documentation") | C binding 343 | [hipsolverDnCgesvd](interfacehipfort__hipsolver_1_1hipsolverdncgesvd.html "Interface documentation") | C binding 344 | [hipsolverDnZgesvd](interfacehipfort__hipsolver_1_1hipsolverdnzgesvd.html "Interface documentation") | C binding 345 | [hipsolverDnSgesvdj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnsgesvdj__buffersize.html "Interface documentation") | C binding 346 | [hipsolverDnDgesvdj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndgesvdj__buffersize.html "Interface documentation") | C binding 347 | [hipsolverDnCgesvdj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdncgesvdj__buffersize.html "Interface documentation") | C binding 348 | [hipsolverDnZgesvdj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzgesvdj__buffersize.html "Interface documentation") | C binding 349 | [hipsolverDnSgesvdj](interfacehipfort__hipsolver_1_1hipsolverdnsgesvdj.html "Interface documentation") | C binding 350 | [hipsolverDnDgesvdj](interfacehipfort__hipsolver_1_1hipsolverdndgesvdj.html "Interface documentation") | C binding 351 | [hipsolverDnCgesvdj](interfacehipfort__hipsolver_1_1hipsolverdncgesvdj.html "Interface documentation") | C binding 352 | [hipsolverDnZgesvdj](interfacehipfort__hipsolver_1_1hipsolverdnzgesvdj.html "Interface documentation") | C binding 353 | [hipsolverDnSgesvdjBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnsgesvdjbatched__buffersize.html "Interface documentation") | C binding 354 | [hipsolverDnDgesvdjBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndgesvdjbatched__buffersize.html "Interface documentation") | C binding 355 | [hipsolverDnCgesvdjBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdncgesvdjbatched__buffersize.html "Interface documentation") | C binding 356 | [hipsolverDnZgesvdjBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzgesvdjbatched__buffersize.html "Interface documentation") | C binding 357 | [hipsolverDnSgesvdjBatched](interfacehipfort__hipsolver_1_1hipsolverdnsgesvdjbatched.html "Interface documentation") | C binding 358 | [hipsolverDnDgesvdjBatched](interfacehipfort__hipsolver_1_1hipsolverdndgesvdjbatched.html "Interface documentation") | C binding 359 | [hipsolverDnCgesvdjBatched](interfacehipfort__hipsolver_1_1hipsolverdncgesvdjbatched.html "Interface documentation") | C binding 360 | [hipsolverDnZgesvdjBatched](interfacehipfort__hipsolver_1_1hipsolverdnzgesvdjbatched.html "Interface documentation") | C binding 361 | [hipsolverDnSgesvdaStridedBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnsgesvdastridedbatched__buffersize.html "Interface documentation") | C binding 362 | [hipsolverDnDgesvdaStridedBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndgesvdastridedbatched__buffersize.html "Interface documentation") | C binding 363 | [hipsolverDnCgesvdaStridedBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdncgesvdastridedbatched__buffersize.html "Interface documentation") | C binding 364 | [hipsolverDnZgesvdaStridedBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzgesvdastridedbatched__buffersize.html "Interface documentation") | C binding 365 | [hipsolverDnSgesvdaStridedBatched](interfacehipfort__hipsolver_1_1hipsolverdnsgesvdastridedbatched.html "Interface documentation") | C binding 366 | [hipsolverDnDgesvdaStridedBatched](interfacehipfort__hipsolver_1_1hipsolverdndgesvdastridedbatched.html "Interface documentation") | C binding 367 | [hipsolverDnCgesvdaStridedBatched](interfacehipfort__hipsolver_1_1hipsolverdncgesvdastridedbatched.html "Interface documentation") | C binding 368 | [hipsolverDnZgesvdaStridedBatched](interfacehipfort__hipsolver_1_1hipsolverdnzgesvdastridedbatched.html "Interface documentation") | C binding 369 | [hipsolverDnSgetrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnsgetrf__buffersize.html "Interface documentation") | C binding 370 | [hipsolverDnDgetrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndgetrf__buffersize.html "Interface documentation") | C binding 371 | [hipsolverDnCgetrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdncgetrf__buffersize.html "Interface documentation") | C binding 372 | [hipsolverDnZgetrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzgetrf__buffersize.html "Interface documentation") | C binding 373 | [hipsolverDnSgetrf](interfacehipfort__hipsolver_1_1hipsolverdnsgetrf.html "Interface documentation") | C binding 374 | [hipsolverDnDgetrf](interfacehipfort__hipsolver_1_1hipsolverdndgetrf.html "Interface documentation") | C binding 375 | [hipsolverDnCgetrf](interfacehipfort__hipsolver_1_1hipsolverdncgetrf.html "Interface documentation") | C binding 376 | [hipsolverDnZgetrf](interfacehipfort__hipsolver_1_1hipsolverdnzgetrf.html "Interface documentation") | C binding 377 | [hipsolverDnSgetrs](interfacehipfort__hipsolver_1_1hipsolverdnsgetrs.html "Interface documentation") | C binding 378 | [hipsolverDnDgetrs](interfacehipfort__hipsolver_1_1hipsolverdndgetrs.html "Interface documentation") | C binding 379 | [hipsolverDnCgetrs](interfacehipfort__hipsolver_1_1hipsolverdncgetrs.html "Interface documentation") | C binding 380 | [hipsolverDnZgetrs](interfacehipfort__hipsolver_1_1hipsolverdnzgetrs.html "Interface documentation") | C binding 381 | [hipsolverDnSpotrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnspotrf__buffersize.html "Interface documentation") | C binding 382 | [hipsolverDnDpotrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndpotrf__buffersize.html "Interface documentation") | C binding 383 | [hipsolverDnCpotrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdncpotrf__buffersize.html "Interface documentation") | C binding 384 | [hipsolverDnZpotrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzpotrf__buffersize.html "Interface documentation") | C binding 385 | [hipsolverDnSpotrf](interfacehipfort__hipsolver_1_1hipsolverdnspotrf.html "Interface documentation") | C binding 386 | [hipsolverDnDpotrf](interfacehipfort__hipsolver_1_1hipsolverdndpotrf.html "Interface documentation") | C binding 387 | [hipsolverDnCpotrf](interfacehipfort__hipsolver_1_1hipsolverdncpotrf.html "Interface documentation") | C binding 388 | [hipsolverDnZpotrf](interfacehipfort__hipsolver_1_1hipsolverdnzpotrf.html "Interface documentation") | C binding 389 | [hipsolverDnSpotrfBatched](interfacehipfort__hipsolver_1_1hipsolverdnspotrfbatched.html "Interface documentation") | C binding 390 | [hipsolverDnDpotrfBatched](interfacehipfort__hipsolver_1_1hipsolverdndpotrfbatched.html "Interface documentation") | C binding 391 | [hipsolverDnCpotrfBatched](interfacehipfort__hipsolver_1_1hipsolverdncpotrfbatched.html "Interface documentation") | C binding 392 | [hipsolverDnZpotrfBatched](interfacehipfort__hipsolver_1_1hipsolverdnzpotrfbatched.html "Interface documentation") | C binding 393 | [hipsolverDnSpotri_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnspotri__buffersize.html "Interface documentation") | C binding 394 | [hipsolverDnDpotri_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndpotri__buffersize.html "Interface documentation") | C binding 395 | [hipsolverDnCpotri_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdncpotri__buffersize.html "Interface documentation") | C binding 396 | [hipsolverDnZpotri_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzpotri__buffersize.html "Interface documentation") | C binding 397 | [hipsolverDnSpotri](interfacehipfort__hipsolver_1_1hipsolverdnspotri.html "Interface documentation") | C binding 398 | [hipsolverDnDpotri](interfacehipfort__hipsolver_1_1hipsolverdndpotri.html "Interface documentation") | C binding 399 | [hipsolverDnCpotri](interfacehipfort__hipsolver_1_1hipsolverdncpotri.html "Interface documentation") | C binding 400 | [hipsolverDnZpotri](interfacehipfort__hipsolver_1_1hipsolverdnzpotri.html "Interface documentation") | C binding 401 | [hipsolverDnSpotrs](interfacehipfort__hipsolver_1_1hipsolverdnspotrs.html "Interface documentation") | C binding 402 | [hipsolverDnDpotrs](interfacehipfort__hipsolver_1_1hipsolverdndpotrs.html "Interface documentation") | C binding 403 | [hipsolverDnCpotrs](interfacehipfort__hipsolver_1_1hipsolverdncpotrs.html "Interface documentation") | C binding 404 | [hipsolverDnZpotrs](interfacehipfort__hipsolver_1_1hipsolverdnzpotrs.html "Interface documentation") | C binding 405 | [hipsolverDnSpotrsBatched](interfacehipfort__hipsolver_1_1hipsolverdnspotrsbatched.html "Interface documentation") | C binding 406 | [hipsolverDnDpotrsBatched](interfacehipfort__hipsolver_1_1hipsolverdndpotrsbatched.html "Interface documentation") | C binding 407 | [hipsolverDnCpotrsBatched](interfacehipfort__hipsolver_1_1hipsolverdncpotrsbatched.html "Interface documentation") | C binding 408 | [hipsolverDnZpotrsBatched](interfacehipfort__hipsolver_1_1hipsolverdnzpotrsbatched.html "Interface documentation") | C binding 409 | [hipsolverDnSsyevd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnssyevd__buffersize.html "Interface documentation") | C binding 410 | [hipsolverDnDsyevd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndsyevd__buffersize.html "Interface documentation") | C binding 411 | [hipsolverDnCheevd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdncheevd__buffersize.html "Interface documentation") | C binding 412 | [hipsolverDnZheevd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzheevd__buffersize.html "Interface documentation") | C binding 413 | [hipsolverDnSsyevd](interfacehipfort__hipsolver_1_1hipsolverdnssyevd.html "Interface documentation") | C binding 414 | [hipsolverDnDsyevd](interfacehipfort__hipsolver_1_1hipsolverdndsyevd.html "Interface documentation") | C binding 415 | [hipsolverDnCheevd](interfacehipfort__hipsolver_1_1hipsolverdncheevd.html "Interface documentation") | C binding 416 | [hipsolverDnZheevd](interfacehipfort__hipsolver_1_1hipsolverdnzheevd.html "Interface documentation") | C binding 417 | [hipsolverDnSsyevdx_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnssyevdx__buffersize.html "Interface documentation") | C binding 418 | [hipsolverDnDsyevdx_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndsyevdx__buffersize.html "Interface documentation") | C binding 419 | [hipsolverDnCheevdx_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdncheevdx__buffersize.html "Interface documentation") | C binding 420 | [hipsolverDnZheevdx_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzheevdx__buffersize.html "Interface documentation") | C binding 421 | [hipsolverDnSsyevdx](interfacehipfort__hipsolver_1_1hipsolverdnssyevdx.html "Interface documentation") | C binding 422 | [hipsolverDnDsyevdx](interfacehipfort__hipsolver_1_1hipsolverdndsyevdx.html "Interface documentation") | C binding 423 | [hipsolverDnCheevdx](interfacehipfort__hipsolver_1_1hipsolverdncheevdx.html "Interface documentation") | C binding 424 | [hipsolverDnZheevdx](interfacehipfort__hipsolver_1_1hipsolverdnzheevdx.html "Interface documentation") | C binding 425 | [hipsolverDnSsyevj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnssyevj__buffersize.html "Interface documentation") | C binding 426 | [hipsolverDnDsyevj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndsyevj__buffersize.html "Interface documentation") | C binding 427 | [hipsolverDnCheevj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdncheevj__buffersize.html "Interface documentation") | C binding 428 | [hipsolverDnZheevj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzheevj__buffersize.html "Interface documentation") | C binding 429 | [hipsolverDnSsyevj](interfacehipfort__hipsolver_1_1hipsolverdnssyevj.html "Interface documentation") | C binding 430 | [hipsolverDnDsyevj](interfacehipfort__hipsolver_1_1hipsolverdndsyevj.html "Interface documentation") | C binding 431 | [hipsolverDnCheevj](interfacehipfort__hipsolver_1_1hipsolverdncheevj.html "Interface documentation") | C binding 432 | [hipsolverDnZheevj](interfacehipfort__hipsolver_1_1hipsolverdnzheevj.html "Interface documentation") | C binding 433 | [hipsolverDnSsyevjBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnssyevjbatched__buffersize.html "Interface documentation") | C binding 434 | [hipsolverDnDsyevjBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndsyevjbatched__buffersize.html "Interface documentation") | C binding 435 | [hipsolverDnCheevjBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdncheevjbatched__buffersize.html "Interface documentation") | C binding 436 | [hipsolverDnZheevjBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzheevjbatched__buffersize.html "Interface documentation") | C binding 437 | [hipsolverDnSsyevjBatched](interfacehipfort__hipsolver_1_1hipsolverdnssyevjbatched.html "Interface documentation") | C binding 438 | [hipsolverDnDsyevjBatched](interfacehipfort__hipsolver_1_1hipsolverdndsyevjbatched.html "Interface documentation") | C binding 439 | [hipsolverDnCheevjBatched](interfacehipfort__hipsolver_1_1hipsolverdncheevjbatched.html "Interface documentation") | C binding 440 | [hipsolverDnZheevjBatched](interfacehipfort__hipsolver_1_1hipsolverdnzheevjbatched.html "Interface documentation") | C binding 441 | [hipsolverDnSsygvd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnssygvd__buffersize.html "Interface documentation") | C binding 442 | [hipsolverDnDsygvd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndsygvd__buffersize.html "Interface documentation") | C binding 443 | [hipsolverDnChegvd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnchegvd__buffersize.html "Interface documentation") | C binding 444 | [hipsolverDnZhegvd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzhegvd__buffersize.html "Interface documentation") | C binding 445 | [hipsolverDnSsygvd](interfacehipfort__hipsolver_1_1hipsolverdnssygvd.html "Interface documentation") | C binding 446 | [hipsolverDnDsygvd](interfacehipfort__hipsolver_1_1hipsolverdndsygvd.html "Interface documentation") | C binding 447 | [hipsolverDnChegvd](interfacehipfort__hipsolver_1_1hipsolverdnchegvd.html "Interface documentation") | C binding 448 | [hipsolverDnZhegvd](interfacehipfort__hipsolver_1_1hipsolverdnzhegvd.html "Interface documentation") | C binding 449 | [hipsolverDnSsygvdx_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnssygvdx__buffersize.html "Interface documentation") | C binding 450 | [hipsolverDnDsygvdx_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndsygvdx__buffersize.html "Interface documentation") | C binding 451 | [hipsolverDnChegvdx_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnchegvdx__buffersize.html "Interface documentation") | C binding 452 | [hipsolverDnZhegvdx_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzhegvdx__buffersize.html "Interface documentation") | C binding 453 | [hipsolverDnSsygvdx](interfacehipfort__hipsolver_1_1hipsolverdnssygvdx.html "Interface documentation") | C binding 454 | [hipsolverDnDsygvdx](interfacehipfort__hipsolver_1_1hipsolverdndsygvdx.html "Interface documentation") | C binding 455 | [hipsolverDnChegvdx](interfacehipfort__hipsolver_1_1hipsolverdnchegvdx.html "Interface documentation") | C binding 456 | [hipsolverDnZhegvdx](interfacehipfort__hipsolver_1_1hipsolverdnzhegvdx.html "Interface documentation") | C binding 457 | [hipsolverDnSsygvj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnssygvj__buffersize.html "Interface documentation") | C binding 458 | [hipsolverDnDsygvj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndsygvj__buffersize.html "Interface documentation") | C binding 459 | [hipsolverDnChegvj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnchegvj__buffersize.html "Interface documentation") | C binding 460 | [hipsolverDnZhegvj_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzhegvj__buffersize.html "Interface documentation") | C binding 461 | [hipsolverDnSsygvj](interfacehipfort__hipsolver_1_1hipsolverdnssygvj.html "Interface documentation") | C binding 462 | [hipsolverDnDsygvj](interfacehipfort__hipsolver_1_1hipsolverdndsygvj.html "Interface documentation") | C binding 463 | [hipsolverDnChegvj](interfacehipfort__hipsolver_1_1hipsolverdnchegvj.html "Interface documentation") | C binding 464 | [hipsolverDnZhegvj](interfacehipfort__hipsolver_1_1hipsolverdnzhegvj.html "Interface documentation") | C binding 465 | [hipsolverDnSsytrd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnssytrd__buffersize.html "Interface documentation") | C binding 466 | [hipsolverDnDsytrd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndsytrd__buffersize.html "Interface documentation") | C binding 467 | [hipsolverDnChetrd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnchetrd__buffersize.html "Interface documentation") | C binding 468 | [hipsolverDnZhetrd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzhetrd__buffersize.html "Interface documentation") | C binding 469 | [hipsolverDnSsytrd](interfacehipfort__hipsolver_1_1hipsolverdnssytrd.html "Interface documentation") | C binding 470 | [hipsolverDnDsytrd](interfacehipfort__hipsolver_1_1hipsolverdndsytrd.html "Interface documentation") | C binding 471 | [hipsolverDnChetrd](interfacehipfort__hipsolver_1_1hipsolverdnchetrd.html "Interface documentation") | C binding 472 | [hipsolverDnZhetrd](interfacehipfort__hipsolver_1_1hipsolverdnzhetrd.html "Interface documentation") | C binding 473 | [hipsolverDnSsytrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnssytrf__buffersize.html "Interface documentation") | C binding 474 | [hipsolverDnDsytrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdndsytrf__buffersize.html "Interface documentation") | C binding 475 | [hipsolverDnCsytrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdncsytrf__buffersize.html "Interface documentation") | C binding 476 | [hipsolverDnZsytrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnzsytrf__buffersize.html "Interface documentation") | C binding 477 | [hipsolverDnSsytrf](interfacehipfort__hipsolver_1_1hipsolverdnssytrf.html "Interface documentation") | C binding 478 | [hipsolverDnDsytrf](interfacehipfort__hipsolver_1_1hipsolverdndsytrf.html "Interface documentation") | C binding 479 | [hipsolverDnCsytrf](interfacehipfort__hipsolver_1_1hipsolverdncsytrf.html "Interface documentation") | C binding 480 | [hipsolverDnZsytrf](interfacehipfort__hipsolver_1_1hipsolverdnzsytrf.html "Interface documentation") | C binding 481 | [hipsolverDnCreateParams](interfacehipfort__hipsolver_1_1hipsolverdncreateparams.html "Interface documentation") | C binding 482 | [hipsolverDnDestroyParams](interfacehipfort__hipsolver_1_1hipsolverdndestroyparams.html "Interface documentation") | C binding 483 | [hipsolverDnSetAdvOptions](interfacehipfort__hipsolver_1_1hipsolverdnsetadvoptions.html "Interface documentation") | C binding 484 | [hipsolverDnXgeev_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnxgeev__buffersize.html "Interface documentation") | C binding 485 | [hipsolverDnXgeev](interfacehipfort__hipsolver_1_1hipsolverdnxgeev.html "Interface documentation") | C binding 486 | [hipsolverDnXgeqrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnxgeqrf__buffersize.html "Interface documentation") | C binding 487 | [hipsolverDnXgeqrf](interfacehipfort__hipsolver_1_1hipsolverdnxgeqrf.html "Interface documentation") | C binding 488 | [hipsolverDnXgetrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnxgetrf__buffersize.html "Interface documentation") | C binding 489 | [hipsolverDnXgetrf](interfacehipfort__hipsolver_1_1hipsolverdnxgetrf.html "Interface documentation") | C binding 490 | [hipsolverDnXgetrs](interfacehipfort__hipsolver_1_1hipsolverdnxgetrs.html "Interface documentation") | C binding 491 | [hipsolverDnXpotrf_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnxpotrf__buffersize.html "Interface documentation") | C binding 492 | [hipsolverDnXpotrf](interfacehipfort__hipsolver_1_1hipsolverdnxpotrf.html "Interface documentation") | C binding 493 | [hipsolverDnXpotrs](interfacehipfort__hipsolver_1_1hipsolverdnxpotrs.html "Interface documentation") | C binding 494 | [hipsolverDnXsyevd_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnxsyevd__buffersize.html "Interface documentation") | C binding 495 | [hipsolverDnXsyevd](interfacehipfort__hipsolver_1_1hipsolverdnxsyevd.html "Interface documentation") | C binding 496 | [hipsolverDnXsyevBatched_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnxsyevbatched__buffersize.html "Interface documentation") | C binding 497 | [hipsolverDnXsyevBatched](interfacehipfort__hipsolver_1_1hipsolverdnxsyevbatched.html "Interface documentation") | C binding 498 | [hipsolverDnXsytrs_bufferSize](interfacehipfort__hipsolver_1_1hipsolverdnxsytrs__buffersize.html "Interface documentation") | C binding 499 | [hipsolverDnXsytrs](interfacehipfort__hipsolver_1_1hipsolverdnxsytrs.html "Interface documentation") | C binding 500 | [hipsolverRfCreate](interfacehipfort__hipsolver_1_1hipsolverrfcreate.html "Interface documentation") | C binding 501 | [hipsolverRfDestroy](interfacehipfort__hipsolver_1_1hipsolverrfdestroy.html "Interface documentation") | C binding 502 | [hipsolverRfSetupDevice](interfacehipfort__hipsolver_1_1hipsolverrfsetupdevice.html "Interface documentation") | C binding 503 | [hipsolverRfSetupHost](interfacehipfort__hipsolver_1_1hipsolverrfsetuphost.html "Interface documentation") | C binding 504 | [hipsolverRfAccessBundledFactorsDevice](interfacehipfort__hipsolver_1_1hipsolverrfaccessbundledfactorsdevice.html "Interface documentation") | C binding 505 | [hipsolverRfAnalyze](interfacehipfort__hipsolver_1_1hipsolverrfanalyze.html "Interface documentation") | C binding 506 | [hipsolverRfExtractBundledFactorsHost](interfacehipfort__hipsolver_1_1hipsolverrfextractbundledfactorshost.html "Interface documentation") | C binding 507 | [hipsolverRfExtractSplitFactorsHost](interfacehipfort__hipsolver_1_1hipsolverrfextractsplitfactorshost.html "Interface documentation") | C binding 508 | [hipsolverRfGet_Algs](interfacehipfort__hipsolver_1_1hipsolverrfget__algs.html "Interface documentation") | C binding 509 | [hipsolverRfGetMatrixFormat](interfacehipfort__hipsolver_1_1hipsolverrfgetmatrixformat.html "Interface documentation") | C binding 510 | [hipsolverRfGetNumericBoostReport](interfacehipfort__hipsolver_1_1hipsolverrfgetnumericboostreport.html "Interface documentation") | C binding 511 | [hipsolverRfGetNumericProperties](interfacehipfort__hipsolver_1_1hipsolverrfgetnumericproperties.html "Interface documentation") | C binding 512 | [hipsolverRfGetResetValuesFastMode](interfacehipfort__hipsolver_1_1hipsolverrfgetresetvaluesfastmode.html "Interface documentation") | C binding 513 | [hipsolverRfRefactor](interfacehipfort__hipsolver_1_1hipsolverrfrefactor.html "Interface documentation") | C binding 514 | [hipsolverRfResetValues](interfacehipfort__hipsolver_1_1hipsolverrfresetvalues.html "Interface documentation") | C binding 515 | [hipsolverRfSetAlgs](interfacehipfort__hipsolver_1_1hipsolverrfsetalgs.html "Interface documentation") | C binding 516 | [hipsolverRfSetMatrixFormat](interfacehipfort__hipsolver_1_1hipsolverrfsetmatrixformat.html "Interface documentation") | C binding 517 | [hipsolverRfSetNumericProperties](interfacehipfort__hipsolver_1_1hipsolverrfsetnumericproperties.html "Interface documentation") | C binding 518 | [hipsolverRfSetResetValuesFastMode](interfacehipfort__hipsolver_1_1hipsolverrfsetresetvaluesfastmode.html "Interface documentation") | C binding 519 | [hipsolverRfSolve](interfacehipfort__hipsolver_1_1hipsolverrfsolve.html "Interface documentation") | C binding 520 | [hipsolverRfBatchSetupHost](interfacehipfort__hipsolver_1_1hipsolverrfbatchsetuphost.html "Interface documentation") | C binding 521 | [hipsolverRfBatchAnalyze](interfacehipfort__hipsolver_1_1hipsolverrfbatchanalyze.html "Interface documentation") | C binding 522 | [hipsolverRfBatchRefactor](interfacehipfort__hipsolver_1_1hipsolverrfbatchrefactor.html "Interface documentation") | C binding 523 | [hipsolverRfBatchResetValues](interfacehipfort__hipsolver_1_1hipsolverrfbatchresetvalues.html "Interface documentation") | C binding 524 | [hipsolverRfBatchSolve](interfacehipfort__hipsolver_1_1hipsolverrfbatchsolve.html "Interface documentation") | C binding 525 | [hipsolverRfBatchZeroPivot](interfacehipfort__hipsolver_1_1hipsolverrfbatchzeropivot.html "Interface documentation") | C binding 526 | [hipsolverSpCreate](interfacehipfort__hipsolver_1_1hipsolverspcreate.html "Interface documentation") | C binding 527 | [hipsolverSpDestroy](interfacehipfort__hipsolver_1_1hipsolverspdestroy.html "Interface documentation") | C binding 528 | [hipsolverSpSetStream](interfacehipfort__hipsolver_1_1hipsolverspsetstream.html "Interface documentation") | C binding 529 | [hipsolverSpScsrlsvchol](interfacehipfort__hipsolver_1_1hipsolverspscsrlsvchol.html "Interface documentation") | C binding 530 | [hipsolverSpDcsrlsvchol](interfacehipfort__hipsolver_1_1hipsolverspdcsrlsvchol.html "Interface documentation") | C binding 531 | [hipsolverSpScsrlsvcholHost](interfacehipfort__hipsolver_1_1hipsolverspscsrlsvcholhost.html "Interface documentation") | C binding 532 | [hipsolverSpDcsrlsvcholHost](interfacehipfort__hipsolver_1_1hipsolverspdcsrlsvcholhost.html "Interface documentation") | C binding 533 | [hipsolverSpScsrlsvqr](interfacehipfort__hipsolver_1_1hipsolverspscsrlsvqr.html "Interface documentation") | C binding 534 | [hipsolverSpDcsrlsvqr](interfacehipfort__hipsolver_1_1hipsolverspdcsrlsvqr.html "Interface documentation") | C binding 535 | [hipsolverSpCcsrlsvqr](interfacehipfort__hipsolver_1_1hipsolverspccsrlsvqr.html "Interface documentation") | C binding 536 | [hipsolverSpZcsrlsvqr](interfacehipfort__hipsolver_1_1hipsolverspzcsrlsvqr.html "Interface documentation") | C binding hipfort-rocm-10.0.0/docs/doxygen/input/supported_api_hipsparse.md000066400000000000000000002464771524740623400252560ustar00rootroot00000000000000# hipSPARSE API support \# | API Name | Variants ----|---------------|--------- 1 | [hipsparseCreate](interfacehipfort__hipsparse_1_1hipsparsecreate.html "Interface documentation") | C binding 2 | [hipsparseDestroy](interfacehipfort__hipsparse_1_1hipsparsedestroy.html "Interface documentation") | C binding 3 | [hipsparseGetErrorName](interfacehipfort__hipsparse_1_1hipsparsegeterrorname.html "Interface documentation") | C binding 4 | [hipsparseGetErrorString](interfacehipfort__hipsparse_1_1hipsparsegeterrorstring.html "Interface documentation") | C binding 5 | [hipsparseGetVersion](interfacehipfort__hipsparse_1_1hipsparsegetversion.html "Interface documentation") | C binding 6 | [hipsparseGetGitRevision](interfacehipfort__hipsparse_1_1hipsparsegetgitrevision.html "Interface documentation") | C binding 7 | [hipsparseSetStream](interfacehipfort__hipsparse_1_1hipsparsesetstream.html "Interface documentation") | C binding 8 | [hipsparseGetStream](interfacehipfort__hipsparse_1_1hipsparsegetstream.html "Interface documentation") | C binding 9 | [hipsparseSetPointerMode](interfacehipfort__hipsparse_1_1hipsparsesetpointermode.html "Interface documentation") | C binding 10 | [hipsparseGetPointerMode](interfacehipfort__hipsparse_1_1hipsparsegetpointermode.html "Interface documentation") | C binding 11 | [hipsparseCreateMatDescr](interfacehipfort__hipsparse_1_1hipsparsecreatematdescr.html "Interface documentation") | C binding 12 | [hipsparseDestroyMatDescr](interfacehipfort__hipsparse_1_1hipsparsedestroymatdescr.html "Interface documentation") | C binding 13 | [hipsparseCopyMatDescr](interfacehipfort__hipsparse_1_1hipsparsecopymatdescr.html "Interface documentation") | C binding 14 | [hipsparseSetMatType](interfacehipfort__hipsparse_1_1hipsparsesetmattype.html "Interface documentation") | C binding 15 | [hipsparseGetMatType](interfacehipfort__hipsparse_1_1hipsparsegetmattype.html "Interface documentation") | C binding 16 | [hipsparseSetMatFillMode](interfacehipfort__hipsparse_1_1hipsparsesetmatfillmode.html "Interface documentation") | C binding 17 | [hipsparseGetMatFillMode](interfacehipfort__hipsparse_1_1hipsparsegetmatfillmode.html "Interface documentation") | C binding 18 | [hipsparseSetMatDiagType](interfacehipfort__hipsparse_1_1hipsparsesetmatdiagtype.html "Interface documentation") | C binding 19 | [hipsparseGetMatDiagType](interfacehipfort__hipsparse_1_1hipsparsegetmatdiagtype.html "Interface documentation") | C binding 20 | [hipsparseSetMatIndexBase](interfacehipfort__hipsparse_1_1hipsparsesetmatindexbase.html "Interface documentation") | C binding 21 | [hipsparseGetMatIndexBase](interfacehipfort__hipsparse_1_1hipsparsegetmatindexbase.html "Interface documentation") | C binding 22 | [hipsparseCreateHybMat](interfacehipfort__hipsparse_1_1hipsparsecreatehybmat.html "Interface documentation") | C binding 23 | [hipsparseDestroyHybMat](interfacehipfort__hipsparse_1_1hipsparsedestroyhybmat.html "Interface documentation") | C binding 24 | [hipsparseCreateBsrsv2Info](interfacehipfort__hipsparse_1_1hipsparsecreatebsrsv2info.html "Interface documentation") | C binding 25 | [hipsparseDestroyBsrsv2Info](interfacehipfort__hipsparse_1_1hipsparsedestroybsrsv2info.html "Interface documentation") | C binding 26 | [hipsparseCreateBsrsm2Info](interfacehipfort__hipsparse_1_1hipsparsecreatebsrsm2info.html "Interface documentation") | C binding 27 | [hipsparseDestroyBsrsm2Info](interfacehipfort__hipsparse_1_1hipsparsedestroybsrsm2info.html "Interface documentation") | C binding 28 | [hipsparseCreateBsrilu02Info](interfacehipfort__hipsparse_1_1hipsparsecreatebsrilu02info.html "Interface documentation") | C binding 29 | [hipsparseDestroyBsrilu02Info](interfacehipfort__hipsparse_1_1hipsparsedestroybsrilu02info.html "Interface documentation") | C binding 30 | [hipsparseCreateBsric02Info](interfacehipfort__hipsparse_1_1hipsparsecreatebsric02info.html "Interface documentation") | C binding 31 | [hipsparseDestroyBsric02Info](interfacehipfort__hipsparse_1_1hipsparsedestroybsric02info.html "Interface documentation") | C binding 32 | [hipsparseCreateCsrsv2Info](interfacehipfort__hipsparse_1_1hipsparsecreatecsrsv2info.html "Interface documentation") | C binding 33 | [hipsparseDestroyCsrsv2Info](interfacehipfort__hipsparse_1_1hipsparsedestroycsrsv2info.html "Interface documentation") | C binding 34 | [hipsparseCreateCsrsm2Info](interfacehipfort__hipsparse_1_1hipsparsecreatecsrsm2info.html "Interface documentation") | C binding 35 | [hipsparseDestroyCsrsm2Info](interfacehipfort__hipsparse_1_1hipsparsedestroycsrsm2info.html "Interface documentation") | C binding 36 | [hipsparseCreateCsrilu02Info](interfacehipfort__hipsparse_1_1hipsparsecreatecsrilu02info.html "Interface documentation") | C binding 37 | [hipsparseDestroyCsrilu02Info](interfacehipfort__hipsparse_1_1hipsparsedestroycsrilu02info.html "Interface documentation") | C binding 38 | [hipsparseCreateCsric02Info](interfacehipfort__hipsparse_1_1hipsparsecreatecsric02info.html "Interface documentation") | C binding 39 | [hipsparseDestroyCsric02Info](interfacehipfort__hipsparse_1_1hipsparsedestroycsric02info.html "Interface documentation") | C binding 40 | [hipsparseCreateCsru2csrInfo](interfacehipfort__hipsparse_1_1hipsparsecreatecsru2csrinfo.html "Interface documentation") | C binding 41 | [hipsparseDestroyCsru2csrInfo](interfacehipfort__hipsparse_1_1hipsparsedestroycsru2csrinfo.html "Interface documentation") | C binding 42 | [hipsparseCreateColorInfo](interfacehipfort__hipsparse_1_1hipsparsecreatecolorinfo.html "Interface documentation") | C binding 43 | [hipsparseDestroyColorInfo](interfacehipfort__hipsparse_1_1hipsparsedestroycolorinfo.html "Interface documentation") | C binding 44 | [hipsparseCreateCsrgemm2Info](interfacehipfort__hipsparse_1_1hipsparsecreatecsrgemm2info.html "Interface documentation") | C binding 45 | [hipsparseDestroyCsrgemm2Info](interfacehipfort__hipsparse_1_1hipsparsedestroycsrgemm2info.html "Interface documentation") | C binding 46 | [hipsparseCreatePruneInfo](interfacehipfort__hipsparse_1_1hipsparsecreatepruneinfo.html "Interface documentation") | C binding 47 | [hipsparseDestroyPruneInfo](interfacehipfort__hipsparse_1_1hipsparsedestroypruneinfo.html "Interface documentation") | C binding 48 | [hipsparseSaxpyi](interfacehipfort__hipsparse_1_1hipsparsesaxpyi.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 49 | [hipsparseDaxpyi](interfacehipfort__hipsparse_1_1hipsparsedaxpyi.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 50 | [hipsparseCaxpyi](interfacehipfort__hipsparse_1_1hipsparsecaxpyi.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 51 | [hipsparseZaxpyi](interfacehipfort__hipsparse_1_1hipsparsezaxpyi.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 52 | [hipsparseCdotci](interfacehipfort__hipsparse_1_1hipsparsecdotci.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 53 | [hipsparseZdotci](interfacehipfort__hipsparse_1_1hipsparsezdotci.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 54 | [hipsparseSdoti](interfacehipfort__hipsparse_1_1hipsparsesdoti.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 55 | [hipsparseDdoti](interfacehipfort__hipsparse_1_1hipsparseddoti.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 56 | [hipsparseCdoti](interfacehipfort__hipsparse_1_1hipsparsecdoti.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 57 | [hipsparseZdoti](interfacehipfort__hipsparse_1_1hipsparsezdoti.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 58 | [hipsparseSgthr](interfacehipfort__hipsparse_1_1hipsparsesgthr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 59 | [hipsparseDgthr](interfacehipfort__hipsparse_1_1hipsparsedgthr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 60 | [hipsparseCgthr](interfacehipfort__hipsparse_1_1hipsparsecgthr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 61 | [hipsparseZgthr](interfacehipfort__hipsparse_1_1hipsparsezgthr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 62 | [hipsparseSgthrz](interfacehipfort__hipsparse_1_1hipsparsesgthrz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 63 | [hipsparseDgthrz](interfacehipfort__hipsparse_1_1hipsparsedgthrz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 64 | [hipsparseCgthrz](interfacehipfort__hipsparse_1_1hipsparsecgthrz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 65 | [hipsparseZgthrz](interfacehipfort__hipsparse_1_1hipsparsezgthrz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 66 | [hipsparseSroti](interfacehipfort__hipsparse_1_1hipsparsesroti.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 67 | [hipsparseDroti](interfacehipfort__hipsparse_1_1hipsparsedroti.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 68 | [hipsparseSsctr](interfacehipfort__hipsparse_1_1hipsparsessctr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 69 | [hipsparseDsctr](interfacehipfort__hipsparse_1_1hipsparsedsctr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 70 | [hipsparseCsctr](interfacehipfort__hipsparse_1_1hipsparsecsctr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 71 | [hipsparseZsctr](interfacehipfort__hipsparse_1_1hipsparsezsctr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 72 | [hipsparseSbsrmv](interfacehipfort__hipsparse_1_1hipsparsesbsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 73 | [hipsparseDbsrmv](interfacehipfort__hipsparse_1_1hipsparsedbsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 74 | [hipsparseCbsrmv](interfacehipfort__hipsparse_1_1hipsparsecbsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 75 | [hipsparseZbsrmv](interfacehipfort__hipsparse_1_1hipsparsezbsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 76 | [hipsparseXbsrsv2_zeroPivot](interfacehipfort__hipsparse_1_1hipsparsexbsrsv2__zeropivot.html "Interface documentation") | C binding 77 | [hipsparseSbsrsv2_bufferSize](interfacehipfort__hipsparse_1_1hipsparsesbsrsv2__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 78 | [hipsparseDbsrsv2_bufferSize](interfacehipfort__hipsparse_1_1hipsparsedbsrsv2__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 79 | [hipsparseCbsrsv2_bufferSize](interfacehipfort__hipsparse_1_1hipsparsecbsrsv2__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 80 | [hipsparseZbsrsv2_bufferSize](interfacehipfort__hipsparse_1_1hipsparsezbsrsv2__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 81 | [hipsparseSbsrsv2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsesbsrsv2__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 82 | [hipsparseDbsrsv2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsedbsrsv2__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 83 | [hipsparseCbsrsv2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsecbsrsv2__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 84 | [hipsparseZbsrsv2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsezbsrsv2__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 85 | [hipsparseSbsrsv2_analysis](interfacehipfort__hipsparse_1_1hipsparsesbsrsv2__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 86 | [hipsparseDbsrsv2_analysis](interfacehipfort__hipsparse_1_1hipsparsedbsrsv2__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 87 | [hipsparseCbsrsv2_analysis](interfacehipfort__hipsparse_1_1hipsparsecbsrsv2__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 88 | [hipsparseZbsrsv2_analysis](interfacehipfort__hipsparse_1_1hipsparsezbsrsv2__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 89 | [hipsparseSbsrsv2_solve](interfacehipfort__hipsparse_1_1hipsparsesbsrsv2__solve.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 90 | [hipsparseDbsrsv2_solve](interfacehipfort__hipsparse_1_1hipsparsedbsrsv2__solve.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 91 | [hipsparseCbsrsv2_solve](interfacehipfort__hipsparse_1_1hipsparsecbsrsv2__solve.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 92 | [hipsparseZbsrsv2_solve](interfacehipfort__hipsparse_1_1hipsparsezbsrsv2__solve.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 93 | [hipsparseSbsrxmv](interfacehipfort__hipsparse_1_1hipsparsesbsrxmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 94 | [hipsparseDbsrxmv](interfacehipfort__hipsparse_1_1hipsparsedbsrxmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 95 | [hipsparseCbsrxmv](interfacehipfort__hipsparse_1_1hipsparsecbsrxmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 96 | [hipsparseZbsrxmv](interfacehipfort__hipsparse_1_1hipsparsezbsrxmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 97 | [hipsparseScsrmv](interfacehipfort__hipsparse_1_1hipsparsescsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 98 | [hipsparseDcsrmv](interfacehipfort__hipsparse_1_1hipsparsedcsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 99 | [hipsparseCcsrmv](interfacehipfort__hipsparse_1_1hipsparseccsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 100 | [hipsparseZcsrmv](interfacehipfort__hipsparse_1_1hipsparsezcsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 101 | [hipsparseXcsrsv2_zeroPivot](interfacehipfort__hipsparse_1_1hipsparsexcsrsv2__zeropivot.html "Interface documentation") | C binding 102 | [hipsparseScsrsv2_bufferSize](interfacehipfort__hipsparse_1_1hipsparsescsrsv2__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 103 | [hipsparseDcsrsv2_bufferSize](interfacehipfort__hipsparse_1_1hipsparsedcsrsv2__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 104 | [hipsparseCcsrsv2_bufferSize](interfacehipfort__hipsparse_1_1hipsparseccsrsv2__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 105 | [hipsparseZcsrsv2_bufferSize](interfacehipfort__hipsparse_1_1hipsparsezcsrsv2__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 106 | [hipsparseScsrsv2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsescsrsv2__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 107 | [hipsparseDcsrsv2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsedcsrsv2__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 108 | [hipsparseCcsrsv2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparseccsrsv2__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 109 | [hipsparseZcsrsv2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsezcsrsv2__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 110 | [hipsparseScsrsv2_analysis](interfacehipfort__hipsparse_1_1hipsparsescsrsv2__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 111 | [hipsparseDcsrsv2_analysis](interfacehipfort__hipsparse_1_1hipsparsedcsrsv2__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 112 | [hipsparseCcsrsv2_analysis](interfacehipfort__hipsparse_1_1hipsparseccsrsv2__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 113 | [hipsparseZcsrsv2_analysis](interfacehipfort__hipsparse_1_1hipsparsezcsrsv2__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 114 | [hipsparseScsrsv2_solve](interfacehipfort__hipsparse_1_1hipsparsescsrsv2__solve.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 115 | [hipsparseDcsrsv2_solve](interfacehipfort__hipsparse_1_1hipsparsedcsrsv2__solve.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 116 | [hipsparseCcsrsv2_solve](interfacehipfort__hipsparse_1_1hipsparseccsrsv2__solve.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 117 | [hipsparseZcsrsv2_solve](interfacehipfort__hipsparse_1_1hipsparsezcsrsv2__solve.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 118 | [hipsparseSgemvi_bufferSize](interfacehipfort__hipsparse_1_1hipsparsesgemvi__buffersize.html "Interface documentation") | C binding 119 | [hipsparseDgemvi_bufferSize](interfacehipfort__hipsparse_1_1hipsparsedgemvi__buffersize.html "Interface documentation") | C binding 120 | [hipsparseCgemvi_bufferSize](interfacehipfort__hipsparse_1_1hipsparsecgemvi__buffersize.html "Interface documentation") | C binding 121 | [hipsparseZgemvi_bufferSize](interfacehipfort__hipsparse_1_1hipsparsezgemvi__buffersize.html "Interface documentation") | C binding 122 | [hipsparseSgemvi](interfacehipfort__hipsparse_1_1hipsparsesgemvi.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 123 | [hipsparseDgemvi](interfacehipfort__hipsparse_1_1hipsparsedgemvi.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 124 | [hipsparseCgemvi](interfacehipfort__hipsparse_1_1hipsparsecgemvi.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 125 | [hipsparseZgemvi](interfacehipfort__hipsparse_1_1hipsparsezgemvi.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 126 | [hipsparseShybmv](interfacehipfort__hipsparse_1_1hipsparseshybmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 127 | [hipsparseDhybmv](interfacehipfort__hipsparse_1_1hipsparsedhybmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 128 | [hipsparseChybmv](interfacehipfort__hipsparse_1_1hipsparsechybmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 129 | [hipsparseZhybmv](interfacehipfort__hipsparse_1_1hipsparsezhybmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 130 | [hipsparseSbsrmm](interfacehipfort__hipsparse_1_1hipsparsesbsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 131 | [hipsparseDbsrmm](interfacehipfort__hipsparse_1_1hipsparsedbsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 132 | [hipsparseCbsrmm](interfacehipfort__hipsparse_1_1hipsparsecbsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 133 | [hipsparseZbsrmm](interfacehipfort__hipsparse_1_1hipsparsezbsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 134 | [hipsparseXbsrsm2_zeroPivot](interfacehipfort__hipsparse_1_1hipsparsexbsrsm2__zeropivot.html "Interface documentation") | C binding 135 | [hipsparseSbsrsm2_bufferSize](interfacehipfort__hipsparse_1_1hipsparsesbsrsm2__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 136 | [hipsparseDbsrsm2_bufferSize](interfacehipfort__hipsparse_1_1hipsparsedbsrsm2__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 137 | [hipsparseCbsrsm2_bufferSize](interfacehipfort__hipsparse_1_1hipsparsecbsrsm2__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 138 | [hipsparseZbsrsm2_bufferSize](interfacehipfort__hipsparse_1_1hipsparsezbsrsm2__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 139 | [hipsparseSbsrsm2_analysis](interfacehipfort__hipsparse_1_1hipsparsesbsrsm2__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 140 | [hipsparseDbsrsm2_analysis](interfacehipfort__hipsparse_1_1hipsparsedbsrsm2__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 141 | [hipsparseCbsrsm2_analysis](interfacehipfort__hipsparse_1_1hipsparsecbsrsm2__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 142 | [hipsparseZbsrsm2_analysis](interfacehipfort__hipsparse_1_1hipsparsezbsrsm2__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 143 | [hipsparseSbsrsm2_solve](interfacehipfort__hipsparse_1_1hipsparsesbsrsm2__solve.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 144 | [hipsparseDbsrsm2_solve](interfacehipfort__hipsparse_1_1hipsparsedbsrsm2__solve.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 145 | [hipsparseCbsrsm2_solve](interfacehipfort__hipsparse_1_1hipsparsecbsrsm2__solve.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 146 | [hipsparseZbsrsm2_solve](interfacehipfort__hipsparse_1_1hipsparsezbsrsm2__solve.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 147 | [hipsparseScsrmm](interfacehipfort__hipsparse_1_1hipsparsescsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 148 | [hipsparseDcsrmm](interfacehipfort__hipsparse_1_1hipsparsedcsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 149 | [hipsparseCcsrmm](interfacehipfort__hipsparse_1_1hipsparseccsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 150 | [hipsparseZcsrmm](interfacehipfort__hipsparse_1_1hipsparsezcsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 151 | [hipsparseScsrmm2](interfacehipfort__hipsparse_1_1hipsparsescsrmm2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 152 | [hipsparseDcsrmm2](interfacehipfort__hipsparse_1_1hipsparsedcsrmm2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 153 | [hipsparseCcsrmm2](interfacehipfort__hipsparse_1_1hipsparseccsrmm2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 154 | [hipsparseZcsrmm2](interfacehipfort__hipsparse_1_1hipsparsezcsrmm2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 155 | [hipsparseXcsrsm2_zeroPivot](interfacehipfort__hipsparse_1_1hipsparsexcsrsm2__zeropivot.html "Interface documentation") | C binding 156 | [hipsparseScsrsm2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsescsrsm2__buffersizeext.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 157 | [hipsparseDcsrsm2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsedcsrsm2__buffersizeext.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 158 | [hipsparseCcsrsm2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparseccsrsm2__buffersizeext.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 159 | [hipsparseZcsrsm2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsezcsrsm2__buffersizeext.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 160 | [hipsparseScsrsm2_analysis](interfacehipfort__hipsparse_1_1hipsparsescsrsm2__analysis.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 161 | [hipsparseDcsrsm2_analysis](interfacehipfort__hipsparse_1_1hipsparsedcsrsm2__analysis.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 162 | [hipsparseCcsrsm2_analysis](interfacehipfort__hipsparse_1_1hipsparseccsrsm2__analysis.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 163 | [hipsparseZcsrsm2_analysis](interfacehipfort__hipsparse_1_1hipsparsezcsrsm2__analysis.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 164 | [hipsparseScsrsm2_solve](interfacehipfort__hipsparse_1_1hipsparsescsrsm2__solve.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 165 | [hipsparseDcsrsm2_solve](interfacehipfort__hipsparse_1_1hipsparsedcsrsm2__solve.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 166 | [hipsparseCcsrsm2_solve](interfacehipfort__hipsparse_1_1hipsparseccsrsm2__solve.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 167 | [hipsparseZcsrsm2_solve](interfacehipfort__hipsparse_1_1hipsparsezcsrsm2__solve.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 168 | [hipsparseSgemmi](interfacehipfort__hipsparse_1_1hipsparsesgemmi.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 169 | [hipsparseDgemmi](interfacehipfort__hipsparse_1_1hipsparsedgemmi.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 170 | [hipsparseCgemmi](interfacehipfort__hipsparse_1_1hipsparsecgemmi.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 171 | [hipsparseZgemmi](interfacehipfort__hipsparse_1_1hipsparsezgemmi.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 172 | [hipsparseXcsrgeamNnz](interfacehipfort__hipsparse_1_1hipsparsexcsrgeamnnz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 173 | [hipsparseScsrgeam](interfacehipfort__hipsparse_1_1hipsparsescsrgeam.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 174 | [hipsparseDcsrgeam](interfacehipfort__hipsparse_1_1hipsparsedcsrgeam.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 175 | [hipsparseCcsrgeam](interfacehipfort__hipsparse_1_1hipsparseccsrgeam.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 176 | [hipsparseZcsrgeam](interfacehipfort__hipsparse_1_1hipsparsezcsrgeam.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 177 | [hipsparseScsrgeam2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsescsrgeam2__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 178 | [hipsparseDcsrgeam2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsedcsrgeam2__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 179 | [hipsparseCcsrgeam2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparseccsrgeam2__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 180 | [hipsparseZcsrgeam2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsezcsrgeam2__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 181 | [hipsparseXcsrgeam2Nnz](interfacehipfort__hipsparse_1_1hipsparsexcsrgeam2nnz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 182 | [hipsparseScsrgeam2](interfacehipfort__hipsparse_1_1hipsparsescsrgeam2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 183 | [hipsparseDcsrgeam2](interfacehipfort__hipsparse_1_1hipsparsedcsrgeam2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 184 | [hipsparseCcsrgeam2](interfacehipfort__hipsparse_1_1hipsparseccsrgeam2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 185 | [hipsparseZcsrgeam2](interfacehipfort__hipsparse_1_1hipsparsezcsrgeam2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 186 | [hipsparseXcsrgemmNnz](interfacehipfort__hipsparse_1_1hipsparsexcsrgemmnnz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 187 | [hipsparseScsrgemm](interfacehipfort__hipsparse_1_1hipsparsescsrgemm.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 188 | [hipsparseDcsrgemm](interfacehipfort__hipsparse_1_1hipsparsedcsrgemm.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 189 | [hipsparseCcsrgemm](interfacehipfort__hipsparse_1_1hipsparseccsrgemm.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 190 | [hipsparseZcsrgemm](interfacehipfort__hipsparse_1_1hipsparsezcsrgemm.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 191 | [hipsparseScsrgemm2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsescsrgemm2__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 192 | [hipsparseDcsrgemm2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsedcsrgemm2__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 193 | [hipsparseCcsrgemm2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparseccsrgemm2__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 194 | [hipsparseZcsrgemm2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsezcsrgemm2__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 195 | [hipsparseXcsrgemm2Nnz](interfacehipfort__hipsparse_1_1hipsparsexcsrgemm2nnz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 196 | [hipsparseScsrgemm2](interfacehipfort__hipsparse_1_1hipsparsescsrgemm2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 197 | [hipsparseDcsrgemm2](interfacehipfort__hipsparse_1_1hipsparsedcsrgemm2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 198 | [hipsparseCcsrgemm2](interfacehipfort__hipsparse_1_1hipsparseccsrgemm2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 199 | [hipsparseZcsrgemm2](interfacehipfort__hipsparse_1_1hipsparsezcsrgemm2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 200 | [hipsparseXbsric02_zeroPivot](interfacehipfort__hipsparse_1_1hipsparsexbsric02__zeropivot.html "Interface documentation") | C binding 201 | [hipsparseSbsric02_bufferSize](interfacehipfort__hipsparse_1_1hipsparsesbsric02__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 202 | [hipsparseDbsric02_bufferSize](interfacehipfort__hipsparse_1_1hipsparsedbsric02__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 203 | [hipsparseCbsric02_bufferSize](interfacehipfort__hipsparse_1_1hipsparsecbsric02__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 204 | [hipsparseZbsric02_bufferSize](interfacehipfort__hipsparse_1_1hipsparsezbsric02__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 205 | [hipsparseSbsric02_analysis](interfacehipfort__hipsparse_1_1hipsparsesbsric02__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 206 | [hipsparseDbsric02_analysis](interfacehipfort__hipsparse_1_1hipsparsedbsric02__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 207 | [hipsparseCbsric02_analysis](interfacehipfort__hipsparse_1_1hipsparsecbsric02__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 208 | [hipsparseZbsric02_analysis](interfacehipfort__hipsparse_1_1hipsparsezbsric02__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 209 | [hipsparseSbsric02](interfacehipfort__hipsparse_1_1hipsparsesbsric02.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 210 | [hipsparseDbsric02](interfacehipfort__hipsparse_1_1hipsparsedbsric02.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 211 | [hipsparseCbsric02](interfacehipfort__hipsparse_1_1hipsparsecbsric02.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 212 | [hipsparseZbsric02](interfacehipfort__hipsparse_1_1hipsparsezbsric02.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 213 | [hipsparseXbsrilu02_zeroPivot](interfacehipfort__hipsparse_1_1hipsparsexbsrilu02__zeropivot.html "Interface documentation") | C binding 214 | [hipsparseSbsrilu02_numericBoost](interfacehipfort__hipsparse_1_1hipsparsesbsrilu02__numericboost.html "Interface documentation") | C binding 215 | [hipsparseDbsrilu02_numericBoost](interfacehipfort__hipsparse_1_1hipsparsedbsrilu02__numericboost.html "Interface documentation") | C binding 216 | [hipsparseCbsrilu02_numericBoost](interfacehipfort__hipsparse_1_1hipsparsecbsrilu02__numericboost.html "Interface documentation") | C binding 217 | [hipsparseZbsrilu02_numericBoost](interfacehipfort__hipsparse_1_1hipsparsezbsrilu02__numericboost.html "Interface documentation") | C binding 218 | [hipsparseSbsrilu02_bufferSize](interfacehipfort__hipsparse_1_1hipsparsesbsrilu02__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 219 | [hipsparseDbsrilu02_bufferSize](interfacehipfort__hipsparse_1_1hipsparsedbsrilu02__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 220 | [hipsparseCbsrilu02_bufferSize](interfacehipfort__hipsparse_1_1hipsparsecbsrilu02__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 221 | [hipsparseZbsrilu02_bufferSize](interfacehipfort__hipsparse_1_1hipsparsezbsrilu02__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 222 | [hipsparseSbsrilu02_analysis](interfacehipfort__hipsparse_1_1hipsparsesbsrilu02__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 223 | [hipsparseDbsrilu02_analysis](interfacehipfort__hipsparse_1_1hipsparsedbsrilu02__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 224 | [hipsparseCbsrilu02_analysis](interfacehipfort__hipsparse_1_1hipsparsecbsrilu02__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 225 | [hipsparseZbsrilu02_analysis](interfacehipfort__hipsparse_1_1hipsparsezbsrilu02__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 226 | [hipsparseSbsrilu02](interfacehipfort__hipsparse_1_1hipsparsesbsrilu02.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 227 | [hipsparseDbsrilu02](interfacehipfort__hipsparse_1_1hipsparsedbsrilu02.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 228 | [hipsparseCbsrilu02](interfacehipfort__hipsparse_1_1hipsparsecbsrilu02.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 229 | [hipsparseZbsrilu02](interfacehipfort__hipsparse_1_1hipsparsezbsrilu02.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 230 | [hipsparseXcsric02_zeroPivot](interfacehipfort__hipsparse_1_1hipsparsexcsric02__zeropivot.html "Interface documentation") | C binding 231 | [hipsparseScsric02_bufferSize](interfacehipfort__hipsparse_1_1hipsparsescsric02__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 232 | [hipsparseDcsric02_bufferSize](interfacehipfort__hipsparse_1_1hipsparsedcsric02__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 233 | [hipsparseCcsric02_bufferSize](interfacehipfort__hipsparse_1_1hipsparseccsric02__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 234 | [hipsparseZcsric02_bufferSize](interfacehipfort__hipsparse_1_1hipsparsezcsric02__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 235 | [hipsparseScsric02_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsescsric02__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 236 | [hipsparseDcsric02_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsedcsric02__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 237 | [hipsparseCcsric02_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparseccsric02__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 238 | [hipsparseZcsric02_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsezcsric02__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 239 | [hipsparseScsric02_analysis](interfacehipfort__hipsparse_1_1hipsparsescsric02__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 240 | [hipsparseDcsric02_analysis](interfacehipfort__hipsparse_1_1hipsparsedcsric02__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 241 | [hipsparseCcsric02_analysis](interfacehipfort__hipsparse_1_1hipsparseccsric02__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 242 | [hipsparseZcsric02_analysis](interfacehipfort__hipsparse_1_1hipsparsezcsric02__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 243 | [hipsparseScsric02](interfacehipfort__hipsparse_1_1hipsparsescsric02.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 244 | [hipsparseDcsric02](interfacehipfort__hipsparse_1_1hipsparsedcsric02.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 245 | [hipsparseCcsric02](interfacehipfort__hipsparse_1_1hipsparseccsric02.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 246 | [hipsparseZcsric02](interfacehipfort__hipsparse_1_1hipsparsezcsric02.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 247 | [hipsparseXcsrilu02_zeroPivot](interfacehipfort__hipsparse_1_1hipsparsexcsrilu02__zeropivot.html "Interface documentation") | C binding 248 | [hipsparseScsrilu02_numericBoost](interfacehipfort__hipsparse_1_1hipsparsescsrilu02__numericboost.html "Interface documentation") | C binding 249 | [hipsparseDcsrilu02_numericBoost](interfacehipfort__hipsparse_1_1hipsparsedcsrilu02__numericboost.html "Interface documentation") | C binding 250 | [hipsparseCcsrilu02_numericBoost](interfacehipfort__hipsparse_1_1hipsparseccsrilu02__numericboost.html "Interface documentation") | C binding 251 | [hipsparseZcsrilu02_numericBoost](interfacehipfort__hipsparse_1_1hipsparsezcsrilu02__numericboost.html "Interface documentation") | C binding 252 | [hipsparseScsrilu02_bufferSize](interfacehipfort__hipsparse_1_1hipsparsescsrilu02__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 253 | [hipsparseDcsrilu02_bufferSize](interfacehipfort__hipsparse_1_1hipsparsedcsrilu02__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 254 | [hipsparseCcsrilu02_bufferSize](interfacehipfort__hipsparse_1_1hipsparseccsrilu02__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 255 | [hipsparseZcsrilu02_bufferSize](interfacehipfort__hipsparse_1_1hipsparsezcsrilu02__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 256 | [hipsparseScsrilu02_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsescsrilu02__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 257 | [hipsparseDcsrilu02_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsedcsrilu02__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 258 | [hipsparseCcsrilu02_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparseccsrilu02__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 259 | [hipsparseZcsrilu02_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsezcsrilu02__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 260 | [hipsparseScsrilu02_analysis](interfacehipfort__hipsparse_1_1hipsparsescsrilu02__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 261 | [hipsparseDcsrilu02_analysis](interfacehipfort__hipsparse_1_1hipsparsedcsrilu02__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 262 | [hipsparseCcsrilu02_analysis](interfacehipfort__hipsparse_1_1hipsparseccsrilu02__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 263 | [hipsparseZcsrilu02_analysis](interfacehipfort__hipsparse_1_1hipsparsezcsrilu02__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 264 | [hipsparseScsrilu02](interfacehipfort__hipsparse_1_1hipsparsescsrilu02.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 265 | [hipsparseDcsrilu02](interfacehipfort__hipsparse_1_1hipsparsedcsrilu02.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 266 | [hipsparseCcsrilu02](interfacehipfort__hipsparse_1_1hipsparseccsrilu02.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 267 | [hipsparseZcsrilu02](interfacehipfort__hipsparse_1_1hipsparsezcsrilu02.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 268 | [hipsparseSgpsvInterleavedBatch_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsesgpsvinterleavedbatch__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 269 | [hipsparseDgpsvInterleavedBatch_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsedgpsvinterleavedbatch__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 270 | [hipsparseCgpsvInterleavedBatch_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsecgpsvinterleavedbatch__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 271 | [hipsparseZgpsvInterleavedBatch_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsezgpsvinterleavedbatch__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 272 | [hipsparseSgpsvInterleavedBatch](interfacehipfort__hipsparse_1_1hipsparsesgpsvinterleavedbatch.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 273 | [hipsparseDgpsvInterleavedBatch](interfacehipfort__hipsparse_1_1hipsparsedgpsvinterleavedbatch.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 274 | [hipsparseCgpsvInterleavedBatch](interfacehipfort__hipsparse_1_1hipsparsecgpsvinterleavedbatch.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 275 | [hipsparseZgpsvInterleavedBatch](interfacehipfort__hipsparse_1_1hipsparsezgpsvinterleavedbatch.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 276 | [hipsparseSgtsv2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsesgtsv2__buffersizeext.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 277 | [hipsparseDgtsv2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsedgtsv2__buffersizeext.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 278 | [hipsparseCgtsv2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsecgtsv2__buffersizeext.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 279 | [hipsparseZgtsv2_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsezgtsv2__buffersizeext.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 280 | [hipsparseSgtsv2](interfacehipfort__hipsparse_1_1hipsparsesgtsv2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 281 | [hipsparseDgtsv2](interfacehipfort__hipsparse_1_1hipsparsedgtsv2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 282 | [hipsparseCgtsv2](interfacehipfort__hipsparse_1_1hipsparsecgtsv2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 283 | [hipsparseZgtsv2](interfacehipfort__hipsparse_1_1hipsparsezgtsv2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 284 | [hipsparseSgtsvInterleavedBatch_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsesgtsvinterleavedbatch__buffersizeext.html "Interface documentation") | C binding 285 | [hipsparseDgtsvInterleavedBatch_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsedgtsvinterleavedbatch__buffersizeext.html "Interface documentation") | C binding 286 | [hipsparseCgtsvInterleavedBatch_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsecgtsvinterleavedbatch__buffersizeext.html "Interface documentation") | C binding 287 | [hipsparseZgtsvInterleavedBatch_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsezgtsvinterleavedbatch__buffersizeext.html "Interface documentation") | C binding 288 | [hipsparseSgtsvInterleavedBatch](interfacehipfort__hipsparse_1_1hipsparsesgtsvinterleavedbatch.html "Interface documentation") | C binding 289 | [hipsparseDgtsvInterleavedBatch](interfacehipfort__hipsparse_1_1hipsparsedgtsvinterleavedbatch.html "Interface documentation") | C binding 290 | [hipsparseCgtsvInterleavedBatch](interfacehipfort__hipsparse_1_1hipsparsecgtsvinterleavedbatch.html "Interface documentation") | C binding 291 | [hipsparseZgtsvInterleavedBatch](interfacehipfort__hipsparse_1_1hipsparsezgtsvinterleavedbatch.html "Interface documentation") | C binding 292 | [hipsparseSgtsv2_nopivot_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsesgtsv2__nopivot__buffersizeext.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 293 | [hipsparseDgtsv2_nopivot_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsedgtsv2__nopivot__buffersizeext.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 294 | [hipsparseCgtsv2_nopivot_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsecgtsv2__nopivot__buffersizeext.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 295 | [hipsparseZgtsv2_nopivot_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsezgtsv2__nopivot__buffersizeext.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 296 | [hipsparseSgtsv2_nopivot](interfacehipfort__hipsparse_1_1hipsparsesgtsv2__nopivot.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 297 | [hipsparseDgtsv2_nopivot](interfacehipfort__hipsparse_1_1hipsparsedgtsv2__nopivot.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 298 | [hipsparseCgtsv2_nopivot](interfacehipfort__hipsparse_1_1hipsparsecgtsv2__nopivot.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 299 | [hipsparseZgtsv2_nopivot](interfacehipfort__hipsparse_1_1hipsparsezgtsv2__nopivot.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 300 | [hipsparseSgtsv2StridedBatch_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsesgtsv2stridedbatch__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 301 | [hipsparseDgtsv2StridedBatch_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsedgtsv2stridedbatch__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 302 | [hipsparseCgtsv2StridedBatch_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsecgtsv2stridedbatch__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 303 | [hipsparseZgtsv2StridedBatch_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsezgtsv2stridedbatch__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 304 | [hipsparseSgtsv2StridedBatch](interfacehipfort__hipsparse_1_1hipsparsesgtsv2stridedbatch.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 305 | [hipsparseDgtsv2StridedBatch](interfacehipfort__hipsparse_1_1hipsparsedgtsv2stridedbatch.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 306 | [hipsparseCgtsv2StridedBatch](interfacehipfort__hipsparse_1_1hipsparsecgtsv2stridedbatch.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 307 | [hipsparseZgtsv2StridedBatch](interfacehipfort__hipsparse_1_1hipsparsezgtsv2stridedbatch.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 308 | [hipsparseSbsr2csr](interfacehipfort__hipsparse_1_1hipsparsesbsr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 309 | [hipsparseDbsr2csr](interfacehipfort__hipsparse_1_1hipsparsedbsr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 310 | [hipsparseCbsr2csr](interfacehipfort__hipsparse_1_1hipsparsecbsr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 311 | [hipsparseZbsr2csr](interfacehipfort__hipsparse_1_1hipsparsezbsr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 312 | [hipsparseXcoo2csr](interfacehipfort__hipsparse_1_1hipsparsexcoo2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 313 | [hipsparseXcoosort_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsexcoosort__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 314 | [hipsparseXcoosortByRow](interfacehipfort__hipsparse_1_1hipsparsexcoosortbyrow.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 315 | [hipsparseXcoosortByColumn](interfacehipfort__hipsparse_1_1hipsparsexcoosortbycolumn.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 316 | [hipsparseCreateIdentityPermutation](interfacehipfort__hipsparse_1_1hipsparsecreateidentitypermutation.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 317 | [hipsparseScsc2dense](interfacehipfort__hipsparse_1_1hipsparsescsc2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 318 | [hipsparseDcsc2dense](interfacehipfort__hipsparse_1_1hipsparsedcsc2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 319 | [hipsparseCcsc2dense](interfacehipfort__hipsparse_1_1hipsparseccsc2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 320 | [hipsparseZcsc2dense](interfacehipfort__hipsparse_1_1hipsparsezcsc2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 321 | [hipsparseXcscsort_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsexcscsort__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 322 | [hipsparseXcscsort](interfacehipfort__hipsparse_1_1hipsparsexcscsort.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 323 | [hipsparseXcsr2bsrNnz](interfacehipfort__hipsparse_1_1hipsparsexcsr2bsrnnz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 324 | [hipsparseScsr2bsr](interfacehipfort__hipsparse_1_1hipsparsescsr2bsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 325 | [hipsparseDcsr2bsr](interfacehipfort__hipsparse_1_1hipsparsedcsr2bsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 326 | [hipsparseCcsr2bsr](interfacehipfort__hipsparse_1_1hipsparseccsr2bsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 327 | [hipsparseZcsr2bsr](interfacehipfort__hipsparse_1_1hipsparsezcsr2bsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 328 | [hipsparseXcsr2coo](interfacehipfort__hipsparse_1_1hipsparsexcsr2coo.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 329 | [hipsparseScsr2csc](interfacehipfort__hipsparse_1_1hipsparsescsr2csc.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 330 | [hipsparseDcsr2csc](interfacehipfort__hipsparse_1_1hipsparsedcsr2csc.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 331 | [hipsparseCcsr2csc](interfacehipfort__hipsparse_1_1hipsparseccsr2csc.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 332 | [hipsparseZcsr2csc](interfacehipfort__hipsparse_1_1hipsparsezcsr2csc.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 333 | [hipsparseCsr2cscEx2_bufferSize](interfacehipfort__hipsparse_1_1hipsparsecsr2cscex2__buffersize.html "Interface documentation") | C binding 334 | [hipsparseCsr2cscEx2](interfacehipfort__hipsparse_1_1hipsparsecsr2cscex2.html "Interface documentation") | C binding 335 | [hipsparseScsr2csr_compress](interfacehipfort__hipsparse_1_1hipsparsescsr2csr__compress.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 336 | [hipsparseDcsr2csr_compress](interfacehipfort__hipsparse_1_1hipsparsedcsr2csr__compress.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 337 | [hipsparseCcsr2csr_compress](interfacehipfort__hipsparse_1_1hipsparseccsr2csr__compress.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 338 | [hipsparseZcsr2csr_compress](interfacehipfort__hipsparse_1_1hipsparsezcsr2csr__compress.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 339 | [hipsparseScsr2csru](interfacehipfort__hipsparse_1_1hipsparsescsr2csru.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 340 | [hipsparseDcsr2csru](interfacehipfort__hipsparse_1_1hipsparsedcsr2csru.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 341 | [hipsparseCcsr2csru](interfacehipfort__hipsparse_1_1hipsparseccsr2csru.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 342 | [hipsparseZcsr2csru](interfacehipfort__hipsparse_1_1hipsparsezcsr2csru.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 343 | [hipsparseScsr2dense](interfacehipfort__hipsparse_1_1hipsparsescsr2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 344 | [hipsparseDcsr2dense](interfacehipfort__hipsparse_1_1hipsparsedcsr2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 345 | [hipsparseCcsr2dense](interfacehipfort__hipsparse_1_1hipsparseccsr2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 346 | [hipsparseZcsr2dense](interfacehipfort__hipsparse_1_1hipsparsezcsr2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 347 | [hipsparseScsr2gebsr_bufferSize](interfacehipfort__hipsparse_1_1hipsparsescsr2gebsr__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 348 | [hipsparseDcsr2gebsr_bufferSize](interfacehipfort__hipsparse_1_1hipsparsedcsr2gebsr__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 349 | [hipsparseCcsr2gebsr_bufferSize](interfacehipfort__hipsparse_1_1hipsparseccsr2gebsr__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 350 | [hipsparseZcsr2gebsr_bufferSize](interfacehipfort__hipsparse_1_1hipsparsezcsr2gebsr__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 351 | [hipsparseXcsr2gebsrNnz](interfacehipfort__hipsparse_1_1hipsparsexcsr2gebsrnnz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 352 | [hipsparseScsr2gebsr](interfacehipfort__hipsparse_1_1hipsparsescsr2gebsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 353 | [hipsparseDcsr2gebsr](interfacehipfort__hipsparse_1_1hipsparsedcsr2gebsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 354 | [hipsparseCcsr2gebsr](interfacehipfort__hipsparse_1_1hipsparseccsr2gebsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 355 | [hipsparseZcsr2gebsr](interfacehipfort__hipsparse_1_1hipsparsezcsr2gebsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 356 | [hipsparseScsr2hyb](interfacehipfort__hipsparse_1_1hipsparsescsr2hyb.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 357 | [hipsparseDcsr2hyb](interfacehipfort__hipsparse_1_1hipsparsedcsr2hyb.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 358 | [hipsparseCcsr2hyb](interfacehipfort__hipsparse_1_1hipsparseccsr2hyb.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 359 | [hipsparseZcsr2hyb](interfacehipfort__hipsparse_1_1hipsparsezcsr2hyb.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 360 | [hipsparseXcsrsort_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsexcsrsort__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 361 | [hipsparseXcsrsort](interfacehipfort__hipsparse_1_1hipsparsexcsrsort.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 362 | [hipsparseScsru2csr_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsescsru2csr__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 363 | [hipsparseDcsru2csr_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsedcsru2csr__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 364 | [hipsparseCcsru2csr_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparseccsru2csr__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 365 | [hipsparseZcsru2csr_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsezcsru2csr__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 366 | [hipsparseScsru2csr](interfacehipfort__hipsparse_1_1hipsparsescsru2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 367 | [hipsparseDcsru2csr](interfacehipfort__hipsparse_1_1hipsparsedcsru2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 368 | [hipsparseCcsru2csr](interfacehipfort__hipsparse_1_1hipsparseccsru2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 369 | [hipsparseZcsru2csr](interfacehipfort__hipsparse_1_1hipsparsezcsru2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 370 | [hipsparseSdense2csc](interfacehipfort__hipsparse_1_1hipsparsesdense2csc.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 371 | [hipsparseDdense2csc](interfacehipfort__hipsparse_1_1hipsparseddense2csc.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 372 | [hipsparseCdense2csc](interfacehipfort__hipsparse_1_1hipsparsecdense2csc.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 373 | [hipsparseZdense2csc](interfacehipfort__hipsparse_1_1hipsparsezdense2csc.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 374 | [hipsparseSdense2csr](interfacehipfort__hipsparse_1_1hipsparsesdense2csr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 375 | [hipsparseDdense2csr](interfacehipfort__hipsparse_1_1hipsparseddense2csr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 376 | [hipsparseCdense2csr](interfacehipfort__hipsparse_1_1hipsparsecdense2csr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 377 | [hipsparseZdense2csr](interfacehipfort__hipsparse_1_1hipsparsezdense2csr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 378 | [hipsparseSgebsr2csr](interfacehipfort__hipsparse_1_1hipsparsesgebsr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 379 | [hipsparseDgebsr2csr](interfacehipfort__hipsparse_1_1hipsparsedgebsr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 380 | [hipsparseCgebsr2csr](interfacehipfort__hipsparse_1_1hipsparsecgebsr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 381 | [hipsparseZgebsr2csr](interfacehipfort__hipsparse_1_1hipsparsezgebsr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 382 | [hipsparseSgebsr2gebsc_bufferSize](interfacehipfort__hipsparse_1_1hipsparsesgebsr2gebsc__buffersize.html "Interface documentation") | C binding 383 | [hipsparseDgebsr2gebsc_bufferSize](interfacehipfort__hipsparse_1_1hipsparsedgebsr2gebsc__buffersize.html "Interface documentation") | C binding 384 | [hipsparseCgebsr2gebsc_bufferSize](interfacehipfort__hipsparse_1_1hipsparsecgebsr2gebsc__buffersize.html "Interface documentation") | C binding 385 | [hipsparseZgebsr2gebsc_bufferSize](interfacehipfort__hipsparse_1_1hipsparsezgebsr2gebsc__buffersize.html "Interface documentation") | C binding 386 | [hipsparseSgebsr2gebsc](interfacehipfort__hipsparse_1_1hipsparsesgebsr2gebsc.html "Interface documentation") | C binding 387 | [hipsparseDgebsr2gebsc](interfacehipfort__hipsparse_1_1hipsparsedgebsr2gebsc.html "Interface documentation") | C binding 388 | [hipsparseCgebsr2gebsc](interfacehipfort__hipsparse_1_1hipsparsecgebsr2gebsc.html "Interface documentation") | C binding 389 | [hipsparseZgebsr2gebsc](interfacehipfort__hipsparse_1_1hipsparsezgebsr2gebsc.html "Interface documentation") | C binding 390 | [hipsparseSgebsr2gebsr_bufferSize](interfacehipfort__hipsparse_1_1hipsparsesgebsr2gebsr__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 391 | [hipsparseDgebsr2gebsr_bufferSize](interfacehipfort__hipsparse_1_1hipsparsedgebsr2gebsr__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 392 | [hipsparseCgebsr2gebsr_bufferSize](interfacehipfort__hipsparse_1_1hipsparsecgebsr2gebsr__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 393 | [hipsparseZgebsr2gebsr_bufferSize](interfacehipfort__hipsparse_1_1hipsparsezgebsr2gebsr__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 394 | [hipsparseXgebsr2gebsrNnz](interfacehipfort__hipsparse_1_1hipsparsexgebsr2gebsrnnz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 395 | [hipsparseSgebsr2gebsr](interfacehipfort__hipsparse_1_1hipsparsesgebsr2gebsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 396 | [hipsparseDgebsr2gebsr](interfacehipfort__hipsparse_1_1hipsparsedgebsr2gebsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 397 | [hipsparseCgebsr2gebsr](interfacehipfort__hipsparse_1_1hipsparsecgebsr2gebsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 398 | [hipsparseZgebsr2gebsr](interfacehipfort__hipsparse_1_1hipsparsezgebsr2gebsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 399 | [hipsparseShyb2csr](interfacehipfort__hipsparse_1_1hipsparseshyb2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 400 | [hipsparseDhyb2csr](interfacehipfort__hipsparse_1_1hipsparsedhyb2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 401 | [hipsparseChyb2csr](interfacehipfort__hipsparse_1_1hipsparsechyb2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 402 | [hipsparseZhyb2csr](interfacehipfort__hipsparse_1_1hipsparsezhyb2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 403 | [hipsparseSnnz](interfacehipfort__hipsparse_1_1hipsparsesnnz.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 404 | [hipsparseDnnz](interfacehipfort__hipsparse_1_1hipsparsednnz.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 405 | [hipsparseCnnz](interfacehipfort__hipsparse_1_1hipsparsecnnz.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 406 | [hipsparseZnnz](interfacehipfort__hipsparse_1_1hipsparseznnz.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 407 | [hipsparseSnnz_compress](interfacehipfort__hipsparse_1_1hipsparsesnnz__compress.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 408 | [hipsparseDnnz_compress](interfacehipfort__hipsparse_1_1hipsparsednnz__compress.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 409 | [hipsparseCnnz_compress](interfacehipfort__hipsparse_1_1hipsparsecnnz__compress.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 410 | [hipsparseZnnz_compress](interfacehipfort__hipsparse_1_1hipsparseznnz__compress.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 411 | [hipsparseSpruneCsr2csr_bufferSize](interfacehipfort__hipsparse_1_1hipsparsesprunecsr2csr__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 412 | [hipsparseDpruneCsr2csr_bufferSize](interfacehipfort__hipsparse_1_1hipsparsedprunecsr2csr__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 413 | [hipsparseSpruneCsr2csr_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsesprunecsr2csr__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 414 | [hipsparseDpruneCsr2csr_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsedprunecsr2csr__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 415 | [hipsparseSpruneCsr2csrNnz](interfacehipfort__hipsparse_1_1hipsparsesprunecsr2csrnnz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 416 | [hipsparseDpruneCsr2csrNnz](interfacehipfort__hipsparse_1_1hipsparsedprunecsr2csrnnz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 417 | [hipsparseSpruneCsr2csr](interfacehipfort__hipsparse_1_1hipsparsesprunecsr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 418 | [hipsparseDpruneCsr2csr](interfacehipfort__hipsparse_1_1hipsparsedprunecsr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 419 | [hipsparseSpruneCsr2csrByPercentage_bufferSize](interfacehipfort__hipsparse_1_1hipsparsesprunecsr2csrbypercentage__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 420 | [hipsparseDpruneCsr2csrByPercentage_bufferSize](interfacehipfort__hipsparse_1_1hipsparsedprunecsr2csrbypercentage__buffersize.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 421 | [hipsparseSpruneCsr2csrByPercentage_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsesprunecsr2csrbypercentage__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 422 | [hipsparseDpruneCsr2csrByPercentage_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsedprunecsr2csrbypercentage__buffersizeext.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 423 | [hipsparseSpruneCsr2csrNnzByPercentage](interfacehipfort__hipsparse_1_1hipsparsesprunecsr2csrnnzbypercentage.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 424 | [hipsparseDpruneCsr2csrNnzByPercentage](interfacehipfort__hipsparse_1_1hipsparsedprunecsr2csrnnzbypercentage.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 425 | [hipsparseSpruneCsr2csrByPercentage](interfacehipfort__hipsparse_1_1hipsparsesprunecsr2csrbypercentage.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 426 | [hipsparseDpruneCsr2csrByPercentage](interfacehipfort__hipsparse_1_1hipsparsedprunecsr2csrbypercentage.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 427 | [hipsparseSpruneDense2csr_bufferSize](interfacehipfort__hipsparse_1_1hipsparsesprunedense2csr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 428 | [hipsparseDpruneDense2csr_bufferSize](interfacehipfort__hipsparse_1_1hipsparsedprunedense2csr__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 429 | [hipsparseSpruneDense2csr_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsesprunedense2csr__buffersizeext.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 430 | [hipsparseDpruneDense2csr_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsedprunedense2csr__buffersizeext.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 431 | [hipsparseSpruneDense2csrNnz](interfacehipfort__hipsparse_1_1hipsparsesprunedense2csrnnz.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 432 | [hipsparseDpruneDense2csrNnz](interfacehipfort__hipsparse_1_1hipsparsedprunedense2csrnnz.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 433 | [hipsparseSpruneDense2csr](interfacehipfort__hipsparse_1_1hipsparsesprunedense2csr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 434 | [hipsparseDpruneDense2csr](interfacehipfort__hipsparse_1_1hipsparsedprunedense2csr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 435 | [hipsparseSpruneDense2csrByPercentage_bufferSize](interfacehipfort__hipsparse_1_1hipsparsesprunedense2csrbypercentage__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 436 | [hipsparseDpruneDense2csrByPercentage_bufferSize](interfacehipfort__hipsparse_1_1hipsparsedprunedense2csrbypercentage__buffersize.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 437 | [hipsparseSpruneDense2csrByPercentage_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsesprunedense2csrbypercentage__buffersizeext.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 438 | [hipsparseDpruneDense2csrByPercentage_bufferSizeExt](interfacehipfort__hipsparse_1_1hipsparsedprunedense2csrbypercentage__buffersizeext.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 439 | [hipsparseSpruneDense2csrNnzByPercentage](interfacehipfort__hipsparse_1_1hipsparsesprunedense2csrnnzbypercentage.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 440 | [hipsparseDpruneDense2csrNnzByPercentage](interfacehipfort__hipsparse_1_1hipsparsedprunedense2csrnnzbypercentage.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 441 | [hipsparseSpruneDense2csrByPercentage](interfacehipfort__hipsparse_1_1hipsparsesprunedense2csrbypercentage.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 442 | [hipsparseDpruneDense2csrByPercentage](interfacehipfort__hipsparse_1_1hipsparsedprunedense2csrbypercentage.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 443 | [hipsparseScsrcolor](interfacehipfort__hipsparse_1_1hipsparsescsrcolor.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 444 | [hipsparseDcsrcolor](interfacehipfort__hipsparse_1_1hipsparsedcsrcolor.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 445 | [hipsparseCcsrcolor](interfacehipfort__hipsparse_1_1hipsparseccsrcolor.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 446 | [hipsparseZcsrcolor](interfacehipfort__hipsparse_1_1hipsparsezcsrcolor.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 447 | [hipsparseCreateSpVec](interfacehipfort__hipsparse_1_1hipsparsecreatespvec.html "Interface documentation") | C binding 448 | [hipsparseCreateConstSpVec](interfacehipfort__hipsparse_1_1hipsparsecreateconstspvec.html "Interface documentation") | C binding 449 | [hipsparseDestroySpVec](interfacehipfort__hipsparse_1_1hipsparsedestroyspvec.html "Interface documentation") | C binding 450 | [hipsparseSpVecGet](interfacehipfort__hipsparse_1_1hipsparsespvecget.html "Interface documentation") | C binding 451 | [hipsparseConstSpVecGet](interfacehipfort__hipsparse_1_1hipsparseconstspvecget.html "Interface documentation") | C binding 452 | [hipsparseSpVecGetIndexBase](interfacehipfort__hipsparse_1_1hipsparsespvecgetindexbase.html "Interface documentation") | C binding 453 | [hipsparseSpVecGetValues](interfacehipfort__hipsparse_1_1hipsparsespvecgetvalues.html "Interface documentation") | C binding 454 | [hipsparseConstSpVecGetValues](interfacehipfort__hipsparse_1_1hipsparseconstspvecgetvalues.html "Interface documentation") | C binding 455 | [hipsparseSpVecSetValues](interfacehipfort__hipsparse_1_1hipsparsespvecsetvalues.html "Interface documentation") | C binding 456 | [hipsparseCreateCoo](interfacehipfort__hipsparse_1_1hipsparsecreatecoo.html "Interface documentation") | C binding 457 | [hipsparseCreateConstCoo](interfacehipfort__hipsparse_1_1hipsparsecreateconstcoo.html "Interface documentation") | C binding 458 | [hipsparseCreateCooAoS](interfacehipfort__hipsparse_1_1hipsparsecreatecooaos.html "Interface documentation") | C binding 459 | [hipsparseCreateCsr](interfacehipfort__hipsparse_1_1hipsparsecreatecsr.html "Interface documentation") | C binding 460 | [hipsparseCreateConstCsr](interfacehipfort__hipsparse_1_1hipsparsecreateconstcsr.html "Interface documentation") | C binding 461 | [hipsparseCreateCsc](interfacehipfort__hipsparse_1_1hipsparsecreatecsc.html "Interface documentation") | C binding 462 | [hipsparseCreateConstCsc](interfacehipfort__hipsparse_1_1hipsparsecreateconstcsc.html "Interface documentation") | C binding 463 | [hipsparseCreateBlockedEll](interfacehipfort__hipsparse_1_1hipsparsecreateblockedell.html "Interface documentation") | C binding 464 | [hipsparseCreateConstBlockedEll](interfacehipfort__hipsparse_1_1hipsparsecreateconstblockedell.html "Interface documentation") | C binding 465 | [hipsparseCreateSlicedEll](interfacehipfort__hipsparse_1_1hipsparsecreateslicedell.html "Interface documentation") | C binding 466 | [hipsparseCreateConstSlicedEll](interfacehipfort__hipsparse_1_1hipsparsecreateconstslicedell.html "Interface documentation") | C binding 467 | [hipsparseCreateBsr](interfacehipfort__hipsparse_1_1hipsparsecreatebsr.html "Interface documentation") | C binding 468 | [hipsparseCreateConstBsr](interfacehipfort__hipsparse_1_1hipsparsecreateconstbsr.html "Interface documentation") | C binding 469 | [hipsparseDestroySpMat](interfacehipfort__hipsparse_1_1hipsparsedestroyspmat.html "Interface documentation") | C binding 470 | [hipsparseCooGet](interfacehipfort__hipsparse_1_1hipsparsecooget.html "Interface documentation") | C binding 471 | [hipsparseConstCooGet](interfacehipfort__hipsparse_1_1hipsparseconstcooget.html "Interface documentation") | C binding 472 | [hipsparseCooAoSGet](interfacehipfort__hipsparse_1_1hipsparsecooaosget.html "Interface documentation") | C binding 473 | [hipsparseCsrGet](interfacehipfort__hipsparse_1_1hipsparsecsrget.html "Interface documentation") | C binding 474 | [hipsparseConstCsrGet](interfacehipfort__hipsparse_1_1hipsparseconstcsrget.html "Interface documentation") | C binding 475 | [hipsparseCscGet](interfacehipfort__hipsparse_1_1hipsparsecscget.html "Interface documentation") | C binding 476 | [hipsparseConstCscGet](interfacehipfort__hipsparse_1_1hipsparseconstcscget.html "Interface documentation") | C binding 477 | [hipsparseBlockedEllGet](interfacehipfort__hipsparse_1_1hipsparseblockedellget.html "Interface documentation") | C binding 478 | [hipsparseConstBlockedEllGet](interfacehipfort__hipsparse_1_1hipsparseconstblockedellget.html "Interface documentation") | C binding 479 | [hipsparseCsrSetPointers](interfacehipfort__hipsparse_1_1hipsparsecsrsetpointers.html "Interface documentation") | C binding 480 | [hipsparseCscSetPointers](interfacehipfort__hipsparse_1_1hipsparsecscsetpointers.html "Interface documentation") | C binding 481 | [hipsparseCooSetPointers](interfacehipfort__hipsparse_1_1hipsparsecoosetpointers.html "Interface documentation") | C binding 482 | [hipsparseBlockedEllSetPointers](interfacehipfort__hipsparse_1_1hipsparseblockedellsetpointers.html "Interface documentation") | C binding 483 | [hipsparseSpMatGetSize](interfacehipfort__hipsparse_1_1hipsparsespmatgetsize.html "Interface documentation") | C binding 484 | [hipsparseSpMatGetFormat](interfacehipfort__hipsparse_1_1hipsparsespmatgetformat.html "Interface documentation") | C binding 485 | [hipsparseSpMatGetIndexBase](interfacehipfort__hipsparse_1_1hipsparsespmatgetindexbase.html "Interface documentation") | C binding 486 | [hipsparseSpMatGetValues](interfacehipfort__hipsparse_1_1hipsparsespmatgetvalues.html "Interface documentation") | C binding 487 | [hipsparseConstSpMatGetValues](interfacehipfort__hipsparse_1_1hipsparseconstspmatgetvalues.html "Interface documentation") | C binding 488 | [hipsparseSpMatSetValues](interfacehipfort__hipsparse_1_1hipsparsespmatsetvalues.html "Interface documentation") | C binding 489 | [hipsparseSpMatGetStridedBatch](interfacehipfort__hipsparse_1_1hipsparsespmatgetstridedbatch.html "Interface documentation") | C binding 490 | [hipsparseSpMatSetStridedBatch](interfacehipfort__hipsparse_1_1hipsparsespmatsetstridedbatch.html "Interface documentation") | C binding 491 | [hipsparseCooSetStridedBatch](interfacehipfort__hipsparse_1_1hipsparsecoosetstridedbatch.html "Interface documentation") | C binding 492 | [hipsparseCsrSetStridedBatch](interfacehipfort__hipsparse_1_1hipsparsecsrsetstridedbatch.html "Interface documentation") | C binding 493 | [hipsparseSpMatGetAttribute](interfacehipfort__hipsparse_1_1hipsparsespmatgetattribute.html "Interface documentation") | C binding 494 | [hipsparseSpMatSetAttribute](interfacehipfort__hipsparse_1_1hipsparsespmatsetattribute.html "Interface documentation") | C binding 495 | [hipsparseCreateDnVec](interfacehipfort__hipsparse_1_1hipsparsecreatednvec.html "Interface documentation") | C binding 496 | [hipsparseCreateConstDnVec](interfacehipfort__hipsparse_1_1hipsparsecreateconstdnvec.html "Interface documentation") | C binding 497 | [hipsparseDestroyDnVec](interfacehipfort__hipsparse_1_1hipsparsedestroydnvec.html "Interface documentation") | C binding 498 | [hipsparseDnVecGet](interfacehipfort__hipsparse_1_1hipsparsednvecget.html "Interface documentation") | C binding 499 | [hipsparseConstDnVecGet](interfacehipfort__hipsparse_1_1hipsparseconstdnvecget.html "Interface documentation") | C binding 500 | [hipsparseDnVecGetValues](interfacehipfort__hipsparse_1_1hipsparsednvecgetvalues.html "Interface documentation") | C binding 501 | [hipsparseConstDnVecGetValues](interfacehipfort__hipsparse_1_1hipsparseconstdnvecgetvalues.html "Interface documentation") | C binding 502 | [hipsparseDnVecSetValues](interfacehipfort__hipsparse_1_1hipsparsednvecsetvalues.html "Interface documentation") | C binding 503 | [hipsparseCreateDnMat](interfacehipfort__hipsparse_1_1hipsparsecreatednmat.html "Interface documentation") | C binding 504 | [hipsparseCreateConstDnMat](interfacehipfort__hipsparse_1_1hipsparsecreateconstdnmat.html "Interface documentation") | C binding 505 | [hipsparseDestroyDnMat](interfacehipfort__hipsparse_1_1hipsparsedestroydnmat.html "Interface documentation") | C binding 506 | [hipsparseDnMatGet](interfacehipfort__hipsparse_1_1hipsparsednmatget.html "Interface documentation") | C binding 507 | [hipsparseConstDnMatGet](interfacehipfort__hipsparse_1_1hipsparseconstdnmatget.html "Interface documentation") | C binding 508 | [hipsparseDnMatGetValues](interfacehipfort__hipsparse_1_1hipsparsednmatgetvalues.html "Interface documentation") | C binding 509 | [hipsparseConstDnMatGetValues](interfacehipfort__hipsparse_1_1hipsparseconstdnmatgetvalues.html "Interface documentation") | C binding 510 | [hipsparseDnMatSetValues](interfacehipfort__hipsparse_1_1hipsparsednmatsetvalues.html "Interface documentation") | C binding 511 | [hipsparseDnMatGetStridedBatch](interfacehipfort__hipsparse_1_1hipsparsednmatgetstridedbatch.html "Interface documentation") | C binding 512 | [hipsparseDnMatSetStridedBatch](interfacehipfort__hipsparse_1_1hipsparsednmatsetstridedbatch.html "Interface documentation") | C binding 513 | [hipsparseAxpby](interfacehipfort__hipsparse_1_1hipsparseaxpby.html "Interface documentation") | C binding 514 | [hipsparseDenseToSparse_bufferSize](interfacehipfort__hipsparse_1_1hipsparsedensetosparse__buffersize.html "Interface documentation") | C binding 515 | [hipsparseDenseToSparse_analysis](interfacehipfort__hipsparse_1_1hipsparsedensetosparse__analysis.html "Interface documentation") | C binding 516 | [hipsparseDenseToSparse_convert](interfacehipfort__hipsparse_1_1hipsparsedensetosparse__convert.html "Interface documentation") | C binding 517 | [hipsparseGather](interfacehipfort__hipsparse_1_1hipsparsegather.html "Interface documentation") | C binding 518 | [hipsparseRot](interfacehipfort__hipsparse_1_1hipsparserot.html "Interface documentation") | C binding 519 | [hipsparseScatter](interfacehipfort__hipsparse_1_1hipsparsescatter.html "Interface documentation") | C binding 520 | [hipsparseSDDMM_bufferSize](interfacehipfort__hipsparse_1_1hipsparsesddmm__buffersize.html "Interface documentation") | C binding 521 | [hipsparseSDDMM_preprocess](interfacehipfort__hipsparse_1_1hipsparsesddmm__preprocess.html "Interface documentation") | C binding 522 | [hipsparseSDDMM](interfacehipfort__hipsparse_1_1hipsparsesddmm.html "Interface documentation") | C binding 523 | [hipsparseSparseToDense_bufferSize](interfacehipfort__hipsparse_1_1hipsparsesparsetodense__buffersize.html "Interface documentation") | C binding 524 | [hipsparseSparseToDense](interfacehipfort__hipsparse_1_1hipsparsesparsetodense.html "Interface documentation") | C binding 525 | [hipsparseSpGEMM_createDescr](interfacehipfort__hipsparse_1_1hipsparsespgemm__createdescr.html "Interface documentation") | C binding 526 | [hipsparseSpGEMM_destroyDescr](interfacehipfort__hipsparse_1_1hipsparsespgemm__destroydescr.html "Interface documentation") | C binding 527 | [hipsparseSpGEMM_workEstimation](interfacehipfort__hipsparse_1_1hipsparsespgemm__workestimation.html "Interface documentation") | C binding 528 | [hipsparseSpGEMM_compute](interfacehipfort__hipsparse_1_1hipsparsespgemm__compute.html "Interface documentation") | C binding 529 | [hipsparseSpGEMM_copy](interfacehipfort__hipsparse_1_1hipsparsespgemm__copy.html "Interface documentation") | C binding 530 | [hipsparseSpGEMMreuse_workEstimation](interfacehipfort__hipsparse_1_1hipsparsespgemmreuse__workestimation.html "Interface documentation") | C binding 531 | [hipsparseSpGEMMreuse_nnz](interfacehipfort__hipsparse_1_1hipsparsespgemmreuse__nnz.html "Interface documentation") | C binding 532 | [hipsparseSpGEMMreuse_copy](interfacehipfort__hipsparse_1_1hipsparsespgemmreuse__copy.html "Interface documentation") | C binding 533 | [hipsparseSpGEMMreuse_compute](interfacehipfort__hipsparse_1_1hipsparsespgemmreuse__compute.html "Interface documentation") | C binding 534 | [hipsparseSpMM_bufferSize](interfacehipfort__hipsparse_1_1hipsparsespmm__buffersize.html "Interface documentation") | C binding 535 | [hipsparseSpMM_preprocess](interfacehipfort__hipsparse_1_1hipsparsespmm__preprocess.html "Interface documentation") | C binding 536 | [hipsparseSpMM](interfacehipfort__hipsparse_1_1hipsparsespmm.html "Interface documentation") | C binding 537 | [hipsparseSpMV_bufferSize](interfacehipfort__hipsparse_1_1hipsparsespmv__buffersize.html "Interface documentation") | C binding 538 | [hipsparseSpMV_preprocess](interfacehipfort__hipsparse_1_1hipsparsespmv__preprocess.html "Interface documentation") | C binding 539 | [hipsparseSpMV](interfacehipfort__hipsparse_1_1hipsparsespmv.html "Interface documentation") | C binding 540 | [hipsparseSpSM_createDescr](interfacehipfort__hipsparse_1_1hipsparsespsm__createdescr.html "Interface documentation") | C binding 541 | [hipsparseSpSM_destroyDescr](interfacehipfort__hipsparse_1_1hipsparsespsm__destroydescr.html "Interface documentation") | C binding 542 | [hipsparseSpSM_bufferSize](interfacehipfort__hipsparse_1_1hipsparsespsm__buffersize.html "Interface documentation") | C binding 543 | [hipsparseSpSM_analysis](interfacehipfort__hipsparse_1_1hipsparsespsm__analysis.html "Interface documentation") | C binding 544 | [hipsparseSpSM_solve](interfacehipfort__hipsparse_1_1hipsparsespsm__solve.html "Interface documentation") | C binding 545 | [hipsparseSpSM_solve_ex](interfacehipfort__hipsparse_1_1hipsparsespsm__solve__ex.html "Interface documentation") | C binding 546 | [hipsparseSpSV_createDescr](interfacehipfort__hipsparse_1_1hipsparsespsv__createdescr.html "Interface documentation") | C binding 547 | [hipsparseSpSV_destroyDescr](interfacehipfort__hipsparse_1_1hipsparsespsv__destroydescr.html "Interface documentation") | C binding 548 | [hipsparseSpSV_bufferSize](interfacehipfort__hipsparse_1_1hipsparsespsv__buffersize.html "Interface documentation") | C binding 549 | [hipsparseSpSV_analysis](interfacehipfort__hipsparse_1_1hipsparsespsv__analysis.html "Interface documentation") | C binding 550 | [hipsparseSpSV_solve](interfacehipfort__hipsparse_1_1hipsparsespsv__solve.html "Interface documentation") | C binding 551 | [hipsparseSpVV_bufferSize](interfacehipfort__hipsparse_1_1hipsparsespvv__buffersize.html "Interface documentation") | C binding 552 | [hipsparseSpVV](interfacehipfort__hipsparse_1_1hipsparsespvv.html "Interface documentation") | C binding hipfort-rocm-10.0.0/docs/doxygen/input/supported_api_rocblas.md000066400000000000000000005172051524740623400246730ustar00rootroot00000000000000# rocBLAS API Support \# | API Name | Variants ----|---------------|--------- 1 | [rocblas_create_handle](interfacehipfort__rocblas_1_1rocblas__create__handle.html "Interface documentation") | C binding 2 | [rocblas_destroy_handle](interfacehipfort__rocblas_1_1rocblas__destroy__handle.html "Interface documentation") | C binding 3 | [rocblas_set_stream](interfacehipfort__rocblas_1_1rocblas__set__stream.html "Interface documentation") | C binding 4 | [rocblas_get_stream](interfacehipfort__rocblas_1_1rocblas__get__stream.html "Interface documentation") | C binding 5 | [rocblas_set_pointer_mode](interfacehipfort__rocblas_1_1rocblas__set__pointer__mode.html "Interface documentation") | C binding 6 | [rocblas_get_pointer_mode](interfacehipfort__rocblas_1_1rocblas__get__pointer__mode.html "Interface documentation") | C binding 7 | [rocblas_set_atomics_mode](interfacehipfort__rocblas_1_1rocblas__set__atomics__mode.html "Interface documentation") | C binding 8 | [rocblas_get_atomics_mode](interfacehipfort__rocblas_1_1rocblas__get__atomics__mode.html "Interface documentation") | C binding 9 | [rocblas_set_batch_alpha_stride](interfacehipfort__rocblas_1_1rocblas__set__batch__alpha__stride.html "Interface documentation") | C binding 10 | [rocblas_get_batch_alpha_stride](interfacehipfort__rocblas_1_1rocblas__get__batch__alpha__stride.html "Interface documentation") | C binding 11 | [rocblas_set_batch_beta_stride](interfacehipfort__rocblas_1_1rocblas__set__batch__beta__stride.html "Interface documentation") | C binding 12 | [rocblas_get_batch_beta_stride](interfacehipfort__rocblas_1_1rocblas__get__batch__beta__stride.html "Interface documentation") | C binding 13 | [rocblas_set_math_mode](interfacehipfort__rocblas_1_1rocblas__set__math__mode.html "Interface documentation") | C binding 14 | [rocblas_get_math_mode](interfacehipfort__rocblas_1_1rocblas__get__math__mode.html "Interface documentation") | C binding 15 | [rocblas_pointer_to_mode](interfacehipfort__rocblas_1_1rocblas__pointer__to__mode.html "Interface documentation") | C binding 16 | [rocblas_set_vector_64](interfacehipfort__rocblas_1_1rocblas__set__vector__64.html "Interface documentation") | C binding 17 | [rocblas_get_vector_64](interfacehipfort__rocblas_1_1rocblas__get__vector__64.html "Interface documentation") | C binding 18 | [rocblas_set_matrix_64](interfacehipfort__rocblas_1_1rocblas__set__matrix__64.html "Interface documentation") | C binding 19 | [rocblas_get_matrix_64](interfacehipfort__rocblas_1_1rocblas__get__matrix__64.html "Interface documentation") | C binding 20 | [rocblas_set_vector_async_64](interfacehipfort__rocblas_1_1rocblas__set__vector__async__64.html "Interface documentation") | C binding 21 | [rocblas_get_vector_async_64](interfacehipfort__rocblas_1_1rocblas__get__vector__async__64.html "Interface documentation") | C binding 22 | [rocblas_set_matrix_async_64](interfacehipfort__rocblas_1_1rocblas__set__matrix__async__64.html "Interface documentation") | C binding 23 | [rocblas_get_matrix_async_64](interfacehipfort__rocblas_1_1rocblas__get__matrix__async__64.html "Interface documentation") | C binding 24 | [rocblas_set_start_stop_events](interfacehipfort__rocblas_1_1rocblas__set__start__stop__events.html "Interface documentation") | C binding 25 | [rocblas_set_solution_fitness_query](interfacehipfort__rocblas_1_1rocblas__set__solution__fitness__query.html "Interface documentation") | C binding 26 | [rocblas_set_performance_metric](interfacehipfort__rocblas_1_1rocblas__set__performance__metric.html "Interface documentation") | C binding 27 | [rocblas_get_performance_metric](interfacehipfort__rocblas_1_1rocblas__get__performance__metric.html "Interface documentation") | C binding 28 | [rocblas_sscal](interfacehipfort__rocblas_1_1rocblas__sscal.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 29 | [rocblas_dscal](interfacehipfort__rocblas_1_1rocblas__dscal.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 30 | [rocblas_cscal](interfacehipfort__rocblas_1_1rocblas__cscal.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 31 | [rocblas_zscal](interfacehipfort__rocblas_1_1rocblas__zscal.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 32 | [rocblas_csscal](interfacehipfort__rocblas_1_1rocblas__csscal.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 33 | [rocblas_zdscal](interfacehipfort__rocblas_1_1rocblas__zdscal.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 34 | [rocblas_sscal_64](interfacehipfort__rocblas_1_1rocblas__sscal__64.html "Interface documentation") | C binding 35 | [rocblas_dscal_64](interfacehipfort__rocblas_1_1rocblas__dscal__64.html "Interface documentation") | C binding 36 | [rocblas_cscal_64](interfacehipfort__rocblas_1_1rocblas__cscal__64.html "Interface documentation") | C binding 37 | [rocblas_zscal_64](interfacehipfort__rocblas_1_1rocblas__zscal__64.html "Interface documentation") | C binding 38 | [rocblas_csscal_64](interfacehipfort__rocblas_1_1rocblas__csscal__64.html "Interface documentation") | C binding 39 | [rocblas_zdscal_64](interfacehipfort__rocblas_1_1rocblas__zdscal__64.html "Interface documentation") | C binding 40 | [rocblas_sscal_batched](interfacehipfort__rocblas_1_1rocblas__sscal__batched.html "Interface documentation") | C binding 41 | [rocblas_dscal_batched](interfacehipfort__rocblas_1_1rocblas__dscal__batched.html "Interface documentation") | C binding 42 | [rocblas_cscal_batched](interfacehipfort__rocblas_1_1rocblas__cscal__batched.html "Interface documentation") | C binding 43 | [rocblas_zscal_batched](interfacehipfort__rocblas_1_1rocblas__zscal__batched.html "Interface documentation") | C binding 44 | [rocblas_csscal_batched](interfacehipfort__rocblas_1_1rocblas__csscal__batched.html "Interface documentation") | C binding 45 | [rocblas_zdscal_batched](interfacehipfort__rocblas_1_1rocblas__zdscal__batched.html "Interface documentation") | C binding 46 | [rocblas_sscal_batched_64](interfacehipfort__rocblas_1_1rocblas__sscal__batched__64.html "Interface documentation") | C binding 47 | [rocblas_dscal_batched_64](interfacehipfort__rocblas_1_1rocblas__dscal__batched__64.html "Interface documentation") | C binding 48 | [rocblas_cscal_batched_64](interfacehipfort__rocblas_1_1rocblas__cscal__batched__64.html "Interface documentation") | C binding 49 | [rocblas_zscal_batched_64](interfacehipfort__rocblas_1_1rocblas__zscal__batched__64.html "Interface documentation") | C binding 50 | [rocblas_csscal_batched_64](interfacehipfort__rocblas_1_1rocblas__csscal__batched__64.html "Interface documentation") | C binding 51 | [rocblas_zdscal_batched_64](interfacehipfort__rocblas_1_1rocblas__zdscal__batched__64.html "Interface documentation") | C binding 52 | [rocblas_sscal_strided_batched](interfacehipfort__rocblas_1_1rocblas__sscal__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 53 | [rocblas_dscal_strided_batched](interfacehipfort__rocblas_1_1rocblas__dscal__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 54 | [rocblas_cscal_strided_batched](interfacehipfort__rocblas_1_1rocblas__cscal__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 55 | [rocblas_zscal_strided_batched](interfacehipfort__rocblas_1_1rocblas__zscal__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 56 | [rocblas_csscal_strided_batched](interfacehipfort__rocblas_1_1rocblas__csscal__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 57 | [rocblas_zdscal_strided_batched](interfacehipfort__rocblas_1_1rocblas__zdscal__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 58 | [rocblas_sscal_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__sscal__strided__batched__64.html "Interface documentation") | C binding 59 | [rocblas_dscal_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dscal__strided__batched__64.html "Interface documentation") | C binding 60 | [rocblas_cscal_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__cscal__strided__batched__64.html "Interface documentation") | C binding 61 | [rocblas_zscal_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zscal__strided__batched__64.html "Interface documentation") | C binding 62 | [rocblas_csscal_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__csscal__strided__batched__64.html "Interface documentation") | C binding 63 | [rocblas_zdscal_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zdscal__strided__batched__64.html "Interface documentation") | C binding 64 | [rocblas_scopy](interfacehipfort__rocblas_1_1rocblas__scopy.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 65 | [rocblas_dcopy](interfacehipfort__rocblas_1_1rocblas__dcopy.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 66 | [rocblas_ccopy](interfacehipfort__rocblas_1_1rocblas__ccopy.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 67 | [rocblas_zcopy](interfacehipfort__rocblas_1_1rocblas__zcopy.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 68 | [rocblas_scopy_64](interfacehipfort__rocblas_1_1rocblas__scopy__64.html "Interface documentation") | C binding 69 | [rocblas_dcopy_64](interfacehipfort__rocblas_1_1rocblas__dcopy__64.html "Interface documentation") | C binding 70 | [rocblas_ccopy_64](interfacehipfort__rocblas_1_1rocblas__ccopy__64.html "Interface documentation") | C binding 71 | [rocblas_zcopy_64](interfacehipfort__rocblas_1_1rocblas__zcopy__64.html "Interface documentation") | C binding 72 | [rocblas_scopy_batched](interfacehipfort__rocblas_1_1rocblas__scopy__batched.html "Interface documentation") | C binding 73 | [rocblas_dcopy_batched](interfacehipfort__rocblas_1_1rocblas__dcopy__batched.html "Interface documentation") | C binding 74 | [rocblas_ccopy_batched](interfacehipfort__rocblas_1_1rocblas__ccopy__batched.html "Interface documentation") | C binding 75 | [rocblas_zcopy_batched](interfacehipfort__rocblas_1_1rocblas__zcopy__batched.html "Interface documentation") | C binding 76 | [rocblas_scopy_batched_64](interfacehipfort__rocblas_1_1rocblas__scopy__batched__64.html "Interface documentation") | C binding 77 | [rocblas_dcopy_batched_64](interfacehipfort__rocblas_1_1rocblas__dcopy__batched__64.html "Interface documentation") | C binding 78 | [rocblas_ccopy_batched_64](interfacehipfort__rocblas_1_1rocblas__ccopy__batched__64.html "Interface documentation") | C binding 79 | [rocblas_zcopy_batched_64](interfacehipfort__rocblas_1_1rocblas__zcopy__batched__64.html "Interface documentation") | C binding 80 | [rocblas_scopy_strided_batched](interfacehipfort__rocblas_1_1rocblas__scopy__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 81 | [rocblas_dcopy_strided_batched](interfacehipfort__rocblas_1_1rocblas__dcopy__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 82 | [rocblas_ccopy_strided_batched](interfacehipfort__rocblas_1_1rocblas__ccopy__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 83 | [rocblas_zcopy_strided_batched](interfacehipfort__rocblas_1_1rocblas__zcopy__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 84 | [rocblas_scopy_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__scopy__strided__batched__64.html "Interface documentation") | C binding 85 | [rocblas_dcopy_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dcopy__strided__batched__64.html "Interface documentation") | C binding 86 | [rocblas_ccopy_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ccopy__strided__batched__64.html "Interface documentation") | C binding 87 | [rocblas_zcopy_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zcopy__strided__batched__64.html "Interface documentation") | C binding 88 | [rocblas_sdot](interfacehipfort__rocblas_1_1rocblas__sdot.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 89 | [rocblas_ddot](interfacehipfort__rocblas_1_1rocblas__ddot.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 90 | [rocblas_hdot](interfacehipfort__rocblas_1_1rocblas__hdot.html "Interface documentation") | C binding 91 | [rocblas_bfdot](interfacehipfort__rocblas_1_1rocblas__bfdot.html "Interface documentation") | C binding 92 | [rocblas_cdotu](interfacehipfort__rocblas_1_1rocblas__cdotu.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 93 | [rocblas_zdotu](interfacehipfort__rocblas_1_1rocblas__zdotu.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 94 | [rocblas_cdotc](interfacehipfort__rocblas_1_1rocblas__cdotc.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 95 | [rocblas_zdotc](interfacehipfort__rocblas_1_1rocblas__zdotc.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 96 | [rocblas_sdot_64](interfacehipfort__rocblas_1_1rocblas__sdot__64.html "Interface documentation") | C binding 97 | [rocblas_ddot_64](interfacehipfort__rocblas_1_1rocblas__ddot__64.html "Interface documentation") | C binding 98 | [rocblas_hdot_64](interfacehipfort__rocblas_1_1rocblas__hdot__64.html "Interface documentation") | C binding 99 | [rocblas_bfdot_64](interfacehipfort__rocblas_1_1rocblas__bfdot__64.html "Interface documentation") | C binding 100 | [rocblas_cdotu_64](interfacehipfort__rocblas_1_1rocblas__cdotu__64.html "Interface documentation") | C binding 101 | [rocblas_zdotu_64](interfacehipfort__rocblas_1_1rocblas__zdotu__64.html "Interface documentation") | C binding 102 | [rocblas_cdotc_64](interfacehipfort__rocblas_1_1rocblas__cdotc__64.html "Interface documentation") | C binding 103 | [rocblas_zdotc_64](interfacehipfort__rocblas_1_1rocblas__zdotc__64.html "Interface documentation") | C binding 104 | [rocblas_sdot_batched](interfacehipfort__rocblas_1_1rocblas__sdot__batched.html "Interface documentation") | C binding 105 | [rocblas_ddot_batched](interfacehipfort__rocblas_1_1rocblas__ddot__batched.html "Interface documentation") | C binding 106 | [rocblas_hdot_batched](interfacehipfort__rocblas_1_1rocblas__hdot__batched.html "Interface documentation") | C binding 107 | [rocblas_bfdot_batched](interfacehipfort__rocblas_1_1rocblas__bfdot__batched.html "Interface documentation") | C binding 108 | [rocblas_cdotu_batched](interfacehipfort__rocblas_1_1rocblas__cdotu__batched.html "Interface documentation") | C binding 109 | [rocblas_zdotu_batched](interfacehipfort__rocblas_1_1rocblas__zdotu__batched.html "Interface documentation") | C binding 110 | [rocblas_cdotc_batched](interfacehipfort__rocblas_1_1rocblas__cdotc__batched.html "Interface documentation") | C binding 111 | [rocblas_zdotc_batched](interfacehipfort__rocblas_1_1rocblas__zdotc__batched.html "Interface documentation") | C binding 112 | [rocblas_sdot_batched_64](interfacehipfort__rocblas_1_1rocblas__sdot__batched__64.html "Interface documentation") | C binding 113 | [rocblas_ddot_batched_64](interfacehipfort__rocblas_1_1rocblas__ddot__batched__64.html "Interface documentation") | C binding 114 | [rocblas_hdot_batched_64](interfacehipfort__rocblas_1_1rocblas__hdot__batched__64.html "Interface documentation") | C binding 115 | [rocblas_bfdot_batched_64](interfacehipfort__rocblas_1_1rocblas__bfdot__batched__64.html "Interface documentation") | C binding 116 | [rocblas_cdotu_batched_64](interfacehipfort__rocblas_1_1rocblas__cdotu__batched__64.html "Interface documentation") | C binding 117 | [rocblas_zdotu_batched_64](interfacehipfort__rocblas_1_1rocblas__zdotu__batched__64.html "Interface documentation") | C binding 118 | [rocblas_cdotc_batched_64](interfacehipfort__rocblas_1_1rocblas__cdotc__batched__64.html "Interface documentation") | C binding 119 | [rocblas_zdotc_batched_64](interfacehipfort__rocblas_1_1rocblas__zdotc__batched__64.html "Interface documentation") | C binding 120 | [rocblas_sdot_strided_batched](interfacehipfort__rocblas_1_1rocblas__sdot__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 121 | [rocblas_ddot_strided_batched](interfacehipfort__rocblas_1_1rocblas__ddot__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 122 | [rocblas_hdot_strided_batched](interfacehipfort__rocblas_1_1rocblas__hdot__strided__batched.html "Interface documentation") | C binding 123 | [rocblas_bfdot_strided_batched](interfacehipfort__rocblas_1_1rocblas__bfdot__strided__batched.html "Interface documentation") | C binding 124 | [rocblas_cdotu_strided_batched](interfacehipfort__rocblas_1_1rocblas__cdotu__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 125 | [rocblas_zdotu_strided_batched](interfacehipfort__rocblas_1_1rocblas__zdotu__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 126 | [rocblas_cdotc_strided_batched](interfacehipfort__rocblas_1_1rocblas__cdotc__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 127 | [rocblas_zdotc_strided_batched](interfacehipfort__rocblas_1_1rocblas__zdotc__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 128 | [rocblas_sdot_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__sdot__strided__batched__64.html "Interface documentation") | C binding 129 | [rocblas_ddot_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ddot__strided__batched__64.html "Interface documentation") | C binding 130 | [rocblas_hdot_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__hdot__strided__batched__64.html "Interface documentation") | C binding 131 | [rocblas_bfdot_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__bfdot__strided__batched__64.html "Interface documentation") | C binding 132 | [rocblas_cdotu_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__cdotu__strided__batched__64.html "Interface documentation") | C binding 133 | [rocblas_zdotu_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zdotu__strided__batched__64.html "Interface documentation") | C binding 134 | [rocblas_cdotc_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__cdotc__strided__batched__64.html "Interface documentation") | C binding 135 | [rocblas_zdotc_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zdotc__strided__batched__64.html "Interface documentation") | C binding 136 | [rocblas_sswap](interfacehipfort__rocblas_1_1rocblas__sswap.html "Interface documentation") | C binding 137 | [rocblas_dswap](interfacehipfort__rocblas_1_1rocblas__dswap.html "Interface documentation") | C binding 138 | [rocblas_cswap](interfacehipfort__rocblas_1_1rocblas__cswap.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 139 | [rocblas_zswap](interfacehipfort__rocblas_1_1rocblas__zswap.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 140 | [rocblas_sswap_64](interfacehipfort__rocblas_1_1rocblas__sswap__64.html "Interface documentation") | C binding 141 | [rocblas_dswap_64](interfacehipfort__rocblas_1_1rocblas__dswap__64.html "Interface documentation") | C binding 142 | [rocblas_cswap_64](interfacehipfort__rocblas_1_1rocblas__cswap__64.html "Interface documentation") | C binding 143 | [rocblas_zswap_64](interfacehipfort__rocblas_1_1rocblas__zswap__64.html "Interface documentation") | C binding 144 | [rocblas_sswap_batched](interfacehipfort__rocblas_1_1rocblas__sswap__batched.html "Interface documentation") | C binding 145 | [rocblas_dswap_batched](interfacehipfort__rocblas_1_1rocblas__dswap__batched.html "Interface documentation") | C binding 146 | [rocblas_cswap_batched](interfacehipfort__rocblas_1_1rocblas__cswap__batched.html "Interface documentation") | C binding 147 | [rocblas_zswap_batched](interfacehipfort__rocblas_1_1rocblas__zswap__batched.html "Interface documentation") | C binding 148 | [rocblas_sswap_batched_64](interfacehipfort__rocblas_1_1rocblas__sswap__batched__64.html "Interface documentation") | C binding 149 | [rocblas_dswap_batched_64](interfacehipfort__rocblas_1_1rocblas__dswap__batched__64.html "Interface documentation") | C binding 150 | [rocblas_cswap_batched_64](interfacehipfort__rocblas_1_1rocblas__cswap__batched__64.html "Interface documentation") | C binding 151 | [rocblas_zswap_batched_64](interfacehipfort__rocblas_1_1rocblas__zswap__batched__64.html "Interface documentation") | C binding 152 | [rocblas_sswap_strided_batched](interfacehipfort__rocblas_1_1rocblas__sswap__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 153 | [rocblas_dswap_strided_batched](interfacehipfort__rocblas_1_1rocblas__dswap__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 154 | [rocblas_cswap_strided_batched](interfacehipfort__rocblas_1_1rocblas__cswap__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 155 | [rocblas_zswap_strided_batched](interfacehipfort__rocblas_1_1rocblas__zswap__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 156 | [rocblas_sswap_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__sswap__strided__batched__64.html "Interface documentation") | C binding 157 | [rocblas_dswap_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dswap__strided__batched__64.html "Interface documentation") | C binding 158 | [rocblas_cswap_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__cswap__strided__batched__64.html "Interface documentation") | C binding 159 | [rocblas_zswap_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zswap__strided__batched__64.html "Interface documentation") | C binding 160 | [rocblas_haxpy](interfacehipfort__rocblas_1_1rocblas__haxpy.html "Interface documentation") | C binding 161 | [rocblas_saxpy](interfacehipfort__rocblas_1_1rocblas__saxpy.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 162 | [rocblas_daxpy](interfacehipfort__rocblas_1_1rocblas__daxpy.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 163 | [rocblas_caxpy](interfacehipfort__rocblas_1_1rocblas__caxpy.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 164 | [rocblas_zaxpy](interfacehipfort__rocblas_1_1rocblas__zaxpy.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 165 | [rocblas_haxpy_64](interfacehipfort__rocblas_1_1rocblas__haxpy__64.html "Interface documentation") | C binding 166 | [rocblas_saxpy_64](interfacehipfort__rocblas_1_1rocblas__saxpy__64.html "Interface documentation") | C binding 167 | [rocblas_daxpy_64](interfacehipfort__rocblas_1_1rocblas__daxpy__64.html "Interface documentation") | C binding 168 | [rocblas_caxpy_64](interfacehipfort__rocblas_1_1rocblas__caxpy__64.html "Interface documentation") | C binding 169 | [rocblas_zaxpy_64](interfacehipfort__rocblas_1_1rocblas__zaxpy__64.html "Interface documentation") | C binding 170 | [rocblas_haxpy_batched](interfacehipfort__rocblas_1_1rocblas__haxpy__batched.html "Interface documentation") | C binding 171 | [rocblas_saxpy_batched](interfacehipfort__rocblas_1_1rocblas__saxpy__batched.html "Interface documentation") | C binding 172 | [rocblas_daxpy_batched](interfacehipfort__rocblas_1_1rocblas__daxpy__batched.html "Interface documentation") | C binding 173 | [rocblas_caxpy_batched](interfacehipfort__rocblas_1_1rocblas__caxpy__batched.html "Interface documentation") | C binding 174 | [rocblas_zaxpy_batched](interfacehipfort__rocblas_1_1rocblas__zaxpy__batched.html "Interface documentation") | C binding 175 | [rocblas_haxpy_batched_64](interfacehipfort__rocblas_1_1rocblas__haxpy__batched__64.html "Interface documentation") | C binding 176 | [rocblas_saxpy_batched_64](interfacehipfort__rocblas_1_1rocblas__saxpy__batched__64.html "Interface documentation") | C binding 177 | [rocblas_daxpy_batched_64](interfacehipfort__rocblas_1_1rocblas__daxpy__batched__64.html "Interface documentation") | C binding 178 | [rocblas_caxpy_batched_64](interfacehipfort__rocblas_1_1rocblas__caxpy__batched__64.html "Interface documentation") | C binding 179 | [rocblas_zaxpy_batched_64](interfacehipfort__rocblas_1_1rocblas__zaxpy__batched__64.html "Interface documentation") | C binding 180 | [rocblas_haxpy_strided_batched](interfacehipfort__rocblas_1_1rocblas__haxpy__strided__batched.html "Interface documentation") | C binding 181 | [rocblas_saxpy_strided_batched](interfacehipfort__rocblas_1_1rocblas__saxpy__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 182 | [rocblas_daxpy_strided_batched](interfacehipfort__rocblas_1_1rocblas__daxpy__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 183 | [rocblas_caxpy_strided_batched](interfacehipfort__rocblas_1_1rocblas__caxpy__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 184 | [rocblas_zaxpy_strided_batched](interfacehipfort__rocblas_1_1rocblas__zaxpy__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 185 | [rocblas_haxpy_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__haxpy__strided__batched__64.html "Interface documentation") | C binding 186 | [rocblas_saxpy_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__saxpy__strided__batched__64.html "Interface documentation") | C binding 187 | [rocblas_daxpy_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__daxpy__strided__batched__64.html "Interface documentation") | C binding 188 | [rocblas_caxpy_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__caxpy__strided__batched__64.html "Interface documentation") | C binding 189 | [rocblas_zaxpy_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zaxpy__strided__batched__64.html "Interface documentation") | C binding 190 | [rocblas_sasum](interfacehipfort__rocblas_1_1rocblas__sasum.html "Interface documentation") | C binding 191 | [rocblas_dasum](interfacehipfort__rocblas_1_1rocblas__dasum.html "Interface documentation") | C binding 192 | [rocblas_scasum](interfacehipfort__rocblas_1_1rocblas__scasum.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 193 | [rocblas_dzasum](interfacehipfort__rocblas_1_1rocblas__dzasum.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 194 | [rocblas_sasum_64](interfacehipfort__rocblas_1_1rocblas__sasum__64.html "Interface documentation") | C binding 195 | [rocblas_dasum_64](interfacehipfort__rocblas_1_1rocblas__dasum__64.html "Interface documentation") | C binding 196 | [rocblas_scasum_64](interfacehipfort__rocblas_1_1rocblas__scasum__64.html "Interface documentation") | C binding 197 | [rocblas_dzasum_64](interfacehipfort__rocblas_1_1rocblas__dzasum__64.html "Interface documentation") | C binding 198 | [rocblas_sasum_batched](interfacehipfort__rocblas_1_1rocblas__sasum__batched.html "Interface documentation") | C binding 199 | [rocblas_dasum_batched](interfacehipfort__rocblas_1_1rocblas__dasum__batched.html "Interface documentation") | C binding 200 | [rocblas_scasum_batched](interfacehipfort__rocblas_1_1rocblas__scasum__batched.html "Interface documentation") | C binding 201 | [rocblas_dzasum_batched](interfacehipfort__rocblas_1_1rocblas__dzasum__batched.html "Interface documentation") | C binding 202 | [rocblas_sasum_batched_64](interfacehipfort__rocblas_1_1rocblas__sasum__batched__64.html "Interface documentation") | C binding 203 | [rocblas_dasum_batched_64](interfacehipfort__rocblas_1_1rocblas__dasum__batched__64.html "Interface documentation") | C binding 204 | [rocblas_scasum_batched_64](interfacehipfort__rocblas_1_1rocblas__scasum__batched__64.html "Interface documentation") | C binding 205 | [rocblas_dzasum_batched_64](interfacehipfort__rocblas_1_1rocblas__dzasum__batched__64.html "Interface documentation") | C binding 206 | [rocblas_sasum_strided_batched](interfacehipfort__rocblas_1_1rocblas__sasum__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 207 | [rocblas_dasum_strided_batched](interfacehipfort__rocblas_1_1rocblas__dasum__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 208 | [rocblas_scasum_strided_batched](interfacehipfort__rocblas_1_1rocblas__scasum__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 209 | [rocblas_dzasum_strided_batched](interfacehipfort__rocblas_1_1rocblas__dzasum__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 210 | [rocblas_sasum_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__sasum__strided__batched__64.html "Interface documentation") | C binding 211 | [rocblas_dasum_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dasum__strided__batched__64.html "Interface documentation") | C binding 212 | [rocblas_scasum_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__scasum__strided__batched__64.html "Interface documentation") | C binding 213 | [rocblas_dzasum_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dzasum__strided__batched__64.html "Interface documentation") | C binding 214 | [rocblas_snrm2](interfacehipfort__rocblas_1_1rocblas__snrm2.html "Interface documentation") | C binding 215 | [rocblas_dnrm2](interfacehipfort__rocblas_1_1rocblas__dnrm2.html "Interface documentation") | C binding 216 | [rocblas_scnrm2](interfacehipfort__rocblas_1_1rocblas__scnrm2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 217 | [rocblas_dznrm2](interfacehipfort__rocblas_1_1rocblas__dznrm2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 218 | [rocblas_snrm2_64](interfacehipfort__rocblas_1_1rocblas__snrm2__64.html "Interface documentation") | C binding 219 | [rocblas_dnrm2_64](interfacehipfort__rocblas_1_1rocblas__dnrm2__64.html "Interface documentation") | C binding 220 | [rocblas_scnrm2_64](interfacehipfort__rocblas_1_1rocblas__scnrm2__64.html "Interface documentation") | C binding 221 | [rocblas_dznrm2_64](interfacehipfort__rocblas_1_1rocblas__dznrm2__64.html "Interface documentation") | C binding 222 | [rocblas_snrm2_batched](interfacehipfort__rocblas_1_1rocblas__snrm2__batched.html "Interface documentation") | C binding 223 | [rocblas_dnrm2_batched](interfacehipfort__rocblas_1_1rocblas__dnrm2__batched.html "Interface documentation") | C binding 224 | [rocblas_scnrm2_batched](interfacehipfort__rocblas_1_1rocblas__scnrm2__batched.html "Interface documentation") | C binding 225 | [rocblas_dznrm2_batched](interfacehipfort__rocblas_1_1rocblas__dznrm2__batched.html "Interface documentation") | C binding 226 | [rocblas_snrm2_batched_64](interfacehipfort__rocblas_1_1rocblas__snrm2__batched__64.html "Interface documentation") | C binding 227 | [rocblas_dnrm2_batched_64](interfacehipfort__rocblas_1_1rocblas__dnrm2__batched__64.html "Interface documentation") | C binding 228 | [rocblas_scnrm2_batched_64](interfacehipfort__rocblas_1_1rocblas__scnrm2__batched__64.html "Interface documentation") | C binding 229 | [rocblas_dznrm2_batched_64](interfacehipfort__rocblas_1_1rocblas__dznrm2__batched__64.html "Interface documentation") | C binding 230 | [rocblas_snrm2_strided_batched](interfacehipfort__rocblas_1_1rocblas__snrm2__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 231 | [rocblas_dnrm2_strided_batched](interfacehipfort__rocblas_1_1rocblas__dnrm2__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 232 | [rocblas_scnrm2_strided_batched](interfacehipfort__rocblas_1_1rocblas__scnrm2__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 233 | [rocblas_dznrm2_strided_batched](interfacehipfort__rocblas_1_1rocblas__dznrm2__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 234 | [rocblas_snrm2_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__snrm2__strided__batched__64.html "Interface documentation") | C binding 235 | [rocblas_dnrm2_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dnrm2__strided__batched__64.html "Interface documentation") | C binding 236 | [rocblas_scnrm2_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__scnrm2__strided__batched__64.html "Interface documentation") | C binding 237 | [rocblas_dznrm2_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dznrm2__strided__batched__64.html "Interface documentation") | C binding 238 | [rocblas_isamax](interfacehipfort__rocblas_1_1rocblas__isamax.html "Interface documentation") | C binding 239 | [rocblas_idamax](interfacehipfort__rocblas_1_1rocblas__idamax.html "Interface documentation") | C binding 240 | [rocblas_icamax](interfacehipfort__rocblas_1_1rocblas__icamax.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 241 | [rocblas_izamax](interfacehipfort__rocblas_1_1rocblas__izamax.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 242 | [rocblas_isamax_64](interfacehipfort__rocblas_1_1rocblas__isamax__64.html "Interface documentation") | C binding 243 | [rocblas_idamax_64](interfacehipfort__rocblas_1_1rocblas__idamax__64.html "Interface documentation") | C binding 244 | [rocblas_icamax_64](interfacehipfort__rocblas_1_1rocblas__icamax__64.html "Interface documentation") | C binding 245 | [rocblas_izamax_64](interfacehipfort__rocblas_1_1rocblas__izamax__64.html "Interface documentation") | C binding 246 | [rocblas_isamax_batched](interfacehipfort__rocblas_1_1rocblas__isamax__batched.html "Interface documentation") | C binding 247 | [rocblas_idamax_batched](interfacehipfort__rocblas_1_1rocblas__idamax__batched.html "Interface documentation") | C binding 248 | [rocblas_icamax_batched](interfacehipfort__rocblas_1_1rocblas__icamax__batched.html "Interface documentation") | C binding 249 | [rocblas_izamax_batched](interfacehipfort__rocblas_1_1rocblas__izamax__batched.html "Interface documentation") | C binding 250 | [rocblas_isamax_batched_64](interfacehipfort__rocblas_1_1rocblas__isamax__batched__64.html "Interface documentation") | C binding 251 | [rocblas_idamax_batched_64](interfacehipfort__rocblas_1_1rocblas__idamax__batched__64.html "Interface documentation") | C binding 252 | [rocblas_icamax_batched_64](interfacehipfort__rocblas_1_1rocblas__icamax__batched__64.html "Interface documentation") | C binding 253 | [rocblas_izamax_batched_64](interfacehipfort__rocblas_1_1rocblas__izamax__batched__64.html "Interface documentation") | C binding 254 | [rocblas_isamax_strided_batched](interfacehipfort__rocblas_1_1rocblas__isamax__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 255 | [rocblas_idamax_strided_batched](interfacehipfort__rocblas_1_1rocblas__idamax__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 256 | [rocblas_icamax_strided_batched](interfacehipfort__rocblas_1_1rocblas__icamax__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 257 | [rocblas_izamax_strided_batched](interfacehipfort__rocblas_1_1rocblas__izamax__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 258 | [rocblas_isamax_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__isamax__strided__batched__64.html "Interface documentation") | C binding 259 | [rocblas_idamax_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__idamax__strided__batched__64.html "Interface documentation") | C binding 260 | [rocblas_icamax_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__icamax__strided__batched__64.html "Interface documentation") | C binding 261 | [rocblas_izamax_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__izamax__strided__batched__64.html "Interface documentation") | C binding 262 | [rocblas_isamin](interfacehipfort__rocblas_1_1rocblas__isamin.html "Interface documentation") | C binding 263 | [rocblas_idamin](interfacehipfort__rocblas_1_1rocblas__idamin.html "Interface documentation") | C binding 264 | [rocblas_icamin](interfacehipfort__rocblas_1_1rocblas__icamin.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 265 | [rocblas_izamin](interfacehipfort__rocblas_1_1rocblas__izamin.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 266 | [rocblas_isamin_64](interfacehipfort__rocblas_1_1rocblas__isamin__64.html "Interface documentation") | C binding 267 | [rocblas_idamin_64](interfacehipfort__rocblas_1_1rocblas__idamin__64.html "Interface documentation") | C binding 268 | [rocblas_icamin_64](interfacehipfort__rocblas_1_1rocblas__icamin__64.html "Interface documentation") | C binding 269 | [rocblas_izamin_64](interfacehipfort__rocblas_1_1rocblas__izamin__64.html "Interface documentation") | C binding 270 | [rocblas_isamin_batched](interfacehipfort__rocblas_1_1rocblas__isamin__batched.html "Interface documentation") | C binding 271 | [rocblas_idamin_batched](interfacehipfort__rocblas_1_1rocblas__idamin__batched.html "Interface documentation") | C binding 272 | [rocblas_icamin_batched](interfacehipfort__rocblas_1_1rocblas__icamin__batched.html "Interface documentation") | C binding 273 | [rocblas_izamin_batched](interfacehipfort__rocblas_1_1rocblas__izamin__batched.html "Interface documentation") | C binding 274 | [rocblas_isamin_batched_64](interfacehipfort__rocblas_1_1rocblas__isamin__batched__64.html "Interface documentation") | C binding 275 | [rocblas_idamin_batched_64](interfacehipfort__rocblas_1_1rocblas__idamin__batched__64.html "Interface documentation") | C binding 276 | [rocblas_icamin_batched_64](interfacehipfort__rocblas_1_1rocblas__icamin__batched__64.html "Interface documentation") | C binding 277 | [rocblas_izamin_batched_64](interfacehipfort__rocblas_1_1rocblas__izamin__batched__64.html "Interface documentation") | C binding 278 | [rocblas_isamin_strided_batched](interfacehipfort__rocblas_1_1rocblas__isamin__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 279 | [rocblas_idamin_strided_batched](interfacehipfort__rocblas_1_1rocblas__idamin__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 280 | [rocblas_icamin_strided_batched](interfacehipfort__rocblas_1_1rocblas__icamin__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 281 | [rocblas_izamin_strided_batched](interfacehipfort__rocblas_1_1rocblas__izamin__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 282 | [rocblas_isamin_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__isamin__strided__batched__64.html "Interface documentation") | C binding 283 | [rocblas_idamin_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__idamin__strided__batched__64.html "Interface documentation") | C binding 284 | [rocblas_icamin_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__icamin__strided__batched__64.html "Interface documentation") | C binding 285 | [rocblas_izamin_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__izamin__strided__batched__64.html "Interface documentation") | C binding 286 | [rocblas_srot](interfacehipfort__rocblas_1_1rocblas__srot.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 287 | [rocblas_drot](interfacehipfort__rocblas_1_1rocblas__drot.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 288 | [rocblas_crot](interfacehipfort__rocblas_1_1rocblas__crot.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 289 | [rocblas_csrot](interfacehipfort__rocblas_1_1rocblas__csrot.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 290 | [rocblas_zrot](interfacehipfort__rocblas_1_1rocblas__zrot.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 291 | [rocblas_zdrot](interfacehipfort__rocblas_1_1rocblas__zdrot.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 292 | [rocblas_srot_64](interfacehipfort__rocblas_1_1rocblas__srot__64.html "Interface documentation") | C binding 293 | [rocblas_drot_64](interfacehipfort__rocblas_1_1rocblas__drot__64.html "Interface documentation") | C binding 294 | [rocblas_crot_64](interfacehipfort__rocblas_1_1rocblas__crot__64.html "Interface documentation") | C binding 295 | [rocblas_csrot_64](interfacehipfort__rocblas_1_1rocblas__csrot__64.html "Interface documentation") | C binding 296 | [rocblas_zrot_64](interfacehipfort__rocblas_1_1rocblas__zrot__64.html "Interface documentation") | C binding 297 | [rocblas_zdrot_64](interfacehipfort__rocblas_1_1rocblas__zdrot__64.html "Interface documentation") | C binding 298 | [rocblas_srot_batched](interfacehipfort__rocblas_1_1rocblas__srot__batched.html "Interface documentation") | C binding 299 | [rocblas_drot_batched](interfacehipfort__rocblas_1_1rocblas__drot__batched.html "Interface documentation") | C binding 300 | [rocblas_crot_batched](interfacehipfort__rocblas_1_1rocblas__crot__batched.html "Interface documentation") | C binding 301 | [rocblas_csrot_batched](interfacehipfort__rocblas_1_1rocblas__csrot__batched.html "Interface documentation") | C binding 302 | [rocblas_zrot_batched](interfacehipfort__rocblas_1_1rocblas__zrot__batched.html "Interface documentation") | C binding 303 | [rocblas_zdrot_batched](interfacehipfort__rocblas_1_1rocblas__zdrot__batched.html "Interface documentation") | C binding 304 | [rocblas_srot_batched_64](interfacehipfort__rocblas_1_1rocblas__srot__batched__64.html "Interface documentation") | C binding 305 | [rocblas_drot_batched_64](interfacehipfort__rocblas_1_1rocblas__drot__batched__64.html "Interface documentation") | C binding 306 | [rocblas_crot_batched_64](interfacehipfort__rocblas_1_1rocblas__crot__batched__64.html "Interface documentation") | C binding 307 | [rocblas_csrot_batched_64](interfacehipfort__rocblas_1_1rocblas__csrot__batched__64.html "Interface documentation") | C binding 308 | [rocblas_zrot_batched_64](interfacehipfort__rocblas_1_1rocblas__zrot__batched__64.html "Interface documentation") | C binding 309 | [rocblas_zdrot_batched_64](interfacehipfort__rocblas_1_1rocblas__zdrot__batched__64.html "Interface documentation") | C binding 310 | [rocblas_srot_strided_batched](interfacehipfort__rocblas_1_1rocblas__srot__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 311 | [rocblas_drot_strided_batched](interfacehipfort__rocblas_1_1rocblas__drot__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 312 | [rocblas_crot_strided_batched](interfacehipfort__rocblas_1_1rocblas__crot__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 313 | [rocblas_csrot_strided_batched](interfacehipfort__rocblas_1_1rocblas__csrot__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 314 | [rocblas_zrot_strided_batched](interfacehipfort__rocblas_1_1rocblas__zrot__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 315 | [rocblas_zdrot_strided_batched](interfacehipfort__rocblas_1_1rocblas__zdrot__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 316 | [rocblas_srot_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__srot__strided__batched__64.html "Interface documentation") | C binding 317 | [rocblas_drot_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__drot__strided__batched__64.html "Interface documentation") | C binding 318 | [rocblas_crot_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__crot__strided__batched__64.html "Interface documentation") | C binding 319 | [rocblas_csrot_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__csrot__strided__batched__64.html "Interface documentation") | C binding 320 | [rocblas_zrot_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zrot__strided__batched__64.html "Interface documentation") | C binding 321 | [rocblas_zdrot_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zdrot__strided__batched__64.html "Interface documentation") | C binding 322 | [rocblas_srotg](interfacehipfort__rocblas_1_1rocblas__srotg.html "Interface documentation") | C binding 323 | [rocblas_drotg](interfacehipfort__rocblas_1_1rocblas__drotg.html "Interface documentation") | C binding 324 | [rocblas_crotg](interfacehipfort__rocblas_1_1rocblas__crotg.html "Interface documentation") | C binding 325 | [rocblas_zrotg](interfacehipfort__rocblas_1_1rocblas__zrotg.html "Interface documentation") | C binding 326 | [rocblas_srotg_64](interfacehipfort__rocblas_1_1rocblas__srotg__64.html "Interface documentation") | C binding 327 | [rocblas_drotg_64](interfacehipfort__rocblas_1_1rocblas__drotg__64.html "Interface documentation") | C binding 328 | [rocblas_crotg_64](interfacehipfort__rocblas_1_1rocblas__crotg__64.html "Interface documentation") | C binding 329 | [rocblas_zrotg_64](interfacehipfort__rocblas_1_1rocblas__zrotg__64.html "Interface documentation") | C binding 330 | [rocblas_srotg_batched](interfacehipfort__rocblas_1_1rocblas__srotg__batched.html "Interface documentation") | C binding 331 | [rocblas_drotg_batched](interfacehipfort__rocblas_1_1rocblas__drotg__batched.html "Interface documentation") | C binding 332 | [rocblas_crotg_batched](interfacehipfort__rocblas_1_1rocblas__crotg__batched.html "Interface documentation") | C binding 333 | [rocblas_zrotg_batched](interfacehipfort__rocblas_1_1rocblas__zrotg__batched.html "Interface documentation") | C binding 334 | [rocblas_srotg_batched_64](interfacehipfort__rocblas_1_1rocblas__srotg__batched__64.html "Interface documentation") | C binding 335 | [rocblas_drotg_batched_64](interfacehipfort__rocblas_1_1rocblas__drotg__batched__64.html "Interface documentation") | C binding 336 | [rocblas_crotg_batched_64](interfacehipfort__rocblas_1_1rocblas__crotg__batched__64.html "Interface documentation") | C binding 337 | [rocblas_zrotg_batched_64](interfacehipfort__rocblas_1_1rocblas__zrotg__batched__64.html "Interface documentation") | C binding 338 | [rocblas_srotg_strided_batched](interfacehipfort__rocblas_1_1rocblas__srotg__strided__batched.html "Interface documentation") | C binding 339 | [rocblas_drotg_strided_batched](interfacehipfort__rocblas_1_1rocblas__drotg__strided__batched.html "Interface documentation") | C binding 340 | [rocblas_crotg_strided_batched](interfacehipfort__rocblas_1_1rocblas__crotg__strided__batched.html "Interface documentation") | C binding 341 | [rocblas_zrotg_strided_batched](interfacehipfort__rocblas_1_1rocblas__zrotg__strided__batched.html "Interface documentation") | C binding 342 | [rocblas_srotg_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__srotg__strided__batched__64.html "Interface documentation") | C binding 343 | [rocblas_drotg_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__drotg__strided__batched__64.html "Interface documentation") | C binding 344 | [rocblas_crotg_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__crotg__strided__batched__64.html "Interface documentation") | C binding 345 | [rocblas_zrotg_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zrotg__strided__batched__64.html "Interface documentation") | C binding 346 | [rocblas_srotm](interfacehipfort__rocblas_1_1rocblas__srotm.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 347 | [rocblas_drotm](interfacehipfort__rocblas_1_1rocblas__drotm.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 348 | [rocblas_srotm_64](interfacehipfort__rocblas_1_1rocblas__srotm__64.html "Interface documentation") | C binding 349 | [rocblas_drotm_64](interfacehipfort__rocblas_1_1rocblas__drotm__64.html "Interface documentation") | C binding 350 | [rocblas_srotm_batched](interfacehipfort__rocblas_1_1rocblas__srotm__batched.html "Interface documentation") | C binding 351 | [rocblas_drotm_batched](interfacehipfort__rocblas_1_1rocblas__drotm__batched.html "Interface documentation") | C binding 352 | [rocblas_srotm_batched_64](interfacehipfort__rocblas_1_1rocblas__srotm__batched__64.html "Interface documentation") | C binding 353 | [rocblas_drotm_batched_64](interfacehipfort__rocblas_1_1rocblas__drotm__batched__64.html "Interface documentation") | C binding 354 | [rocblas_srotm_strided_batched](interfacehipfort__rocblas_1_1rocblas__srotm__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 355 | [rocblas_drotm_strided_batched](interfacehipfort__rocblas_1_1rocblas__drotm__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 356 | [rocblas_srotm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__srotm__strided__batched__64.html "Interface documentation") | C binding 357 | [rocblas_drotm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__drotm__strided__batched__64.html "Interface documentation") | C binding 358 | [rocblas_srotmg](interfacehipfort__rocblas_1_1rocblas__srotmg.html "Interface documentation") | C binding 359 | [rocblas_drotmg](interfacehipfort__rocblas_1_1rocblas__drotmg.html "Interface documentation") | C binding 360 | [rocblas_srotmg_64](interfacehipfort__rocblas_1_1rocblas__srotmg__64.html "Interface documentation") | C binding 361 | [rocblas_drotmg_64](interfacehipfort__rocblas_1_1rocblas__drotmg__64.html "Interface documentation") | C binding 362 | [rocblas_srotmg_batched](interfacehipfort__rocblas_1_1rocblas__srotmg__batched.html "Interface documentation") | C binding 363 | [rocblas_drotmg_batched](interfacehipfort__rocblas_1_1rocblas__drotmg__batched.html "Interface documentation") | C binding 364 | [rocblas_srotmg_batched_64](interfacehipfort__rocblas_1_1rocblas__srotmg__batched__64.html "Interface documentation") | C binding 365 | [rocblas_drotmg_batched_64](interfacehipfort__rocblas_1_1rocblas__drotmg__batched__64.html "Interface documentation") | C binding 366 | [rocblas_srotmg_strided_batched](interfacehipfort__rocblas_1_1rocblas__srotmg__strided__batched.html "Interface documentation") | C binding 367 | [rocblas_drotmg_strided_batched](interfacehipfort__rocblas_1_1rocblas__drotmg__strided__batched.html "Interface documentation") | C binding 368 | [rocblas_srotmg_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__srotmg__strided__batched__64.html "Interface documentation") | C binding 369 | [rocblas_drotmg_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__drotmg__strided__batched__64.html "Interface documentation") | C binding 370 | [rocblas_sgbmv](interfacehipfort__rocblas_1_1rocblas__sgbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 371 | [rocblas_dgbmv](interfacehipfort__rocblas_1_1rocblas__dgbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 372 | [rocblas_cgbmv](interfacehipfort__rocblas_1_1rocblas__cgbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 373 | [rocblas_zgbmv](interfacehipfort__rocblas_1_1rocblas__zgbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 374 | [rocblas_sgbmv_64](interfacehipfort__rocblas_1_1rocblas__sgbmv__64.html "Interface documentation") | C binding 375 | [rocblas_dgbmv_64](interfacehipfort__rocblas_1_1rocblas__dgbmv__64.html "Interface documentation") | C binding 376 | [rocblas_cgbmv_64](interfacehipfort__rocblas_1_1rocblas__cgbmv__64.html "Interface documentation") | C binding 377 | [rocblas_zgbmv_64](interfacehipfort__rocblas_1_1rocblas__zgbmv__64.html "Interface documentation") | C binding 378 | [rocblas_sgbmv_batched](interfacehipfort__rocblas_1_1rocblas__sgbmv__batched.html "Interface documentation") | C binding 379 | [rocblas_dgbmv_batched](interfacehipfort__rocblas_1_1rocblas__dgbmv__batched.html "Interface documentation") | C binding 380 | [rocblas_cgbmv_batched](interfacehipfort__rocblas_1_1rocblas__cgbmv__batched.html "Interface documentation") | C binding 381 | [rocblas_zgbmv_batched](interfacehipfort__rocblas_1_1rocblas__zgbmv__batched.html "Interface documentation") | C binding 382 | [rocblas_sgbmv_batched_64](interfacehipfort__rocblas_1_1rocblas__sgbmv__batched__64.html "Interface documentation") | C binding 383 | [rocblas_dgbmv_batched_64](interfacehipfort__rocblas_1_1rocblas__dgbmv__batched__64.html "Interface documentation") | C binding 384 | [rocblas_cgbmv_batched_64](interfacehipfort__rocblas_1_1rocblas__cgbmv__batched__64.html "Interface documentation") | C binding 385 | [rocblas_zgbmv_batched_64](interfacehipfort__rocblas_1_1rocblas__zgbmv__batched__64.html "Interface documentation") | C binding 386 | [rocblas_sgbmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__sgbmv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 387 | [rocblas_dgbmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__dgbmv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 388 | [rocblas_cgbmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__cgbmv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 389 | [rocblas_zgbmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__zgbmv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 390 | [rocblas_sgbmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__sgbmv__strided__batched__64.html "Interface documentation") | C binding 391 | [rocblas_dgbmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dgbmv__strided__batched__64.html "Interface documentation") | C binding 392 | [rocblas_cgbmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__cgbmv__strided__batched__64.html "Interface documentation") | C binding 393 | [rocblas_zgbmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zgbmv__strided__batched__64.html "Interface documentation") | C binding 394 | [rocblas_sgemv](interfacehipfort__rocblas_1_1rocblas__sgemv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 395 | [rocblas_dgemv](interfacehipfort__rocblas_1_1rocblas__dgemv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 396 | [rocblas_cgemv](interfacehipfort__rocblas_1_1rocblas__cgemv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 397 | [rocblas_zgemv](interfacehipfort__rocblas_1_1rocblas__zgemv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 398 | [rocblas_sgemv_64](interfacehipfort__rocblas_1_1rocblas__sgemv__64.html "Interface documentation") | C binding 399 | [rocblas_dgemv_64](interfacehipfort__rocblas_1_1rocblas__dgemv__64.html "Interface documentation") | C binding 400 | [rocblas_cgemv_64](interfacehipfort__rocblas_1_1rocblas__cgemv__64.html "Interface documentation") | C binding 401 | [rocblas_zgemv_64](interfacehipfort__rocblas_1_1rocblas__zgemv__64.html "Interface documentation") | C binding 402 | [rocblas_sgemv_batched](interfacehipfort__rocblas_1_1rocblas__sgemv__batched.html "Interface documentation") | C binding 403 | [rocblas_dgemv_batched](interfacehipfort__rocblas_1_1rocblas__dgemv__batched.html "Interface documentation") | C binding 404 | [rocblas_cgemv_batched](interfacehipfort__rocblas_1_1rocblas__cgemv__batched.html "Interface documentation") | C binding 405 | [rocblas_zgemv_batched](interfacehipfort__rocblas_1_1rocblas__zgemv__batched.html "Interface documentation") | C binding 406 | [rocblas_hshgemv_batched](interfacehipfort__rocblas_1_1rocblas__hshgemv__batched.html "Interface documentation") | C binding 407 | [rocblas_hssgemv_batched](interfacehipfort__rocblas_1_1rocblas__hssgemv__batched.html "Interface documentation") | C binding 408 | [rocblas_tstgemv_batched](interfacehipfort__rocblas_1_1rocblas__tstgemv__batched.html "Interface documentation") | C binding 409 | [rocblas_tssgemv_batched](interfacehipfort__rocblas_1_1rocblas__tssgemv__batched.html "Interface documentation") | C binding 410 | [rocblas_sgemv_batched_64](interfacehipfort__rocblas_1_1rocblas__sgemv__batched__64.html "Interface documentation") | C binding 411 | [rocblas_dgemv_batched_64](interfacehipfort__rocblas_1_1rocblas__dgemv__batched__64.html "Interface documentation") | C binding 412 | [rocblas_cgemv_batched_64](interfacehipfort__rocblas_1_1rocblas__cgemv__batched__64.html "Interface documentation") | C binding 413 | [rocblas_zgemv_batched_64](interfacehipfort__rocblas_1_1rocblas__zgemv__batched__64.html "Interface documentation") | C binding 414 | [rocblas_hshgemv_batched_64](interfacehipfort__rocblas_1_1rocblas__hshgemv__batched__64.html "Interface documentation") | C binding 415 | [rocblas_hssgemv_batched_64](interfacehipfort__rocblas_1_1rocblas__hssgemv__batched__64.html "Interface documentation") | C binding 416 | [rocblas_tstgemv_batched_64](interfacehipfort__rocblas_1_1rocblas__tstgemv__batched__64.html "Interface documentation") | C binding 417 | [rocblas_tssgemv_batched_64](interfacehipfort__rocblas_1_1rocblas__tssgemv__batched__64.html "Interface documentation") | C binding 418 | [rocblas_sgemv_strided_batched](interfacehipfort__rocblas_1_1rocblas__sgemv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 419 | [rocblas_dgemv_strided_batched](interfacehipfort__rocblas_1_1rocblas__dgemv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 420 | [rocblas_cgemv_strided_batched](interfacehipfort__rocblas_1_1rocblas__cgemv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 421 | [rocblas_zgemv_strided_batched](interfacehipfort__rocblas_1_1rocblas__zgemv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 422 | [rocblas_hshgemv_strided_batched](interfacehipfort__rocblas_1_1rocblas__hshgemv__strided__batched.html "Interface documentation") | C binding 423 | [rocblas_hssgemv_strided_batched](interfacehipfort__rocblas_1_1rocblas__hssgemv__strided__batched.html "Interface documentation") | C binding 424 | [rocblas_tstgemv_strided_batched](interfacehipfort__rocblas_1_1rocblas__tstgemv__strided__batched.html "Interface documentation") | C binding 425 | [rocblas_tssgemv_strided_batched](interfacehipfort__rocblas_1_1rocblas__tssgemv__strided__batched.html "Interface documentation") | C binding 426 | [rocblas_sgemv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__sgemv__strided__batched__64.html "Interface documentation") | C binding 427 | [rocblas_dgemv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dgemv__strided__batched__64.html "Interface documentation") | C binding 428 | [rocblas_cgemv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__cgemv__strided__batched__64.html "Interface documentation") | C binding 429 | [rocblas_zgemv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zgemv__strided__batched__64.html "Interface documentation") | C binding 430 | [rocblas_hshgemv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__hshgemv__strided__batched__64.html "Interface documentation") | C binding 431 | [rocblas_hssgemv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__hssgemv__strided__batched__64.html "Interface documentation") | C binding 432 | [rocblas_tstgemv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__tstgemv__strided__batched__64.html "Interface documentation") | C binding 433 | [rocblas_tssgemv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__tssgemv__strided__batched__64.html "Interface documentation") | C binding 434 | [rocblas_chbmv](interfacehipfort__rocblas_1_1rocblas__chbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 435 | [rocblas_zhbmv](interfacehipfort__rocblas_1_1rocblas__zhbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 436 | [rocblas_chbmv_64](interfacehipfort__rocblas_1_1rocblas__chbmv__64.html "Interface documentation") | C binding 437 | [rocblas_zhbmv_64](interfacehipfort__rocblas_1_1rocblas__zhbmv__64.html "Interface documentation") | C binding 438 | [rocblas_chbmv_batched](interfacehipfort__rocblas_1_1rocblas__chbmv__batched.html "Interface documentation") | C binding 439 | [rocblas_zhbmv_batched](interfacehipfort__rocblas_1_1rocblas__zhbmv__batched.html "Interface documentation") | C binding 440 | [rocblas_chbmv_batched_64](interfacehipfort__rocblas_1_1rocblas__chbmv__batched__64.html "Interface documentation") | C binding 441 | [rocblas_zhbmv_batched_64](interfacehipfort__rocblas_1_1rocblas__zhbmv__batched__64.html "Interface documentation") | C binding 442 | [rocblas_chbmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__chbmv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 443 | [rocblas_zhbmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__zhbmv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 444 | [rocblas_chbmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__chbmv__strided__batched__64.html "Interface documentation") | C binding 445 | [rocblas_zhbmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zhbmv__strided__batched__64.html "Interface documentation") | C binding 446 | [rocblas_chemv](interfacehipfort__rocblas_1_1rocblas__chemv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 447 | [rocblas_zhemv](interfacehipfort__rocblas_1_1rocblas__zhemv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 448 | [rocblas_chemv_64](interfacehipfort__rocblas_1_1rocblas__chemv__64.html "Interface documentation") | C binding 449 | [rocblas_zhemv_64](interfacehipfort__rocblas_1_1rocblas__zhemv__64.html "Interface documentation") | C binding 450 | [rocblas_chemv_batched](interfacehipfort__rocblas_1_1rocblas__chemv__batched.html "Interface documentation") | C binding 451 | [rocblas_zhemv_batched](interfacehipfort__rocblas_1_1rocblas__zhemv__batched.html "Interface documentation") | C binding 452 | [rocblas_chemv_batched_64](interfacehipfort__rocblas_1_1rocblas__chemv__batched__64.html "Interface documentation") | C binding 453 | [rocblas_zhemv_batched_64](interfacehipfort__rocblas_1_1rocblas__zhemv__batched__64.html "Interface documentation") | C binding 454 | [rocblas_chemv_strided_batched](interfacehipfort__rocblas_1_1rocblas__chemv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 455 | [rocblas_zhemv_strided_batched](interfacehipfort__rocblas_1_1rocblas__zhemv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 456 | [rocblas_chemv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__chemv__strided__batched__64.html "Interface documentation") | C binding 457 | [rocblas_zhemv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zhemv__strided__batched__64.html "Interface documentation") | C binding 458 | [rocblas_cher](interfacehipfort__rocblas_1_1rocblas__cher.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 459 | [rocblas_zher](interfacehipfort__rocblas_1_1rocblas__zher.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 460 | [rocblas_cher_64](interfacehipfort__rocblas_1_1rocblas__cher__64.html "Interface documentation") | C binding 461 | [rocblas_zher_64](interfacehipfort__rocblas_1_1rocblas__zher__64.html "Interface documentation") | C binding 462 | [rocblas_cher_batched](interfacehipfort__rocblas_1_1rocblas__cher__batched.html "Interface documentation") | C binding 463 | [rocblas_zher_batched](interfacehipfort__rocblas_1_1rocblas__zher__batched.html "Interface documentation") | C binding 464 | [rocblas_cher_batched_64](interfacehipfort__rocblas_1_1rocblas__cher__batched__64.html "Interface documentation") | C binding 465 | [rocblas_zher_batched_64](interfacehipfort__rocblas_1_1rocblas__zher__batched__64.html "Interface documentation") | C binding 466 | [rocblas_cher_strided_batched](interfacehipfort__rocblas_1_1rocblas__cher__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 467 | [rocblas_zher_strided_batched](interfacehipfort__rocblas_1_1rocblas__zher__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 468 | [rocblas_cher_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__cher__strided__batched__64.html "Interface documentation") | C binding 469 | [rocblas_zher_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zher__strided__batched__64.html "Interface documentation") | C binding 470 | [rocblas_cher2](interfacehipfort__rocblas_1_1rocblas__cher2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 471 | [rocblas_zher2](interfacehipfort__rocblas_1_1rocblas__zher2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 472 | [rocblas_cher2_64](interfacehipfort__rocblas_1_1rocblas__cher2__64.html "Interface documentation") | C binding 473 | [rocblas_zher2_64](interfacehipfort__rocblas_1_1rocblas__zher2__64.html "Interface documentation") | C binding 474 | [rocblas_cher2_batched](interfacehipfort__rocblas_1_1rocblas__cher2__batched.html "Interface documentation") | C binding 475 | [rocblas_zher2_batched](interfacehipfort__rocblas_1_1rocblas__zher2__batched.html "Interface documentation") | C binding 476 | [rocblas_cher2_batched_64](interfacehipfort__rocblas_1_1rocblas__cher2__batched__64.html "Interface documentation") | C binding 477 | [rocblas_zher2_batched_64](interfacehipfort__rocblas_1_1rocblas__zher2__batched__64.html "Interface documentation") | C binding 478 | [rocblas_cher2_strided_batched](interfacehipfort__rocblas_1_1rocblas__cher2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 479 | [rocblas_zher2_strided_batched](interfacehipfort__rocblas_1_1rocblas__zher2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 480 | [rocblas_cher2_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__cher2__strided__batched__64.html "Interface documentation") | C binding 481 | [rocblas_zher2_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zher2__strided__batched__64.html "Interface documentation") | C binding 482 | [rocblas_chpmv](interfacehipfort__rocblas_1_1rocblas__chpmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 483 | [rocblas_zhpmv](interfacehipfort__rocblas_1_1rocblas__zhpmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 484 | [rocblas_chpmv_64](interfacehipfort__rocblas_1_1rocblas__chpmv__64.html "Interface documentation") | C binding 485 | [rocblas_zhpmv_64](interfacehipfort__rocblas_1_1rocblas__zhpmv__64.html "Interface documentation") | C binding 486 | [rocblas_chpmv_batched](interfacehipfort__rocblas_1_1rocblas__chpmv__batched.html "Interface documentation") | C binding 487 | [rocblas_zhpmv_batched](interfacehipfort__rocblas_1_1rocblas__zhpmv__batched.html "Interface documentation") | C binding 488 | [rocblas_chpmv_batched_64](interfacehipfort__rocblas_1_1rocblas__chpmv__batched__64.html "Interface documentation") | C binding 489 | [rocblas_zhpmv_batched_64](interfacehipfort__rocblas_1_1rocblas__zhpmv__batched__64.html "Interface documentation") | C binding 490 | [rocblas_chpmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__chpmv__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 491 | [rocblas_zhpmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__zhpmv__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 492 | [rocblas_chpmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__chpmv__strided__batched__64.html "Interface documentation") | C binding 493 | [rocblas_zhpmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zhpmv__strided__batched__64.html "Interface documentation") | C binding 494 | [rocblas_chpr](interfacehipfort__rocblas_1_1rocblas__chpr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 495 | [rocblas_zhpr](interfacehipfort__rocblas_1_1rocblas__zhpr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 496 | [rocblas_chpr_64](interfacehipfort__rocblas_1_1rocblas__chpr__64.html "Interface documentation") | C binding 497 | [rocblas_zhpr_64](interfacehipfort__rocblas_1_1rocblas__zhpr__64.html "Interface documentation") | C binding 498 | [rocblas_chpr_batched](interfacehipfort__rocblas_1_1rocblas__chpr__batched.html "Interface documentation") | C binding 499 | [rocblas_zhpr_batched](interfacehipfort__rocblas_1_1rocblas__zhpr__batched.html "Interface documentation") | C binding 500 | [rocblas_chpr_batched_64](interfacehipfort__rocblas_1_1rocblas__chpr__batched__64.html "Interface documentation") | C binding 501 | [rocblas_zhpr_batched_64](interfacehipfort__rocblas_1_1rocblas__zhpr__batched__64.html "Interface documentation") | C binding 502 | [rocblas_chpr_strided_batched](interfacehipfort__rocblas_1_1rocblas__chpr__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 503 | [rocblas_zhpr_strided_batched](interfacehipfort__rocblas_1_1rocblas__zhpr__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 504 | [rocblas_chpr_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__chpr__strided__batched__64.html "Interface documentation") | C binding 505 | [rocblas_zhpr_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zhpr__strided__batched__64.html "Interface documentation") | C binding 506 | [rocblas_chpr2](interfacehipfort__rocblas_1_1rocblas__chpr2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 507 | [rocblas_zhpr2](interfacehipfort__rocblas_1_1rocblas__zhpr2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 508 | [rocblas_chpr2_64](interfacehipfort__rocblas_1_1rocblas__chpr2__64.html "Interface documentation") | C binding 509 | [rocblas_zhpr2_64](interfacehipfort__rocblas_1_1rocblas__zhpr2__64.html "Interface documentation") | C binding 510 | [rocblas_chpr2_batched](interfacehipfort__rocblas_1_1rocblas__chpr2__batched.html "Interface documentation") | C binding 511 | [rocblas_zhpr2_batched](interfacehipfort__rocblas_1_1rocblas__zhpr2__batched.html "Interface documentation") | C binding 512 | [rocblas_chpr2_batched_64](interfacehipfort__rocblas_1_1rocblas__chpr2__batched__64.html "Interface documentation") | C binding 513 | [rocblas_zhpr2_batched_64](interfacehipfort__rocblas_1_1rocblas__zhpr2__batched__64.html "Interface documentation") | C binding 514 | [rocblas_chpr2_strided_batched](interfacehipfort__rocblas_1_1rocblas__chpr2__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 515 | [rocblas_zhpr2_strided_batched](interfacehipfort__rocblas_1_1rocblas__zhpr2__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 516 | [rocblas_chpr2_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__chpr2__strided__batched__64.html "Interface documentation") | C binding 517 | [rocblas_zhpr2_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zhpr2__strided__batched__64.html "Interface documentation") | C binding 518 | [rocblas_strmv](interfacehipfort__rocblas_1_1rocblas__strmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 519 | [rocblas_dtrmv](interfacehipfort__rocblas_1_1rocblas__dtrmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 520 | [rocblas_ctrmv](interfacehipfort__rocblas_1_1rocblas__ctrmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 521 | [rocblas_ztrmv](interfacehipfort__rocblas_1_1rocblas__ztrmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 522 | [rocblas_strmv_64](interfacehipfort__rocblas_1_1rocblas__strmv__64.html "Interface documentation") | C binding 523 | [rocblas_dtrmv_64](interfacehipfort__rocblas_1_1rocblas__dtrmv__64.html "Interface documentation") | C binding 524 | [rocblas_ctrmv_64](interfacehipfort__rocblas_1_1rocblas__ctrmv__64.html "Interface documentation") | C binding 525 | [rocblas_ztrmv_64](interfacehipfort__rocblas_1_1rocblas__ztrmv__64.html "Interface documentation") | C binding 526 | [rocblas_strmv_batched](interfacehipfort__rocblas_1_1rocblas__strmv__batched.html "Interface documentation") | C binding 527 | [rocblas_dtrmv_batched](interfacehipfort__rocblas_1_1rocblas__dtrmv__batched.html "Interface documentation") | C binding 528 | [rocblas_ctrmv_batched](interfacehipfort__rocblas_1_1rocblas__ctrmv__batched.html "Interface documentation") | C binding 529 | [rocblas_ztrmv_batched](interfacehipfort__rocblas_1_1rocblas__ztrmv__batched.html "Interface documentation") | C binding 530 | [rocblas_strmv_batched_64](interfacehipfort__rocblas_1_1rocblas__strmv__batched__64.html "Interface documentation") | C binding 531 | [rocblas_dtrmv_batched_64](interfacehipfort__rocblas_1_1rocblas__dtrmv__batched__64.html "Interface documentation") | C binding 532 | [rocblas_ctrmv_batched_64](interfacehipfort__rocblas_1_1rocblas__ctrmv__batched__64.html "Interface documentation") | C binding 533 | [rocblas_ztrmv_batched_64](interfacehipfort__rocblas_1_1rocblas__ztrmv__batched__64.html "Interface documentation") | C binding 534 | [rocblas_strmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__strmv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 535 | [rocblas_dtrmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__dtrmv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 536 | [rocblas_ctrmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__ctrmv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 537 | [rocblas_ztrmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__ztrmv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 538 | [rocblas_strmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__strmv__strided__batched__64.html "Interface documentation") | C binding 539 | [rocblas_dtrmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dtrmv__strided__batched__64.html "Interface documentation") | C binding 540 | [rocblas_ctrmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ctrmv__strided__batched__64.html "Interface documentation") | C binding 541 | [rocblas_ztrmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ztrmv__strided__batched__64.html "Interface documentation") | C binding 542 | [rocblas_stpmv](interfacehipfort__rocblas_1_1rocblas__stpmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 543 | [rocblas_dtpmv](interfacehipfort__rocblas_1_1rocblas__dtpmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 544 | [rocblas_ctpmv](interfacehipfort__rocblas_1_1rocblas__ctpmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 545 | [rocblas_ztpmv](interfacehipfort__rocblas_1_1rocblas__ztpmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 546 | [rocblas_stpmv_64](interfacehipfort__rocblas_1_1rocblas__stpmv__64.html "Interface documentation") | C binding 547 | [rocblas_dtpmv_64](interfacehipfort__rocblas_1_1rocblas__dtpmv__64.html "Interface documentation") | C binding 548 | [rocblas_ctpmv_64](interfacehipfort__rocblas_1_1rocblas__ctpmv__64.html "Interface documentation") | C binding 549 | [rocblas_ztpmv_64](interfacehipfort__rocblas_1_1rocblas__ztpmv__64.html "Interface documentation") | C binding 550 | [rocblas_stpmv_batched](interfacehipfort__rocblas_1_1rocblas__stpmv__batched.html "Interface documentation") | C binding 551 | [rocblas_dtpmv_batched](interfacehipfort__rocblas_1_1rocblas__dtpmv__batched.html "Interface documentation") | C binding 552 | [rocblas_ctpmv_batched](interfacehipfort__rocblas_1_1rocblas__ctpmv__batched.html "Interface documentation") | C binding 553 | [rocblas_ztpmv_batched](interfacehipfort__rocblas_1_1rocblas__ztpmv__batched.html "Interface documentation") | C binding 554 | [rocblas_stpmv_batched_64](interfacehipfort__rocblas_1_1rocblas__stpmv__batched__64.html "Interface documentation") | C binding 555 | [rocblas_dtpmv_batched_64](interfacehipfort__rocblas_1_1rocblas__dtpmv__batched__64.html "Interface documentation") | C binding 556 | [rocblas_ctpmv_batched_64](interfacehipfort__rocblas_1_1rocblas__ctpmv__batched__64.html "Interface documentation") | C binding 557 | [rocblas_ztpmv_batched_64](interfacehipfort__rocblas_1_1rocblas__ztpmv__batched__64.html "Interface documentation") | C binding 558 | [rocblas_stpmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__stpmv__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 559 | [rocblas_dtpmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__dtpmv__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 560 | [rocblas_ctpmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__ctpmv__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 561 | [rocblas_ztpmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__ztpmv__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 562 | [rocblas_stpmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__stpmv__strided__batched__64.html "Interface documentation") | C binding 563 | [rocblas_dtpmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dtpmv__strided__batched__64.html "Interface documentation") | C binding 564 | [rocblas_ctpmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ctpmv__strided__batched__64.html "Interface documentation") | C binding 565 | [rocblas_ztpmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ztpmv__strided__batched__64.html "Interface documentation") | C binding 566 | [rocblas_stbmv](interfacehipfort__rocblas_1_1rocblas__stbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 567 | [rocblas_dtbmv](interfacehipfort__rocblas_1_1rocblas__dtbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 568 | [rocblas_ctbmv](interfacehipfort__rocblas_1_1rocblas__ctbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 569 | [rocblas_ztbmv](interfacehipfort__rocblas_1_1rocblas__ztbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 570 | [rocblas_stbmv_64](interfacehipfort__rocblas_1_1rocblas__stbmv__64.html "Interface documentation") | C binding 571 | [rocblas_dtbmv_64](interfacehipfort__rocblas_1_1rocblas__dtbmv__64.html "Interface documentation") | C binding 572 | [rocblas_ctbmv_64](interfacehipfort__rocblas_1_1rocblas__ctbmv__64.html "Interface documentation") | C binding 573 | [rocblas_ztbmv_64](interfacehipfort__rocblas_1_1rocblas__ztbmv__64.html "Interface documentation") | C binding 574 | [rocblas_stbmv_batched](interfacehipfort__rocblas_1_1rocblas__stbmv__batched.html "Interface documentation") | C binding 575 | [rocblas_dtbmv_batched](interfacehipfort__rocblas_1_1rocblas__dtbmv__batched.html "Interface documentation") | C binding 576 | [rocblas_ctbmv_batched](interfacehipfort__rocblas_1_1rocblas__ctbmv__batched.html "Interface documentation") | C binding 577 | [rocblas_ztbmv_batched](interfacehipfort__rocblas_1_1rocblas__ztbmv__batched.html "Interface documentation") | C binding 578 | [rocblas_stbmv_batched_64](interfacehipfort__rocblas_1_1rocblas__stbmv__batched__64.html "Interface documentation") | C binding 579 | [rocblas_dtbmv_batched_64](interfacehipfort__rocblas_1_1rocblas__dtbmv__batched__64.html "Interface documentation") | C binding 580 | [rocblas_ctbmv_batched_64](interfacehipfort__rocblas_1_1rocblas__ctbmv__batched__64.html "Interface documentation") | C binding 581 | [rocblas_ztbmv_batched_64](interfacehipfort__rocblas_1_1rocblas__ztbmv__batched__64.html "Interface documentation") | C binding 582 | [rocblas_stbmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__stbmv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 583 | [rocblas_dtbmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__dtbmv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 584 | [rocblas_ctbmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__ctbmv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 585 | [rocblas_ztbmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__ztbmv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 586 | [rocblas_stbmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__stbmv__strided__batched__64.html "Interface documentation") | C binding 587 | [rocblas_dtbmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dtbmv__strided__batched__64.html "Interface documentation") | C binding 588 | [rocblas_ctbmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ctbmv__strided__batched__64.html "Interface documentation") | C binding 589 | [rocblas_ztbmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ztbmv__strided__batched__64.html "Interface documentation") | C binding 590 | [rocblas_stbsv](interfacehipfort__rocblas_1_1rocblas__stbsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 591 | [rocblas_dtbsv](interfacehipfort__rocblas_1_1rocblas__dtbsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 592 | [rocblas_ctbsv](interfacehipfort__rocblas_1_1rocblas__ctbsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 593 | [rocblas_ztbsv](interfacehipfort__rocblas_1_1rocblas__ztbsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 594 | [rocblas_stbsv_64](interfacehipfort__rocblas_1_1rocblas__stbsv__64.html "Interface documentation") | C binding 595 | [rocblas_dtbsv_64](interfacehipfort__rocblas_1_1rocblas__dtbsv__64.html "Interface documentation") | C binding 596 | [rocblas_ctbsv_64](interfacehipfort__rocblas_1_1rocblas__ctbsv__64.html "Interface documentation") | C binding 597 | [rocblas_ztbsv_64](interfacehipfort__rocblas_1_1rocblas__ztbsv__64.html "Interface documentation") | C binding 598 | [rocblas_stbsv_batched](interfacehipfort__rocblas_1_1rocblas__stbsv__batched.html "Interface documentation") | C binding 599 | [rocblas_dtbsv_batched](interfacehipfort__rocblas_1_1rocblas__dtbsv__batched.html "Interface documentation") | C binding 600 | [rocblas_ctbsv_batched](interfacehipfort__rocblas_1_1rocblas__ctbsv__batched.html "Interface documentation") | C binding 601 | [rocblas_ztbsv_batched](interfacehipfort__rocblas_1_1rocblas__ztbsv__batched.html "Interface documentation") | C binding 602 | [rocblas_stbsv_batched_64](interfacehipfort__rocblas_1_1rocblas__stbsv__batched__64.html "Interface documentation") | C binding 603 | [rocblas_dtbsv_batched_64](interfacehipfort__rocblas_1_1rocblas__dtbsv__batched__64.html "Interface documentation") | C binding 604 | [rocblas_ctbsv_batched_64](interfacehipfort__rocblas_1_1rocblas__ctbsv__batched__64.html "Interface documentation") | C binding 605 | [rocblas_ztbsv_batched_64](interfacehipfort__rocblas_1_1rocblas__ztbsv__batched__64.html "Interface documentation") | C binding 606 | [rocblas_stbsv_strided_batched](interfacehipfort__rocblas_1_1rocblas__stbsv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 607 | [rocblas_dtbsv_strided_batched](interfacehipfort__rocblas_1_1rocblas__dtbsv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 608 | [rocblas_ctbsv_strided_batched](interfacehipfort__rocblas_1_1rocblas__ctbsv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 609 | [rocblas_ztbsv_strided_batched](interfacehipfort__rocblas_1_1rocblas__ztbsv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 610 | [rocblas_stbsv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__stbsv__strided__batched__64.html "Interface documentation") | C binding 611 | [rocblas_dtbsv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dtbsv__strided__batched__64.html "Interface documentation") | C binding 612 | [rocblas_ctbsv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ctbsv__strided__batched__64.html "Interface documentation") | C binding 613 | [rocblas_ztbsv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ztbsv__strided__batched__64.html "Interface documentation") | C binding 614 | [rocblas_strsv](interfacehipfort__rocblas_1_1rocblas__strsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 615 | [rocblas_dtrsv](interfacehipfort__rocblas_1_1rocblas__dtrsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 616 | [rocblas_ctrsv](interfacehipfort__rocblas_1_1rocblas__ctrsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 617 | [rocblas_ztrsv](interfacehipfort__rocblas_1_1rocblas__ztrsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 618 | [rocblas_strsv_64](interfacehipfort__rocblas_1_1rocblas__strsv__64.html "Interface documentation") | C binding 619 | [rocblas_dtrsv_64](interfacehipfort__rocblas_1_1rocblas__dtrsv__64.html "Interface documentation") | C binding 620 | [rocblas_ctrsv_64](interfacehipfort__rocblas_1_1rocblas__ctrsv__64.html "Interface documentation") | C binding 621 | [rocblas_ztrsv_64](interfacehipfort__rocblas_1_1rocblas__ztrsv__64.html "Interface documentation") | C binding 622 | [rocblas_strsv_batched](interfacehipfort__rocblas_1_1rocblas__strsv__batched.html "Interface documentation") | C binding 623 | [rocblas_dtrsv_batched](interfacehipfort__rocblas_1_1rocblas__dtrsv__batched.html "Interface documentation") | C binding 624 | [rocblas_ctrsv_batched](interfacehipfort__rocblas_1_1rocblas__ctrsv__batched.html "Interface documentation") | C binding 625 | [rocblas_ztrsv_batched](interfacehipfort__rocblas_1_1rocblas__ztrsv__batched.html "Interface documentation") | C binding 626 | [rocblas_strsv_batched_64](interfacehipfort__rocblas_1_1rocblas__strsv__batched__64.html "Interface documentation") | C binding 627 | [rocblas_dtrsv_batched_64](interfacehipfort__rocblas_1_1rocblas__dtrsv__batched__64.html "Interface documentation") | C binding 628 | [rocblas_ctrsv_batched_64](interfacehipfort__rocblas_1_1rocblas__ctrsv__batched__64.html "Interface documentation") | C binding 629 | [rocblas_ztrsv_batched_64](interfacehipfort__rocblas_1_1rocblas__ztrsv__batched__64.html "Interface documentation") | C binding 630 | [rocblas_strsv_strided_batched](interfacehipfort__rocblas_1_1rocblas__strsv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 631 | [rocblas_dtrsv_strided_batched](interfacehipfort__rocblas_1_1rocblas__dtrsv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 632 | [rocblas_ctrsv_strided_batched](interfacehipfort__rocblas_1_1rocblas__ctrsv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 633 | [rocblas_ztrsv_strided_batched](interfacehipfort__rocblas_1_1rocblas__ztrsv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 634 | [rocblas_strsv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__strsv__strided__batched__64.html "Interface documentation") | C binding 635 | [rocblas_dtrsv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dtrsv__strided__batched__64.html "Interface documentation") | C binding 636 | [rocblas_ctrsv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ctrsv__strided__batched__64.html "Interface documentation") | C binding 637 | [rocblas_ztrsv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ztrsv__strided__batched__64.html "Interface documentation") | C binding 638 | [rocblas_stpsv](interfacehipfort__rocblas_1_1rocblas__stpsv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 639 | [rocblas_dtpsv](interfacehipfort__rocblas_1_1rocblas__dtpsv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 640 | [rocblas_ctpsv](interfacehipfort__rocblas_1_1rocblas__ctpsv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 641 | [rocblas_ztpsv](interfacehipfort__rocblas_1_1rocblas__ztpsv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 642 | [rocblas_stpsv_64](interfacehipfort__rocblas_1_1rocblas__stpsv__64.html "Interface documentation") | C binding 643 | [rocblas_dtpsv_64](interfacehipfort__rocblas_1_1rocblas__dtpsv__64.html "Interface documentation") | C binding 644 | [rocblas_ctpsv_64](interfacehipfort__rocblas_1_1rocblas__ctpsv__64.html "Interface documentation") | C binding 645 | [rocblas_ztpsv_64](interfacehipfort__rocblas_1_1rocblas__ztpsv__64.html "Interface documentation") | C binding 646 | [rocblas_stpsv_batched](interfacehipfort__rocblas_1_1rocblas__stpsv__batched.html "Interface documentation") | C binding 647 | [rocblas_dtpsv_batched](interfacehipfort__rocblas_1_1rocblas__dtpsv__batched.html "Interface documentation") | C binding 648 | [rocblas_ctpsv_batched](interfacehipfort__rocblas_1_1rocblas__ctpsv__batched.html "Interface documentation") | C binding 649 | [rocblas_ztpsv_batched](interfacehipfort__rocblas_1_1rocblas__ztpsv__batched.html "Interface documentation") | C binding 650 | [rocblas_stpsv_batched_64](interfacehipfort__rocblas_1_1rocblas__stpsv__batched__64.html "Interface documentation") | C binding 651 | [rocblas_dtpsv_batched_64](interfacehipfort__rocblas_1_1rocblas__dtpsv__batched__64.html "Interface documentation") | C binding 652 | [rocblas_ctpsv_batched_64](interfacehipfort__rocblas_1_1rocblas__ctpsv__batched__64.html "Interface documentation") | C binding 653 | [rocblas_ztpsv_batched_64](interfacehipfort__rocblas_1_1rocblas__ztpsv__batched__64.html "Interface documentation") | C binding 654 | [rocblas_stpsv_strided_batched](interfacehipfort__rocblas_1_1rocblas__stpsv__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 655 | [rocblas_dtpsv_strided_batched](interfacehipfort__rocblas_1_1rocblas__dtpsv__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 656 | [rocblas_ctpsv_strided_batched](interfacehipfort__rocblas_1_1rocblas__ctpsv__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 657 | [rocblas_ztpsv_strided_batched](interfacehipfort__rocblas_1_1rocblas__ztpsv__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 658 | [rocblas_stpsv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__stpsv__strided__batched__64.html "Interface documentation") | C binding 659 | [rocblas_dtpsv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dtpsv__strided__batched__64.html "Interface documentation") | C binding 660 | [rocblas_ctpsv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ctpsv__strided__batched__64.html "Interface documentation") | C binding 661 | [rocblas_ztpsv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ztpsv__strided__batched__64.html "Interface documentation") | C binding 662 | [rocblas_ssymv](interfacehipfort__rocblas_1_1rocblas__ssymv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 663 | [rocblas_dsymv](interfacehipfort__rocblas_1_1rocblas__dsymv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 664 | [rocblas_csymv](interfacehipfort__rocblas_1_1rocblas__csymv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 665 | [rocblas_zsymv](interfacehipfort__rocblas_1_1rocblas__zsymv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 666 | [rocblas_ssymv_64](interfacehipfort__rocblas_1_1rocblas__ssymv__64.html "Interface documentation") | C binding 667 | [rocblas_dsymv_64](interfacehipfort__rocblas_1_1rocblas__dsymv__64.html "Interface documentation") | C binding 668 | [rocblas_csymv_64](interfacehipfort__rocblas_1_1rocblas__csymv__64.html "Interface documentation") | C binding 669 | [rocblas_zsymv_64](interfacehipfort__rocblas_1_1rocblas__zsymv__64.html "Interface documentation") | C binding 670 | [rocblas_ssymv_batched](interfacehipfort__rocblas_1_1rocblas__ssymv__batched.html "Interface documentation") | C binding 671 | [rocblas_dsymv_batched](interfacehipfort__rocblas_1_1rocblas__dsymv__batched.html "Interface documentation") | C binding 672 | [rocblas_csymv_batched](interfacehipfort__rocblas_1_1rocblas__csymv__batched.html "Interface documentation") | C binding 673 | [rocblas_zsymv_batched](interfacehipfort__rocblas_1_1rocblas__zsymv__batched.html "Interface documentation") | C binding 674 | [rocblas_ssymv_batched_64](interfacehipfort__rocblas_1_1rocblas__ssymv__batched__64.html "Interface documentation") | C binding 675 | [rocblas_dsymv_batched_64](interfacehipfort__rocblas_1_1rocblas__dsymv__batched__64.html "Interface documentation") | C binding 676 | [rocblas_csymv_batched_64](interfacehipfort__rocblas_1_1rocblas__csymv__batched__64.html "Interface documentation") | C binding 677 | [rocblas_zsymv_batched_64](interfacehipfort__rocblas_1_1rocblas__zsymv__batched__64.html "Interface documentation") | C binding 678 | [rocblas_ssymv_strided_batched](interfacehipfort__rocblas_1_1rocblas__ssymv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 679 | [rocblas_dsymv_strided_batched](interfacehipfort__rocblas_1_1rocblas__dsymv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 680 | [rocblas_csymv_strided_batched](interfacehipfort__rocblas_1_1rocblas__csymv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 681 | [rocblas_zsymv_strided_batched](interfacehipfort__rocblas_1_1rocblas__zsymv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 682 | [rocblas_ssymv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ssymv__strided__batched__64.html "Interface documentation") | C binding 683 | [rocblas_dsymv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dsymv__strided__batched__64.html "Interface documentation") | C binding 684 | [rocblas_csymv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__csymv__strided__batched__64.html "Interface documentation") | C binding 685 | [rocblas_zsymv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zsymv__strided__batched__64.html "Interface documentation") | C binding 686 | [rocblas_sspmv](interfacehipfort__rocblas_1_1rocblas__sspmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 687 | [rocblas_dspmv](interfacehipfort__rocblas_1_1rocblas__dspmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 688 | [rocblas_sspmv_64](interfacehipfort__rocblas_1_1rocblas__sspmv__64.html "Interface documentation") | C binding 689 | [rocblas_dspmv_64](interfacehipfort__rocblas_1_1rocblas__dspmv__64.html "Interface documentation") | C binding 690 | [rocblas_sspmv_batched](interfacehipfort__rocblas_1_1rocblas__sspmv__batched.html "Interface documentation") | C binding 691 | [rocblas_dspmv_batched](interfacehipfort__rocblas_1_1rocblas__dspmv__batched.html "Interface documentation") | C binding 692 | [rocblas_sspmv_batched_64](interfacehipfort__rocblas_1_1rocblas__sspmv__batched__64.html "Interface documentation") | C binding 693 | [rocblas_dspmv_batched_64](interfacehipfort__rocblas_1_1rocblas__dspmv__batched__64.html "Interface documentation") | C binding 694 | [rocblas_sspmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__sspmv__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 695 | [rocblas_dspmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__dspmv__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 696 | [rocblas_sspmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__sspmv__strided__batched__64.html "Interface documentation") | C binding 697 | [rocblas_dspmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dspmv__strided__batched__64.html "Interface documentation") | C binding 698 | [rocblas_ssbmv](interfacehipfort__rocblas_1_1rocblas__ssbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 699 | [rocblas_dsbmv](interfacehipfort__rocblas_1_1rocblas__dsbmv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 700 | [rocblas_ssbmv_64](interfacehipfort__rocblas_1_1rocblas__ssbmv__64.html "Interface documentation") | C binding 701 | [rocblas_dsbmv_64](interfacehipfort__rocblas_1_1rocblas__dsbmv__64.html "Interface documentation") | C binding 702 | [rocblas_ssbmv_batched](interfacehipfort__rocblas_1_1rocblas__ssbmv__batched.html "Interface documentation") | C binding 703 | [rocblas_dsbmv_batched](interfacehipfort__rocblas_1_1rocblas__dsbmv__batched.html "Interface documentation") | C binding 704 | [rocblas_ssbmv_batched_64](interfacehipfort__rocblas_1_1rocblas__ssbmv__batched__64.html "Interface documentation") | C binding 705 | [rocblas_dsbmv_batched_64](interfacehipfort__rocblas_1_1rocblas__dsbmv__batched__64.html "Interface documentation") | C binding 706 | [rocblas_ssbmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__ssbmv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 707 | [rocblas_dsbmv_strided_batched](interfacehipfort__rocblas_1_1rocblas__dsbmv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 708 | [rocblas_ssbmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ssbmv__strided__batched__64.html "Interface documentation") | C binding 709 | [rocblas_dsbmv_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dsbmv__strided__batched__64.html "Interface documentation") | C binding 710 | [rocblas_sger](interfacehipfort__rocblas_1_1rocblas__sger.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 711 | [rocblas_dger](interfacehipfort__rocblas_1_1rocblas__dger.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 712 | [rocblas_cgeru](interfacehipfort__rocblas_1_1rocblas__cgeru.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 713 | [rocblas_zgeru](interfacehipfort__rocblas_1_1rocblas__zgeru.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 714 | [rocblas_cgerc](interfacehipfort__rocblas_1_1rocblas__cgerc.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 715 | [rocblas_zgerc](interfacehipfort__rocblas_1_1rocblas__zgerc.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 716 | [rocblas_sger_64](interfacehipfort__rocblas_1_1rocblas__sger__64.html "Interface documentation") | C binding 717 | [rocblas_dger_64](interfacehipfort__rocblas_1_1rocblas__dger__64.html "Interface documentation") | C binding 718 | [rocblas_cgeru_64](interfacehipfort__rocblas_1_1rocblas__cgeru__64.html "Interface documentation") | C binding 719 | [rocblas_zgeru_64](interfacehipfort__rocblas_1_1rocblas__zgeru__64.html "Interface documentation") | C binding 720 | [rocblas_cgerc_64](interfacehipfort__rocblas_1_1rocblas__cgerc__64.html "Interface documentation") | C binding 721 | [rocblas_zgerc_64](interfacehipfort__rocblas_1_1rocblas__zgerc__64.html "Interface documentation") | C binding 722 | [rocblas_sger_batched](interfacehipfort__rocblas_1_1rocblas__sger__batched.html "Interface documentation") | C binding 723 | [rocblas_dger_batched](interfacehipfort__rocblas_1_1rocblas__dger__batched.html "Interface documentation") | C binding 724 | [rocblas_cgeru_batched](interfacehipfort__rocblas_1_1rocblas__cgeru__batched.html "Interface documentation") | C binding 725 | [rocblas_zgeru_batched](interfacehipfort__rocblas_1_1rocblas__zgeru__batched.html "Interface documentation") | C binding 726 | [rocblas_cgerc_batched](interfacehipfort__rocblas_1_1rocblas__cgerc__batched.html "Interface documentation") | C binding 727 | [rocblas_zgerc_batched](interfacehipfort__rocblas_1_1rocblas__zgerc__batched.html "Interface documentation") | C binding 728 | [rocblas_sger_batched_64](interfacehipfort__rocblas_1_1rocblas__sger__batched__64.html "Interface documentation") | C binding 729 | [rocblas_dger_batched_64](interfacehipfort__rocblas_1_1rocblas__dger__batched__64.html "Interface documentation") | C binding 730 | [rocblas_cgeru_batched_64](interfacehipfort__rocblas_1_1rocblas__cgeru__batched__64.html "Interface documentation") | C binding 731 | [rocblas_zgeru_batched_64](interfacehipfort__rocblas_1_1rocblas__zgeru__batched__64.html "Interface documentation") | C binding 732 | [rocblas_cgerc_batched_64](interfacehipfort__rocblas_1_1rocblas__cgerc__batched__64.html "Interface documentation") | C binding 733 | [rocblas_zgerc_batched_64](interfacehipfort__rocblas_1_1rocblas__zgerc__batched__64.html "Interface documentation") | C binding 734 | [rocblas_sger_strided_batched](interfacehipfort__rocblas_1_1rocblas__sger__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 735 | [rocblas_dger_strided_batched](interfacehipfort__rocblas_1_1rocblas__dger__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 736 | [rocblas_cgeru_strided_batched](interfacehipfort__rocblas_1_1rocblas__cgeru__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 737 | [rocblas_zgeru_strided_batched](interfacehipfort__rocblas_1_1rocblas__zgeru__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 738 | [rocblas_cgerc_strided_batched](interfacehipfort__rocblas_1_1rocblas__cgerc__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 739 | [rocblas_zgerc_strided_batched](interfacehipfort__rocblas_1_1rocblas__zgerc__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 740 | [rocblas_sger_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__sger__strided__batched__64.html "Interface documentation") | C binding 741 | [rocblas_dger_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dger__strided__batched__64.html "Interface documentation") | C binding 742 | [rocblas_cgeru_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__cgeru__strided__batched__64.html "Interface documentation") | C binding 743 | [rocblas_zgeru_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zgeru__strided__batched__64.html "Interface documentation") | C binding 744 | [rocblas_cgerc_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__cgerc__strided__batched__64.html "Interface documentation") | C binding 745 | [rocblas_zgerc_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zgerc__strided__batched__64.html "Interface documentation") | C binding 746 | [rocblas_sspr](interfacehipfort__rocblas_1_1rocblas__sspr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 747 | [rocblas_dspr](interfacehipfort__rocblas_1_1rocblas__dspr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 748 | [rocblas_cspr](interfacehipfort__rocblas_1_1rocblas__cspr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 749 | [rocblas_zspr](interfacehipfort__rocblas_1_1rocblas__zspr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 750 | [rocblas_sspr_64](interfacehipfort__rocblas_1_1rocblas__sspr__64.html "Interface documentation") | C binding 751 | [rocblas_dspr_64](interfacehipfort__rocblas_1_1rocblas__dspr__64.html "Interface documentation") | C binding 752 | [rocblas_cspr_64](interfacehipfort__rocblas_1_1rocblas__cspr__64.html "Interface documentation") | C binding 753 | [rocblas_zspr_64](interfacehipfort__rocblas_1_1rocblas__zspr__64.html "Interface documentation") | C binding 754 | [rocblas_sspr_batched](interfacehipfort__rocblas_1_1rocblas__sspr__batched.html "Interface documentation") | C binding 755 | [rocblas_dspr_batched](interfacehipfort__rocblas_1_1rocblas__dspr__batched.html "Interface documentation") | C binding 756 | [rocblas_cspr_batched](interfacehipfort__rocblas_1_1rocblas__cspr__batched.html "Interface documentation") | C binding 757 | [rocblas_zspr_batched](interfacehipfort__rocblas_1_1rocblas__zspr__batched.html "Interface documentation") | C binding 758 | [rocblas_sspr_batched_64](interfacehipfort__rocblas_1_1rocblas__sspr__batched__64.html "Interface documentation") | C binding 759 | [rocblas_dspr_batched_64](interfacehipfort__rocblas_1_1rocblas__dspr__batched__64.html "Interface documentation") | C binding 760 | [rocblas_cspr_batched_64](interfacehipfort__rocblas_1_1rocblas__cspr__batched__64.html "Interface documentation") | C binding 761 | [rocblas_zspr_batched_64](interfacehipfort__rocblas_1_1rocblas__zspr__batched__64.html "Interface documentation") | C binding 762 | [rocblas_sspr_strided_batched](interfacehipfort__rocblas_1_1rocblas__sspr__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 763 | [rocblas_dspr_strided_batched](interfacehipfort__rocblas_1_1rocblas__dspr__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 764 | [rocblas_cspr_strided_batched](interfacehipfort__rocblas_1_1rocblas__cspr__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 765 | [rocblas_zspr_strided_batched](interfacehipfort__rocblas_1_1rocblas__zspr__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 766 | [rocblas_sspr_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__sspr__strided__batched__64.html "Interface documentation") | C binding 767 | [rocblas_dspr_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dspr__strided__batched__64.html "Interface documentation") | C binding 768 | [rocblas_cspr_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__cspr__strided__batched__64.html "Interface documentation") | C binding 769 | [rocblas_zspr_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zspr__strided__batched__64.html "Interface documentation") | C binding 770 | [rocblas_sspr2](interfacehipfort__rocblas_1_1rocblas__sspr2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 771 | [rocblas_dspr2](interfacehipfort__rocblas_1_1rocblas__dspr2.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 772 | [rocblas_sspr2_64](interfacehipfort__rocblas_1_1rocblas__sspr2__64.html "Interface documentation") | C binding 773 | [rocblas_dspr2_64](interfacehipfort__rocblas_1_1rocblas__dspr2__64.html "Interface documentation") | C binding 774 | [rocblas_sspr2_batched](interfacehipfort__rocblas_1_1rocblas__sspr2__batched.html "Interface documentation") | C binding 775 | [rocblas_dspr2_batched](interfacehipfort__rocblas_1_1rocblas__dspr2__batched.html "Interface documentation") | C binding 776 | [rocblas_sspr2_batched_64](interfacehipfort__rocblas_1_1rocblas__sspr2__batched__64.html "Interface documentation") | C binding 777 | [rocblas_dspr2_batched_64](interfacehipfort__rocblas_1_1rocblas__dspr2__batched__64.html "Interface documentation") | C binding 778 | [rocblas_sspr2_strided_batched](interfacehipfort__rocblas_1_1rocblas__sspr2__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 779 | [rocblas_dspr2_strided_batched](interfacehipfort__rocblas_1_1rocblas__dspr2__strided__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 780 | [rocblas_sspr2_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__sspr2__strided__batched__64.html "Interface documentation") | C binding 781 | [rocblas_dspr2_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dspr2__strided__batched__64.html "Interface documentation") | C binding 782 | [rocblas_ssyr](interfacehipfort__rocblas_1_1rocblas__ssyr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 783 | [rocblas_dsyr](interfacehipfort__rocblas_1_1rocblas__dsyr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 784 | [rocblas_csyr](interfacehipfort__rocblas_1_1rocblas__csyr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 785 | [rocblas_zsyr](interfacehipfort__rocblas_1_1rocblas__zsyr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 786 | [rocblas_ssyr_64](interfacehipfort__rocblas_1_1rocblas__ssyr__64.html "Interface documentation") | C binding 787 | [rocblas_dsyr_64](interfacehipfort__rocblas_1_1rocblas__dsyr__64.html "Interface documentation") | C binding 788 | [rocblas_csyr_64](interfacehipfort__rocblas_1_1rocblas__csyr__64.html "Interface documentation") | C binding 789 | [rocblas_zsyr_64](interfacehipfort__rocblas_1_1rocblas__zsyr__64.html "Interface documentation") | C binding 790 | [rocblas_ssyr_batched](interfacehipfort__rocblas_1_1rocblas__ssyr__batched.html "Interface documentation") | C binding 791 | [rocblas_dsyr_batched](interfacehipfort__rocblas_1_1rocblas__dsyr__batched.html "Interface documentation") | C binding 792 | [rocblas_csyr_batched](interfacehipfort__rocblas_1_1rocblas__csyr__batched.html "Interface documentation") | C binding 793 | [rocblas_zsyr_batched](interfacehipfort__rocblas_1_1rocblas__zsyr__batched.html "Interface documentation") | C binding 794 | [rocblas_ssyr_batched_64](interfacehipfort__rocblas_1_1rocblas__ssyr__batched__64.html "Interface documentation") | C binding 795 | [rocblas_dsyr_batched_64](interfacehipfort__rocblas_1_1rocblas__dsyr__batched__64.html "Interface documentation") | C binding 796 | [rocblas_csyr_batched_64](interfacehipfort__rocblas_1_1rocblas__csyr__batched__64.html "Interface documentation") | C binding 797 | [rocblas_zsyr_batched_64](interfacehipfort__rocblas_1_1rocblas__zsyr__batched__64.html "Interface documentation") | C binding 798 | [rocblas_ssyr_strided_batched](interfacehipfort__rocblas_1_1rocblas__ssyr__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 799 | [rocblas_dsyr_strided_batched](interfacehipfort__rocblas_1_1rocblas__dsyr__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 800 | [rocblas_csyr_strided_batched](interfacehipfort__rocblas_1_1rocblas__csyr__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 801 | [rocblas_zsyr_strided_batched](interfacehipfort__rocblas_1_1rocblas__zsyr__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 802 | [rocblas_ssyr_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ssyr__strided__batched__64.html "Interface documentation") | C binding 803 | [rocblas_dsyr_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dsyr__strided__batched__64.html "Interface documentation") | C binding 804 | [rocblas_csyr_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__csyr__strided__batched__64.html "Interface documentation") | C binding 805 | [rocblas_zsyr_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zsyr__strided__batched__64.html "Interface documentation") | C binding 806 | [rocblas_ssyr2](interfacehipfort__rocblas_1_1rocblas__ssyr2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 807 | [rocblas_dsyr2](interfacehipfort__rocblas_1_1rocblas__dsyr2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 808 | [rocblas_csyr2](interfacehipfort__rocblas_1_1rocblas__csyr2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 809 | [rocblas_zsyr2](interfacehipfort__rocblas_1_1rocblas__zsyr2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 810 | [rocblas_ssyr2_64](interfacehipfort__rocblas_1_1rocblas__ssyr2__64.html "Interface documentation") | C binding 811 | [rocblas_dsyr2_64](interfacehipfort__rocblas_1_1rocblas__dsyr2__64.html "Interface documentation") | C binding 812 | [rocblas_csyr2_64](interfacehipfort__rocblas_1_1rocblas__csyr2__64.html "Interface documentation") | C binding 813 | [rocblas_zsyr2_64](interfacehipfort__rocblas_1_1rocblas__zsyr2__64.html "Interface documentation") | C binding 814 | [rocblas_ssyr2_batched](interfacehipfort__rocblas_1_1rocblas__ssyr2__batched.html "Interface documentation") | C binding 815 | [rocblas_dsyr2_batched](interfacehipfort__rocblas_1_1rocblas__dsyr2__batched.html "Interface documentation") | C binding 816 | [rocblas_csyr2_batched](interfacehipfort__rocblas_1_1rocblas__csyr2__batched.html "Interface documentation") | C binding 817 | [rocblas_zsyr2_batched](interfacehipfort__rocblas_1_1rocblas__zsyr2__batched.html "Interface documentation") | C binding 818 | [rocblas_ssyr2_batched_64](interfacehipfort__rocblas_1_1rocblas__ssyr2__batched__64.html "Interface documentation") | C binding 819 | [rocblas_dsyr2_batched_64](interfacehipfort__rocblas_1_1rocblas__dsyr2__batched__64.html "Interface documentation") | C binding 820 | [rocblas_csyr2_batched_64](interfacehipfort__rocblas_1_1rocblas__csyr2__batched__64.html "Interface documentation") | C binding 821 | [rocblas_zsyr2_batched_64](interfacehipfort__rocblas_1_1rocblas__zsyr2__batched__64.html "Interface documentation") | C binding 822 | [rocblas_ssyr2_strided_batched](interfacehipfort__rocblas_1_1rocblas__ssyr2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 823 | [rocblas_dsyr2_strided_batched](interfacehipfort__rocblas_1_1rocblas__dsyr2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 824 | [rocblas_csyr2_strided_batched](interfacehipfort__rocblas_1_1rocblas__csyr2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 825 | [rocblas_zsyr2_strided_batched](interfacehipfort__rocblas_1_1rocblas__zsyr2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 826 | [rocblas_ssyr2_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ssyr2__strided__batched__64.html "Interface documentation") | C binding 827 | [rocblas_dsyr2_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dsyr2__strided__batched__64.html "Interface documentation") | C binding 828 | [rocblas_csyr2_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__csyr2__strided__batched__64.html "Interface documentation") | C binding 829 | [rocblas_zsyr2_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zsyr2__strided__batched__64.html "Interface documentation") | C binding 830 | [rocblas_chemm](interfacehipfort__rocblas_1_1rocblas__chemm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 831 | [rocblas_zhemm](interfacehipfort__rocblas_1_1rocblas__zhemm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 832 | [rocblas_chemm_64](interfacehipfort__rocblas_1_1rocblas__chemm__64.html "Interface documentation") | C binding 833 | [rocblas_zhemm_64](interfacehipfort__rocblas_1_1rocblas__zhemm__64.html "Interface documentation") | C binding 834 | [rocblas_chemm_batched](interfacehipfort__rocblas_1_1rocblas__chemm__batched.html "Interface documentation") | C binding 835 | [rocblas_zhemm_batched](interfacehipfort__rocblas_1_1rocblas__zhemm__batched.html "Interface documentation") | C binding 836 | [rocblas_chemm_batched_64](interfacehipfort__rocblas_1_1rocblas__chemm__batched__64.html "Interface documentation") | C binding 837 | [rocblas_zhemm_batched_64](interfacehipfort__rocblas_1_1rocblas__zhemm__batched__64.html "Interface documentation") | C binding 838 | [rocblas_chemm_strided_batched](interfacehipfort__rocblas_1_1rocblas__chemm__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 839 | [rocblas_zhemm_strided_batched](interfacehipfort__rocblas_1_1rocblas__zhemm__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 840 | [rocblas_chemm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__chemm__strided__batched__64.html "Interface documentation") | C binding 841 | [rocblas_zhemm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zhemm__strided__batched__64.html "Interface documentation") | C binding 842 | [rocblas_cherk](interfacehipfort__rocblas_1_1rocblas__cherk.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 843 | [rocblas_zherk](interfacehipfort__rocblas_1_1rocblas__zherk.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 844 | [rocblas_cherk_64](interfacehipfort__rocblas_1_1rocblas__cherk__64.html "Interface documentation") | C binding 845 | [rocblas_zherk_64](interfacehipfort__rocblas_1_1rocblas__zherk__64.html "Interface documentation") | C binding 846 | [rocblas_cherk_batched](interfacehipfort__rocblas_1_1rocblas__cherk__batched.html "Interface documentation") | C binding 847 | [rocblas_zherk_batched](interfacehipfort__rocblas_1_1rocblas__zherk__batched.html "Interface documentation") | C binding 848 | [rocblas_cherk_batched_64](interfacehipfort__rocblas_1_1rocblas__cherk__batched__64.html "Interface documentation") | C binding 849 | [rocblas_zherk_batched_64](interfacehipfort__rocblas_1_1rocblas__zherk__batched__64.html "Interface documentation") | C binding 850 | [rocblas_cherk_strided_batched](interfacehipfort__rocblas_1_1rocblas__cherk__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 851 | [rocblas_zherk_strided_batched](interfacehipfort__rocblas_1_1rocblas__zherk__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 852 | [rocblas_cherk_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__cherk__strided__batched__64.html "Interface documentation") | C binding 853 | [rocblas_zherk_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zherk__strided__batched__64.html "Interface documentation") | C binding 854 | [rocblas_cher2k](interfacehipfort__rocblas_1_1rocblas__cher2k.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 855 | [rocblas_zher2k](interfacehipfort__rocblas_1_1rocblas__zher2k.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 856 | [rocblas_cher2k_64](interfacehipfort__rocblas_1_1rocblas__cher2k__64.html "Interface documentation") | C binding 857 | [rocblas_zher2k_64](interfacehipfort__rocblas_1_1rocblas__zher2k__64.html "Interface documentation") | C binding 858 | [rocblas_cher2k_batched](interfacehipfort__rocblas_1_1rocblas__cher2k__batched.html "Interface documentation") | C binding 859 | [rocblas_zher2k_batched](interfacehipfort__rocblas_1_1rocblas__zher2k__batched.html "Interface documentation") | C binding 860 | [rocblas_cher2k_batched_64](interfacehipfort__rocblas_1_1rocblas__cher2k__batched__64.html "Interface documentation") | C binding 861 | [rocblas_zher2k_batched_64](interfacehipfort__rocblas_1_1rocblas__zher2k__batched__64.html "Interface documentation") | C binding 862 | [rocblas_cher2k_strided_batched](interfacehipfort__rocblas_1_1rocblas__cher2k__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 863 | [rocblas_zher2k_strided_batched](interfacehipfort__rocblas_1_1rocblas__zher2k__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 864 | [rocblas_cher2k_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__cher2k__strided__batched__64.html "Interface documentation") | C binding 865 | [rocblas_zher2k_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zher2k__strided__batched__64.html "Interface documentation") | C binding 866 | [rocblas_cherkx](interfacehipfort__rocblas_1_1rocblas__cherkx.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 867 | [rocblas_zherkx](interfacehipfort__rocblas_1_1rocblas__zherkx.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 868 | [rocblas_cherkx_64](interfacehipfort__rocblas_1_1rocblas__cherkx__64.html "Interface documentation") | C binding 869 | [rocblas_zherkx_64](interfacehipfort__rocblas_1_1rocblas__zherkx__64.html "Interface documentation") | C binding 870 | [rocblas_cherkx_batched](interfacehipfort__rocblas_1_1rocblas__cherkx__batched.html "Interface documentation") | C binding 871 | [rocblas_zherkx_batched](interfacehipfort__rocblas_1_1rocblas__zherkx__batched.html "Interface documentation") | C binding 872 | [rocblas_cherkx_batched_64](interfacehipfort__rocblas_1_1rocblas__cherkx__batched__64.html "Interface documentation") | C binding 873 | [rocblas_zherkx_batched_64](interfacehipfort__rocblas_1_1rocblas__zherkx__batched__64.html "Interface documentation") | C binding 874 | [rocblas_cherkx_strided_batched](interfacehipfort__rocblas_1_1rocblas__cherkx__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 875 | [rocblas_zherkx_strided_batched](interfacehipfort__rocblas_1_1rocblas__zherkx__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 876 | [rocblas_cherkx_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__cherkx__strided__batched__64.html "Interface documentation") | C binding 877 | [rocblas_zherkx_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zherkx__strided__batched__64.html "Interface documentation") | C binding 878 | [rocblas_ssymm](interfacehipfort__rocblas_1_1rocblas__ssymm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 879 | [rocblas_dsymm](interfacehipfort__rocblas_1_1rocblas__dsymm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 880 | [rocblas_csymm](interfacehipfort__rocblas_1_1rocblas__csymm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 881 | [rocblas_zsymm](interfacehipfort__rocblas_1_1rocblas__zsymm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 882 | [rocblas_ssymm_64](interfacehipfort__rocblas_1_1rocblas__ssymm__64.html "Interface documentation") | C binding 883 | [rocblas_dsymm_64](interfacehipfort__rocblas_1_1rocblas__dsymm__64.html "Interface documentation") | C binding 884 | [rocblas_csymm_64](interfacehipfort__rocblas_1_1rocblas__csymm__64.html "Interface documentation") | C binding 885 | [rocblas_zsymm_64](interfacehipfort__rocblas_1_1rocblas__zsymm__64.html "Interface documentation") | C binding 886 | [rocblas_ssymm_batched](interfacehipfort__rocblas_1_1rocblas__ssymm__batched.html "Interface documentation") | C binding 887 | [rocblas_dsymm_batched](interfacehipfort__rocblas_1_1rocblas__dsymm__batched.html "Interface documentation") | C binding 888 | [rocblas_csymm_batched](interfacehipfort__rocblas_1_1rocblas__csymm__batched.html "Interface documentation") | C binding 889 | [rocblas_zsymm_batched](interfacehipfort__rocblas_1_1rocblas__zsymm__batched.html "Interface documentation") | C binding 890 | [rocblas_ssymm_batched_64](interfacehipfort__rocblas_1_1rocblas__ssymm__batched__64.html "Interface documentation") | C binding 891 | [rocblas_dsymm_batched_64](interfacehipfort__rocblas_1_1rocblas__dsymm__batched__64.html "Interface documentation") | C binding 892 | [rocblas_csymm_batched_64](interfacehipfort__rocblas_1_1rocblas__csymm__batched__64.html "Interface documentation") | C binding 893 | [rocblas_zsymm_batched_64](interfacehipfort__rocblas_1_1rocblas__zsymm__batched__64.html "Interface documentation") | C binding 894 | [rocblas_ssymm_strided_batched](interfacehipfort__rocblas_1_1rocblas__ssymm__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 895 | [rocblas_dsymm_strided_batched](interfacehipfort__rocblas_1_1rocblas__dsymm__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 896 | [rocblas_csymm_strided_batched](interfacehipfort__rocblas_1_1rocblas__csymm__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 897 | [rocblas_zsymm_strided_batched](interfacehipfort__rocblas_1_1rocblas__zsymm__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 898 | [rocblas_ssymm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ssymm__strided__batched__64.html "Interface documentation") | C binding 899 | [rocblas_dsymm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dsymm__strided__batched__64.html "Interface documentation") | C binding 900 | [rocblas_csymm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__csymm__strided__batched__64.html "Interface documentation") | C binding 901 | [rocblas_zsymm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zsymm__strided__batched__64.html "Interface documentation") | C binding 902 | [rocblas_ssyrk](interfacehipfort__rocblas_1_1rocblas__ssyrk.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 903 | [rocblas_dsyrk](interfacehipfort__rocblas_1_1rocblas__dsyrk.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 904 | [rocblas_csyrk](interfacehipfort__rocblas_1_1rocblas__csyrk.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 905 | [rocblas_zsyrk](interfacehipfort__rocblas_1_1rocblas__zsyrk.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 906 | [rocblas_ssyrk_64](interfacehipfort__rocblas_1_1rocblas__ssyrk__64.html "Interface documentation") | C binding 907 | [rocblas_dsyrk_64](interfacehipfort__rocblas_1_1rocblas__dsyrk__64.html "Interface documentation") | C binding 908 | [rocblas_csyrk_64](interfacehipfort__rocblas_1_1rocblas__csyrk__64.html "Interface documentation") | C binding 909 | [rocblas_zsyrk_64](interfacehipfort__rocblas_1_1rocblas__zsyrk__64.html "Interface documentation") | C binding 910 | [rocblas_ssyrk_batched](interfacehipfort__rocblas_1_1rocblas__ssyrk__batched.html "Interface documentation") | C binding 911 | [rocblas_dsyrk_batched](interfacehipfort__rocblas_1_1rocblas__dsyrk__batched.html "Interface documentation") | C binding 912 | [rocblas_csyrk_batched](interfacehipfort__rocblas_1_1rocblas__csyrk__batched.html "Interface documentation") | C binding 913 | [rocblas_zsyrk_batched](interfacehipfort__rocblas_1_1rocblas__zsyrk__batched.html "Interface documentation") | C binding 914 | [rocblas_ssyrk_batched_64](interfacehipfort__rocblas_1_1rocblas__ssyrk__batched__64.html "Interface documentation") | C binding 915 | [rocblas_dsyrk_batched_64](interfacehipfort__rocblas_1_1rocblas__dsyrk__batched__64.html "Interface documentation") | C binding 916 | [rocblas_csyrk_batched_64](interfacehipfort__rocblas_1_1rocblas__csyrk__batched__64.html "Interface documentation") | C binding 917 | [rocblas_zsyrk_batched_64](interfacehipfort__rocblas_1_1rocblas__zsyrk__batched__64.html "Interface documentation") | C binding 918 | [rocblas_ssyrk_strided_batched](interfacehipfort__rocblas_1_1rocblas__ssyrk__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 919 | [rocblas_dsyrk_strided_batched](interfacehipfort__rocblas_1_1rocblas__dsyrk__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 920 | [rocblas_csyrk_strided_batched](interfacehipfort__rocblas_1_1rocblas__csyrk__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 921 | [rocblas_zsyrk_strided_batched](interfacehipfort__rocblas_1_1rocblas__zsyrk__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 922 | [rocblas_ssyrk_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ssyrk__strided__batched__64.html "Interface documentation") | C binding 923 | [rocblas_dsyrk_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dsyrk__strided__batched__64.html "Interface documentation") | C binding 924 | [rocblas_csyrk_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__csyrk__strided__batched__64.html "Interface documentation") | C binding 925 | [rocblas_zsyrk_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zsyrk__strided__batched__64.html "Interface documentation") | C binding 926 | [rocblas_ssyr2k](interfacehipfort__rocblas_1_1rocblas__ssyr2k.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 927 | [rocblas_dsyr2k](interfacehipfort__rocblas_1_1rocblas__dsyr2k.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 928 | [rocblas_csyr2k](interfacehipfort__rocblas_1_1rocblas__csyr2k.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 929 | [rocblas_zsyr2k](interfacehipfort__rocblas_1_1rocblas__zsyr2k.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 930 | [rocblas_ssyr2k_64](interfacehipfort__rocblas_1_1rocblas__ssyr2k__64.html "Interface documentation") | C binding 931 | [rocblas_dsyr2k_64](interfacehipfort__rocblas_1_1rocblas__dsyr2k__64.html "Interface documentation") | C binding 932 | [rocblas_csyr2k_64](interfacehipfort__rocblas_1_1rocblas__csyr2k__64.html "Interface documentation") | C binding 933 | [rocblas_zsyr2k_64](interfacehipfort__rocblas_1_1rocblas__zsyr2k__64.html "Interface documentation") | C binding 934 | [rocblas_ssyr2k_batched](interfacehipfort__rocblas_1_1rocblas__ssyr2k__batched.html "Interface documentation") | C binding 935 | [rocblas_dsyr2k_batched](interfacehipfort__rocblas_1_1rocblas__dsyr2k__batched.html "Interface documentation") | C binding 936 | [rocblas_csyr2k_batched](interfacehipfort__rocblas_1_1rocblas__csyr2k__batched.html "Interface documentation") | C binding 937 | [rocblas_zsyr2k_batched](interfacehipfort__rocblas_1_1rocblas__zsyr2k__batched.html "Interface documentation") | C binding 938 | [rocblas_ssyr2k_batched_64](interfacehipfort__rocblas_1_1rocblas__ssyr2k__batched__64.html "Interface documentation") | C binding 939 | [rocblas_dsyr2k_batched_64](interfacehipfort__rocblas_1_1rocblas__dsyr2k__batched__64.html "Interface documentation") | C binding 940 | [rocblas_csyr2k_batched_64](interfacehipfort__rocblas_1_1rocblas__csyr2k__batched__64.html "Interface documentation") | C binding 941 | [rocblas_zsyr2k_batched_64](interfacehipfort__rocblas_1_1rocblas__zsyr2k__batched__64.html "Interface documentation") | C binding 942 | [rocblas_ssyr2k_strided_batched](interfacehipfort__rocblas_1_1rocblas__ssyr2k__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 943 | [rocblas_dsyr2k_strided_batched](interfacehipfort__rocblas_1_1rocblas__dsyr2k__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 944 | [rocblas_csyr2k_strided_batched](interfacehipfort__rocblas_1_1rocblas__csyr2k__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 945 | [rocblas_zsyr2k_strided_batched](interfacehipfort__rocblas_1_1rocblas__zsyr2k__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 946 | [rocblas_ssyr2k_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ssyr2k__strided__batched__64.html "Interface documentation") | C binding 947 | [rocblas_dsyr2k_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dsyr2k__strided__batched__64.html "Interface documentation") | C binding 948 | [rocblas_csyr2k_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__csyr2k__strided__batched__64.html "Interface documentation") | C binding 949 | [rocblas_zsyr2k_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zsyr2k__strided__batched__64.html "Interface documentation") | C binding 950 | [rocblas_ssyrkx](interfacehipfort__rocblas_1_1rocblas__ssyrkx.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 951 | [rocblas_dsyrkx](interfacehipfort__rocblas_1_1rocblas__dsyrkx.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 952 | [rocblas_csyrkx](interfacehipfort__rocblas_1_1rocblas__csyrkx.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 953 | [rocblas_zsyrkx](interfacehipfort__rocblas_1_1rocblas__zsyrkx.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 954 | [rocblas_ssyrkx_64](interfacehipfort__rocblas_1_1rocblas__ssyrkx__64.html "Interface documentation") | C binding 955 | [rocblas_dsyrkx_64](interfacehipfort__rocblas_1_1rocblas__dsyrkx__64.html "Interface documentation") | C binding 956 | [rocblas_csyrkx_64](interfacehipfort__rocblas_1_1rocblas__csyrkx__64.html "Interface documentation") | C binding 957 | [rocblas_zsyrkx_64](interfacehipfort__rocblas_1_1rocblas__zsyrkx__64.html "Interface documentation") | C binding 958 | [rocblas_ssyrkx_batched](interfacehipfort__rocblas_1_1rocblas__ssyrkx__batched.html "Interface documentation") | C binding 959 | [rocblas_dsyrkx_batched](interfacehipfort__rocblas_1_1rocblas__dsyrkx__batched.html "Interface documentation") | C binding 960 | [rocblas_csyrkx_batched](interfacehipfort__rocblas_1_1rocblas__csyrkx__batched.html "Interface documentation") | C binding 961 | [rocblas_zsyrkx_batched](interfacehipfort__rocblas_1_1rocblas__zsyrkx__batched.html "Interface documentation") | C binding 962 | [rocblas_ssyrkx_batched_64](interfacehipfort__rocblas_1_1rocblas__ssyrkx__batched__64.html "Interface documentation") | C binding 963 | [rocblas_dsyrkx_batched_64](interfacehipfort__rocblas_1_1rocblas__dsyrkx__batched__64.html "Interface documentation") | C binding 964 | [rocblas_csyrkx_batched_64](interfacehipfort__rocblas_1_1rocblas__csyrkx__batched__64.html "Interface documentation") | C binding 965 | [rocblas_zsyrkx_batched_64](interfacehipfort__rocblas_1_1rocblas__zsyrkx__batched__64.html "Interface documentation") | C binding 966 | [rocblas_ssyrkx_strided_batched](interfacehipfort__rocblas_1_1rocblas__ssyrkx__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 967 | [rocblas_dsyrkx_strided_batched](interfacehipfort__rocblas_1_1rocblas__dsyrkx__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 968 | [rocblas_csyrkx_strided_batched](interfacehipfort__rocblas_1_1rocblas__csyrkx__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 969 | [rocblas_zsyrkx_strided_batched](interfacehipfort__rocblas_1_1rocblas__zsyrkx__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 970 | [rocblas_ssyrkx_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ssyrkx__strided__batched__64.html "Interface documentation") | C binding 971 | [rocblas_dsyrkx_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dsyrkx__strided__batched__64.html "Interface documentation") | C binding 972 | [rocblas_csyrkx_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__csyrkx__strided__batched__64.html "Interface documentation") | C binding 973 | [rocblas_zsyrkx_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zsyrkx__strided__batched__64.html "Interface documentation") | C binding 974 | [rocblas_strmm](interfacehipfort__rocblas_1_1rocblas__strmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 975 | [rocblas_dtrmm](interfacehipfort__rocblas_1_1rocblas__dtrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 976 | [rocblas_ctrmm](interfacehipfort__rocblas_1_1rocblas__ctrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 977 | [rocblas_ztrmm](interfacehipfort__rocblas_1_1rocblas__ztrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 978 | [rocblas_strmm_64](interfacehipfort__rocblas_1_1rocblas__strmm__64.html "Interface documentation") | C binding 979 | [rocblas_dtrmm_64](interfacehipfort__rocblas_1_1rocblas__dtrmm__64.html "Interface documentation") | C binding 980 | [rocblas_ctrmm_64](interfacehipfort__rocblas_1_1rocblas__ctrmm__64.html "Interface documentation") | C binding 981 | [rocblas_ztrmm_64](interfacehipfort__rocblas_1_1rocblas__ztrmm__64.html "Interface documentation") | C binding 982 | [rocblas_strmm_batched](interfacehipfort__rocblas_1_1rocblas__strmm__batched.html "Interface documentation") | C binding 983 | [rocblas_dtrmm_batched](interfacehipfort__rocblas_1_1rocblas__dtrmm__batched.html "Interface documentation") | C binding 984 | [rocblas_ctrmm_batched](interfacehipfort__rocblas_1_1rocblas__ctrmm__batched.html "Interface documentation") | C binding 985 | [rocblas_ztrmm_batched](interfacehipfort__rocblas_1_1rocblas__ztrmm__batched.html "Interface documentation") | C binding 986 | [rocblas_strmm_batched_64](interfacehipfort__rocblas_1_1rocblas__strmm__batched__64.html "Interface documentation") | C binding 987 | [rocblas_dtrmm_batched_64](interfacehipfort__rocblas_1_1rocblas__dtrmm__batched__64.html "Interface documentation") | C binding 988 | [rocblas_ctrmm_batched_64](interfacehipfort__rocblas_1_1rocblas__ctrmm__batched__64.html "Interface documentation") | C binding 989 | [rocblas_ztrmm_batched_64](interfacehipfort__rocblas_1_1rocblas__ztrmm__batched__64.html "Interface documentation") | C binding 990 | [rocblas_strmm_strided_batched](interfacehipfort__rocblas_1_1rocblas__strmm__strided__batched.html "Interface documentation") | C binding 991 | [rocblas_dtrmm_strided_batched](interfacehipfort__rocblas_1_1rocblas__dtrmm__strided__batched.html "Interface documentation") | C binding 992 | [rocblas_ctrmm_strided_batched](interfacehipfort__rocblas_1_1rocblas__ctrmm__strided__batched.html "Interface documentation") | C binding 993 | [rocblas_ztrmm_strided_batched](interfacehipfort__rocblas_1_1rocblas__ztrmm__strided__batched.html "Interface documentation") | C binding 994 | [rocblas_strmm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__strmm__strided__batched__64.html "Interface documentation") | C binding 995 | [rocblas_dtrmm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dtrmm__strided__batched__64.html "Interface documentation") | C binding 996 | [rocblas_ctrmm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ctrmm__strided__batched__64.html "Interface documentation") | C binding 997 | [rocblas_ztrmm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ztrmm__strided__batched__64.html "Interface documentation") | C binding 998 | [rocblas_strtri](interfacehipfort__rocblas_1_1rocblas__strtri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 999 | [rocblas_dtrtri](interfacehipfort__rocblas_1_1rocblas__dtrtri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1000 | [rocblas_ctrtri](interfacehipfort__rocblas_1_1rocblas__ctrtri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1001 | [rocblas_ztrtri](interfacehipfort__rocblas_1_1rocblas__ztrtri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1002 | [rocblas_strtri_batched](interfacehipfort__rocblas_1_1rocblas__strtri__batched.html "Interface documentation") | C binding 1003 | [rocblas_dtrtri_batched](interfacehipfort__rocblas_1_1rocblas__dtrtri__batched.html "Interface documentation") | C binding 1004 | [rocblas_ctrtri_batched](interfacehipfort__rocblas_1_1rocblas__ctrtri__batched.html "Interface documentation") | C binding 1005 | [rocblas_ztrtri_batched](interfacehipfort__rocblas_1_1rocblas__ztrtri__batched.html "Interface documentation") | C binding 1006 | [rocblas_strtri_strided_batched](interfacehipfort__rocblas_1_1rocblas__strtri__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1007 | [rocblas_dtrtri_strided_batched](interfacehipfort__rocblas_1_1rocblas__dtrtri__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1008 | [rocblas_ctrtri_strided_batched](interfacehipfort__rocblas_1_1rocblas__ctrtri__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1009 | [rocblas_ztrtri_strided_batched](interfacehipfort__rocblas_1_1rocblas__ztrtri__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1010 | [rocblas_strsm](interfacehipfort__rocblas_1_1rocblas__strsm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1011 | [rocblas_dtrsm](interfacehipfort__rocblas_1_1rocblas__dtrsm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1012 | [rocblas_ctrsm](interfacehipfort__rocblas_1_1rocblas__ctrsm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1013 | [rocblas_ztrsm](interfacehipfort__rocblas_1_1rocblas__ztrsm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1014 | [rocblas_strsm_64](interfacehipfort__rocblas_1_1rocblas__strsm__64.html "Interface documentation") | C binding 1015 | [rocblas_dtrsm_64](interfacehipfort__rocblas_1_1rocblas__dtrsm__64.html "Interface documentation") | C binding 1016 | [rocblas_ctrsm_64](interfacehipfort__rocblas_1_1rocblas__ctrsm__64.html "Interface documentation") | C binding 1017 | [rocblas_ztrsm_64](interfacehipfort__rocblas_1_1rocblas__ztrsm__64.html "Interface documentation") | C binding 1018 | [rocblas_strsm_batched](interfacehipfort__rocblas_1_1rocblas__strsm__batched.html "Interface documentation") | C binding 1019 | [rocblas_dtrsm_batched](interfacehipfort__rocblas_1_1rocblas__dtrsm__batched.html "Interface documentation") | C binding 1020 | [rocblas_ctrsm_batched](interfacehipfort__rocblas_1_1rocblas__ctrsm__batched.html "Interface documentation") | C binding 1021 | [rocblas_ztrsm_batched](interfacehipfort__rocblas_1_1rocblas__ztrsm__batched.html "Interface documentation") | C binding 1022 | [rocblas_strsm_batched_64](interfacehipfort__rocblas_1_1rocblas__strsm__batched__64.html "Interface documentation") | C binding 1023 | [rocblas_dtrsm_batched_64](interfacehipfort__rocblas_1_1rocblas__dtrsm__batched__64.html "Interface documentation") | C binding 1024 | [rocblas_ctrsm_batched_64](interfacehipfort__rocblas_1_1rocblas__ctrsm__batched__64.html "Interface documentation") | C binding 1025 | [rocblas_ztrsm_batched_64](interfacehipfort__rocblas_1_1rocblas__ztrsm__batched__64.html "Interface documentation") | C binding 1026 | [rocblas_strsm_strided_batched](interfacehipfort__rocblas_1_1rocblas__strsm__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1027 | [rocblas_dtrsm_strided_batched](interfacehipfort__rocblas_1_1rocblas__dtrsm__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1028 | [rocblas_ctrsm_strided_batched](interfacehipfort__rocblas_1_1rocblas__ctrsm__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1029 | [rocblas_ztrsm_strided_batched](interfacehipfort__rocblas_1_1rocblas__ztrsm__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1030 | [rocblas_strsm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__strsm__strided__batched__64.html "Interface documentation") | C binding 1031 | [rocblas_dtrsm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dtrsm__strided__batched__64.html "Interface documentation") | C binding 1032 | [rocblas_ctrsm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ctrsm__strided__batched__64.html "Interface documentation") | C binding 1033 | [rocblas_ztrsm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ztrsm__strided__batched__64.html "Interface documentation") | C binding 1034 | [rocblas_sgemm](interfacehipfort__rocblas_1_1rocblas__sgemm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1035 | [rocblas_dgemm](interfacehipfort__rocblas_1_1rocblas__dgemm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1036 | [rocblas_hgemm](interfacehipfort__rocblas_1_1rocblas__hgemm.html "Interface documentation") | C binding 1037 | [rocblas_cgemm](interfacehipfort__rocblas_1_1rocblas__cgemm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1038 | [rocblas_zgemm](interfacehipfort__rocblas_1_1rocblas__zgemm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1039 | [rocblas_sgemm_64](interfacehipfort__rocblas_1_1rocblas__sgemm__64.html "Interface documentation") | C binding 1040 | [rocblas_dgemm_64](interfacehipfort__rocblas_1_1rocblas__dgemm__64.html "Interface documentation") | C binding 1041 | [rocblas_hgemm_64](interfacehipfort__rocblas_1_1rocblas__hgemm__64.html "Interface documentation") | C binding 1042 | [rocblas_cgemm_64](interfacehipfort__rocblas_1_1rocblas__cgemm__64.html "Interface documentation") | C binding 1043 | [rocblas_zgemm_64](interfacehipfort__rocblas_1_1rocblas__zgemm__64.html "Interface documentation") | C binding 1044 | [rocblas_sgemm_batched](interfacehipfort__rocblas_1_1rocblas__sgemm__batched.html "Interface documentation") | C binding 1045 | [rocblas_dgemm_batched](interfacehipfort__rocblas_1_1rocblas__dgemm__batched.html "Interface documentation") | C binding 1046 | [rocblas_hgemm_batched](interfacehipfort__rocblas_1_1rocblas__hgemm__batched.html "Interface documentation") | C binding 1047 | [rocblas_cgemm_batched](interfacehipfort__rocblas_1_1rocblas__cgemm__batched.html "Interface documentation") | C binding 1048 | [rocblas_zgemm_batched](interfacehipfort__rocblas_1_1rocblas__zgemm__batched.html "Interface documentation") | C binding 1049 | [rocblas_sgemm_batched_64](interfacehipfort__rocblas_1_1rocblas__sgemm__batched__64.html "Interface documentation") | C binding 1050 | [rocblas_dgemm_batched_64](interfacehipfort__rocblas_1_1rocblas__dgemm__batched__64.html "Interface documentation") | C binding 1051 | [rocblas_hgemm_batched_64](interfacehipfort__rocblas_1_1rocblas__hgemm__batched__64.html "Interface documentation") | C binding 1052 | [rocblas_cgemm_batched_64](interfacehipfort__rocblas_1_1rocblas__cgemm__batched__64.html "Interface documentation") | C binding 1053 | [rocblas_zgemm_batched_64](interfacehipfort__rocblas_1_1rocblas__zgemm__batched__64.html "Interface documentation") | C binding 1054 | [rocblas_sgemm_strided_batched](interfacehipfort__rocblas_1_1rocblas__sgemm__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1055 | [rocblas_dgemm_strided_batched](interfacehipfort__rocblas_1_1rocblas__dgemm__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1056 | [rocblas_hgemm_strided_batched](interfacehipfort__rocblas_1_1rocblas__hgemm__strided__batched.html "Interface documentation") | C binding 1057 | [rocblas_cgemm_strided_batched](interfacehipfort__rocblas_1_1rocblas__cgemm__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1058 | [rocblas_zgemm_strided_batched](interfacehipfort__rocblas_1_1rocblas__zgemm__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1059 | [rocblas_sgemm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__sgemm__strided__batched__64.html "Interface documentation") | C binding 1060 | [rocblas_dgemm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dgemm__strided__batched__64.html "Interface documentation") | C binding 1061 | [rocblas_hgemm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__hgemm__strided__batched__64.html "Interface documentation") | C binding 1062 | [rocblas_cgemm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__cgemm__strided__batched__64.html "Interface documentation") | C binding 1063 | [rocblas_zgemm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zgemm__strided__batched__64.html "Interface documentation") | C binding 1064 | [rocblas_sdgmm](interfacehipfort__rocblas_1_1rocblas__sdgmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1065 | [rocblas_ddgmm](interfacehipfort__rocblas_1_1rocblas__ddgmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1066 | [rocblas_cdgmm](interfacehipfort__rocblas_1_1rocblas__cdgmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1067 | [rocblas_zdgmm](interfacehipfort__rocblas_1_1rocblas__zdgmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1068 | [rocblas_sdgmm_64](interfacehipfort__rocblas_1_1rocblas__sdgmm__64.html "Interface documentation") | C binding 1069 | [rocblas_ddgmm_64](interfacehipfort__rocblas_1_1rocblas__ddgmm__64.html "Interface documentation") | C binding 1070 | [rocblas_cdgmm_64](interfacehipfort__rocblas_1_1rocblas__cdgmm__64.html "Interface documentation") | C binding 1071 | [rocblas_zdgmm_64](interfacehipfort__rocblas_1_1rocblas__zdgmm__64.html "Interface documentation") | C binding 1072 | [rocblas_sdgmm_batched](interfacehipfort__rocblas_1_1rocblas__sdgmm__batched.html "Interface documentation") | C binding 1073 | [rocblas_ddgmm_batched](interfacehipfort__rocblas_1_1rocblas__ddgmm__batched.html "Interface documentation") | C binding 1074 | [rocblas_cdgmm_batched](interfacehipfort__rocblas_1_1rocblas__cdgmm__batched.html "Interface documentation") | C binding 1075 | [rocblas_zdgmm_batched](interfacehipfort__rocblas_1_1rocblas__zdgmm__batched.html "Interface documentation") | C binding 1076 | [rocblas_sdgmm_batched_64](interfacehipfort__rocblas_1_1rocblas__sdgmm__batched__64.html "Interface documentation") | C binding 1077 | [rocblas_ddgmm_batched_64](interfacehipfort__rocblas_1_1rocblas__ddgmm__batched__64.html "Interface documentation") | C binding 1078 | [rocblas_cdgmm_batched_64](interfacehipfort__rocblas_1_1rocblas__cdgmm__batched__64.html "Interface documentation") | C binding 1079 | [rocblas_zdgmm_batched_64](interfacehipfort__rocblas_1_1rocblas__zdgmm__batched__64.html "Interface documentation") | C binding 1080 | [rocblas_sdgmm_strided_batched](interfacehipfort__rocblas_1_1rocblas__sdgmm__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1081 | [rocblas_ddgmm_strided_batched](interfacehipfort__rocblas_1_1rocblas__ddgmm__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1082 | [rocblas_cdgmm_strided_batched](interfacehipfort__rocblas_1_1rocblas__cdgmm__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1083 | [rocblas_zdgmm_strided_batched](interfacehipfort__rocblas_1_1rocblas__zdgmm__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1084 | [rocblas_sdgmm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__sdgmm__strided__batched__64.html "Interface documentation") | C binding 1085 | [rocblas_ddgmm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__ddgmm__strided__batched__64.html "Interface documentation") | C binding 1086 | [rocblas_cdgmm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__cdgmm__strided__batched__64.html "Interface documentation") | C binding 1087 | [rocblas_zdgmm_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zdgmm__strided__batched__64.html "Interface documentation") | C binding 1088 | [rocblas_sgeam](interfacehipfort__rocblas_1_1rocblas__sgeam.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1089 | [rocblas_dgeam](interfacehipfort__rocblas_1_1rocblas__dgeam.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1090 | [rocblas_cgeam](interfacehipfort__rocblas_1_1rocblas__cgeam.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1091 | [rocblas_zgeam](interfacehipfort__rocblas_1_1rocblas__zgeam.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1092 | [rocblas_sgeam_64](interfacehipfort__rocblas_1_1rocblas__sgeam__64.html "Interface documentation") | C binding 1093 | [rocblas_dgeam_64](interfacehipfort__rocblas_1_1rocblas__dgeam__64.html "Interface documentation") | C binding 1094 | [rocblas_cgeam_64](interfacehipfort__rocblas_1_1rocblas__cgeam__64.html "Interface documentation") | C binding 1095 | [rocblas_zgeam_64](interfacehipfort__rocblas_1_1rocblas__zgeam__64.html "Interface documentation") | C binding 1096 | [rocblas_sgeam_batched](interfacehipfort__rocblas_1_1rocblas__sgeam__batched.html "Interface documentation") | C binding 1097 | [rocblas_dgeam_batched](interfacehipfort__rocblas_1_1rocblas__dgeam__batched.html "Interface documentation") | C binding 1098 | [rocblas_cgeam_batched](interfacehipfort__rocblas_1_1rocblas__cgeam__batched.html "Interface documentation") | C binding 1099 | [rocblas_zgeam_batched](interfacehipfort__rocblas_1_1rocblas__zgeam__batched.html "Interface documentation") | C binding 1100 | [rocblas_sgeam_batched_64](interfacehipfort__rocblas_1_1rocblas__sgeam__batched__64.html "Interface documentation") | C binding 1101 | [rocblas_dgeam_batched_64](interfacehipfort__rocblas_1_1rocblas__dgeam__batched__64.html "Interface documentation") | C binding 1102 | [rocblas_cgeam_batched_64](interfacehipfort__rocblas_1_1rocblas__cgeam__batched__64.html "Interface documentation") | C binding 1103 | [rocblas_zgeam_batched_64](interfacehipfort__rocblas_1_1rocblas__zgeam__batched__64.html "Interface documentation") | C binding 1104 | [rocblas_sgeam_strided_batched](interfacehipfort__rocblas_1_1rocblas__sgeam__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1105 | [rocblas_dgeam_strided_batched](interfacehipfort__rocblas_1_1rocblas__dgeam__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1106 | [rocblas_cgeam_strided_batched](interfacehipfort__rocblas_1_1rocblas__cgeam__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1107 | [rocblas_zgeam_strided_batched](interfacehipfort__rocblas_1_1rocblas__zgeam__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1108 | [rocblas_sgeam_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__sgeam__strided__batched__64.html "Interface documentation") | C binding 1109 | [rocblas_dgeam_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dgeam__strided__batched__64.html "Interface documentation") | C binding 1110 | [rocblas_cgeam_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__cgeam__strided__batched__64.html "Interface documentation") | C binding 1111 | [rocblas_zgeam_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zgeam__strided__batched__64.html "Interface documentation") | C binding 1112 | [rocblas_gemm_ex](interfacehipfort__rocblas_1_1rocblas__gemm__ex.html "Interface documentation") | C binding 1113 | [rocblas_gemm_ex_64](interfacehipfort__rocblas_1_1rocblas__gemm__ex__64.html "Interface documentation") | C binding 1114 | [rocblas_gemm_batched_ex](interfacehipfort__rocblas_1_1rocblas__gemm__batched__ex.html "Interface documentation") | C binding 1115 | [rocblas_gemm_batched_ex_64](interfacehipfort__rocblas_1_1rocblas__gemm__batched__ex__64.html "Interface documentation") | C binding 1116 | [rocblas_gemm_strided_batched_ex](interfacehipfort__rocblas_1_1rocblas__gemm__strided__batched__ex.html "Interface documentation") | C binding 1117 | [rocblas_gemm_strided_batched_ex_64](interfacehipfort__rocblas_1_1rocblas__gemm__strided__batched__ex__64.html "Interface documentation") | C binding 1118 | [rocblas_sgemmt](interfacehipfort__rocblas_1_1rocblas__sgemmt.html "Interface documentation") | C binding 1119 | [rocblas_dgemmt](interfacehipfort__rocblas_1_1rocblas__dgemmt.html "Interface documentation") | C binding 1120 | [rocblas_cgemmt](interfacehipfort__rocblas_1_1rocblas__cgemmt.html "Interface documentation") | C binding 1121 | [rocblas_zgemmt](interfacehipfort__rocblas_1_1rocblas__zgemmt.html "Interface documentation") | C binding 1122 | [rocblas_sgemmt_64](interfacehipfort__rocblas_1_1rocblas__sgemmt__64.html "Interface documentation") | C binding 1123 | [rocblas_dgemmt_64](interfacehipfort__rocblas_1_1rocblas__dgemmt__64.html "Interface documentation") | C binding 1124 | [rocblas_cgemmt_64](interfacehipfort__rocblas_1_1rocblas__cgemmt__64.html "Interface documentation") | C binding 1125 | [rocblas_zgemmt_64](interfacehipfort__rocblas_1_1rocblas__zgemmt__64.html "Interface documentation") | C binding 1126 | [rocblas_sgemmt_batched](interfacehipfort__rocblas_1_1rocblas__sgemmt__batched.html "Interface documentation") | C binding 1127 | [rocblas_dgemmt_batched](interfacehipfort__rocblas_1_1rocblas__dgemmt__batched.html "Interface documentation") | C binding 1128 | [rocblas_cgemmt_batched](interfacehipfort__rocblas_1_1rocblas__cgemmt__batched.html "Interface documentation") | C binding 1129 | [rocblas_zgemmt_batched](interfacehipfort__rocblas_1_1rocblas__zgemmt__batched.html "Interface documentation") | C binding 1130 | [rocblas_sgemmt_batched_64](interfacehipfort__rocblas_1_1rocblas__sgemmt__batched__64.html "Interface documentation") | C binding 1131 | [rocblas_dgemmt_batched_64](interfacehipfort__rocblas_1_1rocblas__dgemmt__batched__64.html "Interface documentation") | C binding 1132 | [rocblas_cgemmt_batched_64](interfacehipfort__rocblas_1_1rocblas__cgemmt__batched__64.html "Interface documentation") | C binding 1133 | [rocblas_zgemmt_batched_64](interfacehipfort__rocblas_1_1rocblas__zgemmt__batched__64.html "Interface documentation") | C binding 1134 | [rocblas_sgemmt_strided_batched](interfacehipfort__rocblas_1_1rocblas__sgemmt__strided__batched.html "Interface documentation") | C binding 1135 | [rocblas_dgemmt_strided_batched](interfacehipfort__rocblas_1_1rocblas__dgemmt__strided__batched.html "Interface documentation") | C binding 1136 | [rocblas_cgemmt_strided_batched](interfacehipfort__rocblas_1_1rocblas__cgemmt__strided__batched.html "Interface documentation") | C binding 1137 | [rocblas_zgemmt_strided_batched](interfacehipfort__rocblas_1_1rocblas__zgemmt__strided__batched.html "Interface documentation") | C binding 1138 | [rocblas_sgemmt_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__sgemmt__strided__batched__64.html "Interface documentation") | C binding 1139 | [rocblas_dgemmt_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__dgemmt__strided__batched__64.html "Interface documentation") | C binding 1140 | [rocblas_cgemmt_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__cgemmt__strided__batched__64.html "Interface documentation") | C binding 1141 | [rocblas_zgemmt_strided_batched_64](interfacehipfort__rocblas_1_1rocblas__zgemmt__strided__batched__64.html "Interface documentation") | C binding 1142 | [rocblas_geam_ex](interfacehipfort__rocblas_1_1rocblas__geam__ex.html "Interface documentation") | C binding 1143 | [rocblas_trsm_ex](interfacehipfort__rocblas_1_1rocblas__trsm__ex.html "Interface documentation") | C binding 1144 | [rocblas_trsm_batched_ex](interfacehipfort__rocblas_1_1rocblas__trsm__batched__ex.html "Interface documentation") | C binding 1145 | [rocblas_trsm_strided_batched_ex](interfacehipfort__rocblas_1_1rocblas__trsm__strided__batched__ex.html "Interface documentation") | C binding 1146 | [rocblas_syrk_ex](interfacehipfort__rocblas_1_1rocblas__syrk__ex.html "Interface documentation") | C binding 1147 | [rocblas_herk_ex](interfacehipfort__rocblas_1_1rocblas__herk__ex.html "Interface documentation") | C binding 1148 | [rocblas_axpy_ex](interfacehipfort__rocblas_1_1rocblas__axpy__ex.html "Interface documentation") | C binding 1149 | [rocblas_axpy_ex_64](interfacehipfort__rocblas_1_1rocblas__axpy__ex__64.html "Interface documentation") | C binding 1150 | [rocblas_axpy_batched_ex](interfacehipfort__rocblas_1_1rocblas__axpy__batched__ex.html "Interface documentation") | C binding 1151 | [rocblas_axpy_batched_ex_64](interfacehipfort__rocblas_1_1rocblas__axpy__batched__ex__64.html "Interface documentation") | C binding 1152 | [rocblas_axpy_strided_batched_ex](interfacehipfort__rocblas_1_1rocblas__axpy__strided__batched__ex.html "Interface documentation") | C binding 1153 | [rocblas_axpy_strided_batched_ex_64](interfacehipfort__rocblas_1_1rocblas__axpy__strided__batched__ex__64.html "Interface documentation") | C binding 1154 | [rocblas_dot_ex](interfacehipfort__rocblas_1_1rocblas__dot__ex.html "Interface documentation") | C binding 1155 | [rocblas_dotc_ex](interfacehipfort__rocblas_1_1rocblas__dotc__ex.html "Interface documentation") | C binding 1156 | [rocblas_dot_ex_64](interfacehipfort__rocblas_1_1rocblas__dot__ex__64.html "Interface documentation") | C binding 1157 | [rocblas_dotc_ex_64](interfacehipfort__rocblas_1_1rocblas__dotc__ex__64.html "Interface documentation") | C binding 1158 | [rocblas_dot_batched_ex](interfacehipfort__rocblas_1_1rocblas__dot__batched__ex.html "Interface documentation") | C binding 1159 | [rocblas_dotc_batched_ex](interfacehipfort__rocblas_1_1rocblas__dotc__batched__ex.html "Interface documentation") | C binding 1160 | [rocblas_dot_batched_ex_64](interfacehipfort__rocblas_1_1rocblas__dot__batched__ex__64.html "Interface documentation") | C binding 1161 | [rocblas_dotc_batched_ex_64](interfacehipfort__rocblas_1_1rocblas__dotc__batched__ex__64.html "Interface documentation") | C binding 1162 | [rocblas_dot_strided_batched_ex](interfacehipfort__rocblas_1_1rocblas__dot__strided__batched__ex.html "Interface documentation") | C binding 1163 | [rocblas_dot_strided_batched_ex_64](interfacehipfort__rocblas_1_1rocblas__dot__strided__batched__ex__64.html "Interface documentation") | C binding 1164 | [rocblas_dotc_strided_batched_ex](interfacehipfort__rocblas_1_1rocblas__dotc__strided__batched__ex.html "Interface documentation") | C binding 1165 | [rocblas_dotc_strided_batched_ex_64](interfacehipfort__rocblas_1_1rocblas__dotc__strided__batched__ex__64.html "Interface documentation") | C binding 1166 | [rocblas_nrm2_ex](interfacehipfort__rocblas_1_1rocblas__nrm2__ex.html "Interface documentation") | C binding 1167 | [rocblas_nrm2_ex_64](interfacehipfort__rocblas_1_1rocblas__nrm2__ex__64.html "Interface documentation") | C binding 1168 | [rocblas_nrm2_batched_ex](interfacehipfort__rocblas_1_1rocblas__nrm2__batched__ex.html "Interface documentation") | C binding 1169 | [rocblas_nrm2_batched_ex_64](interfacehipfort__rocblas_1_1rocblas__nrm2__batched__ex__64.html "Interface documentation") | C binding 1170 | [rocblas_nrm2_strided_batched_ex](interfacehipfort__rocblas_1_1rocblas__nrm2__strided__batched__ex.html "Interface documentation") | C binding 1171 | [rocblas_nrm2_strided_batched_ex_64](interfacehipfort__rocblas_1_1rocblas__nrm2__strided__batched__ex__64.html "Interface documentation") | C binding 1172 | [rocblas_rot_ex](interfacehipfort__rocblas_1_1rocblas__rot__ex.html "Interface documentation") | C binding 1173 | [rocblas_rot_ex_64](interfacehipfort__rocblas_1_1rocblas__rot__ex__64.html "Interface documentation") | C binding 1174 | [rocblas_rot_batched_ex](interfacehipfort__rocblas_1_1rocblas__rot__batched__ex.html "Interface documentation") | C binding 1175 | [rocblas_rot_batched_ex_64](interfacehipfort__rocblas_1_1rocblas__rot__batched__ex__64.html "Interface documentation") | C binding 1176 | [rocblas_rot_strided_batched_ex](interfacehipfort__rocblas_1_1rocblas__rot__strided__batched__ex.html "Interface documentation") | C binding 1177 | [rocblas_rot_strided_batched_ex_64](interfacehipfort__rocblas_1_1rocblas__rot__strided__batched__ex__64.html "Interface documentation") | C binding 1178 | [rocblas_scal_ex](interfacehipfort__rocblas_1_1rocblas__scal__ex.html "Interface documentation") | C binding 1179 | [rocblas_scal_ex_64](interfacehipfort__rocblas_1_1rocblas__scal__ex__64.html "Interface documentation") | C binding 1180 | [rocblas_scal_batched_ex](interfacehipfort__rocblas_1_1rocblas__scal__batched__ex.html "Interface documentation") | C binding 1181 | [rocblas_scal_batched_ex_64](interfacehipfort__rocblas_1_1rocblas__scal__batched__ex__64.html "Interface documentation") | C binding 1182 | [rocblas_scal_strided_batched_ex](interfacehipfort__rocblas_1_1rocblas__scal__strided__batched__ex.html "Interface documentation") | C binding 1183 | [rocblas_scal_strided_batched_ex_64](interfacehipfort__rocblas_1_1rocblas__scal__strided__batched__ex__64.html "Interface documentation") | C binding 1184 | [rocblas_status_to_string](interfacehipfort__rocblas_1_1rocblas__status__to__string.html "Interface documentation") | C binding 1185 | [rocblas_initialize](interfacehipfort__rocblas_1_1rocblas__initialize.html "Interface documentation") | C binding 1186 | [rocblas_get_version_string](interfacehipfort__rocblas_1_1rocblas__get__version__string.html "Interface documentation") | C binding 1187 | [rocblas_get_version_string_size](interfacehipfort__rocblas_1_1rocblas__get__version__string__size.html "Interface documentation") | C binding 1188 | [rocblas_get_commit_hash_string](interfacehipfort__rocblas_1_1rocblas__get__commit__hash__string.html "Interface documentation") | C binding 1189 | [rocblas_get_commit_hash_string_size](interfacehipfort__rocblas_1_1rocblas__get__commit__hash__string__size.html "Interface documentation") | C binding 1190 | [rocblas_start_device_memory_size_query](interfacehipfort__rocblas_1_1rocblas__start__device__memory__size__query.html "Interface documentation") | C binding 1191 | [rocblas_stop_device_memory_size_query](interfacehipfort__rocblas_1_1rocblas__stop__device__memory__size__query.html "Interface documentation") | C binding 1192 | [rocblas_is_device_memory_size_query](interfacehipfort__rocblas_1_1rocblas__is__device__memory__size__query.html "Interface documentation") | C binding 1193 | [rocblas_set_optimal_device_memory_size_impl](interfacehipfort__rocblas_1_1rocblas__set__optimal__device__memory__size__impl.html "Interface documentation") | C binding 1194 | [rocblas_device_malloc_alloc](interfacehipfort__rocblas_1_1rocblas__device__malloc__alloc.html "Interface documentation") | C binding 1195 | [rocblas_device_malloc_success](interfacehipfort__rocblas_1_1rocblas__device__malloc__success.html "Interface documentation") | C binding 1196 | [rocblas_device_malloc_ptr](interfacehipfort__rocblas_1_1rocblas__device__malloc__ptr.html "Interface documentation") | C binding 1197 | [rocblas_device_malloc_get](interfacehipfort__rocblas_1_1rocblas__device__malloc__get.html "Interface documentation") | C binding 1198 | [rocblas_device_malloc_free](interfacehipfort__rocblas_1_1rocblas__device__malloc__free.html "Interface documentation") | C binding 1199 | [rocblas_device_malloc_set_default_memory_size](interfacehipfort__rocblas_1_1rocblas__device__malloc__set__default__memory__size.html "Interface documentation") | C binding 1200 | [rocblas_get_device_memory_size](interfacehipfort__rocblas_1_1rocblas__get__device__memory__size.html "Interface documentation") | C binding 1201 | [rocblas_set_device_memory_size](interfacehipfort__rocblas_1_1rocblas__set__device__memory__size.html "Interface documentation") | C binding 1202 | [rocblas_set_workspace](interfacehipfort__rocblas_1_1rocblas__set__workspace.html "Interface documentation") | C binding 1203 | [rocblas_is_managing_device_memory](interfacehipfort__rocblas_1_1rocblas__is__managing__device__memory.html "Interface documentation") | C binding 1204 | [rocblas_is_user_managing_device_memory](interfacehipfort__rocblas_1_1rocblas__is__user__managing__device__memory.html "Interface documentation") | C binding 1205 | [rocblas_abort](interfacehipfort__rocblas_1_1rocblas__abort.html "Interface documentation") | C binding 1206 | [rocblas_set_vector](interfacehipfort__rocblas_1_1rocblas__set__vector.html "Interface documentation") | C binding, full_rank, rank_0, assumed_rank 1207 | [rocblas_get_vector](interfacehipfort__rocblas_1_1rocblas__get__vector.html "Interface documentation") | C binding, full_rank, rank_0, assumed_rank 1208 | [rocblas_set_matrix](interfacehipfort__rocblas_1_1rocblas__set__matrix.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1209 | [rocblas_get_matrix](interfacehipfort__rocblas_1_1rocblas__get__matrix.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1210 | [rocblas_set_vector_async](interfacehipfort__rocblas_1_1rocblas__set__vector__async.html "Interface documentation") | C binding, full_rank, rank_0, assumed_rank 1211 | [rocblas_get_vector_async](interfacehipfort__rocblas_1_1rocblas__get__vector__async.html "Interface documentation") | C binding, full_rank, rank_0, assumed_rank 1212 | [rocblas_set_matrix_async](interfacehipfort__rocblas_1_1rocblas__set__matrix__async.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 1213 | [rocblas_get_matrix_async](interfacehipfort__rocblas_1_1rocblas__get__matrix__async.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank hipfort-rocm-10.0.0/docs/doxygen/input/supported_api_rocfft.md000066400000000000000000000100211524740623400245110ustar00rootroot00000000000000# rocFFT API Support \# | API Name | Variants ----|---------------|--------- 1 | [rocfft_setup](interfacehipfort__rocfft_1_1rocfft__setup.html "Interface documentation") | C binding 2 | [rocfft_cleanup](interfacehipfort__rocfft_1_1rocfft__cleanup.html "Interface documentation") | C binding 3 | [rocfft_plan_create](interfacehipfort__rocfft_1_1rocfft__plan__create.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 4 | [rocfft_execute](interfacehipfort__rocfft_1_1rocfft__execute.html "Interface documentation") | C binding 5 | [rocfft_plan_destroy](interfacehipfort__rocfft_1_1rocfft__plan__destroy.html "Interface documentation") | C binding 6 | [rocfft_plan_description_set_scale_factor](interfacehipfort__rocfft_1_1rocfft__plan__description__set__scale__factor.html "Interface documentation") | C binding 7 | [rocfft_plan_description_set_data_layout](interfacehipfort__rocfft_1_1rocfft__plan__description__set__data__layout.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 8 | [rocfft_field_create](interfacehipfort__rocfft_1_1rocfft__field__create.html "Interface documentation") | C binding 9 | [rocfft_field_destroy](interfacehipfort__rocfft_1_1rocfft__field__destroy.html "Interface documentation") | C binding 10 | [rocfft_get_version_string](interfacehipfort__rocfft_1_1rocfft__get__version__string.html "Interface documentation") | C binding 11 | [rocfft_plan_description_set_comm](interfacehipfort__rocfft_1_1rocfft__plan__description__set__comm.html "Interface documentation") | C binding 12 | [rocfft_brick_create](interfacehipfort__rocfft_1_1rocfft__brick__create.html "Interface documentation") | C binding 13 | [rocfft_brick_destroy](interfacehipfort__rocfft_1_1rocfft__brick__destroy.html "Interface documentation") | C binding 14 | [rocfft_field_add_brick](interfacehipfort__rocfft_1_1rocfft__field__add__brick.html "Interface documentation") | C binding 15 | [rocfft_plan_description_add_infield](interfacehipfort__rocfft_1_1rocfft__plan__description__add__infield.html "Interface documentation") | C binding 16 | [rocfft_plan_description_add_outfield](interfacehipfort__rocfft_1_1rocfft__plan__description__add__outfield.html "Interface documentation") | C binding 17 | [rocfft_plan_get_work_buffer_size](interfacehipfort__rocfft_1_1rocfft__plan__get__work__buffer__size.html "Interface documentation") | C binding 18 | [rocfft_plan_get_print](interfacehipfort__rocfft_1_1rocfft__plan__get__print.html "Interface documentation") | C binding 19 | [rocfft_plan_description_create](interfacehipfort__rocfft_1_1rocfft__plan__description__create.html "Interface documentation") | C binding 20 | [rocfft_plan_description_destroy](interfacehipfort__rocfft_1_1rocfft__plan__description__destroy.html "Interface documentation") | C binding 21 | [rocfft_execution_info_create](interfacehipfort__rocfft_1_1rocfft__execution__info__create.html "Interface documentation") | C binding 22 | [rocfft_execution_info_destroy](interfacehipfort__rocfft_1_1rocfft__execution__info__destroy.html "Interface documentation") | C binding 23 | [rocfft_execution_info_set_work_buffer](interfacehipfort__rocfft_1_1rocfft__execution__info__set__work__buffer.html "Interface documentation") | C binding 24 | [rocfft_execution_info_set_stream](interfacehipfort__rocfft_1_1rocfft__execution__info__set__stream.html "Interface documentation") | C binding 25 | [rocfft_execution_info_set_load_callback](interfacehipfort__rocfft_1_1rocfft__execution__info__set__load__callback.html "Interface documentation") | C binding 26 | [rocfft_execution_info_set_store_callback](interfacehipfort__rocfft_1_1rocfft__execution__info__set__store__callback.html "Interface documentation") | C binding 27 | [rocfft_cache_serialize](interfacehipfort__rocfft_1_1rocfft__cache__serialize.html "Interface documentation") | C binding 28 | [rocfft_cache_buffer_free](interfacehipfort__rocfft_1_1rocfft__cache__buffer__free.html "Interface documentation") | C binding 29 | [rocfft_cache_deserialize](interfacehipfort__rocfft_1_1rocfft__cache__deserialize.html "Interface documentation") | C binding hipfort-rocm-10.0.0/docs/doxygen/input/supported_api_rocrand.md000066400000000000000000000115531524740623400246710ustar00rootroot00000000000000# rocRAND API Support \# | API Name | Variants ----|---------------|--------- 1 | [rocrand_create_generator](interfacehipfort__rocrand_1_1rocrand__create__generator.html "Interface documentation") | C binding 2 | [rocrand_create_generator_host](interfacehipfort__rocrand_1_1rocrand__create__generator__host.html "Interface documentation") | C binding 3 | [rocrand_create_generator_host_blocking](interfacehipfort__rocrand_1_1rocrand__create__generator__host__blocking.html "Interface documentation") | C binding 4 | [rocrand_destroy_generator](interfacehipfort__rocrand_1_1rocrand__destroy__generator.html "Interface documentation") | C binding 5 | [rocrand_generate](interfacehipfort__rocrand_1_1rocrand__generate.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 6 | [rocrand_generate_long_long](interfacehipfort__rocrand_1_1rocrand__generate__long__long.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 7 | [rocrand_generate_char](interfacehipfort__rocrand_1_1rocrand__generate__char.html "Interface documentation") | C binding 8 | [rocrand_generate_short](interfacehipfort__rocrand_1_1rocrand__generate__short.html "Interface documentation") | C binding 9 | [rocrand_generate_uniform](interfacehipfort__rocrand_1_1rocrand__generate__uniform.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 10 | [rocrand_generate_uniform_double](interfacehipfort__rocrand_1_1rocrand__generate__uniform__double.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 11 | [rocrand_generate_uniform_half](interfacehipfort__rocrand_1_1rocrand__generate__uniform__half.html "Interface documentation") | C binding 12 | [rocrand_generate_normal](interfacehipfort__rocrand_1_1rocrand__generate__normal.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 13 | [rocrand_generate_normal_double](interfacehipfort__rocrand_1_1rocrand__generate__normal__double.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 14 | [rocrand_generate_normal_half](interfacehipfort__rocrand_1_1rocrand__generate__normal__half.html "Interface documentation") | C binding 15 | [rocrand_generate_log_normal](interfacehipfort__rocrand_1_1rocrand__generate__log__normal.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 16 | [rocrand_generate_log_normal_double](interfacehipfort__rocrand_1_1rocrand__generate__log__normal__double.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 17 | [rocrand_generate_log_normal_half](interfacehipfort__rocrand_1_1rocrand__generate__log__normal__half.html "Interface documentation") | C binding 18 | [rocrand_generate_poisson](interfacehipfort__rocrand_1_1rocrand__generate__poisson.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 19 | [rocrand_initialize_generator](interfacehipfort__rocrand_1_1rocrand__initialize__generator.html "Interface documentation") | C binding 20 | [rocrand_set_stream](interfacehipfort__rocrand_1_1rocrand__set__stream.html "Interface documentation") | C binding 21 | [rocrand_set_seed](interfacehipfort__rocrand_1_1rocrand__set__seed.html "Interface documentation") | C binding 22 | [rocrand_set_seed_uint4](interfacehipfort__rocrand_1_1rocrand__set__seed__uint4.html "Interface documentation") | C binding 23 | [rocrand_set_offset](interfacehipfort__rocrand_1_1rocrand__set__offset.html "Interface documentation") | C binding 24 | [rocrand_set_ordering](interfacehipfort__rocrand_1_1rocrand__set__ordering.html "Interface documentation") | C binding 25 | [rocrand_set_quasi_random_generator_dimensions](interfacehipfort__rocrand_1_1rocrand__set__quasi__random__generator__dimensions.html "Interface documentation") | C binding 26 | [rocrand_get_version](interfacehipfort__rocrand_1_1rocrand__get__version.html "Interface documentation") | C binding 27 | [rocrand_create_poisson_distribution](interfacehipfort__rocrand_1_1rocrand__create__poisson__distribution.html "Interface documentation") | C binding 28 | [rocrand_create_discrete_distribution](interfacehipfort__rocrand_1_1rocrand__create__discrete__distribution.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 29 | [rocrand_destroy_discrete_distribution](interfacehipfort__rocrand_1_1rocrand__destroy__discrete__distribution.html "Interface documentation") | C binding 30 | [rocrand_get_direction_vectors32](interfacehipfort__rocrand_1_1rocrand__get__direction__vectors32.html "Interface documentation") | C binding 31 | [rocrand_get_direction_vectors64](interfacehipfort__rocrand_1_1rocrand__get__direction__vectors64.html "Interface documentation") | C binding 32 | [rocrand_get_scramble_constants32](interfacehipfort__rocrand_1_1rocrand__get__scramble__constants32.html "Interface documentation") | C binding 33 | [rocrand_get_scramble_constants64](interfacehipfort__rocrand_1_1rocrand__get__scramble__constants64.html "Interface documentation") | C binding hipfort-rocm-10.0.0/docs/doxygen/input/supported_api_rocsolver.md000066400000000000000000004570701524740623400252670ustar00rootroot00000000000000# rocSOLVER API Support \# | API Name | Variants ----|---------------|--------- 1 | [rocsolver_get_version_string](interfacehipfort__rocsolver_1_1rocsolver__get__version__string.html "Interface documentation") | C binding 2 | [rocsolver_get_version_string_size](interfacehipfort__rocsolver_1_1rocsolver__get__version__string__size.html "Interface documentation") | C binding 3 | [rocsolver_log_begin](interfacehipfort__rocsolver_1_1rocsolver__log__begin.html "Interface documentation") | C binding 4 | [rocsolver_log_end](interfacehipfort__rocsolver_1_1rocsolver__log__end.html "Interface documentation") | C binding 5 | [rocsolver_log_set_layer_mode](interfacehipfort__rocsolver_1_1rocsolver__log__set__layer__mode.html "Interface documentation") | C binding 6 | [rocsolver_log_set_max_levels](interfacehipfort__rocsolver_1_1rocsolver__log__set__max__levels.html "Interface documentation") | C binding 7 | [rocsolver_log_restore_defaults](interfacehipfort__rocsolver_1_1rocsolver__log__restore__defaults.html "Interface documentation") | C binding 8 | [rocsolver_log_write_profile](interfacehipfort__rocsolver_1_1rocsolver__log__write__profile.html "Interface documentation") | C binding 9 | [rocsolver_log_flush_profile](interfacehipfort__rocsolver_1_1rocsolver__log__flush__profile.html "Interface documentation") | C binding 10 | [rocsolver_set_alg_mode](interfacehipfort__rocsolver_1_1rocsolver__set__alg__mode.html "Interface documentation") | C binding 11 | [rocsolver_get_alg_mode](interfacehipfort__rocsolver_1_1rocsolver__get__alg__mode.html "Interface documentation") | C binding 12 | [rocsolver_clacgv](interfacehipfort__rocsolver_1_1rocsolver__clacgv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 13 | [rocsolver_zlacgv](interfacehipfort__rocsolver_1_1rocsolver__zlacgv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 14 | [rocsolver_clacgv_64](interfacehipfort__rocsolver_1_1rocsolver__clacgv__64.html "Interface documentation") | C binding 15 | [rocsolver_zlacgv_64](interfacehipfort__rocsolver_1_1rocsolver__zlacgv__64.html "Interface documentation") | C binding 16 | [rocsolver_slange](interfacehipfort__rocsolver_1_1rocsolver__slange.html "Interface documentation") | C binding 17 | [rocsolver_dlange](interfacehipfort__rocsolver_1_1rocsolver__dlange.html "Interface documentation") | C binding 18 | [rocsolver_clange](interfacehipfort__rocsolver_1_1rocsolver__clange.html "Interface documentation") | C binding 19 | [rocsolver_zlange](interfacehipfort__rocsolver_1_1rocsolver__zlange.html "Interface documentation") | C binding 20 | [rocsolver_slange_64](interfacehipfort__rocsolver_1_1rocsolver__slange__64.html "Interface documentation") | C binding 21 | [rocsolver_dlange_64](interfacehipfort__rocsolver_1_1rocsolver__dlange__64.html "Interface documentation") | C binding 22 | [rocsolver_clange_64](interfacehipfort__rocsolver_1_1rocsolver__clange__64.html "Interface documentation") | C binding 23 | [rocsolver_zlange_64](interfacehipfort__rocsolver_1_1rocsolver__zlange__64.html "Interface documentation") | C binding 24 | [rocsolver_sgecon](interfacehipfort__rocsolver_1_1rocsolver__sgecon.html "Interface documentation") | C binding 25 | [rocsolver_dgecon](interfacehipfort__rocsolver_1_1rocsolver__dgecon.html "Interface documentation") | C binding 26 | [rocsolver_cgecon](interfacehipfort__rocsolver_1_1rocsolver__cgecon.html "Interface documentation") | C binding 27 | [rocsolver_zgecon](interfacehipfort__rocsolver_1_1rocsolver__zgecon.html "Interface documentation") | C binding 28 | [rocsolver_sgecon_64](interfacehipfort__rocsolver_1_1rocsolver__sgecon__64.html "Interface documentation") | C binding 29 | [rocsolver_dgecon_64](interfacehipfort__rocsolver_1_1rocsolver__dgecon__64.html "Interface documentation") | C binding 30 | [rocsolver_cgecon_64](interfacehipfort__rocsolver_1_1rocsolver__cgecon__64.html "Interface documentation") | C binding 31 | [rocsolver_zgecon_64](interfacehipfort__rocsolver_1_1rocsolver__zgecon__64.html "Interface documentation") | C binding 32 | [rocsolver_slaswp](interfacehipfort__rocsolver_1_1rocsolver__slaswp.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 33 | [rocsolver_dlaswp](interfacehipfort__rocsolver_1_1rocsolver__dlaswp.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 34 | [rocsolver_claswp](interfacehipfort__rocsolver_1_1rocsolver__claswp.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 35 | [rocsolver_zlaswp](interfacehipfort__rocsolver_1_1rocsolver__zlaswp.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 36 | [rocsolver_slarfg](interfacehipfort__rocsolver_1_1rocsolver__slarfg.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 37 | [rocsolver_dlarfg](interfacehipfort__rocsolver_1_1rocsolver__dlarfg.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 38 | [rocsolver_clarfg](interfacehipfort__rocsolver_1_1rocsolver__clarfg.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 39 | [rocsolver_zlarfg](interfacehipfort__rocsolver_1_1rocsolver__zlarfg.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 40 | [rocsolver_slarfg_64](interfacehipfort__rocsolver_1_1rocsolver__slarfg__64.html "Interface documentation") | C binding 41 | [rocsolver_dlarfg_64](interfacehipfort__rocsolver_1_1rocsolver__dlarfg__64.html "Interface documentation") | C binding 42 | [rocsolver_clarfg_64](interfacehipfort__rocsolver_1_1rocsolver__clarfg__64.html "Interface documentation") | C binding 43 | [rocsolver_zlarfg_64](interfacehipfort__rocsolver_1_1rocsolver__zlarfg__64.html "Interface documentation") | C binding 44 | [rocsolver_slarft](interfacehipfort__rocsolver_1_1rocsolver__slarft.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 45 | [rocsolver_dlarft](interfacehipfort__rocsolver_1_1rocsolver__dlarft.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 46 | [rocsolver_clarft](interfacehipfort__rocsolver_1_1rocsolver__clarft.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 47 | [rocsolver_zlarft](interfacehipfort__rocsolver_1_1rocsolver__zlarft.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 48 | [rocsolver_slarf](interfacehipfort__rocsolver_1_1rocsolver__slarf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 49 | [rocsolver_dlarf](interfacehipfort__rocsolver_1_1rocsolver__dlarf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 50 | [rocsolver_clarf](interfacehipfort__rocsolver_1_1rocsolver__clarf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 51 | [rocsolver_zlarf](interfacehipfort__rocsolver_1_1rocsolver__zlarf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 52 | [rocsolver_slarf_64](interfacehipfort__rocsolver_1_1rocsolver__slarf__64.html "Interface documentation") | C binding 53 | [rocsolver_dlarf_64](interfacehipfort__rocsolver_1_1rocsolver__dlarf__64.html "Interface documentation") | C binding 54 | [rocsolver_clarf_64](interfacehipfort__rocsolver_1_1rocsolver__clarf__64.html "Interface documentation") | C binding 55 | [rocsolver_zlarf_64](interfacehipfort__rocsolver_1_1rocsolver__zlarf__64.html "Interface documentation") | C binding 56 | [rocsolver_slarfb](interfacehipfort__rocsolver_1_1rocsolver__slarfb.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 57 | [rocsolver_dlarfb](interfacehipfort__rocsolver_1_1rocsolver__dlarfb.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 58 | [rocsolver_clarfb](interfacehipfort__rocsolver_1_1rocsolver__clarfb.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 59 | [rocsolver_zlarfb](interfacehipfort__rocsolver_1_1rocsolver__zlarfb.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 60 | [rocsolver_slasr](interfacehipfort__rocsolver_1_1rocsolver__slasr.html "Interface documentation") | C binding 61 | [rocsolver_dlasr](interfacehipfort__rocsolver_1_1rocsolver__dlasr.html "Interface documentation") | C binding 62 | [rocsolver_clasr](interfacehipfort__rocsolver_1_1rocsolver__clasr.html "Interface documentation") | C binding 63 | [rocsolver_zlasr](interfacehipfort__rocsolver_1_1rocsolver__zlasr.html "Interface documentation") | C binding 64 | [rocsolver_slabrd](interfacehipfort__rocsolver_1_1rocsolver__slabrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 65 | [rocsolver_dlabrd](interfacehipfort__rocsolver_1_1rocsolver__dlabrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 66 | [rocsolver_clabrd](interfacehipfort__rocsolver_1_1rocsolver__clabrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 67 | [rocsolver_zlabrd](interfacehipfort__rocsolver_1_1rocsolver__zlabrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 68 | [rocsolver_slatrd](interfacehipfort__rocsolver_1_1rocsolver__slatrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 69 | [rocsolver_dlatrd](interfacehipfort__rocsolver_1_1rocsolver__dlatrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 70 | [rocsolver_clatrd](interfacehipfort__rocsolver_1_1rocsolver__clatrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 71 | [rocsolver_zlatrd](interfacehipfort__rocsolver_1_1rocsolver__zlatrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 72 | [rocsolver_slasyf](interfacehipfort__rocsolver_1_1rocsolver__slasyf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 73 | [rocsolver_dlasyf](interfacehipfort__rocsolver_1_1rocsolver__dlasyf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 74 | [rocsolver_clasyf](interfacehipfort__rocsolver_1_1rocsolver__clasyf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 75 | [rocsolver_zlasyf](interfacehipfort__rocsolver_1_1rocsolver__zlasyf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 76 | [rocsolver_slauum](interfacehipfort__rocsolver_1_1rocsolver__slauum.html "Interface documentation") | C binding 77 | [rocsolver_dlauum](interfacehipfort__rocsolver_1_1rocsolver__dlauum.html "Interface documentation") | C binding 78 | [rocsolver_clauum](interfacehipfort__rocsolver_1_1rocsolver__clauum.html "Interface documentation") | C binding 79 | [rocsolver_zlauum](interfacehipfort__rocsolver_1_1rocsolver__zlauum.html "Interface documentation") | C binding 80 | [rocsolver_sorg2r](interfacehipfort__rocsolver_1_1rocsolver__sorg2r.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 81 | [rocsolver_dorg2r](interfacehipfort__rocsolver_1_1rocsolver__dorg2r.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 82 | [rocsolver_cung2r](interfacehipfort__rocsolver_1_1rocsolver__cung2r.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 83 | [rocsolver_zung2r](interfacehipfort__rocsolver_1_1rocsolver__zung2r.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 84 | [rocsolver_sorgqr](interfacehipfort__rocsolver_1_1rocsolver__sorgqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 85 | [rocsolver_dorgqr](interfacehipfort__rocsolver_1_1rocsolver__dorgqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 86 | [rocsolver_cungqr](interfacehipfort__rocsolver_1_1rocsolver__cungqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 87 | [rocsolver_zungqr](interfacehipfort__rocsolver_1_1rocsolver__zungqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 88 | [rocsolver_sorgl2](interfacehipfort__rocsolver_1_1rocsolver__sorgl2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 89 | [rocsolver_dorgl2](interfacehipfort__rocsolver_1_1rocsolver__dorgl2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 90 | [rocsolver_cungl2](interfacehipfort__rocsolver_1_1rocsolver__cungl2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 91 | [rocsolver_zungl2](interfacehipfort__rocsolver_1_1rocsolver__zungl2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 92 | [rocsolver_sorglq](interfacehipfort__rocsolver_1_1rocsolver__sorglq.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 93 | [rocsolver_dorglq](interfacehipfort__rocsolver_1_1rocsolver__dorglq.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 94 | [rocsolver_cunglq](interfacehipfort__rocsolver_1_1rocsolver__cunglq.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 95 | [rocsolver_zunglq](interfacehipfort__rocsolver_1_1rocsolver__zunglq.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 96 | [rocsolver_sorg2l](interfacehipfort__rocsolver_1_1rocsolver__sorg2l.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 97 | [rocsolver_dorg2l](interfacehipfort__rocsolver_1_1rocsolver__dorg2l.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 98 | [rocsolver_cung2l](interfacehipfort__rocsolver_1_1rocsolver__cung2l.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 99 | [rocsolver_zung2l](interfacehipfort__rocsolver_1_1rocsolver__zung2l.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 100 | [rocsolver_sorgql](interfacehipfort__rocsolver_1_1rocsolver__sorgql.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 101 | [rocsolver_dorgql](interfacehipfort__rocsolver_1_1rocsolver__dorgql.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 102 | [rocsolver_cungql](interfacehipfort__rocsolver_1_1rocsolver__cungql.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 103 | [rocsolver_zungql](interfacehipfort__rocsolver_1_1rocsolver__zungql.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 104 | [rocsolver_sorgbr](interfacehipfort__rocsolver_1_1rocsolver__sorgbr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 105 | [rocsolver_dorgbr](interfacehipfort__rocsolver_1_1rocsolver__dorgbr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 106 | [rocsolver_cungbr](interfacehipfort__rocsolver_1_1rocsolver__cungbr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 107 | [rocsolver_zungbr](interfacehipfort__rocsolver_1_1rocsolver__zungbr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 108 | [rocsolver_sorgtr](interfacehipfort__rocsolver_1_1rocsolver__sorgtr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 109 | [rocsolver_dorgtr](interfacehipfort__rocsolver_1_1rocsolver__dorgtr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 110 | [rocsolver_cungtr](interfacehipfort__rocsolver_1_1rocsolver__cungtr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 111 | [rocsolver_zungtr](interfacehipfort__rocsolver_1_1rocsolver__zungtr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 112 | [rocsolver_sorm2r](interfacehipfort__rocsolver_1_1rocsolver__sorm2r.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 113 | [rocsolver_dorm2r](interfacehipfort__rocsolver_1_1rocsolver__dorm2r.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 114 | [rocsolver_cunm2r](interfacehipfort__rocsolver_1_1rocsolver__cunm2r.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 115 | [rocsolver_zunm2r](interfacehipfort__rocsolver_1_1rocsolver__zunm2r.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 116 | [rocsolver_sormqr](interfacehipfort__rocsolver_1_1rocsolver__sormqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 117 | [rocsolver_dormqr](interfacehipfort__rocsolver_1_1rocsolver__dormqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 118 | [rocsolver_cunmqr](interfacehipfort__rocsolver_1_1rocsolver__cunmqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 119 | [rocsolver_zunmqr](interfacehipfort__rocsolver_1_1rocsolver__zunmqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 120 | [rocsolver_sorml2](interfacehipfort__rocsolver_1_1rocsolver__sorml2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 121 | [rocsolver_dorml2](interfacehipfort__rocsolver_1_1rocsolver__dorml2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 122 | [rocsolver_cunml2](interfacehipfort__rocsolver_1_1rocsolver__cunml2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 123 | [rocsolver_zunml2](interfacehipfort__rocsolver_1_1rocsolver__zunml2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 124 | [rocsolver_sormlq](interfacehipfort__rocsolver_1_1rocsolver__sormlq.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 125 | [rocsolver_dormlq](interfacehipfort__rocsolver_1_1rocsolver__dormlq.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 126 | [rocsolver_cunmlq](interfacehipfort__rocsolver_1_1rocsolver__cunmlq.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 127 | [rocsolver_zunmlq](interfacehipfort__rocsolver_1_1rocsolver__zunmlq.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 128 | [rocsolver_sorm2l](interfacehipfort__rocsolver_1_1rocsolver__sorm2l.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 129 | [rocsolver_dorm2l](interfacehipfort__rocsolver_1_1rocsolver__dorm2l.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 130 | [rocsolver_cunm2l](interfacehipfort__rocsolver_1_1rocsolver__cunm2l.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 131 | [rocsolver_zunm2l](interfacehipfort__rocsolver_1_1rocsolver__zunm2l.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 132 | [rocsolver_sormql](interfacehipfort__rocsolver_1_1rocsolver__sormql.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 133 | [rocsolver_dormql](interfacehipfort__rocsolver_1_1rocsolver__dormql.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 134 | [rocsolver_cunmql](interfacehipfort__rocsolver_1_1rocsolver__cunmql.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 135 | [rocsolver_zunmql](interfacehipfort__rocsolver_1_1rocsolver__zunmql.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 136 | [rocsolver_sormbr](interfacehipfort__rocsolver_1_1rocsolver__sormbr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 137 | [rocsolver_dormbr](interfacehipfort__rocsolver_1_1rocsolver__dormbr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 138 | [rocsolver_cunmbr](interfacehipfort__rocsolver_1_1rocsolver__cunmbr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 139 | [rocsolver_zunmbr](interfacehipfort__rocsolver_1_1rocsolver__zunmbr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 140 | [rocsolver_sormtr](interfacehipfort__rocsolver_1_1rocsolver__sormtr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 141 | [rocsolver_dormtr](interfacehipfort__rocsolver_1_1rocsolver__dormtr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 142 | [rocsolver_cunmtr](interfacehipfort__rocsolver_1_1rocsolver__cunmtr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 143 | [rocsolver_zunmtr](interfacehipfort__rocsolver_1_1rocsolver__zunmtr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 144 | [rocsolver_sbdsqr](interfacehipfort__rocsolver_1_1rocsolver__sbdsqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 145 | [rocsolver_dbdsqr](interfacehipfort__rocsolver_1_1rocsolver__dbdsqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 146 | [rocsolver_cbdsqr](interfacehipfort__rocsolver_1_1rocsolver__cbdsqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 147 | [rocsolver_zbdsqr](interfacehipfort__rocsolver_1_1rocsolver__zbdsqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 148 | [rocsolver_ssterf](interfacehipfort__rocsolver_1_1rocsolver__ssterf.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 149 | [rocsolver_dsterf](interfacehipfort__rocsolver_1_1rocsolver__dsterf.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 150 | [rocsolver_ssteqr](interfacehipfort__rocsolver_1_1rocsolver__ssteqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 151 | [rocsolver_dsteqr](interfacehipfort__rocsolver_1_1rocsolver__dsteqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 152 | [rocsolver_csteqr](interfacehipfort__rocsolver_1_1rocsolver__csteqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 153 | [rocsolver_zsteqr](interfacehipfort__rocsolver_1_1rocsolver__zsteqr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 154 | [rocsolver_sstedc](interfacehipfort__rocsolver_1_1rocsolver__sstedc.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 155 | [rocsolver_dstedc](interfacehipfort__rocsolver_1_1rocsolver__dstedc.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 156 | [rocsolver_cstedc](interfacehipfort__rocsolver_1_1rocsolver__cstedc.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 157 | [rocsolver_zstedc](interfacehipfort__rocsolver_1_1rocsolver__zstedc.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 158 | [rocsolver_sstebz](interfacehipfort__rocsolver_1_1rocsolver__sstebz.html "Interface documentation") | C binding 159 | [rocsolver_dstebz](interfacehipfort__rocsolver_1_1rocsolver__dstebz.html "Interface documentation") | C binding 160 | [rocsolver_sstein](interfacehipfort__rocsolver_1_1rocsolver__sstein.html "Interface documentation") | C binding 161 | [rocsolver_dstein](interfacehipfort__rocsolver_1_1rocsolver__dstein.html "Interface documentation") | C binding 162 | [rocsolver_cstein](interfacehipfort__rocsolver_1_1rocsolver__cstein.html "Interface documentation") | C binding 163 | [rocsolver_zstein](interfacehipfort__rocsolver_1_1rocsolver__zstein.html "Interface documentation") | C binding 164 | [rocsolver_sbdsvdx](interfacehipfort__rocsolver_1_1rocsolver__sbdsvdx.html "Interface documentation") | C binding 165 | [rocsolver_dbdsvdx](interfacehipfort__rocsolver_1_1rocsolver__dbdsvdx.html "Interface documentation") | C binding 166 | [rocsolver_sgetf2_npvt](interfacehipfort__rocsolver_1_1rocsolver__sgetf2__npvt.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 167 | [rocsolver_dgetf2_npvt](interfacehipfort__rocsolver_1_1rocsolver__dgetf2__npvt.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 168 | [rocsolver_cgetf2_npvt](interfacehipfort__rocsolver_1_1rocsolver__cgetf2__npvt.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 169 | [rocsolver_zgetf2_npvt](interfacehipfort__rocsolver_1_1rocsolver__zgetf2__npvt.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 170 | [rocsolver_sgetf2_npvt_64](interfacehipfort__rocsolver_1_1rocsolver__sgetf2__npvt__64.html "Interface documentation") | C binding 171 | [rocsolver_dgetf2_npvt_64](interfacehipfort__rocsolver_1_1rocsolver__dgetf2__npvt__64.html "Interface documentation") | C binding 172 | [rocsolver_cgetf2_npvt_64](interfacehipfort__rocsolver_1_1rocsolver__cgetf2__npvt__64.html "Interface documentation") | C binding 173 | [rocsolver_zgetf2_npvt_64](interfacehipfort__rocsolver_1_1rocsolver__zgetf2__npvt__64.html "Interface documentation") | C binding 174 | [rocsolver_sgetf2_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetf2__npvt__batched.html "Interface documentation") | C binding 175 | [rocsolver_dgetf2_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetf2__npvt__batched.html "Interface documentation") | C binding 176 | [rocsolver_cgetf2_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetf2__npvt__batched.html "Interface documentation") | C binding 177 | [rocsolver_zgetf2_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetf2__npvt__batched.html "Interface documentation") | C binding 178 | [rocsolver_sgetf2_npvt_batched_64](interfacehipfort__rocsolver_1_1rocsolver__sgetf2__npvt__batched__64.html "Interface documentation") | C binding 179 | [rocsolver_dgetf2_npvt_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dgetf2__npvt__batched__64.html "Interface documentation") | C binding 180 | [rocsolver_cgetf2_npvt_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cgetf2__npvt__batched__64.html "Interface documentation") | C binding 181 | [rocsolver_zgetf2_npvt_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zgetf2__npvt__batched__64.html "Interface documentation") | C binding 182 | [rocsolver_sgetf2_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetf2__npvt__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 183 | [rocsolver_dgetf2_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetf2__npvt__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 184 | [rocsolver_cgetf2_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetf2__npvt__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 185 | [rocsolver_zgetf2_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetf2__npvt__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 186 | [rocsolver_sgetf2_npvt_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__sgetf2__npvt__strided__batched__64.html "Interface documentation") | C binding 187 | [rocsolver_dgetf2_npvt_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dgetf2__npvt__strided__batched__64.html "Interface documentation") | C binding 188 | [rocsolver_cgetf2_npvt_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cgetf2__npvt__strided__batched__64.html "Interface documentation") | C binding 189 | [rocsolver_zgetf2_npvt_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zgetf2__npvt__strided__batched__64.html "Interface documentation") | C binding 190 | [rocsolver_sgetrf_npvt](interfacehipfort__rocsolver_1_1rocsolver__sgetrf__npvt.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 191 | [rocsolver_dgetrf_npvt](interfacehipfort__rocsolver_1_1rocsolver__dgetrf__npvt.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 192 | [rocsolver_cgetrf_npvt](interfacehipfort__rocsolver_1_1rocsolver__cgetrf__npvt.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 193 | [rocsolver_zgetrf_npvt](interfacehipfort__rocsolver_1_1rocsolver__zgetrf__npvt.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 194 | [rocsolver_sgetrf_npvt_64](interfacehipfort__rocsolver_1_1rocsolver__sgetrf__npvt__64.html "Interface documentation") | C binding 195 | [rocsolver_dgetrf_npvt_64](interfacehipfort__rocsolver_1_1rocsolver__dgetrf__npvt__64.html "Interface documentation") | C binding 196 | [rocsolver_cgetrf_npvt_64](interfacehipfort__rocsolver_1_1rocsolver__cgetrf__npvt__64.html "Interface documentation") | C binding 197 | [rocsolver_zgetrf_npvt_64](interfacehipfort__rocsolver_1_1rocsolver__zgetrf__npvt__64.html "Interface documentation") | C binding 198 | [rocsolver_sgetrf_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetrf__npvt__batched.html "Interface documentation") | C binding 199 | [rocsolver_dgetrf_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetrf__npvt__batched.html "Interface documentation") | C binding 200 | [rocsolver_cgetrf_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetrf__npvt__batched.html "Interface documentation") | C binding 201 | [rocsolver_zgetrf_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetrf__npvt__batched.html "Interface documentation") | C binding 202 | [rocsolver_sgetrf_npvt_batched_64](interfacehipfort__rocsolver_1_1rocsolver__sgetrf__npvt__batched__64.html "Interface documentation") | C binding 203 | [rocsolver_dgetrf_npvt_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dgetrf__npvt__batched__64.html "Interface documentation") | C binding 204 | [rocsolver_cgetrf_npvt_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cgetrf__npvt__batched__64.html "Interface documentation") | C binding 205 | [rocsolver_zgetrf_npvt_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zgetrf__npvt__batched__64.html "Interface documentation") | C binding 206 | [rocsolver_sgetrf_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetrf__npvt__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 207 | [rocsolver_dgetrf_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetrf__npvt__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 208 | [rocsolver_cgetrf_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetrf__npvt__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 209 | [rocsolver_zgetrf_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetrf__npvt__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 210 | [rocsolver_sgetrf_npvt_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__sgetrf__npvt__strided__batched__64.html "Interface documentation") | C binding 211 | [rocsolver_dgetrf_npvt_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dgetrf__npvt__strided__batched__64.html "Interface documentation") | C binding 212 | [rocsolver_cgetrf_npvt_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cgetrf__npvt__strided__batched__64.html "Interface documentation") | C binding 213 | [rocsolver_zgetrf_npvt_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zgetrf__npvt__strided__batched__64.html "Interface documentation") | C binding 214 | [rocsolver_sgetf2](interfacehipfort__rocsolver_1_1rocsolver__sgetf2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 215 | [rocsolver_dgetf2](interfacehipfort__rocsolver_1_1rocsolver__dgetf2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 216 | [rocsolver_cgetf2](interfacehipfort__rocsolver_1_1rocsolver__cgetf2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 217 | [rocsolver_zgetf2](interfacehipfort__rocsolver_1_1rocsolver__zgetf2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 218 | [rocsolver_sgetf2_64](interfacehipfort__rocsolver_1_1rocsolver__sgetf2__64.html "Interface documentation") | C binding 219 | [rocsolver_dgetf2_64](interfacehipfort__rocsolver_1_1rocsolver__dgetf2__64.html "Interface documentation") | C binding 220 | [rocsolver_cgetf2_64](interfacehipfort__rocsolver_1_1rocsolver__cgetf2__64.html "Interface documentation") | C binding 221 | [rocsolver_zgetf2_64](interfacehipfort__rocsolver_1_1rocsolver__zgetf2__64.html "Interface documentation") | C binding 222 | [rocsolver_sgetf2_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetf2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 223 | [rocsolver_dgetf2_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetf2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 224 | [rocsolver_cgetf2_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetf2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 225 | [rocsolver_zgetf2_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetf2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 226 | [rocsolver_sgetf2_batched_64](interfacehipfort__rocsolver_1_1rocsolver__sgetf2__batched__64.html "Interface documentation") | C binding 227 | [rocsolver_dgetf2_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dgetf2__batched__64.html "Interface documentation") | C binding 228 | [rocsolver_cgetf2_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cgetf2__batched__64.html "Interface documentation") | C binding 229 | [rocsolver_zgetf2_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zgetf2__batched__64.html "Interface documentation") | C binding 230 | [rocsolver_sgetf2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetf2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 231 | [rocsolver_dgetf2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetf2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 232 | [rocsolver_cgetf2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetf2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 233 | [rocsolver_zgetf2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetf2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 234 | [rocsolver_sgetf2_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__sgetf2__strided__batched__64.html "Interface documentation") | C binding 235 | [rocsolver_dgetf2_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dgetf2__strided__batched__64.html "Interface documentation") | C binding 236 | [rocsolver_cgetf2_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cgetf2__strided__batched__64.html "Interface documentation") | C binding 237 | [rocsolver_zgetf2_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zgetf2__strided__batched__64.html "Interface documentation") | C binding 238 | [rocsolver_sgetrf](interfacehipfort__rocsolver_1_1rocsolver__sgetrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 239 | [rocsolver_dgetrf](interfacehipfort__rocsolver_1_1rocsolver__dgetrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 240 | [rocsolver_cgetrf](interfacehipfort__rocsolver_1_1rocsolver__cgetrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 241 | [rocsolver_zgetrf](interfacehipfort__rocsolver_1_1rocsolver__zgetrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 242 | [rocsolver_sgetrf_64](interfacehipfort__rocsolver_1_1rocsolver__sgetrf__64.html "Interface documentation") | C binding 243 | [rocsolver_dgetrf_64](interfacehipfort__rocsolver_1_1rocsolver__dgetrf__64.html "Interface documentation") | C binding 244 | [rocsolver_cgetrf_64](interfacehipfort__rocsolver_1_1rocsolver__cgetrf__64.html "Interface documentation") | C binding 245 | [rocsolver_zgetrf_64](interfacehipfort__rocsolver_1_1rocsolver__zgetrf__64.html "Interface documentation") | C binding 246 | [rocsolver_sgetrf_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetrf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 247 | [rocsolver_dgetrf_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetrf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 248 | [rocsolver_cgetrf_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetrf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 249 | [rocsolver_zgetrf_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetrf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 250 | [rocsolver_sgetrf_batched_64](interfacehipfort__rocsolver_1_1rocsolver__sgetrf__batched__64.html "Interface documentation") | C binding 251 | [rocsolver_dgetrf_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dgetrf__batched__64.html "Interface documentation") | C binding 252 | [rocsolver_cgetrf_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cgetrf__batched__64.html "Interface documentation") | C binding 253 | [rocsolver_zgetrf_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zgetrf__batched__64.html "Interface documentation") | C binding 254 | [rocsolver_sgetrf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetrf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 255 | [rocsolver_dgetrf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetrf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 256 | [rocsolver_cgetrf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetrf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 257 | [rocsolver_zgetrf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetrf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 258 | [rocsolver_sgetrf_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__sgetrf__strided__batched__64.html "Interface documentation") | C binding 259 | [rocsolver_dgetrf_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dgetrf__strided__batched__64.html "Interface documentation") | C binding 260 | [rocsolver_cgetrf_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cgetrf__strided__batched__64.html "Interface documentation") | C binding 261 | [rocsolver_zgetrf_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zgetrf__strided__batched__64.html "Interface documentation") | C binding 262 | [rocsolver_sgeqr2](interfacehipfort__rocsolver_1_1rocsolver__sgeqr2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 263 | [rocsolver_dgeqr2](interfacehipfort__rocsolver_1_1rocsolver__dgeqr2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 264 | [rocsolver_cgeqr2](interfacehipfort__rocsolver_1_1rocsolver__cgeqr2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 265 | [rocsolver_zgeqr2](interfacehipfort__rocsolver_1_1rocsolver__zgeqr2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 266 | [rocsolver_sgeqr2_64](interfacehipfort__rocsolver_1_1rocsolver__sgeqr2__64.html "Interface documentation") | C binding 267 | [rocsolver_dgeqr2_64](interfacehipfort__rocsolver_1_1rocsolver__dgeqr2__64.html "Interface documentation") | C binding 268 | [rocsolver_cgeqr2_64](interfacehipfort__rocsolver_1_1rocsolver__cgeqr2__64.html "Interface documentation") | C binding 269 | [rocsolver_zgeqr2_64](interfacehipfort__rocsolver_1_1rocsolver__zgeqr2__64.html "Interface documentation") | C binding 270 | [rocsolver_sgeqr2_batched](interfacehipfort__rocsolver_1_1rocsolver__sgeqr2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 271 | [rocsolver_dgeqr2_batched](interfacehipfort__rocsolver_1_1rocsolver__dgeqr2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 272 | [rocsolver_cgeqr2_batched](interfacehipfort__rocsolver_1_1rocsolver__cgeqr2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 273 | [rocsolver_zgeqr2_batched](interfacehipfort__rocsolver_1_1rocsolver__zgeqr2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 274 | [rocsolver_sgeqr2_batched_64](interfacehipfort__rocsolver_1_1rocsolver__sgeqr2__batched__64.html "Interface documentation") | C binding 275 | [rocsolver_dgeqr2_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dgeqr2__batched__64.html "Interface documentation") | C binding 276 | [rocsolver_cgeqr2_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cgeqr2__batched__64.html "Interface documentation") | C binding 277 | [rocsolver_zgeqr2_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zgeqr2__batched__64.html "Interface documentation") | C binding 278 | [rocsolver_sgeqr2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgeqr2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 279 | [rocsolver_dgeqr2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgeqr2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 280 | [rocsolver_cgeqr2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgeqr2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 281 | [rocsolver_zgeqr2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgeqr2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 282 | [rocsolver_sgeqr2_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__sgeqr2__strided__batched__64.html "Interface documentation") | C binding 283 | [rocsolver_dgeqr2_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dgeqr2__strided__batched__64.html "Interface documentation") | C binding 284 | [rocsolver_cgeqr2_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cgeqr2__strided__batched__64.html "Interface documentation") | C binding 285 | [rocsolver_zgeqr2_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zgeqr2__strided__batched__64.html "Interface documentation") | C binding 286 | [rocsolver_sgerq2](interfacehipfort__rocsolver_1_1rocsolver__sgerq2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 287 | [rocsolver_dgerq2](interfacehipfort__rocsolver_1_1rocsolver__dgerq2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 288 | [rocsolver_cgerq2](interfacehipfort__rocsolver_1_1rocsolver__cgerq2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 289 | [rocsolver_zgerq2](interfacehipfort__rocsolver_1_1rocsolver__zgerq2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 290 | [rocsolver_sgerq2_batched](interfacehipfort__rocsolver_1_1rocsolver__sgerq2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 291 | [rocsolver_dgerq2_batched](interfacehipfort__rocsolver_1_1rocsolver__dgerq2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 292 | [rocsolver_cgerq2_batched](interfacehipfort__rocsolver_1_1rocsolver__cgerq2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 293 | [rocsolver_zgerq2_batched](interfacehipfort__rocsolver_1_1rocsolver__zgerq2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 294 | [rocsolver_sgerq2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgerq2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 295 | [rocsolver_dgerq2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgerq2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 296 | [rocsolver_cgerq2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgerq2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 297 | [rocsolver_zgerq2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgerq2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 298 | [rocsolver_sgeql2](interfacehipfort__rocsolver_1_1rocsolver__sgeql2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 299 | [rocsolver_dgeql2](interfacehipfort__rocsolver_1_1rocsolver__dgeql2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 300 | [rocsolver_cgeql2](interfacehipfort__rocsolver_1_1rocsolver__cgeql2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 301 | [rocsolver_zgeql2](interfacehipfort__rocsolver_1_1rocsolver__zgeql2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 302 | [rocsolver_sgeql2_batched](interfacehipfort__rocsolver_1_1rocsolver__sgeql2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 303 | [rocsolver_dgeql2_batched](interfacehipfort__rocsolver_1_1rocsolver__dgeql2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 304 | [rocsolver_cgeql2_batched](interfacehipfort__rocsolver_1_1rocsolver__cgeql2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 305 | [rocsolver_zgeql2_batched](interfacehipfort__rocsolver_1_1rocsolver__zgeql2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 306 | [rocsolver_sgeql2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgeql2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 307 | [rocsolver_dgeql2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgeql2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 308 | [rocsolver_cgeql2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgeql2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 309 | [rocsolver_zgeql2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgeql2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 310 | [rocsolver_sgelq2](interfacehipfort__rocsolver_1_1rocsolver__sgelq2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 311 | [rocsolver_dgelq2](interfacehipfort__rocsolver_1_1rocsolver__dgelq2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 312 | [rocsolver_cgelq2](interfacehipfort__rocsolver_1_1rocsolver__cgelq2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 313 | [rocsolver_zgelq2](interfacehipfort__rocsolver_1_1rocsolver__zgelq2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 314 | [rocsolver_sgelq2_batched](interfacehipfort__rocsolver_1_1rocsolver__sgelq2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 315 | [rocsolver_dgelq2_batched](interfacehipfort__rocsolver_1_1rocsolver__dgelq2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 316 | [rocsolver_cgelq2_batched](interfacehipfort__rocsolver_1_1rocsolver__cgelq2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 317 | [rocsolver_zgelq2_batched](interfacehipfort__rocsolver_1_1rocsolver__zgelq2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 318 | [rocsolver_sgelq2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgelq2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 319 | [rocsolver_dgelq2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgelq2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 320 | [rocsolver_cgelq2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgelq2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 321 | [rocsolver_zgelq2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgelq2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 322 | [rocsolver_sgeqrf](interfacehipfort__rocsolver_1_1rocsolver__sgeqrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 323 | [rocsolver_dgeqrf](interfacehipfort__rocsolver_1_1rocsolver__dgeqrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 324 | [rocsolver_cgeqrf](interfacehipfort__rocsolver_1_1rocsolver__cgeqrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 325 | [rocsolver_zgeqrf](interfacehipfort__rocsolver_1_1rocsolver__zgeqrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 326 | [rocsolver_sgeqrf_64](interfacehipfort__rocsolver_1_1rocsolver__sgeqrf__64.html "Interface documentation") | C binding 327 | [rocsolver_dgeqrf_64](interfacehipfort__rocsolver_1_1rocsolver__dgeqrf__64.html "Interface documentation") | C binding 328 | [rocsolver_cgeqrf_64](interfacehipfort__rocsolver_1_1rocsolver__cgeqrf__64.html "Interface documentation") | C binding 329 | [rocsolver_zgeqrf_64](interfacehipfort__rocsolver_1_1rocsolver__zgeqrf__64.html "Interface documentation") | C binding 330 | [rocsolver_sgeqrf_batched](interfacehipfort__rocsolver_1_1rocsolver__sgeqrf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 331 | [rocsolver_dgeqrf_batched](interfacehipfort__rocsolver_1_1rocsolver__dgeqrf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 332 | [rocsolver_cgeqrf_batched](interfacehipfort__rocsolver_1_1rocsolver__cgeqrf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 333 | [rocsolver_zgeqrf_batched](interfacehipfort__rocsolver_1_1rocsolver__zgeqrf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 334 | [rocsolver_sgeqrf_batched_64](interfacehipfort__rocsolver_1_1rocsolver__sgeqrf__batched__64.html "Interface documentation") | C binding 335 | [rocsolver_dgeqrf_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dgeqrf__batched__64.html "Interface documentation") | C binding 336 | [rocsolver_cgeqrf_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cgeqrf__batched__64.html "Interface documentation") | C binding 337 | [rocsolver_zgeqrf_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zgeqrf__batched__64.html "Interface documentation") | C binding 338 | [rocsolver_sgeqrf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgeqrf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 339 | [rocsolver_dgeqrf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgeqrf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 340 | [rocsolver_cgeqrf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgeqrf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 341 | [rocsolver_zgeqrf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgeqrf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 342 | [rocsolver_sgeqrf_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__sgeqrf__strided__batched__64.html "Interface documentation") | C binding 343 | [rocsolver_dgeqrf_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dgeqrf__strided__batched__64.html "Interface documentation") | C binding 344 | [rocsolver_cgeqrf_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cgeqrf__strided__batched__64.html "Interface documentation") | C binding 345 | [rocsolver_zgeqrf_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zgeqrf__strided__batched__64.html "Interface documentation") | C binding 346 | [rocsolver_sgerqf](interfacehipfort__rocsolver_1_1rocsolver__sgerqf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 347 | [rocsolver_dgerqf](interfacehipfort__rocsolver_1_1rocsolver__dgerqf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 348 | [rocsolver_cgerqf](interfacehipfort__rocsolver_1_1rocsolver__cgerqf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 349 | [rocsolver_zgerqf](interfacehipfort__rocsolver_1_1rocsolver__zgerqf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 350 | [rocsolver_sgerqf_batched](interfacehipfort__rocsolver_1_1rocsolver__sgerqf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 351 | [rocsolver_dgerqf_batched](interfacehipfort__rocsolver_1_1rocsolver__dgerqf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 352 | [rocsolver_cgerqf_batched](interfacehipfort__rocsolver_1_1rocsolver__cgerqf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 353 | [rocsolver_zgerqf_batched](interfacehipfort__rocsolver_1_1rocsolver__zgerqf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 354 | [rocsolver_sgerqf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgerqf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 355 | [rocsolver_dgerqf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgerqf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 356 | [rocsolver_cgerqf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgerqf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 357 | [rocsolver_zgerqf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgerqf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 358 | [rocsolver_sgeqlf](interfacehipfort__rocsolver_1_1rocsolver__sgeqlf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 359 | [rocsolver_dgeqlf](interfacehipfort__rocsolver_1_1rocsolver__dgeqlf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 360 | [rocsolver_cgeqlf](interfacehipfort__rocsolver_1_1rocsolver__cgeqlf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 361 | [rocsolver_zgeqlf](interfacehipfort__rocsolver_1_1rocsolver__zgeqlf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 362 | [rocsolver_sgeqlf_batched](interfacehipfort__rocsolver_1_1rocsolver__sgeqlf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 363 | [rocsolver_dgeqlf_batched](interfacehipfort__rocsolver_1_1rocsolver__dgeqlf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 364 | [rocsolver_cgeqlf_batched](interfacehipfort__rocsolver_1_1rocsolver__cgeqlf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 365 | [rocsolver_zgeqlf_batched](interfacehipfort__rocsolver_1_1rocsolver__zgeqlf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 366 | [rocsolver_sgeqlf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgeqlf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 367 | [rocsolver_dgeqlf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgeqlf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 368 | [rocsolver_cgeqlf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgeqlf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 369 | [rocsolver_zgeqlf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgeqlf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 370 | [rocsolver_sgelqf](interfacehipfort__rocsolver_1_1rocsolver__sgelqf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 371 | [rocsolver_dgelqf](interfacehipfort__rocsolver_1_1rocsolver__dgelqf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 372 | [rocsolver_cgelqf](interfacehipfort__rocsolver_1_1rocsolver__cgelqf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 373 | [rocsolver_zgelqf](interfacehipfort__rocsolver_1_1rocsolver__zgelqf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 374 | [rocsolver_sgelqf_batched](interfacehipfort__rocsolver_1_1rocsolver__sgelqf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 375 | [rocsolver_dgelqf_batched](interfacehipfort__rocsolver_1_1rocsolver__dgelqf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 376 | [rocsolver_cgelqf_batched](interfacehipfort__rocsolver_1_1rocsolver__cgelqf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 377 | [rocsolver_zgelqf_batched](interfacehipfort__rocsolver_1_1rocsolver__zgelqf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 378 | [rocsolver_sgelqf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgelqf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 379 | [rocsolver_dgelqf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgelqf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 380 | [rocsolver_cgelqf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgelqf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 381 | [rocsolver_zgelqf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgelqf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 382 | [rocsolver_sgebd2](interfacehipfort__rocsolver_1_1rocsolver__sgebd2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 383 | [rocsolver_dgebd2](interfacehipfort__rocsolver_1_1rocsolver__dgebd2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 384 | [rocsolver_cgebd2](interfacehipfort__rocsolver_1_1rocsolver__cgebd2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 385 | [rocsolver_zgebd2](interfacehipfort__rocsolver_1_1rocsolver__zgebd2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 386 | [rocsolver_sgebd2_batched](interfacehipfort__rocsolver_1_1rocsolver__sgebd2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 387 | [rocsolver_dgebd2_batched](interfacehipfort__rocsolver_1_1rocsolver__dgebd2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 388 | [rocsolver_cgebd2_batched](interfacehipfort__rocsolver_1_1rocsolver__cgebd2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 389 | [rocsolver_zgebd2_batched](interfacehipfort__rocsolver_1_1rocsolver__zgebd2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 390 | [rocsolver_sgebd2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgebd2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 391 | [rocsolver_dgebd2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgebd2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 392 | [rocsolver_cgebd2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgebd2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 393 | [rocsolver_zgebd2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgebd2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 394 | [rocsolver_sgebrd](interfacehipfort__rocsolver_1_1rocsolver__sgebrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 395 | [rocsolver_dgebrd](interfacehipfort__rocsolver_1_1rocsolver__dgebrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 396 | [rocsolver_cgebrd](interfacehipfort__rocsolver_1_1rocsolver__cgebrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 397 | [rocsolver_zgebrd](interfacehipfort__rocsolver_1_1rocsolver__zgebrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 398 | [rocsolver_sgebrd_batched](interfacehipfort__rocsolver_1_1rocsolver__sgebrd__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 399 | [rocsolver_dgebrd_batched](interfacehipfort__rocsolver_1_1rocsolver__dgebrd__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 400 | [rocsolver_cgebrd_batched](interfacehipfort__rocsolver_1_1rocsolver__cgebrd__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 401 | [rocsolver_zgebrd_batched](interfacehipfort__rocsolver_1_1rocsolver__zgebrd__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 402 | [rocsolver_sgebrd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgebrd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 403 | [rocsolver_dgebrd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgebrd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 404 | [rocsolver_cgebrd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgebrd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 405 | [rocsolver_zgebrd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgebrd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 406 | [rocsolver_sgetrs](interfacehipfort__rocsolver_1_1rocsolver__sgetrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 407 | [rocsolver_dgetrs](interfacehipfort__rocsolver_1_1rocsolver__dgetrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 408 | [rocsolver_cgetrs](interfacehipfort__rocsolver_1_1rocsolver__cgetrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 409 | [rocsolver_zgetrs](interfacehipfort__rocsolver_1_1rocsolver__zgetrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 410 | [rocsolver_sgetrs_64](interfacehipfort__rocsolver_1_1rocsolver__sgetrs__64.html "Interface documentation") | C binding 411 | [rocsolver_dgetrs_64](interfacehipfort__rocsolver_1_1rocsolver__dgetrs__64.html "Interface documentation") | C binding 412 | [rocsolver_cgetrs_64](interfacehipfort__rocsolver_1_1rocsolver__cgetrs__64.html "Interface documentation") | C binding 413 | [rocsolver_zgetrs_64](interfacehipfort__rocsolver_1_1rocsolver__zgetrs__64.html "Interface documentation") | C binding 414 | [rocsolver_sgetrs_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetrs__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 415 | [rocsolver_dgetrs_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetrs__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 416 | [rocsolver_cgetrs_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetrs__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 417 | [rocsolver_zgetrs_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetrs__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 418 | [rocsolver_sgetrs_batched_64](interfacehipfort__rocsolver_1_1rocsolver__sgetrs__batched__64.html "Interface documentation") | C binding 419 | [rocsolver_dgetrs_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dgetrs__batched__64.html "Interface documentation") | C binding 420 | [rocsolver_cgetrs_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cgetrs__batched__64.html "Interface documentation") | C binding 421 | [rocsolver_zgetrs_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zgetrs__batched__64.html "Interface documentation") | C binding 422 | [rocsolver_sgetrs_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetrs__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 423 | [rocsolver_dgetrs_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetrs__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 424 | [rocsolver_cgetrs_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetrs__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 425 | [rocsolver_zgetrs_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetrs__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 426 | [rocsolver_sgetrs_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__sgetrs__strided__batched__64.html "Interface documentation") | C binding 427 | [rocsolver_dgetrs_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dgetrs__strided__batched__64.html "Interface documentation") | C binding 428 | [rocsolver_cgetrs_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cgetrs__strided__batched__64.html "Interface documentation") | C binding 429 | [rocsolver_zgetrs_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zgetrs__strided__batched__64.html "Interface documentation") | C binding 430 | [rocsolver_ssytrs](interfacehipfort__rocsolver_1_1rocsolver__ssytrs.html "Interface documentation") | C binding 431 | [rocsolver_dsytrs](interfacehipfort__rocsolver_1_1rocsolver__dsytrs.html "Interface documentation") | C binding 432 | [rocsolver_csytrs](interfacehipfort__rocsolver_1_1rocsolver__csytrs.html "Interface documentation") | C binding 433 | [rocsolver_zsytrs](interfacehipfort__rocsolver_1_1rocsolver__zsytrs.html "Interface documentation") | C binding 434 | [rocsolver_ssytrs_64](interfacehipfort__rocsolver_1_1rocsolver__ssytrs__64.html "Interface documentation") | C binding 435 | [rocsolver_dsytrs_64](interfacehipfort__rocsolver_1_1rocsolver__dsytrs__64.html "Interface documentation") | C binding 436 | [rocsolver_csytrs_64](interfacehipfort__rocsolver_1_1rocsolver__csytrs__64.html "Interface documentation") | C binding 437 | [rocsolver_zsytrs_64](interfacehipfort__rocsolver_1_1rocsolver__zsytrs__64.html "Interface documentation") | C binding 438 | [rocsolver_ssytrs_batched](interfacehipfort__rocsolver_1_1rocsolver__ssytrs__batched.html "Interface documentation") | C binding 439 | [rocsolver_dsytrs_batched](interfacehipfort__rocsolver_1_1rocsolver__dsytrs__batched.html "Interface documentation") | C binding 440 | [rocsolver_csytrs_batched](interfacehipfort__rocsolver_1_1rocsolver__csytrs__batched.html "Interface documentation") | C binding 441 | [rocsolver_zsytrs_batched](interfacehipfort__rocsolver_1_1rocsolver__zsytrs__batched.html "Interface documentation") | C binding 442 | [rocsolver_ssytrs_batched_64](interfacehipfort__rocsolver_1_1rocsolver__ssytrs__batched__64.html "Interface documentation") | C binding 443 | [rocsolver_dsytrs_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dsytrs__batched__64.html "Interface documentation") | C binding 444 | [rocsolver_csytrs_batched_64](interfacehipfort__rocsolver_1_1rocsolver__csytrs__batched__64.html "Interface documentation") | C binding 445 | [rocsolver_zsytrs_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zsytrs__batched__64.html "Interface documentation") | C binding 446 | [rocsolver_ssytrs_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ssytrs__strided__batched.html "Interface documentation") | C binding 447 | [rocsolver_dsytrs_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dsytrs__strided__batched.html "Interface documentation") | C binding 448 | [rocsolver_csytrs_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__csytrs__strided__batched.html "Interface documentation") | C binding 449 | [rocsolver_zsytrs_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zsytrs__strided__batched.html "Interface documentation") | C binding 450 | [rocsolver_ssytrs_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__ssytrs__strided__batched__64.html "Interface documentation") | C binding 451 | [rocsolver_dsytrs_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dsytrs__strided__batched__64.html "Interface documentation") | C binding 452 | [rocsolver_csytrs_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__csytrs__strided__batched__64.html "Interface documentation") | C binding 453 | [rocsolver_zsytrs_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zsytrs__strided__batched__64.html "Interface documentation") | C binding 454 | [rocsolver_sgesv](interfacehipfort__rocsolver_1_1rocsolver__sgesv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 455 | [rocsolver_dgesv](interfacehipfort__rocsolver_1_1rocsolver__dgesv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 456 | [rocsolver_cgesv](interfacehipfort__rocsolver_1_1rocsolver__cgesv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 457 | [rocsolver_zgesv](interfacehipfort__rocsolver_1_1rocsolver__zgesv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 458 | [rocsolver_sgesv_batched](interfacehipfort__rocsolver_1_1rocsolver__sgesv__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 459 | [rocsolver_dgesv_batched](interfacehipfort__rocsolver_1_1rocsolver__dgesv__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 460 | [rocsolver_cgesv_batched](interfacehipfort__rocsolver_1_1rocsolver__cgesv__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 461 | [rocsolver_zgesv_batched](interfacehipfort__rocsolver_1_1rocsolver__zgesv__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 462 | [rocsolver_sgesv_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgesv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 463 | [rocsolver_dgesv_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgesv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 464 | [rocsolver_cgesv_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgesv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 465 | [rocsolver_zgesv_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgesv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 466 | [rocsolver_sgetrs_npvt](interfacehipfort__rocsolver_1_1rocsolver__sgetrs__npvt.html "Interface documentation") | C binding 467 | [rocsolver_dgetrs_npvt](interfacehipfort__rocsolver_1_1rocsolver__dgetrs__npvt.html "Interface documentation") | C binding 468 | [rocsolver_cgetrs_npvt](interfacehipfort__rocsolver_1_1rocsolver__cgetrs__npvt.html "Interface documentation") | C binding 469 | [rocsolver_zgetrs_npvt](interfacehipfort__rocsolver_1_1rocsolver__zgetrs__npvt.html "Interface documentation") | C binding 470 | [rocsolver_sgetrs_npvt_64](interfacehipfort__rocsolver_1_1rocsolver__sgetrs__npvt__64.html "Interface documentation") | C binding 471 | [rocsolver_dgetrs_npvt_64](interfacehipfort__rocsolver_1_1rocsolver__dgetrs__npvt__64.html "Interface documentation") | C binding 472 | [rocsolver_cgetrs_npvt_64](interfacehipfort__rocsolver_1_1rocsolver__cgetrs__npvt__64.html "Interface documentation") | C binding 473 | [rocsolver_zgetrs_npvt_64](interfacehipfort__rocsolver_1_1rocsolver__zgetrs__npvt__64.html "Interface documentation") | C binding 474 | [rocsolver_sgetrs_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetrs__npvt__batched.html "Interface documentation") | C binding 475 | [rocsolver_dgetrs_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetrs__npvt__batched.html "Interface documentation") | C binding 476 | [rocsolver_cgetrs_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetrs__npvt__batched.html "Interface documentation") | C binding 477 | [rocsolver_zgetrs_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetrs__npvt__batched.html "Interface documentation") | C binding 478 | [rocsolver_sgetrs_npvt_batched_64](interfacehipfort__rocsolver_1_1rocsolver__sgetrs__npvt__batched__64.html "Interface documentation") | C binding 479 | [rocsolver_dgetrs_npvt_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dgetrs__npvt__batched__64.html "Interface documentation") | C binding 480 | [rocsolver_cgetrs_npvt_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cgetrs__npvt__batched__64.html "Interface documentation") | C binding 481 | [rocsolver_zgetrs_npvt_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zgetrs__npvt__batched__64.html "Interface documentation") | C binding 482 | [rocsolver_sgetrs_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetrs__npvt__strided__batched.html "Interface documentation") | C binding 483 | [rocsolver_dgetrs_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetrs__npvt__strided__batched.html "Interface documentation") | C binding 484 | [rocsolver_cgetrs_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetrs__npvt__strided__batched.html "Interface documentation") | C binding 485 | [rocsolver_zgetrs_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetrs__npvt__strided__batched.html "Interface documentation") | C binding 486 | [rocsolver_sgetrs_npvt_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__sgetrs__npvt__strided__batched__64.html "Interface documentation") | C binding 487 | [rocsolver_dgetrs_npvt_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dgetrs__npvt__strided__batched__64.html "Interface documentation") | C binding 488 | [rocsolver_cgetrs_npvt_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cgetrs__npvt__strided__batched__64.html "Interface documentation") | C binding 489 | [rocsolver_zgetrs_npvt_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zgetrs__npvt__strided__batched__64.html "Interface documentation") | C binding 490 | [rocsolver_sgetri](interfacehipfort__rocsolver_1_1rocsolver__sgetri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 491 | [rocsolver_dgetri](interfacehipfort__rocsolver_1_1rocsolver__dgetri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 492 | [rocsolver_cgetri](interfacehipfort__rocsolver_1_1rocsolver__cgetri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 493 | [rocsolver_zgetri](interfacehipfort__rocsolver_1_1rocsolver__zgetri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 494 | [rocsolver_sgetri_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetri__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 495 | [rocsolver_dgetri_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetri__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 496 | [rocsolver_cgetri_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetri__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 497 | [rocsolver_zgetri_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetri__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 498 | [rocsolver_sgetri_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetri__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 499 | [rocsolver_dgetri_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetri__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 500 | [rocsolver_cgetri_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetri__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 501 | [rocsolver_zgetri_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetri__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 502 | [rocsolver_sgetri_npvt](interfacehipfort__rocsolver_1_1rocsolver__sgetri__npvt.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 503 | [rocsolver_dgetri_npvt](interfacehipfort__rocsolver_1_1rocsolver__dgetri__npvt.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 504 | [rocsolver_cgetri_npvt](interfacehipfort__rocsolver_1_1rocsolver__cgetri__npvt.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 505 | [rocsolver_zgetri_npvt](interfacehipfort__rocsolver_1_1rocsolver__zgetri__npvt.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 506 | [rocsolver_sgetri_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetri__npvt__batched.html "Interface documentation") | C binding 507 | [rocsolver_dgetri_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetri__npvt__batched.html "Interface documentation") | C binding 508 | [rocsolver_cgetri_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetri__npvt__batched.html "Interface documentation") | C binding 509 | [rocsolver_zgetri_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetri__npvt__batched.html "Interface documentation") | C binding 510 | [rocsolver_sgetri_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetri__npvt__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 511 | [rocsolver_dgetri_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetri__npvt__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 512 | [rocsolver_cgetri_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetri__npvt__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 513 | [rocsolver_zgetri_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetri__npvt__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 514 | [rocsolver_sgels](interfacehipfort__rocsolver_1_1rocsolver__sgels.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 515 | [rocsolver_dgels](interfacehipfort__rocsolver_1_1rocsolver__dgels.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 516 | [rocsolver_cgels](interfacehipfort__rocsolver_1_1rocsolver__cgels.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 517 | [rocsolver_zgels](interfacehipfort__rocsolver_1_1rocsolver__zgels.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 518 | [rocsolver_sgels_batched](interfacehipfort__rocsolver_1_1rocsolver__sgels__batched.html "Interface documentation") | C binding 519 | [rocsolver_dgels_batched](interfacehipfort__rocsolver_1_1rocsolver__dgels__batched.html "Interface documentation") | C binding 520 | [rocsolver_cgels_batched](interfacehipfort__rocsolver_1_1rocsolver__cgels__batched.html "Interface documentation") | C binding 521 | [rocsolver_zgels_batched](interfacehipfort__rocsolver_1_1rocsolver__zgels__batched.html "Interface documentation") | C binding 522 | [rocsolver_sgels_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgels__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 523 | [rocsolver_dgels_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgels__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 524 | [rocsolver_cgels_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgels__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 525 | [rocsolver_zgels_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgels__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 526 | [rocsolver_spotf2](interfacehipfort__rocsolver_1_1rocsolver__spotf2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 527 | [rocsolver_dpotf2](interfacehipfort__rocsolver_1_1rocsolver__dpotf2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 528 | [rocsolver_cpotf2](interfacehipfort__rocsolver_1_1rocsolver__cpotf2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 529 | [rocsolver_zpotf2](interfacehipfort__rocsolver_1_1rocsolver__zpotf2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 530 | [rocsolver_spotf2_64](interfacehipfort__rocsolver_1_1rocsolver__spotf2__64.html "Interface documentation") | C binding 531 | [rocsolver_dpotf2_64](interfacehipfort__rocsolver_1_1rocsolver__dpotf2__64.html "Interface documentation") | C binding 532 | [rocsolver_cpotf2_64](interfacehipfort__rocsolver_1_1rocsolver__cpotf2__64.html "Interface documentation") | C binding 533 | [rocsolver_zpotf2_64](interfacehipfort__rocsolver_1_1rocsolver__zpotf2__64.html "Interface documentation") | C binding 534 | [rocsolver_spotf2_batched](interfacehipfort__rocsolver_1_1rocsolver__spotf2__batched.html "Interface documentation") | C binding 535 | [rocsolver_dpotf2_batched](interfacehipfort__rocsolver_1_1rocsolver__dpotf2__batched.html "Interface documentation") | C binding 536 | [rocsolver_cpotf2_batched](interfacehipfort__rocsolver_1_1rocsolver__cpotf2__batched.html "Interface documentation") | C binding 537 | [rocsolver_zpotf2_batched](interfacehipfort__rocsolver_1_1rocsolver__zpotf2__batched.html "Interface documentation") | C binding 538 | [rocsolver_spotf2_batched_64](interfacehipfort__rocsolver_1_1rocsolver__spotf2__batched__64.html "Interface documentation") | C binding 539 | [rocsolver_dpotf2_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dpotf2__batched__64.html "Interface documentation") | C binding 540 | [rocsolver_cpotf2_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cpotf2__batched__64.html "Interface documentation") | C binding 541 | [rocsolver_zpotf2_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zpotf2__batched__64.html "Interface documentation") | C binding 542 | [rocsolver_spotf2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__spotf2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 543 | [rocsolver_dpotf2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dpotf2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 544 | [rocsolver_cpotf2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cpotf2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 545 | [rocsolver_zpotf2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zpotf2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 546 | [rocsolver_spotf2_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__spotf2__strided__batched__64.html "Interface documentation") | C binding 547 | [rocsolver_dpotf2_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dpotf2__strided__batched__64.html "Interface documentation") | C binding 548 | [rocsolver_cpotf2_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cpotf2__strided__batched__64.html "Interface documentation") | C binding 549 | [rocsolver_zpotf2_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zpotf2__strided__batched__64.html "Interface documentation") | C binding 550 | [rocsolver_spotrf](interfacehipfort__rocsolver_1_1rocsolver__spotrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 551 | [rocsolver_dpotrf](interfacehipfort__rocsolver_1_1rocsolver__dpotrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 552 | [rocsolver_cpotrf](interfacehipfort__rocsolver_1_1rocsolver__cpotrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 553 | [rocsolver_zpotrf](interfacehipfort__rocsolver_1_1rocsolver__zpotrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 554 | [rocsolver_spotrf_64](interfacehipfort__rocsolver_1_1rocsolver__spotrf__64.html "Interface documentation") | C binding 555 | [rocsolver_dpotrf_64](interfacehipfort__rocsolver_1_1rocsolver__dpotrf__64.html "Interface documentation") | C binding 556 | [rocsolver_cpotrf_64](interfacehipfort__rocsolver_1_1rocsolver__cpotrf__64.html "Interface documentation") | C binding 557 | [rocsolver_zpotrf_64](interfacehipfort__rocsolver_1_1rocsolver__zpotrf__64.html "Interface documentation") | C binding 558 | [rocsolver_spotrf_batched](interfacehipfort__rocsolver_1_1rocsolver__spotrf__batched.html "Interface documentation") | C binding 559 | [rocsolver_dpotrf_batched](interfacehipfort__rocsolver_1_1rocsolver__dpotrf__batched.html "Interface documentation") | C binding 560 | [rocsolver_cpotrf_batched](interfacehipfort__rocsolver_1_1rocsolver__cpotrf__batched.html "Interface documentation") | C binding 561 | [rocsolver_zpotrf_batched](interfacehipfort__rocsolver_1_1rocsolver__zpotrf__batched.html "Interface documentation") | C binding 562 | [rocsolver_spotrf_batched_64](interfacehipfort__rocsolver_1_1rocsolver__spotrf__batched__64.html "Interface documentation") | C binding 563 | [rocsolver_dpotrf_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dpotrf__batched__64.html "Interface documentation") | C binding 564 | [rocsolver_cpotrf_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cpotrf__batched__64.html "Interface documentation") | C binding 565 | [rocsolver_zpotrf_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zpotrf__batched__64.html "Interface documentation") | C binding 566 | [rocsolver_spotrf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__spotrf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 567 | [rocsolver_dpotrf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dpotrf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 568 | [rocsolver_cpotrf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cpotrf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 569 | [rocsolver_zpotrf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zpotrf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 570 | [rocsolver_spotrf_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__spotrf__strided__batched__64.html "Interface documentation") | C binding 571 | [rocsolver_dpotrf_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dpotrf__strided__batched__64.html "Interface documentation") | C binding 572 | [rocsolver_cpotrf_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cpotrf__strided__batched__64.html "Interface documentation") | C binding 573 | [rocsolver_zpotrf_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zpotrf__strided__batched__64.html "Interface documentation") | C binding 574 | [rocsolver_spotrs](interfacehipfort__rocsolver_1_1rocsolver__spotrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 575 | [rocsolver_dpotrs](interfacehipfort__rocsolver_1_1rocsolver__dpotrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 576 | [rocsolver_cpotrs](interfacehipfort__rocsolver_1_1rocsolver__cpotrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 577 | [rocsolver_zpotrs](interfacehipfort__rocsolver_1_1rocsolver__zpotrs.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 578 | [rocsolver_spotrs_64](interfacehipfort__rocsolver_1_1rocsolver__spotrs__64.html "Interface documentation") | C binding 579 | [rocsolver_dpotrs_64](interfacehipfort__rocsolver_1_1rocsolver__dpotrs__64.html "Interface documentation") | C binding 580 | [rocsolver_cpotrs_64](interfacehipfort__rocsolver_1_1rocsolver__cpotrs__64.html "Interface documentation") | C binding 581 | [rocsolver_zpotrs_64](interfacehipfort__rocsolver_1_1rocsolver__zpotrs__64.html "Interface documentation") | C binding 582 | [rocsolver_spotrs_batched](interfacehipfort__rocsolver_1_1rocsolver__spotrs__batched.html "Interface documentation") | C binding 583 | [rocsolver_dpotrs_batched](interfacehipfort__rocsolver_1_1rocsolver__dpotrs__batched.html "Interface documentation") | C binding 584 | [rocsolver_cpotrs_batched](interfacehipfort__rocsolver_1_1rocsolver__cpotrs__batched.html "Interface documentation") | C binding 585 | [rocsolver_zpotrs_batched](interfacehipfort__rocsolver_1_1rocsolver__zpotrs__batched.html "Interface documentation") | C binding 586 | [rocsolver_spotrs_batched_64](interfacehipfort__rocsolver_1_1rocsolver__spotrs__batched__64.html "Interface documentation") | C binding 587 | [rocsolver_dpotrs_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dpotrs__batched__64.html "Interface documentation") | C binding 588 | [rocsolver_cpotrs_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cpotrs__batched__64.html "Interface documentation") | C binding 589 | [rocsolver_zpotrs_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zpotrs__batched__64.html "Interface documentation") | C binding 590 | [rocsolver_spotrs_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__spotrs__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 591 | [rocsolver_dpotrs_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dpotrs__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 592 | [rocsolver_cpotrs_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cpotrs__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 593 | [rocsolver_zpotrs_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zpotrs__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 594 | [rocsolver_spotrs_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__spotrs__strided__batched__64.html "Interface documentation") | C binding 595 | [rocsolver_dpotrs_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dpotrs__strided__batched__64.html "Interface documentation") | C binding 596 | [rocsolver_cpotrs_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cpotrs__strided__batched__64.html "Interface documentation") | C binding 597 | [rocsolver_zpotrs_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zpotrs__strided__batched__64.html "Interface documentation") | C binding 598 | [rocsolver_sposv](interfacehipfort__rocsolver_1_1rocsolver__sposv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 599 | [rocsolver_dposv](interfacehipfort__rocsolver_1_1rocsolver__dposv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 600 | [rocsolver_cposv](interfacehipfort__rocsolver_1_1rocsolver__cposv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 601 | [rocsolver_zposv](interfacehipfort__rocsolver_1_1rocsolver__zposv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 602 | [rocsolver_sposv_batched](interfacehipfort__rocsolver_1_1rocsolver__sposv__batched.html "Interface documentation") | C binding 603 | [rocsolver_dposv_batched](interfacehipfort__rocsolver_1_1rocsolver__dposv__batched.html "Interface documentation") | C binding 604 | [rocsolver_cposv_batched](interfacehipfort__rocsolver_1_1rocsolver__cposv__batched.html "Interface documentation") | C binding 605 | [rocsolver_zposv_batched](interfacehipfort__rocsolver_1_1rocsolver__zposv__batched.html "Interface documentation") | C binding 606 | [rocsolver_sposv_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sposv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 607 | [rocsolver_dposv_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dposv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 608 | [rocsolver_cposv_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cposv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 609 | [rocsolver_zposv_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zposv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 610 | [rocsolver_spotri](interfacehipfort__rocsolver_1_1rocsolver__spotri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 611 | [rocsolver_dpotri](interfacehipfort__rocsolver_1_1rocsolver__dpotri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 612 | [rocsolver_cpotri](interfacehipfort__rocsolver_1_1rocsolver__cpotri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 613 | [rocsolver_zpotri](interfacehipfort__rocsolver_1_1rocsolver__zpotri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 614 | [rocsolver_spotri_batched](interfacehipfort__rocsolver_1_1rocsolver__spotri__batched.html "Interface documentation") | C binding 615 | [rocsolver_dpotri_batched](interfacehipfort__rocsolver_1_1rocsolver__dpotri__batched.html "Interface documentation") | C binding 616 | [rocsolver_cpotri_batched](interfacehipfort__rocsolver_1_1rocsolver__cpotri__batched.html "Interface documentation") | C binding 617 | [rocsolver_zpotri_batched](interfacehipfort__rocsolver_1_1rocsolver__zpotri__batched.html "Interface documentation") | C binding 618 | [rocsolver_spotri_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__spotri__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 619 | [rocsolver_dpotri_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dpotri__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 620 | [rocsolver_cpotri_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cpotri__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 621 | [rocsolver_zpotri_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zpotri__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 622 | [rocsolver_sgesvd](interfacehipfort__rocsolver_1_1rocsolver__sgesvd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 623 | [rocsolver_dgesvd](interfacehipfort__rocsolver_1_1rocsolver__dgesvd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 624 | [rocsolver_cgesvd](interfacehipfort__rocsolver_1_1rocsolver__cgesvd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 625 | [rocsolver_zgesvd](interfacehipfort__rocsolver_1_1rocsolver__zgesvd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 626 | [rocsolver_sgesvd_batched](interfacehipfort__rocsolver_1_1rocsolver__sgesvd__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 627 | [rocsolver_dgesvd_batched](interfacehipfort__rocsolver_1_1rocsolver__dgesvd__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 628 | [rocsolver_cgesvd_batched](interfacehipfort__rocsolver_1_1rocsolver__cgesvd__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 629 | [rocsolver_zgesvd_batched](interfacehipfort__rocsolver_1_1rocsolver__zgesvd__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 630 | [rocsolver_sgesvd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgesvd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 631 | [rocsolver_dgesvd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgesvd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 632 | [rocsolver_cgesvd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgesvd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 633 | [rocsolver_zgesvd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgesvd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 634 | [rocsolver_sgesdd](interfacehipfort__rocsolver_1_1rocsolver__sgesdd.html "Interface documentation") | C binding 635 | [rocsolver_dgesdd](interfacehipfort__rocsolver_1_1rocsolver__dgesdd.html "Interface documentation") | C binding 636 | [rocsolver_cgesdd](interfacehipfort__rocsolver_1_1rocsolver__cgesdd.html "Interface documentation") | C binding 637 | [rocsolver_zgesdd](interfacehipfort__rocsolver_1_1rocsolver__zgesdd.html "Interface documentation") | C binding 638 | [rocsolver_sgesdd_batched](interfacehipfort__rocsolver_1_1rocsolver__sgesdd__batched.html "Interface documentation") | C binding 639 | [rocsolver_dgesdd_batched](interfacehipfort__rocsolver_1_1rocsolver__dgesdd__batched.html "Interface documentation") | C binding 640 | [rocsolver_cgesdd_batched](interfacehipfort__rocsolver_1_1rocsolver__cgesdd__batched.html "Interface documentation") | C binding 641 | [rocsolver_zgesdd_batched](interfacehipfort__rocsolver_1_1rocsolver__zgesdd__batched.html "Interface documentation") | C binding 642 | [rocsolver_sgesdd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgesdd__strided__batched.html "Interface documentation") | C binding 643 | [rocsolver_dgesdd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgesdd__strided__batched.html "Interface documentation") | C binding 644 | [rocsolver_cgesdd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgesdd__strided__batched.html "Interface documentation") | C binding 645 | [rocsolver_zgesdd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgesdd__strided__batched.html "Interface documentation") | C binding 646 | [rocsolver_sgesvdj](interfacehipfort__rocsolver_1_1rocsolver__sgesvdj.html "Interface documentation") | C binding 647 | [rocsolver_dgesvdj](interfacehipfort__rocsolver_1_1rocsolver__dgesvdj.html "Interface documentation") | C binding 648 | [rocsolver_cgesvdj](interfacehipfort__rocsolver_1_1rocsolver__cgesvdj.html "Interface documentation") | C binding 649 | [rocsolver_zgesvdj](interfacehipfort__rocsolver_1_1rocsolver__zgesvdj.html "Interface documentation") | C binding 650 | [rocsolver_sgesvdj_batched](interfacehipfort__rocsolver_1_1rocsolver__sgesvdj__batched.html "Interface documentation") | C binding 651 | [rocsolver_dgesvdj_batched](interfacehipfort__rocsolver_1_1rocsolver__dgesvdj__batched.html "Interface documentation") | C binding 652 | [rocsolver_cgesvdj_batched](interfacehipfort__rocsolver_1_1rocsolver__cgesvdj__batched.html "Interface documentation") | C binding 653 | [rocsolver_zgesvdj_batched](interfacehipfort__rocsolver_1_1rocsolver__zgesvdj__batched.html "Interface documentation") | C binding 654 | [rocsolver_sgesvdj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgesvdj__strided__batched.html "Interface documentation") | C binding 655 | [rocsolver_dgesvdj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgesvdj__strided__batched.html "Interface documentation") | C binding 656 | [rocsolver_cgesvdj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgesvdj__strided__batched.html "Interface documentation") | C binding 657 | [rocsolver_zgesvdj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgesvdj__strided__batched.html "Interface documentation") | C binding 658 | [rocsolver_sgesvdx](interfacehipfort__rocsolver_1_1rocsolver__sgesvdx.html "Interface documentation") | C binding 659 | [rocsolver_dgesvdx](interfacehipfort__rocsolver_1_1rocsolver__dgesvdx.html "Interface documentation") | C binding 660 | [rocsolver_cgesvdx](interfacehipfort__rocsolver_1_1rocsolver__cgesvdx.html "Interface documentation") | C binding 661 | [rocsolver_zgesvdx](interfacehipfort__rocsolver_1_1rocsolver__zgesvdx.html "Interface documentation") | C binding 662 | [rocsolver_sgesvdx_batched](interfacehipfort__rocsolver_1_1rocsolver__sgesvdx__batched.html "Interface documentation") | C binding 663 | [rocsolver_dgesvdx_batched](interfacehipfort__rocsolver_1_1rocsolver__dgesvdx__batched.html "Interface documentation") | C binding 664 | [rocsolver_cgesvdx_batched](interfacehipfort__rocsolver_1_1rocsolver__cgesvdx__batched.html "Interface documentation") | C binding 665 | [rocsolver_zgesvdx_batched](interfacehipfort__rocsolver_1_1rocsolver__zgesvdx__batched.html "Interface documentation") | C binding 666 | [rocsolver_sgesvdx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgesvdx__strided__batched.html "Interface documentation") | C binding 667 | [rocsolver_dgesvdx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgesvdx__strided__batched.html "Interface documentation") | C binding 668 | [rocsolver_cgesvdx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgesvdx__strided__batched.html "Interface documentation") | C binding 669 | [rocsolver_zgesvdx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgesvdx__strided__batched.html "Interface documentation") | C binding 670 | [rocsolver_ssytd2](interfacehipfort__rocsolver_1_1rocsolver__ssytd2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 671 | [rocsolver_dsytd2](interfacehipfort__rocsolver_1_1rocsolver__dsytd2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 672 | [rocsolver_chetd2](interfacehipfort__rocsolver_1_1rocsolver__chetd2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 673 | [rocsolver_zhetd2](interfacehipfort__rocsolver_1_1rocsolver__zhetd2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 674 | [rocsolver_ssytd2_batched](interfacehipfort__rocsolver_1_1rocsolver__ssytd2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 675 | [rocsolver_dsytd2_batched](interfacehipfort__rocsolver_1_1rocsolver__dsytd2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 676 | [rocsolver_chetd2_batched](interfacehipfort__rocsolver_1_1rocsolver__chetd2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 677 | [rocsolver_zhetd2_batched](interfacehipfort__rocsolver_1_1rocsolver__zhetd2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 678 | [rocsolver_ssytd2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ssytd2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 679 | [rocsolver_dsytd2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dsytd2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 680 | [rocsolver_chetd2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__chetd2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 681 | [rocsolver_zhetd2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zhetd2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 682 | [rocsolver_ssytrd](interfacehipfort__rocsolver_1_1rocsolver__ssytrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 683 | [rocsolver_dsytrd](interfacehipfort__rocsolver_1_1rocsolver__dsytrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 684 | [rocsolver_chetrd](interfacehipfort__rocsolver_1_1rocsolver__chetrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 685 | [rocsolver_zhetrd](interfacehipfort__rocsolver_1_1rocsolver__zhetrd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 686 | [rocsolver_ssytrd_batched](interfacehipfort__rocsolver_1_1rocsolver__ssytrd__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 687 | [rocsolver_dsytrd_batched](interfacehipfort__rocsolver_1_1rocsolver__dsytrd__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 688 | [rocsolver_chetrd_batched](interfacehipfort__rocsolver_1_1rocsolver__chetrd__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 689 | [rocsolver_zhetrd_batched](interfacehipfort__rocsolver_1_1rocsolver__zhetrd__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 690 | [rocsolver_ssytrd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ssytrd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 691 | [rocsolver_dsytrd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dsytrd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 692 | [rocsolver_chetrd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__chetrd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 693 | [rocsolver_zhetrd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zhetrd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 694 | [rocsolver_ssygs2](interfacehipfort__rocsolver_1_1rocsolver__ssygs2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 695 | [rocsolver_dsygs2](interfacehipfort__rocsolver_1_1rocsolver__dsygs2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 696 | [rocsolver_chegs2](interfacehipfort__rocsolver_1_1rocsolver__chegs2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 697 | [rocsolver_zhegs2](interfacehipfort__rocsolver_1_1rocsolver__zhegs2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 698 | [rocsolver_ssygs2_batched](interfacehipfort__rocsolver_1_1rocsolver__ssygs2__batched.html "Interface documentation") | C binding 699 | [rocsolver_dsygs2_batched](interfacehipfort__rocsolver_1_1rocsolver__dsygs2__batched.html "Interface documentation") | C binding 700 | [rocsolver_chegs2_batched](interfacehipfort__rocsolver_1_1rocsolver__chegs2__batched.html "Interface documentation") | C binding 701 | [rocsolver_zhegs2_batched](interfacehipfort__rocsolver_1_1rocsolver__zhegs2__batched.html "Interface documentation") | C binding 702 | [rocsolver_ssygs2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ssygs2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 703 | [rocsolver_dsygs2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dsygs2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 704 | [rocsolver_chegs2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__chegs2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 705 | [rocsolver_zhegs2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zhegs2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 706 | [rocsolver_ssygst](interfacehipfort__rocsolver_1_1rocsolver__ssygst.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 707 | [rocsolver_dsygst](interfacehipfort__rocsolver_1_1rocsolver__dsygst.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 708 | [rocsolver_chegst](interfacehipfort__rocsolver_1_1rocsolver__chegst.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 709 | [rocsolver_zhegst](interfacehipfort__rocsolver_1_1rocsolver__zhegst.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 710 | [rocsolver_ssygst_batched](interfacehipfort__rocsolver_1_1rocsolver__ssygst__batched.html "Interface documentation") | C binding 711 | [rocsolver_dsygst_batched](interfacehipfort__rocsolver_1_1rocsolver__dsygst__batched.html "Interface documentation") | C binding 712 | [rocsolver_chegst_batched](interfacehipfort__rocsolver_1_1rocsolver__chegst__batched.html "Interface documentation") | C binding 713 | [rocsolver_zhegst_batched](interfacehipfort__rocsolver_1_1rocsolver__zhegst__batched.html "Interface documentation") | C binding 714 | [rocsolver_ssygst_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ssygst__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 715 | [rocsolver_dsygst_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dsygst__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 716 | [rocsolver_chegst_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__chegst__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 717 | [rocsolver_zhegst_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zhegst__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 718 | [rocsolver_ssyev](interfacehipfort__rocsolver_1_1rocsolver__ssyev.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 719 | [rocsolver_dsyev](interfacehipfort__rocsolver_1_1rocsolver__dsyev.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 720 | [rocsolver_ssyev_64](interfacehipfort__rocsolver_1_1rocsolver__ssyev__64.html "Interface documentation") | C binding 721 | [rocsolver_dsyev_64](interfacehipfort__rocsolver_1_1rocsolver__dsyev__64.html "Interface documentation") | C binding 722 | [rocsolver_cheev](interfacehipfort__rocsolver_1_1rocsolver__cheev.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 723 | [rocsolver_zheev](interfacehipfort__rocsolver_1_1rocsolver__zheev.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 724 | [rocsolver_cheev_64](interfacehipfort__rocsolver_1_1rocsolver__cheev__64.html "Interface documentation") | C binding 725 | [rocsolver_zheev_64](interfacehipfort__rocsolver_1_1rocsolver__zheev__64.html "Interface documentation") | C binding 726 | [rocsolver_ssyev_batched](interfacehipfort__rocsolver_1_1rocsolver__ssyev__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 727 | [rocsolver_dsyev_batched](interfacehipfort__rocsolver_1_1rocsolver__dsyev__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 728 | [rocsolver_ssyev_batched_64](interfacehipfort__rocsolver_1_1rocsolver__ssyev__batched__64.html "Interface documentation") | C binding 729 | [rocsolver_dsyev_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dsyev__batched__64.html "Interface documentation") | C binding 730 | [rocsolver_cheev_batched](interfacehipfort__rocsolver_1_1rocsolver__cheev__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 731 | [rocsolver_zheev_batched](interfacehipfort__rocsolver_1_1rocsolver__zheev__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 732 | [rocsolver_cheev_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cheev__batched__64.html "Interface documentation") | C binding 733 | [rocsolver_zheev_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zheev__batched__64.html "Interface documentation") | C binding 734 | [rocsolver_ssyev_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ssyev__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 735 | [rocsolver_dsyev_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dsyev__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 736 | [rocsolver_ssyev_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__ssyev__strided__batched__64.html "Interface documentation") | C binding 737 | [rocsolver_dsyev_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dsyev__strided__batched__64.html "Interface documentation") | C binding 738 | [rocsolver_cheev_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cheev__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 739 | [rocsolver_zheev_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zheev__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 740 | [rocsolver_cheev_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cheev__strided__batched__64.html "Interface documentation") | C binding 741 | [rocsolver_zheev_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zheev__strided__batched__64.html "Interface documentation") | C binding 742 | [rocsolver_ssyevd](interfacehipfort__rocsolver_1_1rocsolver__ssyevd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 743 | [rocsolver_dsyevd](interfacehipfort__rocsolver_1_1rocsolver__dsyevd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 744 | [rocsolver_ssyevd_64](interfacehipfort__rocsolver_1_1rocsolver__ssyevd__64.html "Interface documentation") | C binding 745 | [rocsolver_dsyevd_64](interfacehipfort__rocsolver_1_1rocsolver__dsyevd__64.html "Interface documentation") | C binding 746 | [rocsolver_cheevd](interfacehipfort__rocsolver_1_1rocsolver__cheevd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 747 | [rocsolver_zheevd](interfacehipfort__rocsolver_1_1rocsolver__zheevd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 748 | [rocsolver_cheevd_64](interfacehipfort__rocsolver_1_1rocsolver__cheevd__64.html "Interface documentation") | C binding 749 | [rocsolver_zheevd_64](interfacehipfort__rocsolver_1_1rocsolver__zheevd__64.html "Interface documentation") | C binding 750 | [rocsolver_ssyevd_batched](interfacehipfort__rocsolver_1_1rocsolver__ssyevd__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 751 | [rocsolver_dsyevd_batched](interfacehipfort__rocsolver_1_1rocsolver__dsyevd__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 752 | [rocsolver_ssyevd_batched_64](interfacehipfort__rocsolver_1_1rocsolver__ssyevd__batched__64.html "Interface documentation") | C binding 753 | [rocsolver_dsyevd_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dsyevd__batched__64.html "Interface documentation") | C binding 754 | [rocsolver_cheevd_batched](interfacehipfort__rocsolver_1_1rocsolver__cheevd__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 755 | [rocsolver_zheevd_batched](interfacehipfort__rocsolver_1_1rocsolver__zheevd__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 756 | [rocsolver_cheevd_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cheevd__batched__64.html "Interface documentation") | C binding 757 | [rocsolver_zheevd_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zheevd__batched__64.html "Interface documentation") | C binding 758 | [rocsolver_ssyevd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ssyevd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 759 | [rocsolver_dsyevd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dsyevd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 760 | [rocsolver_ssyevd_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__ssyevd__strided__batched__64.html "Interface documentation") | C binding 761 | [rocsolver_dsyevd_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__dsyevd__strided__batched__64.html "Interface documentation") | C binding 762 | [rocsolver_cheevd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cheevd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 763 | [rocsolver_zheevd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zheevd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 764 | [rocsolver_cheevd_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__cheevd__strided__batched__64.html "Interface documentation") | C binding 765 | [rocsolver_zheevd_strided_batched_64](interfacehipfort__rocsolver_1_1rocsolver__zheevd__strided__batched__64.html "Interface documentation") | C binding 766 | [rocsolver_ssyevdj](interfacehipfort__rocsolver_1_1rocsolver__ssyevdj.html "Interface documentation") | C binding 767 | [rocsolver_dsyevdj](interfacehipfort__rocsolver_1_1rocsolver__dsyevdj.html "Interface documentation") | C binding 768 | [rocsolver_cheevdj](interfacehipfort__rocsolver_1_1rocsolver__cheevdj.html "Interface documentation") | C binding 769 | [rocsolver_zheevdj](interfacehipfort__rocsolver_1_1rocsolver__zheevdj.html "Interface documentation") | C binding 770 | [rocsolver_ssyevdj_batched](interfacehipfort__rocsolver_1_1rocsolver__ssyevdj__batched.html "Interface documentation") | C binding 771 | [rocsolver_dsyevdj_batched](interfacehipfort__rocsolver_1_1rocsolver__dsyevdj__batched.html "Interface documentation") | C binding 772 | [rocsolver_cheevdj_batched](interfacehipfort__rocsolver_1_1rocsolver__cheevdj__batched.html "Interface documentation") | C binding 773 | [rocsolver_zheevdj_batched](interfacehipfort__rocsolver_1_1rocsolver__zheevdj__batched.html "Interface documentation") | C binding 774 | [rocsolver_ssyevdj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ssyevdj__strided__batched.html "Interface documentation") | C binding 775 | [rocsolver_dsyevdj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dsyevdj__strided__batched.html "Interface documentation") | C binding 776 | [rocsolver_cheevdj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cheevdj__strided__batched.html "Interface documentation") | C binding 777 | [rocsolver_zheevdj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zheevdj__strided__batched.html "Interface documentation") | C binding 778 | [rocsolver_ssygvdj](interfacehipfort__rocsolver_1_1rocsolver__ssygvdj.html "Interface documentation") | C binding 779 | [rocsolver_dsygvdj](interfacehipfort__rocsolver_1_1rocsolver__dsygvdj.html "Interface documentation") | C binding 780 | [rocsolver_chegvdj](interfacehipfort__rocsolver_1_1rocsolver__chegvdj.html "Interface documentation") | C binding 781 | [rocsolver_zhegvdj](interfacehipfort__rocsolver_1_1rocsolver__zhegvdj.html "Interface documentation") | C binding 782 | [rocsolver_ssygvdj_batched](interfacehipfort__rocsolver_1_1rocsolver__ssygvdj__batched.html "Interface documentation") | C binding 783 | [rocsolver_dsygvdj_batched](interfacehipfort__rocsolver_1_1rocsolver__dsygvdj__batched.html "Interface documentation") | C binding 784 | [rocsolver_chegvdj_batched](interfacehipfort__rocsolver_1_1rocsolver__chegvdj__batched.html "Interface documentation") | C binding 785 | [rocsolver_zhegvdj_batched](interfacehipfort__rocsolver_1_1rocsolver__zhegvdj__batched.html "Interface documentation") | C binding 786 | [rocsolver_ssygvdj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ssygvdj__strided__batched.html "Interface documentation") | C binding 787 | [rocsolver_dsygvdj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dsygvdj__strided__batched.html "Interface documentation") | C binding 788 | [rocsolver_chegvdj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__chegvdj__strided__batched.html "Interface documentation") | C binding 789 | [rocsolver_zhegvdj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zhegvdj__strided__batched.html "Interface documentation") | C binding 790 | [rocsolver_ssyevj](interfacehipfort__rocsolver_1_1rocsolver__ssyevj.html "Interface documentation") | C binding 791 | [rocsolver_dsyevj](interfacehipfort__rocsolver_1_1rocsolver__dsyevj.html "Interface documentation") | C binding 792 | [rocsolver_cheevj](interfacehipfort__rocsolver_1_1rocsolver__cheevj.html "Interface documentation") | C binding 793 | [rocsolver_zheevj](interfacehipfort__rocsolver_1_1rocsolver__zheevj.html "Interface documentation") | C binding 794 | [rocsolver_ssyevj_batched](interfacehipfort__rocsolver_1_1rocsolver__ssyevj__batched.html "Interface documentation") | C binding 795 | [rocsolver_dsyevj_batched](interfacehipfort__rocsolver_1_1rocsolver__dsyevj__batched.html "Interface documentation") | C binding 796 | [rocsolver_cheevj_batched](interfacehipfort__rocsolver_1_1rocsolver__cheevj__batched.html "Interface documentation") | C binding 797 | [rocsolver_zheevj_batched](interfacehipfort__rocsolver_1_1rocsolver__zheevj__batched.html "Interface documentation") | C binding 798 | [rocsolver_ssyevj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ssyevj__strided__batched.html "Interface documentation") | C binding 799 | [rocsolver_dsyevj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dsyevj__strided__batched.html "Interface documentation") | C binding 800 | [rocsolver_cheevj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cheevj__strided__batched.html "Interface documentation") | C binding 801 | [rocsolver_zheevj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zheevj__strided__batched.html "Interface documentation") | C binding 802 | [rocsolver_ssyevx](interfacehipfort__rocsolver_1_1rocsolver__ssyevx.html "Interface documentation") | C binding 803 | [rocsolver_dsyevx](interfacehipfort__rocsolver_1_1rocsolver__dsyevx.html "Interface documentation") | C binding 804 | [rocsolver_cheevx](interfacehipfort__rocsolver_1_1rocsolver__cheevx.html "Interface documentation") | C binding 805 | [rocsolver_zheevx](interfacehipfort__rocsolver_1_1rocsolver__zheevx.html "Interface documentation") | C binding 806 | [rocsolver_ssyevx_batched](interfacehipfort__rocsolver_1_1rocsolver__ssyevx__batched.html "Interface documentation") | C binding 807 | [rocsolver_dsyevx_batched](interfacehipfort__rocsolver_1_1rocsolver__dsyevx__batched.html "Interface documentation") | C binding 808 | [rocsolver_cheevx_batched](interfacehipfort__rocsolver_1_1rocsolver__cheevx__batched.html "Interface documentation") | C binding 809 | [rocsolver_zheevx_batched](interfacehipfort__rocsolver_1_1rocsolver__zheevx__batched.html "Interface documentation") | C binding 810 | [rocsolver_ssyevx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ssyevx__strided__batched.html "Interface documentation") | C binding 811 | [rocsolver_dsyevx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dsyevx__strided__batched.html "Interface documentation") | C binding 812 | [rocsolver_cheevx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cheevx__strided__batched.html "Interface documentation") | C binding 813 | [rocsolver_zheevx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zheevx__strided__batched.html "Interface documentation") | C binding 814 | [rocsolver_ssygv](interfacehipfort__rocsolver_1_1rocsolver__ssygv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 815 | [rocsolver_dsygv](interfacehipfort__rocsolver_1_1rocsolver__dsygv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 816 | [rocsolver_chegv](interfacehipfort__rocsolver_1_1rocsolver__chegv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 817 | [rocsolver_zhegv](interfacehipfort__rocsolver_1_1rocsolver__zhegv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 818 | [rocsolver_ssygv_batched](interfacehipfort__rocsolver_1_1rocsolver__ssygv__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 819 | [rocsolver_dsygv_batched](interfacehipfort__rocsolver_1_1rocsolver__dsygv__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 820 | [rocsolver_chegv_batched](interfacehipfort__rocsolver_1_1rocsolver__chegv__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 821 | [rocsolver_zhegv_batched](interfacehipfort__rocsolver_1_1rocsolver__zhegv__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 822 | [rocsolver_ssygv_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ssygv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 823 | [rocsolver_dsygv_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dsygv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 824 | [rocsolver_chegv_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__chegv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 825 | [rocsolver_zhegv_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zhegv__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 826 | [rocsolver_ssygvd](interfacehipfort__rocsolver_1_1rocsolver__ssygvd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 827 | [rocsolver_dsygvd](interfacehipfort__rocsolver_1_1rocsolver__dsygvd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 828 | [rocsolver_chegvd](interfacehipfort__rocsolver_1_1rocsolver__chegvd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 829 | [rocsolver_zhegvd](interfacehipfort__rocsolver_1_1rocsolver__zhegvd.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 830 | [rocsolver_ssygvd_batched](interfacehipfort__rocsolver_1_1rocsolver__ssygvd__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 831 | [rocsolver_dsygvd_batched](interfacehipfort__rocsolver_1_1rocsolver__dsygvd__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 832 | [rocsolver_chegvd_batched](interfacehipfort__rocsolver_1_1rocsolver__chegvd__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 833 | [rocsolver_zhegvd_batched](interfacehipfort__rocsolver_1_1rocsolver__zhegvd__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 834 | [rocsolver_ssygvd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ssygvd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 835 | [rocsolver_dsygvd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dsygvd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 836 | [rocsolver_chegvd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__chegvd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 837 | [rocsolver_zhegvd_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zhegvd__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 838 | [rocsolver_ssygvj](interfacehipfort__rocsolver_1_1rocsolver__ssygvj.html "Interface documentation") | C binding 839 | [rocsolver_dsygvj](interfacehipfort__rocsolver_1_1rocsolver__dsygvj.html "Interface documentation") | C binding 840 | [rocsolver_chegvj](interfacehipfort__rocsolver_1_1rocsolver__chegvj.html "Interface documentation") | C binding 841 | [rocsolver_zhegvj](interfacehipfort__rocsolver_1_1rocsolver__zhegvj.html "Interface documentation") | C binding 842 | [rocsolver_ssygvj_batched](interfacehipfort__rocsolver_1_1rocsolver__ssygvj__batched.html "Interface documentation") | C binding 843 | [rocsolver_dsygvj_batched](interfacehipfort__rocsolver_1_1rocsolver__dsygvj__batched.html "Interface documentation") | C binding 844 | [rocsolver_chegvj_batched](interfacehipfort__rocsolver_1_1rocsolver__chegvj__batched.html "Interface documentation") | C binding 845 | [rocsolver_zhegvj_batched](interfacehipfort__rocsolver_1_1rocsolver__zhegvj__batched.html "Interface documentation") | C binding 846 | [rocsolver_ssygvj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ssygvj__strided__batched.html "Interface documentation") | C binding 847 | [rocsolver_dsygvj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dsygvj__strided__batched.html "Interface documentation") | C binding 848 | [rocsolver_chegvj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__chegvj__strided__batched.html "Interface documentation") | C binding 849 | [rocsolver_zhegvj_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zhegvj__strided__batched.html "Interface documentation") | C binding 850 | [rocsolver_ssygvx](interfacehipfort__rocsolver_1_1rocsolver__ssygvx.html "Interface documentation") | C binding 851 | [rocsolver_dsygvx](interfacehipfort__rocsolver_1_1rocsolver__dsygvx.html "Interface documentation") | C binding 852 | [rocsolver_chegvx](interfacehipfort__rocsolver_1_1rocsolver__chegvx.html "Interface documentation") | C binding 853 | [rocsolver_zhegvx](interfacehipfort__rocsolver_1_1rocsolver__zhegvx.html "Interface documentation") | C binding 854 | [rocsolver_ssygvx_batched](interfacehipfort__rocsolver_1_1rocsolver__ssygvx__batched.html "Interface documentation") | C binding 855 | [rocsolver_dsygvx_batched](interfacehipfort__rocsolver_1_1rocsolver__dsygvx__batched.html "Interface documentation") | C binding 856 | [rocsolver_chegvx_batched](interfacehipfort__rocsolver_1_1rocsolver__chegvx__batched.html "Interface documentation") | C binding 857 | [rocsolver_zhegvx_batched](interfacehipfort__rocsolver_1_1rocsolver__zhegvx__batched.html "Interface documentation") | C binding 858 | [rocsolver_ssygvx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ssygvx__strided__batched.html "Interface documentation") | C binding 859 | [rocsolver_dsygvx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dsygvx__strided__batched.html "Interface documentation") | C binding 860 | [rocsolver_chegvx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__chegvx__strided__batched.html "Interface documentation") | C binding 861 | [rocsolver_zhegvx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zhegvx__strided__batched.html "Interface documentation") | C binding 862 | [rocsolver_sgetri_outofplace](interfacehipfort__rocsolver_1_1rocsolver__sgetri__outofplace.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 863 | [rocsolver_dgetri_outofplace](interfacehipfort__rocsolver_1_1rocsolver__dgetri__outofplace.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 864 | [rocsolver_cgetri_outofplace](interfacehipfort__rocsolver_1_1rocsolver__cgetri__outofplace.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 865 | [rocsolver_zgetri_outofplace](interfacehipfort__rocsolver_1_1rocsolver__zgetri__outofplace.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 866 | [rocsolver_sgetri_outofplace_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetri__outofplace__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 867 | [rocsolver_dgetri_outofplace_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetri__outofplace__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 868 | [rocsolver_cgetri_outofplace_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetri__outofplace__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 869 | [rocsolver_zgetri_outofplace_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetri__outofplace__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 870 | [rocsolver_sgetri_outofplace_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetri__outofplace__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 871 | [rocsolver_dgetri_outofplace_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetri__outofplace__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 872 | [rocsolver_cgetri_outofplace_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetri__outofplace__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 873 | [rocsolver_zgetri_outofplace_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetri__outofplace__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 874 | [rocsolver_sgetri_npvt_outofplace](interfacehipfort__rocsolver_1_1rocsolver__sgetri__npvt__outofplace.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 875 | [rocsolver_dgetri_npvt_outofplace](interfacehipfort__rocsolver_1_1rocsolver__dgetri__npvt__outofplace.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 876 | [rocsolver_cgetri_npvt_outofplace](interfacehipfort__rocsolver_1_1rocsolver__cgetri__npvt__outofplace.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 877 | [rocsolver_zgetri_npvt_outofplace](interfacehipfort__rocsolver_1_1rocsolver__zgetri__npvt__outofplace.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 878 | [rocsolver_sgetri_npvt_outofplace_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetri__npvt__outofplace__batched.html "Interface documentation") | C binding 879 | [rocsolver_dgetri_npvt_outofplace_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetri__npvt__outofplace__batched.html "Interface documentation") | C binding 880 | [rocsolver_cgetri_npvt_outofplace_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetri__npvt__outofplace__batched.html "Interface documentation") | C binding 881 | [rocsolver_zgetri_npvt_outofplace_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetri__npvt__outofplace__batched.html "Interface documentation") | C binding 882 | [rocsolver_sgetri_npvt_outofplace_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgetri__npvt__outofplace__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 883 | [rocsolver_dgetri_npvt_outofplace_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgetri__npvt__outofplace__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 884 | [rocsolver_cgetri_npvt_outofplace_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgetri__npvt__outofplace__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 885 | [rocsolver_zgetri_npvt_outofplace_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgetri__npvt__outofplace__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 886 | [rocsolver_strtri](interfacehipfort__rocsolver_1_1rocsolver__strtri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 887 | [rocsolver_dtrtri](interfacehipfort__rocsolver_1_1rocsolver__dtrtri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 888 | [rocsolver_ctrtri](interfacehipfort__rocsolver_1_1rocsolver__ctrtri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 889 | [rocsolver_ztrtri](interfacehipfort__rocsolver_1_1rocsolver__ztrtri.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 890 | [rocsolver_strtri_batched](interfacehipfort__rocsolver_1_1rocsolver__strtri__batched.html "Interface documentation") | C binding 891 | [rocsolver_dtrtri_batched](interfacehipfort__rocsolver_1_1rocsolver__dtrtri__batched.html "Interface documentation") | C binding 892 | [rocsolver_ctrtri_batched](interfacehipfort__rocsolver_1_1rocsolver__ctrtri__batched.html "Interface documentation") | C binding 893 | [rocsolver_ztrtri_batched](interfacehipfort__rocsolver_1_1rocsolver__ztrtri__batched.html "Interface documentation") | C binding 894 | [rocsolver_strtri_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__strtri__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 895 | [rocsolver_dtrtri_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dtrtri__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 896 | [rocsolver_ctrtri_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ctrtri__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 897 | [rocsolver_ztrtri_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ztrtri__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 898 | [rocsolver_ssytf2](interfacehipfort__rocsolver_1_1rocsolver__ssytf2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 899 | [rocsolver_dsytf2](interfacehipfort__rocsolver_1_1rocsolver__dsytf2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 900 | [rocsolver_csytf2](interfacehipfort__rocsolver_1_1rocsolver__csytf2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 901 | [rocsolver_zsytf2](interfacehipfort__rocsolver_1_1rocsolver__zsytf2.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 902 | [rocsolver_ssytf2_batched](interfacehipfort__rocsolver_1_1rocsolver__ssytf2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 903 | [rocsolver_dsytf2_batched](interfacehipfort__rocsolver_1_1rocsolver__dsytf2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 904 | [rocsolver_csytf2_batched](interfacehipfort__rocsolver_1_1rocsolver__csytf2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 905 | [rocsolver_zsytf2_batched](interfacehipfort__rocsolver_1_1rocsolver__zsytf2__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 906 | [rocsolver_ssytf2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ssytf2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 907 | [rocsolver_dsytf2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dsytf2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 908 | [rocsolver_csytf2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__csytf2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 909 | [rocsolver_zsytf2_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zsytf2__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 910 | [rocsolver_ssytrf](interfacehipfort__rocsolver_1_1rocsolver__ssytrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 911 | [rocsolver_dsytrf](interfacehipfort__rocsolver_1_1rocsolver__dsytrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 912 | [rocsolver_csytrf](interfacehipfort__rocsolver_1_1rocsolver__csytrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 913 | [rocsolver_zsytrf](interfacehipfort__rocsolver_1_1rocsolver__zsytrf.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 914 | [rocsolver_ssytrf_batched](interfacehipfort__rocsolver_1_1rocsolver__ssytrf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 915 | [rocsolver_dsytrf_batched](interfacehipfort__rocsolver_1_1rocsolver__dsytrf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 916 | [rocsolver_csytrf_batched](interfacehipfort__rocsolver_1_1rocsolver__csytrf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 917 | [rocsolver_zsytrf_batched](interfacehipfort__rocsolver_1_1rocsolver__zsytrf__batched.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 918 | [rocsolver_ssytrf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ssytrf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 919 | [rocsolver_dsytrf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dsytrf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 920 | [rocsolver_csytrf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__csytrf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 921 | [rocsolver_zsytrf_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zsytrf__strided__batched.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 922 | [rocsolver_sgeblttrf_npvt](interfacehipfort__rocsolver_1_1rocsolver__sgeblttrf__npvt.html "Interface documentation") | C binding 923 | [rocsolver_dgeblttrf_npvt](interfacehipfort__rocsolver_1_1rocsolver__dgeblttrf__npvt.html "Interface documentation") | C binding 924 | [rocsolver_cgeblttrf_npvt](interfacehipfort__rocsolver_1_1rocsolver__cgeblttrf__npvt.html "Interface documentation") | C binding 925 | [rocsolver_zgeblttrf_npvt](interfacehipfort__rocsolver_1_1rocsolver__zgeblttrf__npvt.html "Interface documentation") | C binding 926 | [rocsolver_sgeblttrf_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__sgeblttrf__npvt__batched.html "Interface documentation") | C binding 927 | [rocsolver_dgeblttrf_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__dgeblttrf__npvt__batched.html "Interface documentation") | C binding 928 | [rocsolver_cgeblttrf_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__cgeblttrf__npvt__batched.html "Interface documentation") | C binding 929 | [rocsolver_zgeblttrf_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__zgeblttrf__npvt__batched.html "Interface documentation") | C binding 930 | [rocsolver_sgeblttrf_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgeblttrf__npvt__strided__batched.html "Interface documentation") | C binding 931 | [rocsolver_dgeblttrf_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgeblttrf__npvt__strided__batched.html "Interface documentation") | C binding 932 | [rocsolver_cgeblttrf_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgeblttrf__npvt__strided__batched.html "Interface documentation") | C binding 933 | [rocsolver_zgeblttrf_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgeblttrf__npvt__strided__batched.html "Interface documentation") | C binding 934 | [rocsolver_sgeblttrf_npvt_interleaved_batched](interfacehipfort__rocsolver_1_1rocsolver__sgeblttrf__npvt__interleaved__batched.html "Interface documentation") | C binding 935 | [rocsolver_dgeblttrf_npvt_interleaved_batched](interfacehipfort__rocsolver_1_1rocsolver__dgeblttrf__npvt__interleaved__batched.html "Interface documentation") | C binding 936 | [rocsolver_cgeblttrf_npvt_interleaved_batched](interfacehipfort__rocsolver_1_1rocsolver__cgeblttrf__npvt__interleaved__batched.html "Interface documentation") | C binding 937 | [rocsolver_zgeblttrf_npvt_interleaved_batched](interfacehipfort__rocsolver_1_1rocsolver__zgeblttrf__npvt__interleaved__batched.html "Interface documentation") | C binding 938 | [rocsolver_sgeblttrs_npvt](interfacehipfort__rocsolver_1_1rocsolver__sgeblttrs__npvt.html "Interface documentation") | C binding 939 | [rocsolver_dgeblttrs_npvt](interfacehipfort__rocsolver_1_1rocsolver__dgeblttrs__npvt.html "Interface documentation") | C binding 940 | [rocsolver_cgeblttrs_npvt](interfacehipfort__rocsolver_1_1rocsolver__cgeblttrs__npvt.html "Interface documentation") | C binding 941 | [rocsolver_zgeblttrs_npvt](interfacehipfort__rocsolver_1_1rocsolver__zgeblttrs__npvt.html "Interface documentation") | C binding 942 | [rocsolver_sgeblttrs_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__sgeblttrs__npvt__batched.html "Interface documentation") | C binding 943 | [rocsolver_dgeblttrs_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__dgeblttrs__npvt__batched.html "Interface documentation") | C binding 944 | [rocsolver_cgeblttrs_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__cgeblttrs__npvt__batched.html "Interface documentation") | C binding 945 | [rocsolver_zgeblttrs_npvt_batched](interfacehipfort__rocsolver_1_1rocsolver__zgeblttrs__npvt__batched.html "Interface documentation") | C binding 946 | [rocsolver_sgeblttrs_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__sgeblttrs__npvt__strided__batched.html "Interface documentation") | C binding 947 | [rocsolver_dgeblttrs_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dgeblttrs__npvt__strided__batched.html "Interface documentation") | C binding 948 | [rocsolver_cgeblttrs_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cgeblttrs__npvt__strided__batched.html "Interface documentation") | C binding 949 | [rocsolver_zgeblttrs_npvt_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zgeblttrs__npvt__strided__batched.html "Interface documentation") | C binding 950 | [rocsolver_sgeblttrs_npvt_interleaved_batched](interfacehipfort__rocsolver_1_1rocsolver__sgeblttrs__npvt__interleaved__batched.html "Interface documentation") | C binding 951 | [rocsolver_dgeblttrs_npvt_interleaved_batched](interfacehipfort__rocsolver_1_1rocsolver__dgeblttrs__npvt__interleaved__batched.html "Interface documentation") | C binding 952 | [rocsolver_cgeblttrs_npvt_interleaved_batched](interfacehipfort__rocsolver_1_1rocsolver__cgeblttrs__npvt__interleaved__batched.html "Interface documentation") | C binding 953 | [rocsolver_zgeblttrs_npvt_interleaved_batched](interfacehipfort__rocsolver_1_1rocsolver__zgeblttrs__npvt__interleaved__batched.html "Interface documentation") | C binding 954 | [rocsolver_create_rfinfo](interfacehipfort__rocsolver_1_1rocsolver__create__rfinfo.html "Interface documentation") | C binding 955 | [rocsolver_destroy_rfinfo](interfacehipfort__rocsolver_1_1rocsolver__destroy__rfinfo.html "Interface documentation") | C binding 956 | [rocsolver_set_rfinfo_mode](interfacehipfort__rocsolver_1_1rocsolver__set__rfinfo__mode.html "Interface documentation") | C binding 957 | [rocsolver_get_rfinfo_mode](interfacehipfort__rocsolver_1_1rocsolver__get__rfinfo__mode.html "Interface documentation") | C binding 958 | [rocsolver_scsrrf_sumlu](interfacehipfort__rocsolver_1_1rocsolver__scsrrf__sumlu.html "Interface documentation") | C binding 959 | [rocsolver_dcsrrf_sumlu](interfacehipfort__rocsolver_1_1rocsolver__dcsrrf__sumlu.html "Interface documentation") | C binding 960 | [rocsolver_scsrrf_splitlu](interfacehipfort__rocsolver_1_1rocsolver__scsrrf__splitlu.html "Interface documentation") | C binding 961 | [rocsolver_dcsrrf_splitlu](interfacehipfort__rocsolver_1_1rocsolver__dcsrrf__splitlu.html "Interface documentation") | C binding 962 | [rocsolver_scsrrf_analysis](interfacehipfort__rocsolver_1_1rocsolver__scsrrf__analysis.html "Interface documentation") | C binding 963 | [rocsolver_dcsrrf_analysis](interfacehipfort__rocsolver_1_1rocsolver__dcsrrf__analysis.html "Interface documentation") | C binding 964 | [rocsolver_scsrrf_refactlu](interfacehipfort__rocsolver_1_1rocsolver__scsrrf__refactlu.html "Interface documentation") | C binding 965 | [rocsolver_dcsrrf_refactlu](interfacehipfort__rocsolver_1_1rocsolver__dcsrrf__refactlu.html "Interface documentation") | C binding 966 | [rocsolver_scsrrf_refactchol](interfacehipfort__rocsolver_1_1rocsolver__scsrrf__refactchol.html "Interface documentation") | C binding 967 | [rocsolver_dcsrrf_refactchol](interfacehipfort__rocsolver_1_1rocsolver__dcsrrf__refactchol.html "Interface documentation") | C binding 968 | [rocsolver_scsrrf_solve](interfacehipfort__rocsolver_1_1rocsolver__scsrrf__solve.html "Interface documentation") | C binding 969 | [rocsolver_dcsrrf_solve](interfacehipfort__rocsolver_1_1rocsolver__dcsrrf__solve.html "Interface documentation") | C binding 970 | [rocsolver_ssyevdx](interfacehipfort__rocsolver_1_1rocsolver__ssyevdx.html "Interface documentation") | C binding 971 | [rocsolver_dsyevdx](interfacehipfort__rocsolver_1_1rocsolver__dsyevdx.html "Interface documentation") | C binding 972 | [rocsolver_cheevdx](interfacehipfort__rocsolver_1_1rocsolver__cheevdx.html "Interface documentation") | C binding 973 | [rocsolver_zheevdx](interfacehipfort__rocsolver_1_1rocsolver__zheevdx.html "Interface documentation") | C binding 974 | [rocsolver_ssyevdx_batched](interfacehipfort__rocsolver_1_1rocsolver__ssyevdx__batched.html "Interface documentation") | C binding 975 | [rocsolver_dsyevdx_batched](interfacehipfort__rocsolver_1_1rocsolver__dsyevdx__batched.html "Interface documentation") | C binding 976 | [rocsolver_cheevdx_batched](interfacehipfort__rocsolver_1_1rocsolver__cheevdx__batched.html "Interface documentation") | C binding 977 | [rocsolver_zheevdx_batched](interfacehipfort__rocsolver_1_1rocsolver__zheevdx__batched.html "Interface documentation") | C binding 978 | [rocsolver_ssyevdx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ssyevdx__strided__batched.html "Interface documentation") | C binding 979 | [rocsolver_dsyevdx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dsyevdx__strided__batched.html "Interface documentation") | C binding 980 | [rocsolver_cheevdx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__cheevdx__strided__batched.html "Interface documentation") | C binding 981 | [rocsolver_zheevdx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zheevdx__strided__batched.html "Interface documentation") | C binding 982 | [rocsolver_ssygvdx](interfacehipfort__rocsolver_1_1rocsolver__ssygvdx.html "Interface documentation") | C binding 983 | [rocsolver_dsygvdx](interfacehipfort__rocsolver_1_1rocsolver__dsygvdx.html "Interface documentation") | C binding 984 | [rocsolver_chegvdx](interfacehipfort__rocsolver_1_1rocsolver__chegvdx.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 985 | [rocsolver_zhegvdx](interfacehipfort__rocsolver_1_1rocsolver__zhegvdx.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 986 | [rocsolver_ssygvdx_batched](interfacehipfort__rocsolver_1_1rocsolver__ssygvdx__batched.html "Interface documentation") | C binding 987 | [rocsolver_dsygvdx_batched](interfacehipfort__rocsolver_1_1rocsolver__dsygvdx__batched.html "Interface documentation") | C binding 988 | [rocsolver_chegvdx_batched](interfacehipfort__rocsolver_1_1rocsolver__chegvdx__batched.html "Interface documentation") | C binding 989 | [rocsolver_zhegvdx_batched](interfacehipfort__rocsolver_1_1rocsolver__zhegvdx__batched.html "Interface documentation") | C binding 990 | [rocsolver_ssygvdx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__ssygvdx__strided__batched.html "Interface documentation") | C binding 991 | [rocsolver_dsygvdx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__dsygvdx__strided__batched.html "Interface documentation") | C binding 992 | [rocsolver_chegvdx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__chegvdx__strided__batched.html "Interface documentation") | C binding 993 | [rocsolver_zhegvdx_strided_batched](interfacehipfort__rocsolver_1_1rocsolver__zhegvdx__strided__batched.html "Interface documentation") | C binding hipfort-rocm-10.0.0/docs/doxygen/input/supported_api_rocsparse.md000066400000000000000000003335471524740623400252540ustar00rootroot00000000000000# rocSPARSE API Support \# | API Name | Variants ----|---------------|--------- 1 | [rocsparse_create_handle](interfacehipfort__rocsparse_1_1rocsparse__create__handle.html "Interface documentation") | C binding 2 | [rocsparse_handle_create](interfacehipfort__rocsparse_1_1rocsparse__handle__create.html "Interface documentation") | C binding 3 | [rocsparse_destroy_handle](interfacehipfort__rocsparse_1_1rocsparse__destroy__handle.html "Interface documentation") | C binding 4 | [rocsparse_handle_destroy](interfacehipfort__rocsparse_1_1rocsparse__handle__destroy.html "Interface documentation") | C binding 5 | [rocsparse_destroy_error](interfacehipfort__rocsparse_1_1rocsparse__destroy__error.html "Interface documentation") | C binding 6 | [rocsparse_error_get_message](interfacehipfort__rocsparse_1_1rocsparse__error__get__message.html "Interface documentation") | C binding 7 | [rocsparse_get_status_name](interfacehipfort__rocsparse_1_1rocsparse__get__status__name.html "Interface documentation") | C binding 8 | [rocsparse_get_status_description](interfacehipfort__rocsparse_1_1rocsparse__get__status__description.html "Interface documentation") | C binding 9 | [rocsparse_set_stream](interfacehipfort__rocsparse_1_1rocsparse__set__stream.html "Interface documentation") | C binding 10 | [rocsparse_get_stream](interfacehipfort__rocsparse_1_1rocsparse__get__stream.html "Interface documentation") | C binding 11 | [rocsparse_set_pointer_mode](interfacehipfort__rocsparse_1_1rocsparse__set__pointer__mode.html "Interface documentation") | C binding 12 | [rocsparse_get_pointer_mode](interfacehipfort__rocsparse_1_1rocsparse__get__pointer__mode.html "Interface documentation") | C binding 13 | [rocsparse_get_version](interfacehipfort__rocsparse_1_1rocsparse__get__version.html "Interface documentation") | C binding 14 | [rocsparse_get_git_rev](interfacehipfort__rocsparse_1_1rocsparse__get__git__rev.html "Interface documentation") | C binding 15 | [rocsparse_create_mat_descr](interfacehipfort__rocsparse_1_1rocsparse__create__mat__descr.html "Interface documentation") | C binding 16 | [rocsparse_copy_mat_descr](interfacehipfort__rocsparse_1_1rocsparse__copy__mat__descr.html "Interface documentation") | C binding 17 | [rocsparse_destroy_mat_descr](interfacehipfort__rocsparse_1_1rocsparse__destroy__mat__descr.html "Interface documentation") | C binding 18 | [rocsparse_set_mat_index_base](interfacehipfort__rocsparse_1_1rocsparse__set__mat__index__base.html "Interface documentation") | C binding 19 | [rocsparse_get_mat_index_base](interfacehipfort__rocsparse_1_1rocsparse__get__mat__index__base.html "Interface documentation") | C binding 20 | [rocsparse_set_mat_type](interfacehipfort__rocsparse_1_1rocsparse__set__mat__type.html "Interface documentation") | C binding 21 | [rocsparse_get_mat_type](interfacehipfort__rocsparse_1_1rocsparse__get__mat__type.html "Interface documentation") | C binding 22 | [rocsparse_set_mat_fill_mode](interfacehipfort__rocsparse_1_1rocsparse__set__mat__fill__mode.html "Interface documentation") | C binding 23 | [rocsparse_get_mat_fill_mode](interfacehipfort__rocsparse_1_1rocsparse__get__mat__fill__mode.html "Interface documentation") | C binding 24 | [rocsparse_set_mat_diag_type](interfacehipfort__rocsparse_1_1rocsparse__set__mat__diag__type.html "Interface documentation") | C binding 25 | [rocsparse_get_mat_diag_type](interfacehipfort__rocsparse_1_1rocsparse__get__mat__diag__type.html "Interface documentation") | C binding 26 | [rocsparse_set_mat_storage_mode](interfacehipfort__rocsparse_1_1rocsparse__set__mat__storage__mode.html "Interface documentation") | C binding 27 | [rocsparse_get_mat_storage_mode](interfacehipfort__rocsparse_1_1rocsparse__get__mat__storage__mode.html "Interface documentation") | C binding 28 | [rocsparse_create_hyb_mat](interfacehipfort__rocsparse_1_1rocsparse__create__hyb__mat.html "Interface documentation") | C binding 29 | [rocsparse_copy_hyb_mat](interfacehipfort__rocsparse_1_1rocsparse__copy__hyb__mat.html "Interface documentation") | C binding 30 | [rocsparse_destroy_hyb_mat](interfacehipfort__rocsparse_1_1rocsparse__destroy__hyb__mat.html "Interface documentation") | C binding 31 | [rocsparse_create_mat_info](interfacehipfort__rocsparse_1_1rocsparse__create__mat__info.html "Interface documentation") | C binding 32 | [rocsparse_copy_mat_info](interfacehipfort__rocsparse_1_1rocsparse__copy__mat__info.html "Interface documentation") | C binding 33 | [rocsparse_destroy_mat_info](interfacehipfort__rocsparse_1_1rocsparse__destroy__mat__info.html "Interface documentation") | C binding 34 | [rocsparse_create_color_info](interfacehipfort__rocsparse_1_1rocsparse__create__color__info.html "Interface documentation") | C binding 35 | [rocsparse_copy_color_info](interfacehipfort__rocsparse_1_1rocsparse__copy__color__info.html "Interface documentation") | C binding 36 | [rocsparse_destroy_color_info](interfacehipfort__rocsparse_1_1rocsparse__destroy__color__info.html "Interface documentation") | C binding 37 | [rocsparse_create_spvec_descr](interfacehipfort__rocsparse_1_1rocsparse__create__spvec__descr.html "Interface documentation") | C binding 38 | [rocsparse_create_const_spvec_descr](interfacehipfort__rocsparse_1_1rocsparse__create__const__spvec__descr.html "Interface documentation") | C binding 39 | [rocsparse_destroy_spvec_descr](interfacehipfort__rocsparse_1_1rocsparse__destroy__spvec__descr.html "Interface documentation") | C binding 40 | [rocsparse_spvec_get](interfacehipfort__rocsparse_1_1rocsparse__spvec__get.html "Interface documentation") | C binding 41 | [rocsparse_const_spvec_get](interfacehipfort__rocsparse_1_1rocsparse__const__spvec__get.html "Interface documentation") | C binding 42 | [rocsparse_spvec_get_index_base](interfacehipfort__rocsparse_1_1rocsparse__spvec__get__index__base.html "Interface documentation") | C binding 43 | [rocsparse_spvec_get_values](interfacehipfort__rocsparse_1_1rocsparse__spvec__get__values.html "Interface documentation") | C binding 44 | [rocsparse_const_spvec_get_values](interfacehipfort__rocsparse_1_1rocsparse__const__spvec__get__values.html "Interface documentation") | C binding 45 | [rocsparse_spvec_set_values](interfacehipfort__rocsparse_1_1rocsparse__spvec__set__values.html "Interface documentation") | C binding 46 | [rocsparse_create_coo_descr](interfacehipfort__rocsparse_1_1rocsparse__create__coo__descr.html "Interface documentation") | C binding 47 | [rocsparse_create_const_coo_descr](interfacehipfort__rocsparse_1_1rocsparse__create__const__coo__descr.html "Interface documentation") | C binding 48 | [rocsparse_create_coo_aos_descr](interfacehipfort__rocsparse_1_1rocsparse__create__coo__aos__descr.html "Interface documentation") | C binding 49 | [rocsparse_create_bsr_descr](interfacehipfort__rocsparse_1_1rocsparse__create__bsr__descr.html "Interface documentation") | C binding 50 | [rocsparse_create_const_bsr_descr](interfacehipfort__rocsparse_1_1rocsparse__create__const__bsr__descr.html "Interface documentation") | C binding 51 | [rocsparse_create_csr_descr](interfacehipfort__rocsparse_1_1rocsparse__create__csr__descr.html "Interface documentation") | C binding 52 | [rocsparse_create_const_csr_descr](interfacehipfort__rocsparse_1_1rocsparse__create__const__csr__descr.html "Interface documentation") | C binding 53 | [rocsparse_create_csc_descr](interfacehipfort__rocsparse_1_1rocsparse__create__csc__descr.html "Interface documentation") | C binding 54 | [rocsparse_create_const_csc_descr](interfacehipfort__rocsparse_1_1rocsparse__create__const__csc__descr.html "Interface documentation") | C binding 55 | [rocsparse_create_ell_descr](interfacehipfort__rocsparse_1_1rocsparse__create__ell__descr.html "Interface documentation") | C binding 56 | [rocsparse_create_bell_descr](interfacehipfort__rocsparse_1_1rocsparse__create__bell__descr.html "Interface documentation") | C binding 57 | [rocsparse_create_const_bell_descr](interfacehipfort__rocsparse_1_1rocsparse__create__const__bell__descr.html "Interface documentation") | C binding 58 | [rocsparse_create_sell_descr](interfacehipfort__rocsparse_1_1rocsparse__create__sell__descr.html "Interface documentation") | C binding 59 | [rocsparse_create_const_sell_descr](interfacehipfort__rocsparse_1_1rocsparse__create__const__sell__descr.html "Interface documentation") | C binding 60 | [rocsparse_destroy_spmat_descr](interfacehipfort__rocsparse_1_1rocsparse__destroy__spmat__descr.html "Interface documentation") | C binding 61 | [rocsparse_create_sparse_to_sparse_descr](interfacehipfort__rocsparse_1_1rocsparse__create__sparse__to__sparse__descr.html "Interface documentation") | C binding 62 | [rocsparse_sparse_to_sparse_permissive](interfacehipfort__rocsparse_1_1rocsparse__sparse__to__sparse__permissive.html "Interface documentation") | C binding 63 | [rocsparse_destroy_sparse_to_sparse_descr](interfacehipfort__rocsparse_1_1rocsparse__destroy__sparse__to__sparse__descr.html "Interface documentation") | C binding 64 | [rocsparse_create_extract_descr](interfacehipfort__rocsparse_1_1rocsparse__create__extract__descr.html "Interface documentation") | C binding 65 | [rocsparse_destroy_extract_descr](interfacehipfort__rocsparse_1_1rocsparse__destroy__extract__descr.html "Interface documentation") | C binding 66 | [rocsparse_create_spgeam_descr](interfacehipfort__rocsparse_1_1rocsparse__create__spgeam__descr.html "Interface documentation") | C binding 67 | [rocsparse_destroy_spgeam_descr](interfacehipfort__rocsparse_1_1rocsparse__destroy__spgeam__descr.html "Interface documentation") | C binding 68 | [rocsparse_spgeam_set_input](interfacehipfort__rocsparse_1_1rocsparse__spgeam__set__input.html "Interface documentation") | C binding 69 | [rocsparse_spgeam_get_output](interfacehipfort__rocsparse_1_1rocsparse__spgeam__get__output.html "Interface documentation") | C binding 70 | [rocsparse_create_spmv_descr](interfacehipfort__rocsparse_1_1rocsparse__create__spmv__descr.html "Interface documentation") | C binding 71 | [rocsparse_destroy_spmv_descr](interfacehipfort__rocsparse_1_1rocsparse__destroy__spmv__descr.html "Interface documentation") | C binding 72 | [rocsparse_spmv_set_input](interfacehipfort__rocsparse_1_1rocsparse__spmv__set__input.html "Interface documentation") | C binding 73 | [rocsparse_sptrsv_descr_create](interfacehipfort__rocsparse_1_1rocsparse__sptrsv__descr__create.html "Interface documentation") | C binding 74 | [rocsparse_sptrsv_descr_destroy](interfacehipfort__rocsparse_1_1rocsparse__sptrsv__descr__destroy.html "Interface documentation") | C binding 75 | [rocsparse_create_sptrsv_descr](interfacehipfort__rocsparse_1_1rocsparse__create__sptrsv__descr.html "Interface documentation") | C binding 76 | [rocsparse_destroy_sptrsv_descr](interfacehipfort__rocsparse_1_1rocsparse__destroy__sptrsv__descr.html "Interface documentation") | C binding 77 | [rocsparse_sptrsv_set_input](interfacehipfort__rocsparse_1_1rocsparse__sptrsv__set__input.html "Interface documentation") | C binding 78 | [rocsparse_sptrsv_get_output](interfacehipfort__rocsparse_1_1rocsparse__sptrsv__get__output.html "Interface documentation") | C binding 79 | [rocsparse_create_sptrsm_descr](interfacehipfort__rocsparse_1_1rocsparse__create__sptrsm__descr.html "Interface documentation") | C binding 80 | [rocsparse_destroy_sptrsm_descr](interfacehipfort__rocsparse_1_1rocsparse__destroy__sptrsm__descr.html "Interface documentation") | C binding 81 | [rocsparse_sptrsm_set_input](interfacehipfort__rocsparse_1_1rocsparse__sptrsm__set__input.html "Interface documentation") | C binding 82 | [rocsparse_sptrsm_get_output](interfacehipfort__rocsparse_1_1rocsparse__sptrsm__get__output.html "Interface documentation") | C binding 83 | [rocsparse_spic0_descr_create](interfacehipfort__rocsparse_1_1rocsparse__spic0__descr__create.html "Interface documentation") | C binding 84 | [rocsparse_spic0_descr_destroy](interfacehipfort__rocsparse_1_1rocsparse__spic0__descr__destroy.html "Interface documentation") | C binding 85 | [rocsparse_spic0_set_input](interfacehipfort__rocsparse_1_1rocsparse__spic0__set__input.html "Interface documentation") | C binding 86 | [rocsparse_spic0_get_output](interfacehipfort__rocsparse_1_1rocsparse__spic0__get__output.html "Interface documentation") | C binding 87 | [rocsparse_spilu0_descr_create](interfacehipfort__rocsparse_1_1rocsparse__spilu0__descr__create.html "Interface documentation") | C binding 88 | [rocsparse_spilu0_descr_destroy](interfacehipfort__rocsparse_1_1rocsparse__spilu0__descr__destroy.html "Interface documentation") | C binding 89 | [rocsparse_spilu0_set_input](interfacehipfort__rocsparse_1_1rocsparse__spilu0__set__input.html "Interface documentation") | C binding 90 | [rocsparse_spilu0_get_output](interfacehipfort__rocsparse_1_1rocsparse__spilu0__get__output.html "Interface documentation") | C binding 91 | [rocsparse_spildlt0_descr_create](interfacehipfort__rocsparse_1_1rocsparse__spildlt0__descr__create.html "Interface documentation") | C binding 92 | [rocsparse_spildlt0_descr_destroy](interfacehipfort__rocsparse_1_1rocsparse__spildlt0__descr__destroy.html "Interface documentation") | C binding 93 | [rocsparse_spildlt0_set_input](interfacehipfort__rocsparse_1_1rocsparse__spildlt0__set__input.html "Interface documentation") | C binding 94 | [rocsparse_spildlt0_get_output](interfacehipfort__rocsparse_1_1rocsparse__spildlt0__get__output.html "Interface documentation") | C binding 95 | [rocsparse_coo_get](interfacehipfort__rocsparse_1_1rocsparse__coo__get.html "Interface documentation") | C binding 96 | [rocsparse_const_coo_get](interfacehipfort__rocsparse_1_1rocsparse__const__coo__get.html "Interface documentation") | C binding 97 | [rocsparse_coo_aos_get](interfacehipfort__rocsparse_1_1rocsparse__coo__aos__get.html "Interface documentation") | C binding 98 | [rocsparse_const_coo_aos_get](interfacehipfort__rocsparse_1_1rocsparse__const__coo__aos__get.html "Interface documentation") | C binding 99 | [rocsparse_csr_get](interfacehipfort__rocsparse_1_1rocsparse__csr__get.html "Interface documentation") | C binding 100 | [rocsparse_const_csr_get](interfacehipfort__rocsparse_1_1rocsparse__const__csr__get.html "Interface documentation") | C binding 101 | [rocsparse_csc_get](interfacehipfort__rocsparse_1_1rocsparse__csc__get.html "Interface documentation") | C binding 102 | [rocsparse_const_csc_get](interfacehipfort__rocsparse_1_1rocsparse__const__csc__get.html "Interface documentation") | C binding 103 | [rocsparse_ell_get](interfacehipfort__rocsparse_1_1rocsparse__ell__get.html "Interface documentation") | C binding 104 | [rocsparse_const_ell_get](interfacehipfort__rocsparse_1_1rocsparse__const__ell__get.html "Interface documentation") | C binding 105 | [rocsparse_bell_get](interfacehipfort__rocsparse_1_1rocsparse__bell__get.html "Interface documentation") | C binding 106 | [rocsparse_const_bell_get](interfacehipfort__rocsparse_1_1rocsparse__const__bell__get.html "Interface documentation") | C binding 107 | [rocsparse_sell_get](interfacehipfort__rocsparse_1_1rocsparse__sell__get.html "Interface documentation") | C binding 108 | [rocsparse_const_sell_get](interfacehipfort__rocsparse_1_1rocsparse__const__sell__get.html "Interface documentation") | C binding 109 | [rocsparse_bsr_get](interfacehipfort__rocsparse_1_1rocsparse__bsr__get.html "Interface documentation") | C binding 110 | [rocsparse_const_bsr_get](interfacehipfort__rocsparse_1_1rocsparse__const__bsr__get.html "Interface documentation") | C binding 111 | [rocsparse_coo_set_pointers](interfacehipfort__rocsparse_1_1rocsparse__coo__set__pointers.html "Interface documentation") | C binding 112 | [rocsparse_coo_aos_set_pointers](interfacehipfort__rocsparse_1_1rocsparse__coo__aos__set__pointers.html "Interface documentation") | C binding 113 | [rocsparse_csr_set_pointers](interfacehipfort__rocsparse_1_1rocsparse__csr__set__pointers.html "Interface documentation") | C binding 114 | [rocsparse_csc_set_pointers](interfacehipfort__rocsparse_1_1rocsparse__csc__set__pointers.html "Interface documentation") | C binding 115 | [rocsparse_ell_set_pointers](interfacehipfort__rocsparse_1_1rocsparse__ell__set__pointers.html "Interface documentation") | C binding 116 | [rocsparse_bsr_set_pointers](interfacehipfort__rocsparse_1_1rocsparse__bsr__set__pointers.html "Interface documentation") | C binding 117 | [rocsparse_bell_set_pointers](interfacehipfort__rocsparse_1_1rocsparse__bell__set__pointers.html "Interface documentation") | C binding 118 | [rocsparse_spmat_get_size](interfacehipfort__rocsparse_1_1rocsparse__spmat__get__size.html "Interface documentation") | C binding 119 | [rocsparse_spmat_get_format](interfacehipfort__rocsparse_1_1rocsparse__spmat__get__format.html "Interface documentation") | C binding 120 | [rocsparse_spmat_get_index_base](interfacehipfort__rocsparse_1_1rocsparse__spmat__get__index__base.html "Interface documentation") | C binding 121 | [rocsparse_spmat_get_values](interfacehipfort__rocsparse_1_1rocsparse__spmat__get__values.html "Interface documentation") | C binding 122 | [rocsparse_const_spmat_get_values](interfacehipfort__rocsparse_1_1rocsparse__const__spmat__get__values.html "Interface documentation") | C binding 123 | [rocsparse_spmat_set_values](interfacehipfort__rocsparse_1_1rocsparse__spmat__set__values.html "Interface documentation") | C binding 124 | [rocsparse_spmat_get_nnz](interfacehipfort__rocsparse_1_1rocsparse__spmat__get__nnz.html "Interface documentation") | C binding 125 | [rocsparse_spmat_set_nnz](interfacehipfort__rocsparse_1_1rocsparse__spmat__set__nnz.html "Interface documentation") | C binding 126 | [rocsparse_spmat_get_strided_batch](interfacehipfort__rocsparse_1_1rocsparse__spmat__get__strided__batch.html "Interface documentation") | C binding 127 | [rocsparse_spmat_set_strided_batch](interfacehipfort__rocsparse_1_1rocsparse__spmat__set__strided__batch.html "Interface documentation") | C binding 128 | [rocsparse_coo_set_strided_batch](interfacehipfort__rocsparse_1_1rocsparse__coo__set__strided__batch.html "Interface documentation") | C binding 129 | [rocsparse_csr_set_strided_batch](interfacehipfort__rocsparse_1_1rocsparse__csr__set__strided__batch.html "Interface documentation") | C binding 130 | [rocsparse_csc_set_strided_batch](interfacehipfort__rocsparse_1_1rocsparse__csc__set__strided__batch.html "Interface documentation") | C binding 131 | [rocsparse_spmat_get_attribute](interfacehipfort__rocsparse_1_1rocsparse__spmat__get__attribute.html "Interface documentation") | C binding 132 | [rocsparse_spmat_set_attribute](interfacehipfort__rocsparse_1_1rocsparse__spmat__set__attribute.html "Interface documentation") | C binding 133 | [rocsparse_create_dnvec_descr](interfacehipfort__rocsparse_1_1rocsparse__create__dnvec__descr.html "Interface documentation") | C binding 134 | [rocsparse_create_const_dnvec_descr](interfacehipfort__rocsparse_1_1rocsparse__create__const__dnvec__descr.html "Interface documentation") | C binding 135 | [rocsparse_destroy_dnvec_descr](interfacehipfort__rocsparse_1_1rocsparse__destroy__dnvec__descr.html "Interface documentation") | C binding 136 | [rocsparse_dnvec_get](interfacehipfort__rocsparse_1_1rocsparse__dnvec__get.html "Interface documentation") | C binding 137 | [rocsparse_const_dnvec_get](interfacehipfort__rocsparse_1_1rocsparse__const__dnvec__get.html "Interface documentation") | C binding 138 | [rocsparse_dnvec_get_values](interfacehipfort__rocsparse_1_1rocsparse__dnvec__get__values.html "Interface documentation") | C binding 139 | [rocsparse_const_dnvec_get_values](interfacehipfort__rocsparse_1_1rocsparse__const__dnvec__get__values.html "Interface documentation") | C binding 140 | [rocsparse_dnvec_set_values](interfacehipfort__rocsparse_1_1rocsparse__dnvec__set__values.html "Interface documentation") | C binding 141 | [rocsparse_create_dnmat_descr](interfacehipfort__rocsparse_1_1rocsparse__create__dnmat__descr.html "Interface documentation") | C binding 142 | [rocsparse_create_const_dnmat_descr](interfacehipfort__rocsparse_1_1rocsparse__create__const__dnmat__descr.html "Interface documentation") | C binding 143 | [rocsparse_destroy_dnmat_descr](interfacehipfort__rocsparse_1_1rocsparse__destroy__dnmat__descr.html "Interface documentation") | C binding 144 | [rocsparse_dnmat_get](interfacehipfort__rocsparse_1_1rocsparse__dnmat__get.html "Interface documentation") | C binding 145 | [rocsparse_const_dnmat_get](interfacehipfort__rocsparse_1_1rocsparse__const__dnmat__get.html "Interface documentation") | C binding 146 | [rocsparse_dnmat_get_values](interfacehipfort__rocsparse_1_1rocsparse__dnmat__get__values.html "Interface documentation") | C binding 147 | [rocsparse_const_dnmat_get_values](interfacehipfort__rocsparse_1_1rocsparse__const__dnmat__get__values.html "Interface documentation") | C binding 148 | [rocsparse_dnmat_set_values](interfacehipfort__rocsparse_1_1rocsparse__dnmat__set__values.html "Interface documentation") | C binding 149 | [rocsparse_dnmat_get_strided_batch](interfacehipfort__rocsparse_1_1rocsparse__dnmat__get__strided__batch.html "Interface documentation") | C binding 150 | [rocsparse_dnmat_set_strided_batch](interfacehipfort__rocsparse_1_1rocsparse__dnmat__set__strided__batch.html "Interface documentation") | C binding 151 | [rocsparse_dnvec_get_strided_batch](interfacehipfort__rocsparse_1_1rocsparse__dnvec__get__strided__batch.html "Interface documentation") | C binding 152 | [rocsparse_dnvec_set_strided_batch](interfacehipfort__rocsparse_1_1rocsparse__dnvec__set__strided__batch.html "Interface documentation") | C binding 153 | [rocsparse_enable_debug_kernel_launch](interfacehipfort__rocsparse_1_1rocsparse__enable__debug__kernel__launch.html "Interface documentation") | C binding 154 | [rocsparse_disable_debug_kernel_launch](interfacehipfort__rocsparse_1_1rocsparse__disable__debug__kernel__launch.html "Interface documentation") | C binding 155 | [rocsparse_state_debug_kernel_launch](interfacehipfort__rocsparse_1_1rocsparse__state__debug__kernel__launch.html "Interface documentation") | C binding 156 | [rocsparse_enable_debug_arguments](interfacehipfort__rocsparse_1_1rocsparse__enable__debug__arguments.html "Interface documentation") | C binding 157 | [rocsparse_disable_debug_arguments](interfacehipfort__rocsparse_1_1rocsparse__disable__debug__arguments.html "Interface documentation") | C binding 158 | [rocsparse_state_debug_arguments](interfacehipfort__rocsparse_1_1rocsparse__state__debug__arguments.html "Interface documentation") | C binding 159 | [rocsparse_enable_debug_arguments_verbose](interfacehipfort__rocsparse_1_1rocsparse__enable__debug__arguments__verbose.html "Interface documentation") | C binding 160 | [rocsparse_disable_debug_arguments_verbose](interfacehipfort__rocsparse_1_1rocsparse__disable__debug__arguments__verbose.html "Interface documentation") | C binding 161 | [rocsparse_state_debug_arguments_verbose](interfacehipfort__rocsparse_1_1rocsparse__state__debug__arguments__verbose.html "Interface documentation") | C binding 162 | [rocsparse_enable_debug](interfacehipfort__rocsparse_1_1rocsparse__enable__debug.html "Interface documentation") | C binding 163 | [rocsparse_disable_debug](interfacehipfort__rocsparse_1_1rocsparse__disable__debug.html "Interface documentation") | C binding 164 | [rocsparse_state_debug](interfacehipfort__rocsparse_1_1rocsparse__state__debug.html "Interface documentation") | C binding 165 | [rocsparse_enable_debug_warnings](interfacehipfort__rocsparse_1_1rocsparse__enable__debug__warnings.html "Interface documentation") | C binding 166 | [rocsparse_disable_debug_warnings](interfacehipfort__rocsparse_1_1rocsparse__disable__debug__warnings.html "Interface documentation") | C binding 167 | [rocsparse_enable_debug_verbose](interfacehipfort__rocsparse_1_1rocsparse__enable__debug__verbose.html "Interface documentation") | C binding 168 | [rocsparse_disable_debug_verbose](interfacehipfort__rocsparse_1_1rocsparse__disable__debug__verbose.html "Interface documentation") | C binding 169 | [rocsparse_state_debug_verbose](interfacehipfort__rocsparse_1_1rocsparse__state__debug__verbose.html "Interface documentation") | C binding 170 | [rocsparse_enable_debug_force_host_assert](interfacehipfort__rocsparse_1_1rocsparse__enable__debug__force__host__assert.html "Interface documentation") | C binding 171 | [rocsparse_disable_debug_force_host_assert](interfacehipfort__rocsparse_1_1rocsparse__disable__debug__force__host__assert.html "Interface documentation") | C binding 172 | [rocsparse_state_debug_force_host_assert](interfacehipfort__rocsparse_1_1rocsparse__state__debug__force__host__assert.html "Interface documentation") | C binding 173 | [rocsparse_sbsr2csr](interfacehipfort__rocsparse_1_1rocsparse__sbsr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 174 | [rocsparse_dbsr2csr](interfacehipfort__rocsparse_1_1rocsparse__dbsr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 175 | [rocsparse_cbsr2csr](interfacehipfort__rocsparse_1_1rocsparse__cbsr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 176 | [rocsparse_zbsr2csr](interfacehipfort__rocsparse_1_1rocsparse__zbsr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 177 | [rocsparse_sbsrpad_value](interfacehipfort__rocsparse_1_1rocsparse__sbsrpad__value.html "Interface documentation") | C binding 178 | [rocsparse_dbsrpad_value](interfacehipfort__rocsparse_1_1rocsparse__dbsrpad__value.html "Interface documentation") | C binding 179 | [rocsparse_cbsrpad_value](interfacehipfort__rocsparse_1_1rocsparse__cbsrpad__value.html "Interface documentation") | C binding 180 | [rocsparse_zbsrpad_value](interfacehipfort__rocsparse_1_1rocsparse__zbsrpad__value.html "Interface documentation") | C binding 181 | [rocsparse_coo2csr](interfacehipfort__rocsparse_1_1rocsparse__coo2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 182 | [rocsparse_scoo2dense](interfacehipfort__rocsparse_1_1rocsparse__scoo2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 183 | [rocsparse_dcoo2dense](interfacehipfort__rocsparse_1_1rocsparse__dcoo2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 184 | [rocsparse_ccoo2dense](interfacehipfort__rocsparse_1_1rocsparse__ccoo2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 185 | [rocsparse_zcoo2dense](interfacehipfort__rocsparse_1_1rocsparse__zcoo2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 186 | [rocsparse_coosort_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__coosort__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 187 | [rocsparse_coosort_by_row](interfacehipfort__rocsparse_1_1rocsparse__coosort__by__row.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 188 | [rocsparse_coosort_by_column](interfacehipfort__rocsparse_1_1rocsparse__coosort__by__column.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 189 | [rocsparse_scsc2dense](interfacehipfort__rocsparse_1_1rocsparse__scsc2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 190 | [rocsparse_dcsc2dense](interfacehipfort__rocsparse_1_1rocsparse__dcsc2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 191 | [rocsparse_ccsc2dense](interfacehipfort__rocsparse_1_1rocsparse__ccsc2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 192 | [rocsparse_zcsc2dense](interfacehipfort__rocsparse_1_1rocsparse__zcsc2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 193 | [rocsparse_cscsort_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__cscsort__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 194 | [rocsparse_cscsort](interfacehipfort__rocsparse_1_1rocsparse__cscsort.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 195 | [rocsparse_csr2bsr_nnz](interfacehipfort__rocsparse_1_1rocsparse__csr2bsr__nnz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 196 | [rocsparse_scsr2bsr](interfacehipfort__rocsparse_1_1rocsparse__scsr2bsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 197 | [rocsparse_dcsr2bsr](interfacehipfort__rocsparse_1_1rocsparse__dcsr2bsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 198 | [rocsparse_ccsr2bsr](interfacehipfort__rocsparse_1_1rocsparse__ccsr2bsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 199 | [rocsparse_zcsr2bsr](interfacehipfort__rocsparse_1_1rocsparse__zcsr2bsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 200 | [rocsparse_csr2coo](interfacehipfort__rocsparse_1_1rocsparse__csr2coo.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 201 | [rocsparse_csr2csc_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__csr2csc__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 202 | [rocsparse_scsr2csc](interfacehipfort__rocsparse_1_1rocsparse__scsr2csc.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 203 | [rocsparse_dcsr2csc](interfacehipfort__rocsparse_1_1rocsparse__dcsr2csc.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 204 | [rocsparse_ccsr2csc](interfacehipfort__rocsparse_1_1rocsparse__ccsr2csc.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 205 | [rocsparse_zcsr2csc](interfacehipfort__rocsparse_1_1rocsparse__zcsr2csc.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 206 | [rocsparse_scsr2csr_compress](interfacehipfort__rocsparse_1_1rocsparse__scsr2csr__compress.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 207 | [rocsparse_dcsr2csr_compress](interfacehipfort__rocsparse_1_1rocsparse__dcsr2csr__compress.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 208 | [rocsparse_ccsr2csr_compress](interfacehipfort__rocsparse_1_1rocsparse__ccsr2csr__compress.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 209 | [rocsparse_zcsr2csr_compress](interfacehipfort__rocsparse_1_1rocsparse__zcsr2csr__compress.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 210 | [rocsparse_scsr2dense](interfacehipfort__rocsparse_1_1rocsparse__scsr2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 211 | [rocsparse_dcsr2dense](interfacehipfort__rocsparse_1_1rocsparse__dcsr2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 212 | [rocsparse_ccsr2dense](interfacehipfort__rocsparse_1_1rocsparse__ccsr2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 213 | [rocsparse_zcsr2dense](interfacehipfort__rocsparse_1_1rocsparse__zcsr2dense.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 214 | [rocsparse_csr2ell_width](interfacehipfort__rocsparse_1_1rocsparse__csr2ell__width.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 215 | [rocsparse_scsr2ell](interfacehipfort__rocsparse_1_1rocsparse__scsr2ell.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 216 | [rocsparse_dcsr2ell](interfacehipfort__rocsparse_1_1rocsparse__dcsr2ell.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 217 | [rocsparse_ccsr2ell](interfacehipfort__rocsparse_1_1rocsparse__ccsr2ell.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 218 | [rocsparse_zcsr2ell](interfacehipfort__rocsparse_1_1rocsparse__zcsr2ell.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 219 | [rocsparse_scsr2gebsr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__scsr2gebsr__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 220 | [rocsparse_dcsr2gebsr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dcsr2gebsr__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 221 | [rocsparse_ccsr2gebsr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__ccsr2gebsr__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 222 | [rocsparse_zcsr2gebsr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zcsr2gebsr__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 223 | [rocsparse_csr2gebsr_nnz](interfacehipfort__rocsparse_1_1rocsparse__csr2gebsr__nnz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 224 | [rocsparse_scsr2gebsr](interfacehipfort__rocsparse_1_1rocsparse__scsr2gebsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 225 | [rocsparse_dcsr2gebsr](interfacehipfort__rocsparse_1_1rocsparse__dcsr2gebsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 226 | [rocsparse_ccsr2gebsr](interfacehipfort__rocsparse_1_1rocsparse__ccsr2gebsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 227 | [rocsparse_zcsr2gebsr](interfacehipfort__rocsparse_1_1rocsparse__zcsr2gebsr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 228 | [rocsparse_scsr2hyb](interfacehipfort__rocsparse_1_1rocsparse__scsr2hyb.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 229 | [rocsparse_dcsr2hyb](interfacehipfort__rocsparse_1_1rocsparse__dcsr2hyb.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 230 | [rocsparse_ccsr2hyb](interfacehipfort__rocsparse_1_1rocsparse__ccsr2hyb.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 231 | [rocsparse_zcsr2hyb](interfacehipfort__rocsparse_1_1rocsparse__zcsr2hyb.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 232 | [rocsparse_csrsort_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__csrsort__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 233 | [rocsparse_csrsort](interfacehipfort__rocsparse_1_1rocsparse__csrsort.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 234 | [rocsparse_sdense2coo](interfacehipfort__rocsparse_1_1rocsparse__sdense2coo.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 235 | [rocsparse_ddense2coo](interfacehipfort__rocsparse_1_1rocsparse__ddense2coo.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 236 | [rocsparse_cdense2coo](interfacehipfort__rocsparse_1_1rocsparse__cdense2coo.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 237 | [rocsparse_zdense2coo](interfacehipfort__rocsparse_1_1rocsparse__zdense2coo.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 238 | [rocsparse_sdense2csc](interfacehipfort__rocsparse_1_1rocsparse__sdense2csc.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 239 | [rocsparse_ddense2csc](interfacehipfort__rocsparse_1_1rocsparse__ddense2csc.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 240 | [rocsparse_cdense2csc](interfacehipfort__rocsparse_1_1rocsparse__cdense2csc.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 241 | [rocsparse_zdense2csc](interfacehipfort__rocsparse_1_1rocsparse__zdense2csc.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 242 | [rocsparse_sdense2csr](interfacehipfort__rocsparse_1_1rocsparse__sdense2csr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 243 | [rocsparse_ddense2csr](interfacehipfort__rocsparse_1_1rocsparse__ddense2csr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 244 | [rocsparse_cdense2csr](interfacehipfort__rocsparse_1_1rocsparse__cdense2csr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 245 | [rocsparse_zdense2csr](interfacehipfort__rocsparse_1_1rocsparse__zdense2csr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 246 | [rocsparse_ell2csr_nnz](interfacehipfort__rocsparse_1_1rocsparse__ell2csr__nnz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 247 | [rocsparse_sell2csr](interfacehipfort__rocsparse_1_1rocsparse__sell2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 248 | [rocsparse_dell2csr](interfacehipfort__rocsparse_1_1rocsparse__dell2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 249 | [rocsparse_cell2csr](interfacehipfort__rocsparse_1_1rocsparse__cell2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 250 | [rocsparse_zell2csr](interfacehipfort__rocsparse_1_1rocsparse__zell2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 251 | [rocsparse_sgebsr2csr](interfacehipfort__rocsparse_1_1rocsparse__sgebsr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 252 | [rocsparse_dgebsr2csr](interfacehipfort__rocsparse_1_1rocsparse__dgebsr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 253 | [rocsparse_cgebsr2csr](interfacehipfort__rocsparse_1_1rocsparse__cgebsr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 254 | [rocsparse_zgebsr2csr](interfacehipfort__rocsparse_1_1rocsparse__zgebsr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 255 | [rocsparse_sgebsr2gebsc_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sgebsr2gebsc__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 256 | [rocsparse_dgebsr2gebsc_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dgebsr2gebsc__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 257 | [rocsparse_cgebsr2gebsc_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__cgebsr2gebsc__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 258 | [rocsparse_zgebsr2gebsc_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zgebsr2gebsc__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 259 | [rocsparse_sgebsr2gebsc](interfacehipfort__rocsparse_1_1rocsparse__sgebsr2gebsc.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 260 | [rocsparse_dgebsr2gebsc](interfacehipfort__rocsparse_1_1rocsparse__dgebsr2gebsc.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 261 | [rocsparse_cgebsr2gebsc](interfacehipfort__rocsparse_1_1rocsparse__cgebsr2gebsc.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 262 | [rocsparse_zgebsr2gebsc](interfacehipfort__rocsparse_1_1rocsparse__zgebsr2gebsc.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 263 | [rocsparse_sgebsr2gebsr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sgebsr2gebsr__buffer__size.html "Interface documentation") | C binding 264 | [rocsparse_dgebsr2gebsr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dgebsr2gebsr__buffer__size.html "Interface documentation") | C binding 265 | [rocsparse_cgebsr2gebsr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__cgebsr2gebsr__buffer__size.html "Interface documentation") | C binding 266 | [rocsparse_zgebsr2gebsr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zgebsr2gebsr__buffer__size.html "Interface documentation") | C binding 267 | [rocsparse_gebsr2gebsr_nnz](interfacehipfort__rocsparse_1_1rocsparse__gebsr2gebsr__nnz.html "Interface documentation") | C binding 268 | [rocsparse_sgebsr2gebsr](interfacehipfort__rocsparse_1_1rocsparse__sgebsr2gebsr.html "Interface documentation") | C binding 269 | [rocsparse_dgebsr2gebsr](interfacehipfort__rocsparse_1_1rocsparse__dgebsr2gebsr.html "Interface documentation") | C binding 270 | [rocsparse_cgebsr2gebsr](interfacehipfort__rocsparse_1_1rocsparse__cgebsr2gebsr.html "Interface documentation") | C binding 271 | [rocsparse_zgebsr2gebsr](interfacehipfort__rocsparse_1_1rocsparse__zgebsr2gebsr.html "Interface documentation") | C binding 272 | [rocsparse_hyb2csr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__hyb2csr__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 273 | [rocsparse_shyb2csr](interfacehipfort__rocsparse_1_1rocsparse__shyb2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 274 | [rocsparse_dhyb2csr](interfacehipfort__rocsparse_1_1rocsparse__dhyb2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 275 | [rocsparse_chyb2csr](interfacehipfort__rocsparse_1_1rocsparse__chyb2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 276 | [rocsparse_zhyb2csr](interfacehipfort__rocsparse_1_1rocsparse__zhyb2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 277 | [rocsparse_create_identity_permutation](interfacehipfort__rocsparse_1_1rocsparse__create__identity__permutation.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 278 | [rocsparse_inverse_permutation](interfacehipfort__rocsparse_1_1rocsparse__inverse__permutation.html "Interface documentation") | C binding 279 | [rocsparse_set_identity_permutation](interfacehipfort__rocsparse_1_1rocsparse__set__identity__permutation.html "Interface documentation") | C binding 280 | [rocsparse_snnz](interfacehipfort__rocsparse_1_1rocsparse__snnz.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 281 | [rocsparse_dnnz](interfacehipfort__rocsparse_1_1rocsparse__dnnz.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 282 | [rocsparse_cnnz](interfacehipfort__rocsparse_1_1rocsparse__cnnz.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 283 | [rocsparse_znnz](interfacehipfort__rocsparse_1_1rocsparse__znnz.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 284 | [rocsparse_snnz_compress](interfacehipfort__rocsparse_1_1rocsparse__snnz__compress.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 285 | [rocsparse_dnnz_compress](interfacehipfort__rocsparse_1_1rocsparse__dnnz__compress.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 286 | [rocsparse_cnnz_compress](interfacehipfort__rocsparse_1_1rocsparse__cnnz__compress.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 287 | [rocsparse_znnz_compress](interfacehipfort__rocsparse_1_1rocsparse__znnz__compress.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 288 | [rocsparse_sprune_csr2csr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sprune__csr2csr__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 289 | [rocsparse_dprune_csr2csr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dprune__csr2csr__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 290 | [rocsparse_sprune_csr2csr_nnz](interfacehipfort__rocsparse_1_1rocsparse__sprune__csr2csr__nnz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 291 | [rocsparse_dprune_csr2csr_nnz](interfacehipfort__rocsparse_1_1rocsparse__dprune__csr2csr__nnz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 292 | [rocsparse_sprune_csr2csr](interfacehipfort__rocsparse_1_1rocsparse__sprune__csr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 293 | [rocsparse_dprune_csr2csr](interfacehipfort__rocsparse_1_1rocsparse__dprune__csr2csr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 294 | [rocsparse_sprune_csr2csr_by_percentage_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sprune__csr2csr__by__percentage__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 295 | [rocsparse_dprune_csr2csr_by_percentage_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dprune__csr2csr__by__percentage__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 296 | [rocsparse_sprune_csr2csr_nnz_by_percentage](interfacehipfort__rocsparse_1_1rocsparse__sprune__csr2csr__nnz__by__percentage.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 297 | [rocsparse_dprune_csr2csr_nnz_by_percentage](interfacehipfort__rocsparse_1_1rocsparse__dprune__csr2csr__nnz__by__percentage.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 298 | [rocsparse_sprune_csr2csr_by_percentage](interfacehipfort__rocsparse_1_1rocsparse__sprune__csr2csr__by__percentage.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 299 | [rocsparse_dprune_csr2csr_by_percentage](interfacehipfort__rocsparse_1_1rocsparse__dprune__csr2csr__by__percentage.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 300 | [rocsparse_sprune_dense2csr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sprune__dense2csr__buffer__size.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 301 | [rocsparse_dprune_dense2csr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dprune__dense2csr__buffer__size.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 302 | [rocsparse_sprune_dense2csr_nnz](interfacehipfort__rocsparse_1_1rocsparse__sprune__dense2csr__nnz.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 303 | [rocsparse_dprune_dense2csr_nnz](interfacehipfort__rocsparse_1_1rocsparse__dprune__dense2csr__nnz.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 304 | [rocsparse_sprune_dense2csr](interfacehipfort__rocsparse_1_1rocsparse__sprune__dense2csr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 305 | [rocsparse_dprune_dense2csr](interfacehipfort__rocsparse_1_1rocsparse__dprune__dense2csr.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 306 | [rocsparse_sprune_dense2csr_by_percentage_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sprune__dense2csr__by__percentage__buffer__size.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 307 | [rocsparse_dprune_dense2csr_by_percentage_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dprune__dense2csr__by__percentage__buffer__size.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 308 | [rocsparse_sprune_dense2csr_nnz_by_percentage](interfacehipfort__rocsparse_1_1rocsparse__sprune__dense2csr__nnz__by__percentage.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 309 | [rocsparse_dprune_dense2csr_nnz_by_percentage](interfacehipfort__rocsparse_1_1rocsparse__dprune__dense2csr__nnz__by__percentage.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 310 | [rocsparse_sprune_dense2csr_by_percentage](interfacehipfort__rocsparse_1_1rocsparse__sprune__dense2csr__by__percentage.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 311 | [rocsparse_dprune_dense2csr_by_percentage](interfacehipfort__rocsparse_1_1rocsparse__dprune__dense2csr__by__percentage.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 312 | [rocsparse_bsrgeam_nnzb](interfacehipfort__rocsparse_1_1rocsparse__bsrgeam__nnzb.html "Interface documentation") | C binding 313 | [rocsparse_sbsrgeam](interfacehipfort__rocsparse_1_1rocsparse__sbsrgeam.html "Interface documentation") | C binding 314 | [rocsparse_dbsrgeam](interfacehipfort__rocsparse_1_1rocsparse__dbsrgeam.html "Interface documentation") | C binding 315 | [rocsparse_cbsrgeam](interfacehipfort__rocsparse_1_1rocsparse__cbsrgeam.html "Interface documentation") | C binding 316 | [rocsparse_zbsrgeam](interfacehipfort__rocsparse_1_1rocsparse__zbsrgeam.html "Interface documentation") | C binding 317 | [rocsparse_sbsrgemm_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sbsrgemm__buffer__size.html "Interface documentation") | C binding 318 | [rocsparse_dbsrgemm_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dbsrgemm__buffer__size.html "Interface documentation") | C binding 319 | [rocsparse_cbsrgemm_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__cbsrgemm__buffer__size.html "Interface documentation") | C binding 320 | [rocsparse_zbsrgemm_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zbsrgemm__buffer__size.html "Interface documentation") | C binding 321 | [rocsparse_bsrgemm_nnzb](interfacehipfort__rocsparse_1_1rocsparse__bsrgemm__nnzb.html "Interface documentation") | C binding 322 | [rocsparse_sbsrgemm](interfacehipfort__rocsparse_1_1rocsparse__sbsrgemm.html "Interface documentation") | C binding 323 | [rocsparse_dbsrgemm](interfacehipfort__rocsparse_1_1rocsparse__dbsrgemm.html "Interface documentation") | C binding 324 | [rocsparse_cbsrgemm](interfacehipfort__rocsparse_1_1rocsparse__cbsrgemm.html "Interface documentation") | C binding 325 | [rocsparse_zbsrgemm](interfacehipfort__rocsparse_1_1rocsparse__zbsrgemm.html "Interface documentation") | C binding 326 | [rocsparse_csrgeam_nnz](interfacehipfort__rocsparse_1_1rocsparse__csrgeam__nnz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 327 | [rocsparse_scsrgeam](interfacehipfort__rocsparse_1_1rocsparse__scsrgeam.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 328 | [rocsparse_dcsrgeam](interfacehipfort__rocsparse_1_1rocsparse__dcsrgeam.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 329 | [rocsparse_ccsrgeam](interfacehipfort__rocsparse_1_1rocsparse__ccsrgeam.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 330 | [rocsparse_zcsrgeam](interfacehipfort__rocsparse_1_1rocsparse__zcsrgeam.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 331 | [rocsparse_scsrgemm_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__scsrgemm__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 332 | [rocsparse_dcsrgemm_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dcsrgemm__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 333 | [rocsparse_ccsrgemm_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__ccsrgemm__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 334 | [rocsparse_zcsrgemm_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zcsrgemm__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 335 | [rocsparse_csrgemm_nnz](interfacehipfort__rocsparse_1_1rocsparse__csrgemm__nnz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 336 | [rocsparse_scsrgemm](interfacehipfort__rocsparse_1_1rocsparse__scsrgemm.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 337 | [rocsparse_dcsrgemm](interfacehipfort__rocsparse_1_1rocsparse__dcsrgemm.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 338 | [rocsparse_ccsrgemm](interfacehipfort__rocsparse_1_1rocsparse__ccsrgemm.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 339 | [rocsparse_zcsrgemm](interfacehipfort__rocsparse_1_1rocsparse__zcsrgemm.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 340 | [rocsparse_csrgemm_symbolic](interfacehipfort__rocsparse_1_1rocsparse__csrgemm__symbolic.html "Interface documentation") | C binding 341 | [rocsparse_scsrgemm_numeric](interfacehipfort__rocsparse_1_1rocsparse__scsrgemm__numeric.html "Interface documentation") | C binding 342 | [rocsparse_dcsrgemm_numeric](interfacehipfort__rocsparse_1_1rocsparse__dcsrgemm__numeric.html "Interface documentation") | C binding 343 | [rocsparse_ccsrgemm_numeric](interfacehipfort__rocsparse_1_1rocsparse__ccsrgemm__numeric.html "Interface documentation") | C binding 344 | [rocsparse_zcsrgemm_numeric](interfacehipfort__rocsparse_1_1rocsparse__zcsrgemm__numeric.html "Interface documentation") | C binding 345 | [rocsparse_axpby](interfacehipfort__rocsparse_1_1rocsparse__axpby.html "Interface documentation") | C binding 346 | [rocsparse_check_spmat](interfacehipfort__rocsparse_1_1rocsparse__check__spmat.html "Interface documentation") | C binding 347 | [rocsparse_dense_to_sparse](interfacehipfort__rocsparse_1_1rocsparse__dense__to__sparse.html "Interface documentation") | C binding 348 | [rocsparse_extract_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__extract__buffer__size.html "Interface documentation") | C binding 349 | [rocsparse_extract_nnz](interfacehipfort__rocsparse_1_1rocsparse__extract__nnz.html "Interface documentation") | C binding 350 | [rocsparse_extract](interfacehipfort__rocsparse_1_1rocsparse__extract.html "Interface documentation") | C binding 351 | [rocsparse_gather](interfacehipfort__rocsparse_1_1rocsparse__gather.html "Interface documentation") | C binding 352 | [rocsparse_rot](interfacehipfort__rocsparse_1_1rocsparse__rot.html "Interface documentation") | C binding 353 | [rocsparse_scatter](interfacehipfort__rocsparse_1_1rocsparse__scatter.html "Interface documentation") | C binding 354 | [rocsparse_sddmm_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sddmm__buffer__size.html "Interface documentation") | C binding 355 | [rocsparse_sddmm_preprocess](interfacehipfort__rocsparse_1_1rocsparse__sddmm__preprocess.html "Interface documentation") | C binding 356 | [rocsparse_sddmm](interfacehipfort__rocsparse_1_1rocsparse__sddmm.html "Interface documentation") | C binding 357 | [rocsparse_sparse_to_dense](interfacehipfort__rocsparse_1_1rocsparse__sparse__to__dense.html "Interface documentation") | C binding 358 | [rocsparse_sparse_to_sparse_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sparse__to__sparse__buffer__size.html "Interface documentation") | C binding 359 | [rocsparse_sparse_to_sparse](interfacehipfort__rocsparse_1_1rocsparse__sparse__to__sparse.html "Interface documentation") | C binding 360 | [rocsparse_spgeam_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__spgeam__buffer__size.html "Interface documentation") | C binding 361 | [rocsparse_spgeam](interfacehipfort__rocsparse_1_1rocsparse__spgeam.html "Interface documentation") | C binding 362 | [rocsparse_spgemm](interfacehipfort__rocsparse_1_1rocsparse__spgemm.html "Interface documentation") | C binding 363 | [rocsparse_spic0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__spic0__buffer__size.html "Interface documentation") | C binding 364 | [rocsparse_spic0](interfacehipfort__rocsparse_1_1rocsparse__spic0.html "Interface documentation") | C binding 365 | [rocsparse_spildlt0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__spildlt0__buffer__size.html "Interface documentation") | C binding 366 | [rocsparse_spildlt0](interfacehipfort__rocsparse_1_1rocsparse__spildlt0.html "Interface documentation") | C binding 367 | [rocsparse_spilu0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__spilu0__buffer__size.html "Interface documentation") | C binding 368 | [rocsparse_spilu0](interfacehipfort__rocsparse_1_1rocsparse__spilu0.html "Interface documentation") | C binding 369 | [rocsparse_spitsv](interfacehipfort__rocsparse_1_1rocsparse__spitsv.html "Interface documentation") | C binding 370 | [rocsparse_spmm](interfacehipfort__rocsparse_1_1rocsparse__spmm.html "Interface documentation") | C binding 371 | [rocsparse_spmv](interfacehipfort__rocsparse_1_1rocsparse__spmv.html "Interface documentation") | C binding 372 | [rocsparse_spsm](interfacehipfort__rocsparse_1_1rocsparse__spsm.html "Interface documentation") | C binding 373 | [rocsparse_spsv](interfacehipfort__rocsparse_1_1rocsparse__spsv.html "Interface documentation") | C binding 374 | [rocsparse_sptrsm_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sptrsm__buffer__size.html "Interface documentation") | C binding 375 | [rocsparse_sptrsm](interfacehipfort__rocsparse_1_1rocsparse__sptrsm.html "Interface documentation") | C binding 376 | [rocsparse_sptrsv_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sptrsv__buffer__size.html "Interface documentation") | C binding 377 | [rocsparse_sptrsv](interfacehipfort__rocsparse_1_1rocsparse__sptrsv.html "Interface documentation") | C binding 378 | [rocsparse_spvv](interfacehipfort__rocsparse_1_1rocsparse__spvv.html "Interface documentation") | C binding 379 | [rocsparse_v2_spmv_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__v2__spmv__buffer__size.html "Interface documentation") | C binding 380 | [rocsparse_v2_spmv](interfacehipfort__rocsparse_1_1rocsparse__v2__spmv.html "Interface documentation") | C binding 381 | [rocsparse_spmv_set_extra](interfacehipfort__rocsparse_1_1rocsparse__spmv__set__extra.html "Interface documentation") | C binding 382 | [rocsparse_spmv_clear_extra](interfacehipfort__rocsparse_1_1rocsparse__spmv__clear__extra.html "Interface documentation") | C binding 383 | [rocsparse_saxpyi](interfacehipfort__rocsparse_1_1rocsparse__saxpyi.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 384 | [rocsparse_daxpyi](interfacehipfort__rocsparse_1_1rocsparse__daxpyi.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 385 | [rocsparse_caxpyi](interfacehipfort__rocsparse_1_1rocsparse__caxpyi.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 386 | [rocsparse_zaxpyi](interfacehipfort__rocsparse_1_1rocsparse__zaxpyi.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 387 | [rocsparse_cdotci](interfacehipfort__rocsparse_1_1rocsparse__cdotci.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 388 | [rocsparse_zdotci](interfacehipfort__rocsparse_1_1rocsparse__zdotci.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 389 | [rocsparse_sdoti](interfacehipfort__rocsparse_1_1rocsparse__sdoti.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 390 | [rocsparse_ddoti](interfacehipfort__rocsparse_1_1rocsparse__ddoti.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 391 | [rocsparse_cdoti](interfacehipfort__rocsparse_1_1rocsparse__cdoti.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 392 | [rocsparse_zdoti](interfacehipfort__rocsparse_1_1rocsparse__zdoti.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 393 | [rocsparse_sgthr](interfacehipfort__rocsparse_1_1rocsparse__sgthr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 394 | [rocsparse_dgthr](interfacehipfort__rocsparse_1_1rocsparse__dgthr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 395 | [rocsparse_cgthr](interfacehipfort__rocsparse_1_1rocsparse__cgthr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 396 | [rocsparse_zgthr](interfacehipfort__rocsparse_1_1rocsparse__zgthr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 397 | [rocsparse_sgthrz](interfacehipfort__rocsparse_1_1rocsparse__sgthrz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 398 | [rocsparse_dgthrz](interfacehipfort__rocsparse_1_1rocsparse__dgthrz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 399 | [rocsparse_cgthrz](interfacehipfort__rocsparse_1_1rocsparse__cgthrz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 400 | [rocsparse_zgthrz](interfacehipfort__rocsparse_1_1rocsparse__zgthrz.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 401 | [rocsparse_sroti](interfacehipfort__rocsparse_1_1rocsparse__sroti.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 402 | [rocsparse_droti](interfacehipfort__rocsparse_1_1rocsparse__droti.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 403 | [rocsparse_ssctr](interfacehipfort__rocsparse_1_1rocsparse__ssctr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 404 | [rocsparse_dsctr](interfacehipfort__rocsparse_1_1rocsparse__dsctr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 405 | [rocsparse_csctr](interfacehipfort__rocsparse_1_1rocsparse__csctr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 406 | [rocsparse_zsctr](interfacehipfort__rocsparse_1_1rocsparse__zsctr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 407 | [rocsparse_isctr](interfacehipfort__rocsparse_1_1rocsparse__isctr.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 408 | [rocsparse_sbsrmv_analysis](interfacehipfort__rocsparse_1_1rocsparse__sbsrmv__analysis.html "Interface documentation") | C binding 409 | [rocsparse_dbsrmv_analysis](interfacehipfort__rocsparse_1_1rocsparse__dbsrmv__analysis.html "Interface documentation") | C binding 410 | [rocsparse_cbsrmv_analysis](interfacehipfort__rocsparse_1_1rocsparse__cbsrmv__analysis.html "Interface documentation") | C binding 411 | [rocsparse_zbsrmv_analysis](interfacehipfort__rocsparse_1_1rocsparse__zbsrmv__analysis.html "Interface documentation") | C binding 412 | [rocsparse_sbsrmv](interfacehipfort__rocsparse_1_1rocsparse__sbsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 413 | [rocsparse_dbsrmv](interfacehipfort__rocsparse_1_1rocsparse__dbsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 414 | [rocsparse_cbsrmv](interfacehipfort__rocsparse_1_1rocsparse__cbsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 415 | [rocsparse_zbsrmv](interfacehipfort__rocsparse_1_1rocsparse__zbsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 416 | [rocsparse_bsrmv_clear](interfacehipfort__rocsparse_1_1rocsparse__bsrmv__clear.html "Interface documentation") | C binding 417 | [rocsparse_bsrsv_zero_pivot](interfacehipfort__rocsparse_1_1rocsparse__bsrsv__zero__pivot.html "Interface documentation") | C binding 418 | [rocsparse_sbsrsv_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sbsrsv__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 419 | [rocsparse_dbsrsv_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dbsrsv__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 420 | [rocsparse_cbsrsv_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__cbsrsv__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 421 | [rocsparse_zbsrsv_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zbsrsv__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 422 | [rocsparse_sbsrsv_analysis](interfacehipfort__rocsparse_1_1rocsparse__sbsrsv__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 423 | [rocsparse_dbsrsv_analysis](interfacehipfort__rocsparse_1_1rocsparse__dbsrsv__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 424 | [rocsparse_cbsrsv_analysis](interfacehipfort__rocsparse_1_1rocsparse__cbsrsv__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 425 | [rocsparse_zbsrsv_analysis](interfacehipfort__rocsparse_1_1rocsparse__zbsrsv__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 426 | [rocsparse_bsrsv_clear](interfacehipfort__rocsparse_1_1rocsparse__bsrsv__clear.html "Interface documentation") | C binding 427 | [rocsparse_sbsrsv_solve](interfacehipfort__rocsparse_1_1rocsparse__sbsrsv__solve.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 428 | [rocsparse_dbsrsv_solve](interfacehipfort__rocsparse_1_1rocsparse__dbsrsv__solve.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 429 | [rocsparse_cbsrsv_solve](interfacehipfort__rocsparse_1_1rocsparse__cbsrsv__solve.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 430 | [rocsparse_zbsrsv_solve](interfacehipfort__rocsparse_1_1rocsparse__zbsrsv__solve.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 431 | [rocsparse_sbsrxmv](interfacehipfort__rocsparse_1_1rocsparse__sbsrxmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 432 | [rocsparse_dbsrxmv](interfacehipfort__rocsparse_1_1rocsparse__dbsrxmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 433 | [rocsparse_cbsrxmv](interfacehipfort__rocsparse_1_1rocsparse__cbsrxmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 434 | [rocsparse_zbsrxmv](interfacehipfort__rocsparse_1_1rocsparse__zbsrxmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 435 | [rocsparse_scoomv](interfacehipfort__rocsparse_1_1rocsparse__scoomv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 436 | [rocsparse_dcoomv](interfacehipfort__rocsparse_1_1rocsparse__dcoomv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 437 | [rocsparse_ccoomv](interfacehipfort__rocsparse_1_1rocsparse__ccoomv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 438 | [rocsparse_zcoomv](interfacehipfort__rocsparse_1_1rocsparse__zcoomv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 439 | [rocsparse_csritsv_zero_pivot](interfacehipfort__rocsparse_1_1rocsparse__csritsv__zero__pivot.html "Interface documentation") | C binding 440 | [rocsparse_scsritsv_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__scsritsv__buffer__size.html "Interface documentation") | C binding 441 | [rocsparse_dcsritsv_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dcsritsv__buffer__size.html "Interface documentation") | C binding 442 | [rocsparse_ccsritsv_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__ccsritsv__buffer__size.html "Interface documentation") | C binding 443 | [rocsparse_zcsritsv_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zcsritsv__buffer__size.html "Interface documentation") | C binding 444 | [rocsparse_scsritsv_analysis](interfacehipfort__rocsparse_1_1rocsparse__scsritsv__analysis.html "Interface documentation") | C binding 445 | [rocsparse_dcsritsv_analysis](interfacehipfort__rocsparse_1_1rocsparse__dcsritsv__analysis.html "Interface documentation") | C binding 446 | [rocsparse_ccsritsv_analysis](interfacehipfort__rocsparse_1_1rocsparse__ccsritsv__analysis.html "Interface documentation") | C binding 447 | [rocsparse_zcsritsv_analysis](interfacehipfort__rocsparse_1_1rocsparse__zcsritsv__analysis.html "Interface documentation") | C binding 448 | [rocsparse_csritsv_clear](interfacehipfort__rocsparse_1_1rocsparse__csritsv__clear.html "Interface documentation") | C binding 449 | [rocsparse_scsritsv_solve](interfacehipfort__rocsparse_1_1rocsparse__scsritsv__solve.html "Interface documentation") | C binding 450 | [rocsparse_dcsritsv_solve](interfacehipfort__rocsparse_1_1rocsparse__dcsritsv__solve.html "Interface documentation") | C binding 451 | [rocsparse_ccsritsv_solve](interfacehipfort__rocsparse_1_1rocsparse__ccsritsv__solve.html "Interface documentation") | C binding 452 | [rocsparse_zcsritsv_solve](interfacehipfort__rocsparse_1_1rocsparse__zcsritsv__solve.html "Interface documentation") | C binding 453 | [rocsparse_scsritsv_solve_ex](interfacehipfort__rocsparse_1_1rocsparse__scsritsv__solve__ex.html "Interface documentation") | C binding 454 | [rocsparse_dcsritsv_solve_ex](interfacehipfort__rocsparse_1_1rocsparse__dcsritsv__solve__ex.html "Interface documentation") | C binding 455 | [rocsparse_ccsritsv_solve_ex](interfacehipfort__rocsparse_1_1rocsparse__ccsritsv__solve__ex.html "Interface documentation") | C binding 456 | [rocsparse_zcsritsv_solve_ex](interfacehipfort__rocsparse_1_1rocsparse__zcsritsv__solve__ex.html "Interface documentation") | C binding 457 | [rocsparse_scsrmv_analysis](interfacehipfort__rocsparse_1_1rocsparse__scsrmv__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 458 | [rocsparse_dcsrmv_analysis](interfacehipfort__rocsparse_1_1rocsparse__dcsrmv__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 459 | [rocsparse_ccsrmv_analysis](interfacehipfort__rocsparse_1_1rocsparse__ccsrmv__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 460 | [rocsparse_zcsrmv_analysis](interfacehipfort__rocsparse_1_1rocsparse__zcsrmv__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 461 | [rocsparse_csrmv_clear](interfacehipfort__rocsparse_1_1rocsparse__csrmv__clear.html "Interface documentation") | C binding 462 | [rocsparse_scsrmv](interfacehipfort__rocsparse_1_1rocsparse__scsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 463 | [rocsparse_dcsrmv](interfacehipfort__rocsparse_1_1rocsparse__dcsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 464 | [rocsparse_ccsrmv](interfacehipfort__rocsparse_1_1rocsparse__ccsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 465 | [rocsparse_zcsrmv](interfacehipfort__rocsparse_1_1rocsparse__zcsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 466 | [rocsparse_csrsv_zero_pivot](interfacehipfort__rocsparse_1_1rocsparse__csrsv__zero__pivot.html "Interface documentation") | C binding 467 | [rocsparse_scsrsv_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__scsrsv__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 468 | [rocsparse_dcsrsv_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dcsrsv__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 469 | [rocsparse_ccsrsv_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__ccsrsv__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 470 | [rocsparse_zcsrsv_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zcsrsv__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 471 | [rocsparse_scsrsv_analysis](interfacehipfort__rocsparse_1_1rocsparse__scsrsv__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 472 | [rocsparse_dcsrsv_analysis](interfacehipfort__rocsparse_1_1rocsparse__dcsrsv__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 473 | [rocsparse_ccsrsv_analysis](interfacehipfort__rocsparse_1_1rocsparse__ccsrsv__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 474 | [rocsparse_zcsrsv_analysis](interfacehipfort__rocsparse_1_1rocsparse__zcsrsv__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 475 | [rocsparse_csrsv_clear](interfacehipfort__rocsparse_1_1rocsparse__csrsv__clear.html "Interface documentation") | C binding 476 | [rocsparse_scsrsv_solve](interfacehipfort__rocsparse_1_1rocsparse__scsrsv__solve.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 477 | [rocsparse_dcsrsv_solve](interfacehipfort__rocsparse_1_1rocsparse__dcsrsv__solve.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 478 | [rocsparse_ccsrsv_solve](interfacehipfort__rocsparse_1_1rocsparse__ccsrsv__solve.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 479 | [rocsparse_zcsrsv_solve](interfacehipfort__rocsparse_1_1rocsparse__zcsrsv__solve.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 480 | [rocsparse_sellmv](interfacehipfort__rocsparse_1_1rocsparse__sellmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 481 | [rocsparse_dellmv](interfacehipfort__rocsparse_1_1rocsparse__dellmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 482 | [rocsparse_cellmv](interfacehipfort__rocsparse_1_1rocsparse__cellmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 483 | [rocsparse_zellmv](interfacehipfort__rocsparse_1_1rocsparse__zellmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 484 | [rocsparse_sgebsrmv](interfacehipfort__rocsparse_1_1rocsparse__sgebsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 485 | [rocsparse_dgebsrmv](interfacehipfort__rocsparse_1_1rocsparse__dgebsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 486 | [rocsparse_cgebsrmv](interfacehipfort__rocsparse_1_1rocsparse__cgebsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 487 | [rocsparse_zgebsrmv](interfacehipfort__rocsparse_1_1rocsparse__zgebsrmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 488 | [rocsparse_sgemvi_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sgemvi__buffer__size.html "Interface documentation") | C binding 489 | [rocsparse_dgemvi_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dgemvi__buffer__size.html "Interface documentation") | C binding 490 | [rocsparse_cgemvi_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__cgemvi__buffer__size.html "Interface documentation") | C binding 491 | [rocsparse_zgemvi_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zgemvi__buffer__size.html "Interface documentation") | C binding 492 | [rocsparse_sgemvi](interfacehipfort__rocsparse_1_1rocsparse__sgemvi.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 493 | [rocsparse_dgemvi](interfacehipfort__rocsparse_1_1rocsparse__dgemvi.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 494 | [rocsparse_cgemvi](interfacehipfort__rocsparse_1_1rocsparse__cgemvi.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 495 | [rocsparse_zgemvi](interfacehipfort__rocsparse_1_1rocsparse__zgemvi.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 496 | [rocsparse_shybmv](interfacehipfort__rocsparse_1_1rocsparse__shybmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 497 | [rocsparse_dhybmv](interfacehipfort__rocsparse_1_1rocsparse__dhybmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 498 | [rocsparse_chybmv](interfacehipfort__rocsparse_1_1rocsparse__chybmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 499 | [rocsparse_zhybmv](interfacehipfort__rocsparse_1_1rocsparse__zhybmv.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 500 | [rocsparse_sbsrmm](interfacehipfort__rocsparse_1_1rocsparse__sbsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 501 | [rocsparse_dbsrmm](interfacehipfort__rocsparse_1_1rocsparse__dbsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 502 | [rocsparse_cbsrmm](interfacehipfort__rocsparse_1_1rocsparse__cbsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 503 | [rocsparse_zbsrmm](interfacehipfort__rocsparse_1_1rocsparse__zbsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 504 | [rocsparse_bsrsm_zero_pivot](interfacehipfort__rocsparse_1_1rocsparse__bsrsm__zero__pivot.html "Interface documentation") | C binding 505 | [rocsparse_sbsrsm_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sbsrsm__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 506 | [rocsparse_dbsrsm_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dbsrsm__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 507 | [rocsparse_cbsrsm_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__cbsrsm__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 508 | [rocsparse_zbsrsm_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zbsrsm__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 509 | [rocsparse_sbsrsm_analysis](interfacehipfort__rocsparse_1_1rocsparse__sbsrsm__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 510 | [rocsparse_dbsrsm_analysis](interfacehipfort__rocsparse_1_1rocsparse__dbsrsm__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 511 | [rocsparse_cbsrsm_analysis](interfacehipfort__rocsparse_1_1rocsparse__cbsrsm__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 512 | [rocsparse_zbsrsm_analysis](interfacehipfort__rocsparse_1_1rocsparse__zbsrsm__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 513 | [rocsparse_bsrsm_clear](interfacehipfort__rocsparse_1_1rocsparse__bsrsm__clear.html "Interface documentation") | C binding 514 | [rocsparse_sbsrsm_solve](interfacehipfort__rocsparse_1_1rocsparse__sbsrsm__solve.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 515 | [rocsparse_dbsrsm_solve](interfacehipfort__rocsparse_1_1rocsparse__dbsrsm__solve.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 516 | [rocsparse_cbsrsm_solve](interfacehipfort__rocsparse_1_1rocsparse__cbsrsm__solve.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 517 | [rocsparse_zbsrsm_solve](interfacehipfort__rocsparse_1_1rocsparse__zbsrsm__solve.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 518 | [rocsparse_scsrmm](interfacehipfort__rocsparse_1_1rocsparse__scsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 519 | [rocsparse_dcsrmm](interfacehipfort__rocsparse_1_1rocsparse__dcsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 520 | [rocsparse_ccsrmm](interfacehipfort__rocsparse_1_1rocsparse__ccsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 521 | [rocsparse_zcsrmm](interfacehipfort__rocsparse_1_1rocsparse__zcsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 522 | [rocsparse_csrsm_zero_pivot](interfacehipfort__rocsparse_1_1rocsparse__csrsm__zero__pivot.html "Interface documentation") | C binding 523 | [rocsparse_scsrsm_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__scsrsm__buffer__size.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 524 | [rocsparse_dcsrsm_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dcsrsm__buffer__size.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 525 | [rocsparse_ccsrsm_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__ccsrsm__buffer__size.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 526 | [rocsparse_zcsrsm_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zcsrsm__buffer__size.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 527 | [rocsparse_scsrsm_analysis](interfacehipfort__rocsparse_1_1rocsparse__scsrsm__analysis.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 528 | [rocsparse_dcsrsm_analysis](interfacehipfort__rocsparse_1_1rocsparse__dcsrsm__analysis.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 529 | [rocsparse_ccsrsm_analysis](interfacehipfort__rocsparse_1_1rocsparse__ccsrsm__analysis.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 530 | [rocsparse_zcsrsm_analysis](interfacehipfort__rocsparse_1_1rocsparse__zcsrsm__analysis.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 531 | [rocsparse_csrsm_clear](interfacehipfort__rocsparse_1_1rocsparse__csrsm__clear.html "Interface documentation") | C binding 532 | [rocsparse_scsrsm_solve](interfacehipfort__rocsparse_1_1rocsparse__scsrsm__solve.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 533 | [rocsparse_dcsrsm_solve](interfacehipfort__rocsparse_1_1rocsparse__dcsrsm__solve.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 534 | [rocsparse_ccsrsm_solve](interfacehipfort__rocsparse_1_1rocsparse__ccsrsm__solve.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 535 | [rocsparse_zcsrsm_solve](interfacehipfort__rocsparse_1_1rocsparse__zcsrsm__solve.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 536 | [rocsparse_sgebsrmm](interfacehipfort__rocsparse_1_1rocsparse__sgebsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 537 | [rocsparse_dgebsrmm](interfacehipfort__rocsparse_1_1rocsparse__dgebsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 538 | [rocsparse_cgebsrmm](interfacehipfort__rocsparse_1_1rocsparse__cgebsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 539 | [rocsparse_zgebsrmm](interfacehipfort__rocsparse_1_1rocsparse__zgebsrmm.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 540 | [rocsparse_sgemmi](interfacehipfort__rocsparse_1_1rocsparse__sgemmi.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 541 | [rocsparse_dgemmi](interfacehipfort__rocsparse_1_1rocsparse__dgemmi.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 542 | [rocsparse_cgemmi](interfacehipfort__rocsparse_1_1rocsparse__cgemmi.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 543 | [rocsparse_zgemmi](interfacehipfort__rocsparse_1_1rocsparse__zgemmi.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 544 | [rocsparse_bsric0_zero_pivot](interfacehipfort__rocsparse_1_1rocsparse__bsric0__zero__pivot.html "Interface documentation") | C binding 545 | [rocsparse_sbsric0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sbsric0__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 546 | [rocsparse_dbsric0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dbsric0__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 547 | [rocsparse_cbsric0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__cbsric0__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 548 | [rocsparse_zbsric0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zbsric0__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 549 | [rocsparse_sbsric0_analysis](interfacehipfort__rocsparse_1_1rocsparse__sbsric0__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 550 | [rocsparse_dbsric0_analysis](interfacehipfort__rocsparse_1_1rocsparse__dbsric0__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 551 | [rocsparse_cbsric0_analysis](interfacehipfort__rocsparse_1_1rocsparse__cbsric0__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 552 | [rocsparse_zbsric0_analysis](interfacehipfort__rocsparse_1_1rocsparse__zbsric0__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 553 | [rocsparse_bsric0_clear](interfacehipfort__rocsparse_1_1rocsparse__bsric0__clear.html "Interface documentation") | C binding 554 | [rocsparse_sbsric0](interfacehipfort__rocsparse_1_1rocsparse__sbsric0.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 555 | [rocsparse_dbsric0](interfacehipfort__rocsparse_1_1rocsparse__dbsric0.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 556 | [rocsparse_cbsric0](interfacehipfort__rocsparse_1_1rocsparse__cbsric0.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 557 | [rocsparse_zbsric0](interfacehipfort__rocsparse_1_1rocsparse__zbsric0.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 558 | [rocsparse_bsrilu0_zero_pivot](interfacehipfort__rocsparse_1_1rocsparse__bsrilu0__zero__pivot.html "Interface documentation") | C binding 559 | [rocsparse_sbsrilu0_numeric_boost](interfacehipfort__rocsparse_1_1rocsparse__sbsrilu0__numeric__boost.html "Interface documentation") | C binding 560 | [rocsparse_dbsrilu0_numeric_boost](interfacehipfort__rocsparse_1_1rocsparse__dbsrilu0__numeric__boost.html "Interface documentation") | C binding 561 | [rocsparse_cbsrilu0_numeric_boost](interfacehipfort__rocsparse_1_1rocsparse__cbsrilu0__numeric__boost.html "Interface documentation") | C binding 562 | [rocsparse_zbsrilu0_numeric_boost](interfacehipfort__rocsparse_1_1rocsparse__zbsrilu0__numeric__boost.html "Interface documentation") | C binding 563 | [rocsparse_dsbsrilu0_numeric_boost](interfacehipfort__rocsparse_1_1rocsparse__dsbsrilu0__numeric__boost.html "Interface documentation") | C binding 564 | [rocsparse_dcbsrilu0_numeric_boost](interfacehipfort__rocsparse_1_1rocsparse__dcbsrilu0__numeric__boost.html "Interface documentation") | C binding 565 | [rocsparse_sbsrilu0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sbsrilu0__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 566 | [rocsparse_dbsrilu0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dbsrilu0__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 567 | [rocsparse_cbsrilu0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__cbsrilu0__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 568 | [rocsparse_zbsrilu0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zbsrilu0__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 569 | [rocsparse_sbsrilu0_analysis](interfacehipfort__rocsparse_1_1rocsparse__sbsrilu0__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 570 | [rocsparse_dbsrilu0_analysis](interfacehipfort__rocsparse_1_1rocsparse__dbsrilu0__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 571 | [rocsparse_cbsrilu0_analysis](interfacehipfort__rocsparse_1_1rocsparse__cbsrilu0__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 572 | [rocsparse_zbsrilu0_analysis](interfacehipfort__rocsparse_1_1rocsparse__zbsrilu0__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 573 | [rocsparse_bsrilu0_clear](interfacehipfort__rocsparse_1_1rocsparse__bsrilu0__clear.html "Interface documentation") | C binding 574 | [rocsparse_sbsrilu0](interfacehipfort__rocsparse_1_1rocsparse__sbsrilu0.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 575 | [rocsparse_dbsrilu0](interfacehipfort__rocsparse_1_1rocsparse__dbsrilu0.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 576 | [rocsparse_cbsrilu0](interfacehipfort__rocsparse_1_1rocsparse__cbsrilu0.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 577 | [rocsparse_zbsrilu0](interfacehipfort__rocsparse_1_1rocsparse__zbsrilu0.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 578 | [rocsparse_csric0_zero_pivot](interfacehipfort__rocsparse_1_1rocsparse__csric0__zero__pivot.html "Interface documentation") | C binding 579 | [rocsparse_csric0_singular_pivot](interfacehipfort__rocsparse_1_1rocsparse__csric0__singular__pivot.html "Interface documentation") | C binding 580 | [rocsparse_csric0_set_tolerance](interfacehipfort__rocsparse_1_1rocsparse__csric0__set__tolerance.html "Interface documentation") | C binding 581 | [rocsparse_csric0_get_tolerance](interfacehipfort__rocsparse_1_1rocsparse__csric0__get__tolerance.html "Interface documentation") | C binding 582 | [rocsparse_scsric0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__scsric0__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 583 | [rocsparse_dcsric0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dcsric0__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 584 | [rocsparse_ccsric0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__ccsric0__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 585 | [rocsparse_zcsric0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zcsric0__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 586 | [rocsparse_scsric0_analysis](interfacehipfort__rocsparse_1_1rocsparse__scsric0__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 587 | [rocsparse_dcsric0_analysis](interfacehipfort__rocsparse_1_1rocsparse__dcsric0__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 588 | [rocsparse_ccsric0_analysis](interfacehipfort__rocsparse_1_1rocsparse__ccsric0__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 589 | [rocsparse_zcsric0_analysis](interfacehipfort__rocsparse_1_1rocsparse__zcsric0__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 590 | [rocsparse_csric0_clear](interfacehipfort__rocsparse_1_1rocsparse__csric0__clear.html "Interface documentation") | C binding 591 | [rocsparse_scsric0](interfacehipfort__rocsparse_1_1rocsparse__scsric0.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 592 | [rocsparse_dcsric0](interfacehipfort__rocsparse_1_1rocsparse__dcsric0.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 593 | [rocsparse_ccsric0](interfacehipfort__rocsparse_1_1rocsparse__ccsric0.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 594 | [rocsparse_zcsric0](interfacehipfort__rocsparse_1_1rocsparse__zcsric0.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 595 | [rocsparse_csrilu0_zero_pivot](interfacehipfort__rocsparse_1_1rocsparse__csrilu0__zero__pivot.html "Interface documentation") | C binding 596 | [rocsparse_csrilu0_set_tolerance](interfacehipfort__rocsparse_1_1rocsparse__csrilu0__set__tolerance.html "Interface documentation") | C binding 597 | [rocsparse_csrilu0_get_tolerance](interfacehipfort__rocsparse_1_1rocsparse__csrilu0__get__tolerance.html "Interface documentation") | C binding 598 | [rocsparse_csrilu0_singular_pivot](interfacehipfort__rocsparse_1_1rocsparse__csrilu0__singular__pivot.html "Interface documentation") | C binding 599 | [rocsparse_scsrilu0_numeric_boost](interfacehipfort__rocsparse_1_1rocsparse__scsrilu0__numeric__boost.html "Interface documentation") | C binding 600 | [rocsparse_dcsrilu0_numeric_boost](interfacehipfort__rocsparse_1_1rocsparse__dcsrilu0__numeric__boost.html "Interface documentation") | C binding 601 | [rocsparse_ccsrilu0_numeric_boost](interfacehipfort__rocsparse_1_1rocsparse__ccsrilu0__numeric__boost.html "Interface documentation") | C binding 602 | [rocsparse_zcsrilu0_numeric_boost](interfacehipfort__rocsparse_1_1rocsparse__zcsrilu0__numeric__boost.html "Interface documentation") | C binding 603 | [rocsparse_dscsrilu0_numeric_boost](interfacehipfort__rocsparse_1_1rocsparse__dscsrilu0__numeric__boost.html "Interface documentation") | C binding 604 | [rocsparse_dccsrilu0_numeric_boost](interfacehipfort__rocsparse_1_1rocsparse__dccsrilu0__numeric__boost.html "Interface documentation") | C binding 605 | [rocsparse_scsrilu0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__scsrilu0__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 606 | [rocsparse_dcsrilu0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dcsrilu0__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 607 | [rocsparse_ccsrilu0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__ccsrilu0__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 608 | [rocsparse_zcsrilu0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zcsrilu0__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 609 | [rocsparse_scsrilu0_analysis](interfacehipfort__rocsparse_1_1rocsparse__scsrilu0__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 610 | [rocsparse_dcsrilu0_analysis](interfacehipfort__rocsparse_1_1rocsparse__dcsrilu0__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 611 | [rocsparse_ccsrilu0_analysis](interfacehipfort__rocsparse_1_1rocsparse__ccsrilu0__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 612 | [rocsparse_zcsrilu0_analysis](interfacehipfort__rocsparse_1_1rocsparse__zcsrilu0__analysis.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 613 | [rocsparse_csrilu0_clear](interfacehipfort__rocsparse_1_1rocsparse__csrilu0__clear.html "Interface documentation") | C binding 614 | [rocsparse_scsrilu0](interfacehipfort__rocsparse_1_1rocsparse__scsrilu0.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 615 | [rocsparse_dcsrilu0](interfacehipfort__rocsparse_1_1rocsparse__dcsrilu0.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 616 | [rocsparse_ccsrilu0](interfacehipfort__rocsparse_1_1rocsparse__ccsrilu0.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 617 | [rocsparse_zcsrilu0](interfacehipfort__rocsparse_1_1rocsparse__zcsrilu0.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 618 | [rocsparse_csritilu0_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__csritilu0__buffer__size.html "Interface documentation") | C binding 619 | [rocsparse_csritilu0_preprocess](interfacehipfort__rocsparse_1_1rocsparse__csritilu0__preprocess.html "Interface documentation") | C binding 620 | [rocsparse_scsritilu0_compute](interfacehipfort__rocsparse_1_1rocsparse__scsritilu0__compute.html "Interface documentation") | C binding 621 | [rocsparse_dcsritilu0_compute](interfacehipfort__rocsparse_1_1rocsparse__dcsritilu0__compute.html "Interface documentation") | C binding 622 | [rocsparse_ccsritilu0_compute](interfacehipfort__rocsparse_1_1rocsparse__ccsritilu0__compute.html "Interface documentation") | C binding 623 | [rocsparse_zcsritilu0_compute](interfacehipfort__rocsparse_1_1rocsparse__zcsritilu0__compute.html "Interface documentation") | C binding 624 | [rocsparse_scsritilu0_compute_ex](interfacehipfort__rocsparse_1_1rocsparse__scsritilu0__compute__ex.html "Interface documentation") | C binding 625 | [rocsparse_dcsritilu0_compute_ex](interfacehipfort__rocsparse_1_1rocsparse__dcsritilu0__compute__ex.html "Interface documentation") | C binding 626 | [rocsparse_ccsritilu0_compute_ex](interfacehipfort__rocsparse_1_1rocsparse__ccsritilu0__compute__ex.html "Interface documentation") | C binding 627 | [rocsparse_zcsritilu0_compute_ex](interfacehipfort__rocsparse_1_1rocsparse__zcsritilu0__compute__ex.html "Interface documentation") | C binding 628 | [rocsparse_scsritilu0_history](interfacehipfort__rocsparse_1_1rocsparse__scsritilu0__history.html "Interface documentation") | C binding 629 | [rocsparse_dcsritilu0_history](interfacehipfort__rocsparse_1_1rocsparse__dcsritilu0__history.html "Interface documentation") | C binding 630 | [rocsparse_ccsritilu0_history](interfacehipfort__rocsparse_1_1rocsparse__ccsritilu0__history.html "Interface documentation") | C binding 631 | [rocsparse_zcsritilu0_history](interfacehipfort__rocsparse_1_1rocsparse__zcsritilu0__history.html "Interface documentation") | C binding 632 | [rocsparse_sgpsv_interleaved_batch_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sgpsv__interleaved__batch__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 633 | [rocsparse_dgpsv_interleaved_batch_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dgpsv__interleaved__batch__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 634 | [rocsparse_cgpsv_interleaved_batch_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__cgpsv__interleaved__batch__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 635 | [rocsparse_zgpsv_interleaved_batch_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zgpsv__interleaved__batch__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 636 | [rocsparse_sgpsv_interleaved_batch](interfacehipfort__rocsparse_1_1rocsparse__sgpsv__interleaved__batch.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 637 | [rocsparse_dgpsv_interleaved_batch](interfacehipfort__rocsparse_1_1rocsparse__dgpsv__interleaved__batch.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 638 | [rocsparse_cgpsv_interleaved_batch](interfacehipfort__rocsparse_1_1rocsparse__cgpsv__interleaved__batch.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 639 | [rocsparse_zgpsv_interleaved_batch](interfacehipfort__rocsparse_1_1rocsparse__zgpsv__interleaved__batch.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 640 | [rocsparse_sgtsv_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sgtsv__buffer__size.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 641 | [rocsparse_dgtsv_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dgtsv__buffer__size.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 642 | [rocsparse_cgtsv_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__cgtsv__buffer__size.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 643 | [rocsparse_zgtsv_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zgtsv__buffer__size.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 644 | [rocsparse_sgtsv](interfacehipfort__rocsparse_1_1rocsparse__sgtsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 645 | [rocsparse_dgtsv](interfacehipfort__rocsparse_1_1rocsparse__dgtsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 646 | [rocsparse_cgtsv](interfacehipfort__rocsparse_1_1rocsparse__cgtsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 647 | [rocsparse_zgtsv](interfacehipfort__rocsparse_1_1rocsparse__zgtsv.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 648 | [rocsparse_sgtsv_no_pivot_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sgtsv__no__pivot__buffer__size.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 649 | [rocsparse_dgtsv_no_pivot_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dgtsv__no__pivot__buffer__size.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 650 | [rocsparse_cgtsv_no_pivot_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__cgtsv__no__pivot__buffer__size.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 651 | [rocsparse_zgtsv_no_pivot_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zgtsv__no__pivot__buffer__size.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 652 | [rocsparse_sgtsv_no_pivot](interfacehipfort__rocsparse_1_1rocsparse__sgtsv__no__pivot.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 653 | [rocsparse_dgtsv_no_pivot](interfacehipfort__rocsparse_1_1rocsparse__dgtsv__no__pivot.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 654 | [rocsparse_cgtsv_no_pivot](interfacehipfort__rocsparse_1_1rocsparse__cgtsv__no__pivot.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 655 | [rocsparse_zgtsv_no_pivot](interfacehipfort__rocsparse_1_1rocsparse__zgtsv__no__pivot.html "Interface documentation") | C binding, full_rank, rank_0, rank_1, assumed_rank 656 | [rocsparse_sgtsv_no_pivot_strided_batch_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sgtsv__no__pivot__strided__batch__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 657 | [rocsparse_dgtsv_no_pivot_strided_batch_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dgtsv__no__pivot__strided__batch__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 658 | [rocsparse_cgtsv_no_pivot_strided_batch_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__cgtsv__no__pivot__strided__batch__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 659 | [rocsparse_zgtsv_no_pivot_strided_batch_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zgtsv__no__pivot__strided__batch__buffer__size.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 660 | [rocsparse_sgtsv_no_pivot_strided_batch](interfacehipfort__rocsparse_1_1rocsparse__sgtsv__no__pivot__strided__batch.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 661 | [rocsparse_dgtsv_no_pivot_strided_batch](interfacehipfort__rocsparse_1_1rocsparse__dgtsv__no__pivot__strided__batch.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 662 | [rocsparse_cgtsv_no_pivot_strided_batch](interfacehipfort__rocsparse_1_1rocsparse__cgtsv__no__pivot__strided__batch.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 663 | [rocsparse_zgtsv_no_pivot_strided_batch](interfacehipfort__rocsparse_1_1rocsparse__zgtsv__no__pivot__strided__batch.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 664 | [rocsparse_sgtsv_interleaved_batch_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__sgtsv__interleaved__batch__buffer__size.html "Interface documentation") | C binding 665 | [rocsparse_dgtsv_interleaved_batch_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dgtsv__interleaved__batch__buffer__size.html "Interface documentation") | C binding 666 | [rocsparse_cgtsv_interleaved_batch_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__cgtsv__interleaved__batch__buffer__size.html "Interface documentation") | C binding 667 | [rocsparse_zgtsv_interleaved_batch_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zgtsv__interleaved__batch__buffer__size.html "Interface documentation") | C binding 668 | [rocsparse_sgtsv_interleaved_batch](interfacehipfort__rocsparse_1_1rocsparse__sgtsv__interleaved__batch.html "Interface documentation") | C binding 669 | [rocsparse_dgtsv_interleaved_batch](interfacehipfort__rocsparse_1_1rocsparse__dgtsv__interleaved__batch.html "Interface documentation") | C binding 670 | [rocsparse_cgtsv_interleaved_batch](interfacehipfort__rocsparse_1_1rocsparse__cgtsv__interleaved__batch.html "Interface documentation") | C binding 671 | [rocsparse_zgtsv_interleaved_batch](interfacehipfort__rocsparse_1_1rocsparse__zgtsv__interleaved__batch.html "Interface documentation") | C binding 672 | [rocsparse_scsrcolor](interfacehipfort__rocsparse_1_1rocsparse__scsrcolor.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 673 | [rocsparse_dcsrcolor](interfacehipfort__rocsparse_1_1rocsparse__dcsrcolor.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 674 | [rocsparse_ccsrcolor](interfacehipfort__rocsparse_1_1rocsparse__ccsrcolor.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 675 | [rocsparse_zcsrcolor](interfacehipfort__rocsparse_1_1rocsparse__zcsrcolor.html "Interface documentation") | C binding, rank_0, rank_1, assumed_rank 676 | [rocsparse_scheck_matrix_coo_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__scheck__matrix__coo__buffer__size.html "Interface documentation") | C binding 677 | [rocsparse_dcheck_matrix_coo_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dcheck__matrix__coo__buffer__size.html "Interface documentation") | C binding 678 | [rocsparse_ccheck_matrix_coo_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__ccheck__matrix__coo__buffer__size.html "Interface documentation") | C binding 679 | [rocsparse_zcheck_matrix_coo_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zcheck__matrix__coo__buffer__size.html "Interface documentation") | C binding 680 | [rocsparse_scheck_matrix_coo](interfacehipfort__rocsparse_1_1rocsparse__scheck__matrix__coo.html "Interface documentation") | C binding 681 | [rocsparse_dcheck_matrix_coo](interfacehipfort__rocsparse_1_1rocsparse__dcheck__matrix__coo.html "Interface documentation") | C binding 682 | [rocsparse_ccheck_matrix_coo](interfacehipfort__rocsparse_1_1rocsparse__ccheck__matrix__coo.html "Interface documentation") | C binding 683 | [rocsparse_zcheck_matrix_coo](interfacehipfort__rocsparse_1_1rocsparse__zcheck__matrix__coo.html "Interface documentation") | C binding 684 | [rocsparse_scheck_matrix_csc_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__scheck__matrix__csc__buffer__size.html "Interface documentation") | C binding 685 | [rocsparse_dcheck_matrix_csc_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dcheck__matrix__csc__buffer__size.html "Interface documentation") | C binding 686 | [rocsparse_ccheck_matrix_csc_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__ccheck__matrix__csc__buffer__size.html "Interface documentation") | C binding 687 | [rocsparse_zcheck_matrix_csc_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zcheck__matrix__csc__buffer__size.html "Interface documentation") | C binding 688 | [rocsparse_scheck_matrix_csc](interfacehipfort__rocsparse_1_1rocsparse__scheck__matrix__csc.html "Interface documentation") | C binding 689 | [rocsparse_dcheck_matrix_csc](interfacehipfort__rocsparse_1_1rocsparse__dcheck__matrix__csc.html "Interface documentation") | C binding 690 | [rocsparse_ccheck_matrix_csc](interfacehipfort__rocsparse_1_1rocsparse__ccheck__matrix__csc.html "Interface documentation") | C binding 691 | [rocsparse_zcheck_matrix_csc](interfacehipfort__rocsparse_1_1rocsparse__zcheck__matrix__csc.html "Interface documentation") | C binding 692 | [rocsparse_scheck_matrix_csr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__scheck__matrix__csr__buffer__size.html "Interface documentation") | C binding 693 | [rocsparse_dcheck_matrix_csr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dcheck__matrix__csr__buffer__size.html "Interface documentation") | C binding 694 | [rocsparse_ccheck_matrix_csr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__ccheck__matrix__csr__buffer__size.html "Interface documentation") | C binding 695 | [rocsparse_zcheck_matrix_csr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zcheck__matrix__csr__buffer__size.html "Interface documentation") | C binding 696 | [rocsparse_scheck_matrix_csr](interfacehipfort__rocsparse_1_1rocsparse__scheck__matrix__csr.html "Interface documentation") | C binding 697 | [rocsparse_dcheck_matrix_csr](interfacehipfort__rocsparse_1_1rocsparse__dcheck__matrix__csr.html "Interface documentation") | C binding 698 | [rocsparse_ccheck_matrix_csr](interfacehipfort__rocsparse_1_1rocsparse__ccheck__matrix__csr.html "Interface documentation") | C binding 699 | [rocsparse_zcheck_matrix_csr](interfacehipfort__rocsparse_1_1rocsparse__zcheck__matrix__csr.html "Interface documentation") | C binding 700 | [rocsparse_scheck_matrix_ell_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__scheck__matrix__ell__buffer__size.html "Interface documentation") | C binding 701 | [rocsparse_dcheck_matrix_ell_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dcheck__matrix__ell__buffer__size.html "Interface documentation") | C binding 702 | [rocsparse_ccheck_matrix_ell_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__ccheck__matrix__ell__buffer__size.html "Interface documentation") | C binding 703 | [rocsparse_zcheck_matrix_ell_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zcheck__matrix__ell__buffer__size.html "Interface documentation") | C binding 704 | [rocsparse_scheck_matrix_ell](interfacehipfort__rocsparse_1_1rocsparse__scheck__matrix__ell.html "Interface documentation") | C binding 705 | [rocsparse_dcheck_matrix_ell](interfacehipfort__rocsparse_1_1rocsparse__dcheck__matrix__ell.html "Interface documentation") | C binding 706 | [rocsparse_ccheck_matrix_ell](interfacehipfort__rocsparse_1_1rocsparse__ccheck__matrix__ell.html "Interface documentation") | C binding 707 | [rocsparse_zcheck_matrix_ell](interfacehipfort__rocsparse_1_1rocsparse__zcheck__matrix__ell.html "Interface documentation") | C binding 708 | [rocsparse_scheck_matrix_gebsc_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__scheck__matrix__gebsc__buffer__size.html "Interface documentation") | C binding 709 | [rocsparse_dcheck_matrix_gebsc_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dcheck__matrix__gebsc__buffer__size.html "Interface documentation") | C binding 710 | [rocsparse_ccheck_matrix_gebsc_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__ccheck__matrix__gebsc__buffer__size.html "Interface documentation") | C binding 711 | [rocsparse_zcheck_matrix_gebsc_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zcheck__matrix__gebsc__buffer__size.html "Interface documentation") | C binding 712 | [rocsparse_scheck_matrix_gebsc](interfacehipfort__rocsparse_1_1rocsparse__scheck__matrix__gebsc.html "Interface documentation") | C binding 713 | [rocsparse_dcheck_matrix_gebsc](interfacehipfort__rocsparse_1_1rocsparse__dcheck__matrix__gebsc.html "Interface documentation") | C binding 714 | [rocsparse_ccheck_matrix_gebsc](interfacehipfort__rocsparse_1_1rocsparse__ccheck__matrix__gebsc.html "Interface documentation") | C binding 715 | [rocsparse_zcheck_matrix_gebsc](interfacehipfort__rocsparse_1_1rocsparse__zcheck__matrix__gebsc.html "Interface documentation") | C binding 716 | [rocsparse_scheck_matrix_gebsr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__scheck__matrix__gebsr__buffer__size.html "Interface documentation") | C binding 717 | [rocsparse_dcheck_matrix_gebsr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__dcheck__matrix__gebsr__buffer__size.html "Interface documentation") | C binding 718 | [rocsparse_ccheck_matrix_gebsr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__ccheck__matrix__gebsr__buffer__size.html "Interface documentation") | C binding 719 | [rocsparse_zcheck_matrix_gebsr_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__zcheck__matrix__gebsr__buffer__size.html "Interface documentation") | C binding 720 | [rocsparse_scheck_matrix_gebsr](interfacehipfort__rocsparse_1_1rocsparse__scheck__matrix__gebsr.html "Interface documentation") | C binding 721 | [rocsparse_dcheck_matrix_gebsr](interfacehipfort__rocsparse_1_1rocsparse__dcheck__matrix__gebsr.html "Interface documentation") | C binding 722 | [rocsparse_ccheck_matrix_gebsr](interfacehipfort__rocsparse_1_1rocsparse__ccheck__matrix__gebsr.html "Interface documentation") | C binding 723 | [rocsparse_zcheck_matrix_gebsr](interfacehipfort__rocsparse_1_1rocsparse__zcheck__matrix__gebsr.html "Interface documentation") | C binding 724 | [rocsparse_check_matrix_hyb_buffer_size](interfacehipfort__rocsparse_1_1rocsparse__check__matrix__hyb__buffer__size.html "Interface documentation") | C binding 725 | [rocsparse_check_matrix_hyb](interfacehipfort__rocsparse_1_1rocsparse__check__matrix__hyb.html "Interface documentation") | C binding 726 | [rocsparse_enable_roctx](interfacehipfort__rocsparse_1_1rocsparse__enable__roctx.html "Interface documentation") | C binding 727 | [rocsparse_disable_roctx](interfacehipfort__rocsparse_1_1rocsparse__disable__roctx.html "Interface documentation") | C binding 728 | [rocsparse_state_roctx](interfacehipfort__rocsparse_1_1rocsparse__state__roctx.html "Interface documentation") | C binding hipfort-rocm-10.0.0/docs/doxygen/input/supported_api_roctx.md000066400000000000000000000011321524740623400243700ustar00rootroot00000000000000# rocTX API Support \# | API Name | Variants ----|---------------|--------- 1 | [roctxMark](interfacehipfort__roctx_1_1roctxmark.html "Interface documentation") | C binding 2 | [roctxRangePush](interfacehipfort__roctx_1_1roctxrangepush.html "Interface documentation") | C binding 3 | [roctxRangePop](interfacehipfort__roctx_1_1roctxrangepop.html "Interface documentation") | C binding 4 | [roctxRangeStart](interfacehipfort__roctx_1_1roctxrangestart.html "Interface documentation") | C binding 5 | [roctxRangeStop](interfacehipfort__roctx_1_1roctxrangestop.html "Interface documentation") | C binding hipfort-rocm-10.0.0/docs/how-to/000077500000000000000000000000001524740623400163555ustar00rootroot00000000000000hipfort-rocm-10.0.0/docs/how-to/using-hipfort.rst000066400000000000000000000146321524740623400217130ustar00rootroot00000000000000.. meta:: :description: How to use hipFORT :keywords: fortran, hipFORT, compiler, AMD, ROCm, usage guide ********************************* Using hipFORT in your application ********************************* The following topic provides instructions and tips for using hipFORT. Fortran interfaces ================== hipFORT provides interfaces to the HIP runtime and to the ROCm libraries: * **HIP runtime and tooling**: * HIP runtime * rocTX * **ROCm math libraries** (``roc*``): * rocBLAS * rocFFT * rocRAND * rocSOLVER * rocSPARSE * **HIP math libraries** (``hip*``), whose APIs follow their NVIDIA counterparts: * hipBLAS * hipFFT * hipRAND * hipSOLVER * hipSPARSE * **FFTW3-compatible interface**: * hipFFTW, whose routine names, planner flags, and calling sequence follow FFTW3 rather than an NVIDIA library The available interfaces depend on which Fortran compiler was used to compile the hipFORT modules and libraries. The interfaces use the ``iso_c_binding`` module, so the minimum requirement is a Fortran compiler that supports the Fortran 2003 standard (`f2003`). These interfaces typically require passing ``type(c_ptr)`` variables and the number of bytes to memory management. Some examples include ``hipMalloc`` and math library routines like ``hipblasDGEMM``. If your compiler can understand the Fortran 2008 (`f2008`) code constructs, additional interfaces are compiled into the hipFORT modules and libraries. These interfaces take Fortran (array) variables and the number of elements, instead of ``type(c_ptr)`` variables and the number of bytes. Therefore, they reduce the chance of introducing compile-time and runtime errors into your code and make it easier to read. These additional interfaces are guarded by the ``USE_FPOINTER_INTERFACES`` preprocessor definition, which hipFORT enables automatically once it detects Fortran 2008 support in your compiler. The ``hipMalloc`` and ``hipMemcpy`` array overloads are an exception: they are not guarded and are therefore available in every hipFORT build. By convention, application and test sources that rely on them use the ``.f08`` file extension (see the ``test/f2008`` examples), while Fortran 2003 sources use ``.f03``. AMD's ``amdflang`` (ROCm's LLVM Flang, bundled with ROCm) is the recommended default, and ``gfortran`` (version 7.5.0 or newer) is also supported. Please open an issue at https://github.com/ROCm/hipfort/issues if you run into problems. Building your application with CMake ------------------------------------ hipFORT installs CMake package files, so you can locate it with ``find_package`` and link against its exported ``hipfort::*`` targets. Each target pulls in the right Fortran module (``.mod``) search path, the hipFORT library, and the underlying ROCm library it wraps. .. code-block:: cmake cmake_minimum_required(VERSION 3.18) project(my_app Fortran) find_package(hipfort REQUIRED COMPONENTS hip rocblas hipblas) add_executable(my_app main.f08) target_link_libraries(my_app PRIVATE hipfort::rocblas hipfort::hipblas hipfort::hip) List the libraries your code uses as ``COMPONENTS`` (``hip``, ``roctx``, ``rocblas``, ``rocfft``, ``rocrand``, ``rocsolver``, ``rocsparse``, ``hipblas``, ``hipfft``, ``hipfftw``, ``hiprand``, ``hipsolver``, ``hipsparse``) and link the matching ``hipfort::`` targets. A ``hipfort::`` target is only defined when that component is listed, and the Fortran language must be enabled before ``find_package(hipfort)``. If hipFORT is not in a default location, point CMake at it with ``-Dhipfort_ROOT=/path/to/hipfort`` (or ``CMAKE_PREFIX_PATH``). Multiple Fortran toolchains ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Fortran ``.mod`` files are compiler-specific, so a hipFORT build works only with the compiler that produced it. To let several toolchains coexist, hipFORT installs its modules and libraries into compiler-specific subdirectories (``include/fortran/`` and ``lib/fortran/``). This is enabled by the ``HIPFORT_MULTITOOLCHAIN_LAYOUT`` CMake option (``ON`` by default). The exported ``hipfort::*`` targets resolve these paths automatically, so your application picks the right modules and library by using the hipFORT installation that was built with the same Fortran compiler. To build hipFORT itself with a specific compiler or backend, use one of the example toolchain files in ``cmake/toolchains`` via ``-DCMAKE_TOOLCHAIN_FILE=...``. Examples -------- To see some examples for the `f2003` and `f2008` interfaces, see the :doc:`hipFORT samples <../tutorials/examples>`. For complete, runnable programs that use a ROCm math library, see the :doc:`rocFFT examples <../tutorials/rocfft-examples>`, the :doc:`rocSOLVER examples <../tutorials/rocsolver-examples>`, and the :doc:`rocSPARSE examples <../tutorials/rocsparse-examples>`. The ``hip*`` libraries, whose APIs follow their NVIDIA counterparts, have their own examples: the :doc:`hipFFT examples <../tutorials/hipfft-examples>`, the :doc:`hipSOLVER examples <../tutorials/hipsolver-examples>`, and the :doc:`hipSPARSE examples <../tutorials/hipsparse-examples>`. For the FFTW3-compatible interface, see the :doc:`hipFFTW examples <../tutorials/hipfftw-examples>`. Supported HIP and ROCm APIs --------------------------- The current set of hipFORT interfaces is derived from ROCm 10.0.0. The following tables list the supported APIs: * :doc:`HIP API <../doxygen/html/md_input_2supported__api__hip>` * :doc:`hipBLAS API <../doxygen/html/md_input_2supported__api__hipblas>` * :doc:`hipFFT API <../doxygen/html/md_input_2supported__api__hipfft>` * :doc:`hipFFTW API <../doxygen/html/md_input_2supported__api__hipfftw>` * :doc:`hipRAND API <../doxygen/html/md_input_2supported__api__hiprand>` * :doc:`hipSOLVER API <../doxygen/html/md_input_2supported__api__hipsolver>` * :doc:`hipSPARSE API <../doxygen/html/md_input_2supported__api__hipsparse>` * :doc:`rocBLAS API <../doxygen/html/md_input_2supported__api__rocblas>` * :doc:`rocFFT API <../doxygen/html/md_input_2supported__api__rocfft>` * :doc:`rocRAND API <../doxygen/html/md_input_2supported__api__rocrand>` * :doc:`rocSOLVER API <../doxygen/html/md_input_2supported__api__rocsolver>` * :doc:`rocSPARSE API <../doxygen/html/md_input_2supported__api__rocsparse>` * :doc:`rocTX API <../doxygen/html/md_input_2supported__api__roctx>` .. note:: Use the **Search** function from the hipFORT table of contents to get more information on the arguments for an interface. hipfort-rocm-10.0.0/docs/index.rst000066400000000000000000000035201524740623400170010ustar00rootroot00000000000000 .. meta:: :description: hipFORT documentation and API reference library :keywords: hipFORT, ROCm, API, documentation ********************* hipFORT documentation ********************* hipFORT is a Fortran interface library for accessing GPU kernels. It exposes the HIP API and ROCm accelerated libraries in Fortran with an open and portable set of standard Fortran module interfaces. The hipFORT public repository is located at ``_. .. grid:: 2 :gutter: 3 .. grid-item-card:: Install * :doc:`Quick start installation guide <./install/quick-start>` * :doc:`Detailed install <./install/install>` .. grid-item-card:: How to * :doc:`Use hipFORT <./how-to/using-hipfort>` .. grid-item-card:: Tutorials * :doc:`Examples <./tutorials/examples>` * :doc:`HIP runtime examples <./tutorials/hip-examples>` * :doc:`rocFFT examples <./tutorials/rocfft-examples>` * :doc:`rocSOLVER examples <./tutorials/rocsolver-examples>` * :doc:`rocSPARSE examples <./tutorials/rocsparse-examples>` * :doc:`hipFFT examples <./tutorials/hipfft-examples>` * :doc:`hipFFTW examples <./tutorials/hipfftw-examples>` * :doc:`hipSOLVER examples <./tutorials/hipsolver-examples>` * :doc:`hipSPARSE examples <./tutorials/hipsparse-examples>` .. grid-item-card:: API reference * :doc:`Supported APIs <./reference/index>` * :doc:`Modules <./doxygen/html/namespaces_modules>` * :doc:`Namespaces <./doxygen/html/namespaces>` * :doc:`Data types list <./doxygen/html/annotated>` * :doc:`Files <./doxygen/html/files>` To contribute to the documentation, see `Contributing to ROCm `_. You can find licensing information on the `Licensing `_ page. hipfort-rocm-10.0.0/docs/install/000077500000000000000000000000001524740623400166065ustar00rootroot00000000000000hipfort-rocm-10.0.0/docs/install/install.rst000066400000000000000000000125431524740623400210130ustar00rootroot00000000000000.. meta:: :description: Install guide for hipFORT :keywords: install, hipFORT, AMD, ROCm, building, tests ******************************* Installing and building hipFORT ******************************* This topic discusses how to build and install hipFORT from source with CMake. It also provides information on how to build and run the tests. Prerequisites ============= hipFORT requires a Fortran compiler that supports at least the Fortran 2003 standard. AMD ``amdflang`` (ROCm's LLVM Flang, bundled with ROCm) is the recommended default; ``gfortran`` version 7.5.0 or newer (see the `GFortran website `_) is also supported. Please open an issue at https://github.com/ROCm/hipfort/issues if you run into problems. Ready-made CMake toolchain files are provided; see :ref:`hipfort-toolchain-files`. .. _build-test-hipfort-from-source: Building and testing hipFORT from source ======================================== #. Ensure you have installed a Fortran compiler (``amdflang`` or ``gfortran``), ``git``, ``cmake``, and :doc:`HIP `. #. Build, install, and test hipFORT from source using the following commands: .. code-block:: shell git clone https://github.com/ROCm/hipfort.git cd hipfort cmake -S. -Bbuild -DCMAKE_INSTALL_PREFIX=/tmp/hipfort -DHIPFORT_BUILD_NVPTX=OFF -DBUILD_TESTING=ON cmake --build build cmake --install build ctest --test-dir build .. note:: ``-DHIPFORT_BUILD_NVPTX=OFF`` restricts the build to the ROCm backend (``hipfort-amdgcn``). The CUDA backend archive (``hipfort-nvptx``) is built by default, so omit the option if you also want it. When installing hipFORT from source, you do not need to specify the ``HIP_PLATFORM`` environment variable. Customizing the build --------------------- You can customize the build by setting the following environment variables: * ``FC``: The Fortran compiler to use * ``FFLAGS``: Compiler flags for building hipFORT or by setting the CMake cache variables: * ``CMAKE_BUILD_TYPE``: Set to ``RELEASE``, ``TESTING``, or ``DEBUG`` * ``CMAKE_AR``: Static archive command * ``CMAKE_RANLIB``: The ``ranlib`` used to create the static archive * ``CMAKE_INSTALL_PREFIX``: The install directory * ``ROCM_PATH``: The ROCm installation root, if it cannot be detected automatically * ``HIPFORT_BUILD_NVPTX``: Build the CUDA (``nvptx``) backend archive (``ON`` by default) .. _hipfort-toolchain-files: Toolchain files --------------- Rather than setting the compiler and backend cache variables by hand, you can select a ready-made CMake toolchain file from ``cmake/toolchains/`` with ``-DCMAKE_TOOLCHAIN_FILE``: .. code-block:: shell cmake -S . -Bbuild -DCMAKE_TOOLCHAIN_FILE=cmake/toolchains/amdflang.cmake Each file only sets the Fortran and C compilers, so they compose with the other build options above. hipFORT is pure Fortran, so no C++ compiler is required. Linking against hipFORT ======================= To use hipFORT in your project, invoke your Fortran and HIP compilers directly and link against the appropriate ROCm libraries. hipFORT provides exported CMake targets (such as ``hipfort::hip``, ``hipfort::rocblas``, and ``hipfort::hipblas``) to make this straightforward: .. code-block:: cmake project(my_app Fortran) find_package(hipfort REQUIRED COMPONENTS hip hipblas) add_executable(my_app main.f08) target_link_libraries(my_app PRIVATE hipfort::hipblas hipfort::hip) List each library you use as a ``COMPONENTS`` entry: a ``hipfort::`` target is only defined when that component is requested. The Fortran language must be enabled before ``find_package(hipfort)``. See :doc:`../how-to/using-hipfort` for the full component list. The installed CMake package targets the ROCm backend only. ``hipfort-config.cmake`` is written when hipFORT is configured for ROCm; it pulls in ``libhipfort-amdgcn`` and resolves each component against its ROCm package, so ``find_package(hipfort)`` does not work against the optional CUDA (``nvptx``) backend even when that archive is built and installed. Link ``libhipfort-nvptx`` and the CUDA libraries directly instead. Examples and tests ================== The examples in the ``f2003`` and ``f2008`` subdirectories of the ``test`` folder in the repository also serve as tests. Both test collections implement the same tests. However, the ``f2008`` tests require the Fortran compiler to support the Fortran 2008 standard or newer. The ``f2003`` tests only require support for the Fortran 2003 (`f2003`) standard. The ``f2003`` and ``f2008`` subdirectories are further subdivided into tests for the various hip* and roc* libraries. Building and running the tests ------------------------------ The tests are driven by CTest. Configure the build with ``-DBUILD_TESTING=ON``, build hipFORT, and run the suite with ``ctest`` (see :ref:`build-test-hipfort-from-source`). The commands below need the ROCm math libraries. The ROCm root is detected from ``ROCM_PATH`` or from ``hipcc`` on your ``PATH``; override with ``-DROCM_PATH=``. .. code-block:: shell cmake -S. -Bbuild -DCMAKE_INSTALL_PREFIX=/tmp/hipfort -DHIPFORT_BUILD_NVPTX=OFF -DBUILD_TESTING=ON cmake --build build ctest --test-dir build To run a single test, pass its name to ``ctest`` using the ``-R`` filter: .. code-block:: shell ctest --test-dir build -R hipfort_test_f2008_hipblas_dgemm hipfort-rocm-10.0.0/docs/install/quick-start.rst000066400000000000000000000027231524740623400216130ustar00rootroot00000000000000.. meta:: :description: Quick start installation guide for hipFORT. :keywords: install, hipFORT, AMD, ROCm, quick start Quick start installation guide ****************************** This topic discusses how to quickly build hipFORT from source. Prerequisites ============= hipFORT requires a Fortran compiler that supports at least the Fortran 2003 standard. AMD ``amdflang`` (ROCm's LLVM Flang, bundled with ROCm) is the recommended default; ``gfortran`` version 7.5.0 or newer (see the `GFortran website `_) is also supported. Please open an issue at https://github.com/ROCm/hipfort/issues if you run into problems. Building and testing hipFORT from source ======================================== 1. Ensure you have installed a Fortran compiler (``amdflang`` or ``gfortran``), ``git``, ``cmake``, and :doc:`HIP `. 2. Build, install, and test hipFORT from source using the following commands: .. code-block:: shell git clone https://github.com/ROCm/hipfort.git cd hipfort cmake -S. -Bbuild -DCMAKE_INSTALL_PREFIX=/tmp/hipfort -DHIPFORT_BUILD_NVPTX=OFF -DBUILD_TESTING=ON cmake --build build cmake --install build ctest --test-dir build To build with a specific compiler and backend, pass one of the provided toolchain files, for example ``-DCMAKE_TOOLCHAIN_FILE=cmake/toolchains/amdflang.cmake``. See :doc:`the detailed install guide <./install>` for the full list. hipfort-rocm-10.0.0/docs/license.md000066400000000000000000000002731524740623400171060ustar00rootroot00000000000000--- myst: html_meta: "description": "hipFORT license information" "keywords": "hipfort, ROCm, API, documentation, license" --- # License ```{include} ../LICENSE ``` hipfort-rocm-10.0.0/docs/reference/000077500000000000000000000000001524740623400170765ustar00rootroot00000000000000hipfort-rocm-10.0.0/docs/reference/index.md000066400000000000000000000020411524740623400205240ustar00rootroot00000000000000 # API reference This section provides technical descriptions and important information about the different hipFORT APIs and library components. - {doc}`/doxygen/html/md_input_2supported__api__hip` - {doc}`/doxygen/html/md_input_2supported__api__hipblas` - {doc}`/doxygen/html/md_input_2supported__api__hipfft` - {doc}`/doxygen/html/md_input_2supported__api__hipfftw` - {doc}`/doxygen/html/md_input_2supported__api__hiprand` - {doc}`/doxygen/html/md_input_2supported__api__hipsolver` - {doc}`/doxygen/html/md_input_2supported__api__hipsparse` - {doc}`/doxygen/html/md_input_2supported__api__rocblas` - {doc}`/doxygen/html/md_input_2supported__api__rocfft` - {doc}`/doxygen/html/md_input_2supported__api__rocrand` - {doc}`/doxygen/html/md_input_2supported__api__rocsolver` - {doc}`/doxygen/html/md_input_2supported__api__rocsparse` - {doc}`/doxygen/html/md_input_2supported__api__roctx` hipfort-rocm-10.0.0/docs/sphinx/000077500000000000000000000000001524740623400164515ustar00rootroot00000000000000hipfort-rocm-10.0.0/docs/sphinx/.gitignore000066400000000000000000000000121524740623400204320ustar00rootroot00000000000000/_toc.yml hipfort-rocm-10.0.0/docs/sphinx/.python-version000066400000000000000000000000051524740623400214510ustar00rootroot000000000000003.10 hipfort-rocm-10.0.0/docs/sphinx/_toc.yml.in000066400000000000000000000024611524740623400205300ustar00rootroot00000000000000--- defaults: numbered: false root: index subtrees: - caption: Install entries: - file: install/quick-start.rst title: Quick start installation guide - file: install/install.rst title: Detailed install - caption: How to entries: - file: how-to/using-hipfort.rst title: Use hipFORT - caption: Tutorials entries: - file: tutorials/examples.rst title: Examples - file: tutorials/hip-examples.rst title: HIP runtime examples - file: tutorials/rocfft-examples.rst title: rocFFT examples - file: tutorials/rocsolver-examples.rst title: rocSOLVER examples - file: tutorials/rocsparse-examples.rst title: rocSPARSE examples - file: tutorials/hipfft-examples.rst title: hipFFT examples - file: tutorials/hipfftw-examples.rst title: hipFFTW examples - file: tutorials/hipsolver-examples.rst title: hipSOLVER examples - file: tutorials/hipsparse-examples.rst title: hipSPARSE examples - caption: API reference entries: - file: doxygen/html/index title: hipFORT API reference - file: reference/index.md title: Supported APIs - caption: About entries: - file: license.md title: License hipfort-rocm-10.0.0/docs/sphinx/requirements.in000066400000000000000000000000461524740623400215240ustar00rootroot00000000000000rocm-docs-core[api_reference]==1.40.2 hipfort-rocm-10.0.0/docs/sphinx/requirements.txt000066400000000000000000000132051524740623400217360ustar00rootroot00000000000000# # This file is autogenerated by pip-compile with Python 3.10 # by the following command: # # pip-compile --cert=None --client-cert=None --index-url=None --pip-args=None requirements.in # accessible-pygments==0.0.5 # via pydata-sphinx-theme alabaster==1.0.0 # via sphinx asttokens==3.0.1 # via stack-data attrs==25.4.0 # via # jsonschema # jupyter-cache # referencing babel==2.18.0 # via # pydata-sphinx-theme # sphinx beautifulsoup4==4.14.3 # via pydata-sphinx-theme breathe==4.36.0 # via rocm-docs-core certifi==2026.1.4 # via requests cffi==2.0.0 # via # cryptography # pynacl charset-normalizer==3.4.4 # via requests click==8.3.1 # via # click-log # doxysphinx # jupyter-cache # sphinx-external-toc click-log==0.4.0 # via doxysphinx comm==0.2.3 # via ipykernel cryptography==46.0.5 # via pyjwt debugpy==1.8.20 # via ipykernel decorator==5.2.1 # via ipython docutils==0.21.2 # via # myst-parser # pydata-sphinx-theme # sphinx doxysphinx==3.3.14 # via rocm-docs-core exceptiongroup==1.3.1 # via ipython executing==2.2.1 # via stack-data fastjsonschema==2.21.2 # via # nbformat # rocm-docs-core gitdb==4.0.12 # via gitpython gitpython==3.1.46 # via rocm-docs-core greenlet==3.3.1 # via sqlalchemy idna==3.11 # via requests imagesize==1.4.1 # via sphinx importlib-metadata==8.7.1 # via # jupyter-cache # myst-nb ipykernel==7.2.0 # via myst-nb ipython==8.38.0 # via # ipykernel # myst-nb jedi==0.19.2 # via ipython jinja2==3.1.6 # via # myst-parser # sphinx jsonschema==4.26.0 # via nbformat jsonschema-specifications==2025.9.1 # via jsonschema jupyter-cache==1.0.1 # via myst-nb jupyter-client==8.8.0 # via # ipykernel # nbclient jupyter-core==5.9.1 # via # ipykernel # jupyter-client # nbclient # nbformat libsass==0.22.0 # via doxysphinx lxml==5.2.1 # via doxysphinx markdown-it-py==3.0.0 # via # mdit-py-plugins # myst-parser markupsafe==3.0.3 # via jinja2 matplotlib-inline==0.2.1 # via # ipykernel # ipython mdit-py-plugins==0.5.0 # via myst-parser mdurl==0.1.2 # via markdown-it-py mpire==2.10.2 # via doxysphinx myst-nb==1.3.0 # via rocm-docs-core myst-parser==4.0.1 # via myst-nb nbclient==0.10.4 # via # jupyter-cache # myst-nb nbformat==5.10.4 # via # jupyter-cache # myst-nb # nbclient nest-asyncio==1.6.0 # via ipykernel packaging==26.0 # via # ipykernel # pydata-sphinx-theme # sphinx parso==0.8.6 # via jedi pexpect==4.9.0 # via ipython platformdirs==4.9.2 # via jupyter-core prompt-toolkit==3.0.52 # via ipython psutil==7.2.2 # via ipykernel ptyprocess==0.7.0 # via pexpect pure-eval==0.2.3 # via stack-data pycparser==3.0 # via cffi pydata-sphinx-theme==0.15.4 # via # rocm-docs-core # sphinx-book-theme pygithub==2.8.1 # via rocm-docs-core pygments==2.19.2 # via # accessible-pygments # ipython # mpire # pydata-sphinx-theme # sphinx pyjson5==1.6.9 # via doxysphinx pyjwt[crypto]==2.11.0 # via pygithub pynacl==1.6.2 # via pygithub pyparsing==3.3.2 # via doxysphinx python-dateutil==2.9.0.post0 # via jupyter-client pyyaml==6.0.3 # via # jupyter-cache # myst-nb # myst-parser # rocm-docs-core # sphinx-external-toc pyzmq==27.1.0 # via # ipykernel # jupyter-client referencing==0.37.0 # via # jsonschema # jsonschema-specifications requests==2.32.5 # via # pygithub # sphinx rocm-docs-core[api-reference]==1.40.2 # via -r requirements.in rpds-py==0.30.0 # via # jsonschema # referencing six==1.17.0 # via python-dateutil smmap==5.0.2 # via gitdb snowballstemmer==3.0.1 # via sphinx soupsieve==2.8.3 # via beautifulsoup4 sphinx==8.1.3 # via # breathe # myst-nb # myst-parser # pydata-sphinx-theme # rocm-docs-core # sphinx-book-theme # sphinx-copybutton # sphinx-design # sphinx-external-toc # sphinx-multitoc-numbering # sphinx-notfound-page sphinx-book-theme==1.1.4 # via rocm-docs-core sphinx-copybutton==0.5.2 # via rocm-docs-core sphinx-design==0.6.1 # via rocm-docs-core sphinx-external-toc==1.1.0 # via rocm-docs-core sphinx-multitoc-numbering==0.1.3 # via sphinx-external-toc sphinx-notfound-page==1.1.0 # via rocm-docs-core sphinxcontrib-applehelp==2.0.0 # via sphinx sphinxcontrib-devhelp==2.0.0 # via sphinx sphinxcontrib-htmlhelp==2.1.0 # via sphinx sphinxcontrib-jsmath==1.0.1 # via sphinx sphinxcontrib-qthelp==2.0.0 # via sphinx sphinxcontrib-serializinghtml==2.0.0 # via sphinx sqlalchemy==2.0.46 # via jupyter-cache stack-data==0.6.3 # via ipython tabulate==0.9.0 # via jupyter-cache tomli==2.4.0 # via sphinx tornado==6.5.4 # via # ipykernel # jupyter-client tqdm==4.67.3 # via mpire traitlets==5.14.3 # via # ipykernel # ipython # jupyter-client # jupyter-core # matplotlib-inline # nbclient # nbformat typing-extensions==4.15.0 # via # beautifulsoup4 # cryptography # exceptiongroup # ipython # myst-nb # pydata-sphinx-theme # pygithub # referencing # sqlalchemy urllib3==2.6.3 # via # pygithub # requests wcwidth==0.6.0 # via prompt-toolkit zipp==3.23.0 # via importlib-metadata hipfort-rocm-10.0.0/docs/tutorials/000077500000000000000000000000001524740623400171665ustar00rootroot00000000000000hipfort-rocm-10.0.0/docs/tutorials/examples.rst000066400000000000000000000051221524740623400215360ustar00rootroot00000000000000.. meta:: :description: hipFORT examples and API references :keywords: hipFORT, ROCm, API, documentation, examples, tutorials **************** hipFORT examples **************** Use the following examples to express Fortran 2003 (`f2003`) interfaces: **Example 1** .. code-block:: use iso_c_binding use hipfort integer :: ierr ! error code real, target :: a_h(5,6) ! host array ('target' is required by c_loc) type(c_ptr) :: a_d ! device array pointer ! ierr = hipMalloc(a_d,size(a_h)*4_c_size_t) ! real has 4 bytes ! append suffix '_c_size_t' to write '4' ! as 'integer(c_size_t)' ierr = hipMemcpy(a_d,c_loc(a_h),size(a_h)*4_c_size_t,hipMemcpyHostToDevice) **Example 2** .. code-block:: use hipfort integer :: ierr ! error code real :: a_h(5,6) ! host array real,pointer :: a_d(:,:) ! device array pointer ! ierr = hipMalloc(a_d,shape(a_h)) ! or hipMalloc(a_d,[5,6]) or hipMalloc(a_d,5,6) or hipMalloc(a_d,mold=a_h) ierr = hipMemcpy(a_d,a_h,size(a_h),hipMemcpyHostToDevice) .. note:: ``hipMalloc`` is also overloaded with ``source`` and ``mold`` arguments, similar to the ``ALLOCATE`` intrinsic. Unlike the array interfaces of the math libraries, the ``hipMalloc`` and ``hipMemcpy`` overloads are not guarded by ``USE_FPOINTER_INTERFACES``, so they are available in every hipFORT build. For example: .. code-block:: integer :: ierr ! error code real :: a_h(5,6) ! host array real,pointer :: a_d(:,:) ! device array pointer ! ierr = hipMalloc(a_d,source=a_h) ! take shape (incl. bounds) of a_h and perform a blocking copy to device In addition to ``source``, there is also ``dsource``, which is used if the source is a device array. Library examples ================ Complete, runnable programs are available for the HIP runtime and the ROCm math libraries: * :doc:`HIP runtime examples <./hip-examples>` * :doc:`rocFFT examples <./rocfft-examples>` * :doc:`rocSOLVER examples <./rocsolver-examples>` * :doc:`rocSPARSE examples <./rocsparse-examples>` The ``hip*`` libraries offer the same functionality through APIs that follow their NVIDIA counterparts: * :doc:`hipFFT examples <./hipfft-examples>` * :doc:`hipSOLVER examples <./hipsolver-examples>` * :doc:`hipSPARSE examples <./hipsparse-examples>` hipFFTW instead exposes an FFTW3-compatible API: * :doc:`hipFFTW examples <./hipfftw-examples>` hipfort-rocm-10.0.0/docs/tutorials/hip-examples.rst000066400000000000000000000174231524740623400223230ustar00rootroot00000000000000.. meta:: :description: HIP runtime examples written with the hipFORT Fortran interfaces :keywords: hipFORT, ROCm, HIP, runtime, Fortran, examples, tutorials ******************** HIP runtime examples ******************** The `HIP runtime `_ is the API used to manage devices, memory, streams, events, graphs and kernel launches. hipFORT exposes it through the ``hipfort`` module, with enumerators in ``hipfort_enums``, derived types in ``hipfort_types``, and the status-checking helpers in ``hipfort_check``. A few routines live in their own modules: ``hipGetDeviceProperties`` in ``hipfort_auxiliary``, ``hipMemcpy2DAsync`` in ``hipfort_hipmemcpy`` and ``hipHostRegister`` in ``hipfort_hiphostregister``. Every program on this page is complete and self-contained, and is built and run as part of the hipFORT test suite. The sources live in ``test/f2003/hip``, and the programs that benefit from Fortran array pointers have a Fortran 2008 twin in ``test/f2008/hip``. Conventions =========== * **Device pointers.** The Fortran 2003 programs hold device memory in a ``type(c_ptr)`` and pass byte counts, as in ``hipMalloc(dx, nbytes)`` and ``hipMemcpy(dx, c_loc(hx(1)), nbytes, hipMemcpyHostToDevice)``. The Fortran 2008 interfaces instead accept a Fortran array pointer and an element count, as in ``hipMalloc(dx, n)`` or ``hipMalloc(dx, source=hx)``. * **Every call returns a status code.** The programs wrap calls in ``hipCheck`` from the ``hipfort_check`` module, which aborts on failure. A call whose non-success return is the thing being tested, such as ``hipStreamQuery``, keeps the status in a variable instead. * **Enumerators are integers.** Declare status variables as ``integer(kind(hipSuccess))`` so they match the kind the interfaces return. * **Host callbacks and kernel stubs** are passed as ``c_funloc`` of a procedure declared ``bind(c)``. Building and running ==================== The programs only need the ``hip`` hipFORT component: .. code-block:: cmake find_package(hipfort REQUIRED COMPONENTS hip) add_executable(my_app stream.f03) target_link_libraries(my_app PRIVATE hipfort::hip) See :doc:`../how-to/using-hipfort` for the full set of build options. Device management ================= The device queries report how many GPUs are visible, select one for the calling thread, and read back its limits and free memory. .. literalinclude:: ../../test/f2003/hip/device_management.f03 :language: fortran ``hipGetDeviceProperties`` returns the same information in one ``hipDeviceProp_t`` structure; ``test/f2003/hip/device_properties.f03`` reads it and cross-checks a few fields against ``hipDeviceGetAttribute``. Memory copies and fills ======================= Beyond ``hipMemcpy`` and ``hipMemset``, the runtime offers pitched two dimensional operations, typed fills, and asynchronous forms that take a stream. .. literalinclude:: ../../test/f2003/hip/memory_ops.f03 :language: fortran ``test/f2003/hip/memcpy2d.f03`` covers ``hipMemcpy2D`` on a column-major matrix, and ``test/f2003/hip/memcpy_async.f03`` covers ``hipMemcpyAsync`` and ``hipMemcpyWithStream``. Pinned and managed memory ========================= ``hipHostMalloc`` allocates page-locked host memory, which the GPU can copy to and from without a staging buffer. .. literalinclude:: ../../test/f2003/hip/host_malloc.f03 :language: fortran An existing host array can be page-locked in place with ``hipHostRegister`` (``test/f2003/hip/host_register.f03``). ``hipMallocManaged`` (``test/f2003/hip/malloc_managed.f03``) allocates memory that both the host and the device address directly, and ``test/f2003/hip/mem_advise.f03`` adds migration hints on top of it. ``test/f2003/hip/pointer_attributes.f03`` queries which of the three kinds a pointer belongs to. Virtual memory management ========================= The virtual memory API separates the address range from the physical memory backing it: reserve a range, create a physical allocation, map one onto the other, then grant the device access. This allows an allocation to grow without changing the pointer the application already holds. .. literalinclude:: ../../test/f2003/hip/virtual_memory.f03 :language: fortran Streams ======= Work queued on the same stream runs in order, and work on different streams may overlap. Streams can be created with flags and with a priority from the range the device reports. .. literalinclude:: ../../test/f2003/hip/stream_flags.f03 :language: fortran ``test/f2003/hip/stream.f03`` shows the basic create, synchronize and destroy sequence. Host functions on a stream ========================== ``hipStreamAddCallback`` and ``hipLaunchHostFunc`` run a host procedure once the work queued before it on the stream has completed. .. literalinclude:: ../../test/f2003/hip/stream_callback.f03 :language: fortran Events ====== Events mark a point in a stream. They time device work and make one stream wait for another. .. literalinclude:: ../../test/f2003/hip/event_timing.f03 :language: fortran ``test/f2003/hip/event.f03`` shows the shorter form: record, synchronize and read the elapsed time. Graphs ====== A graph records a sequence of operations and their dependencies once, so that repeated executions skip the per-call launch overhead. The simplest way to build one is to capture a stream. .. literalinclude:: ../../test/f2003/hip/graph.f03 :language: fortran A graph can also be built node by node, with the dependencies stated explicitly. .. literalinclude:: ../../test/f2003/hip/graph_nodes.f03 :language: fortran ``test/f2003/hip/graph_memset_node.f03`` adds a memset node from a ``hipMemsetParams`` structure, and ``test/f2003/hip/graph_empty_node.f03`` builds a diamond shape with an empty node as the join point. Launching a kernel ================== Kernels themselves are written in HIP C++. The Fortran program calls a small ``bind(c)`` launcher that the HIP compiler builds alongside it. .. literalinclude:: ../../test/f2003/vecadd/main.f03 :language: fortran The kernel and its launcher: .. literalinclude:: ../../test/f2003/vecadd/hip_implementation.cpp :language: cpp Loading a code object ===================== The module API loads a kernel from a code object at run time, which avoids linking any HIP C++ into the Fortran program. Build the code object with ``hipcc --genco`` and look the kernel up by its mangled name. .. literalinclude:: ../../test/f2003/hip/module_kernel.f03 :language: fortran Occupancy ========= The occupancy calculator reports how many blocks of a given size can be resident on a compute unit, and suggests a block size that maximizes occupancy. Both entry points take the host stub of a kernel. .. literalinclude:: ../../test/f2003/hip/occupancy.f03 :language: fortran ``hipModuleOccupancyMaxActiveBlocksPerMultiprocessor`` answers the same question for a kernel loaded from a code object. Cooperative launch ================== A cooperative launch guarantees that every block of the grid is resident at the same time, which is what allows a kernel to synchronize across the whole grid. The grid is therefore limited by the occupancy of the kernel times the number of compute units, and a larger grid is rejected. .. literalinclude:: ../../test/f2003/hip/cooperative_launch.f03 :language: fortran Error handling and version queries ================================== HIP records the last error per thread. ``hipPeekAtLastError`` reads it and ``hipGetLastError`` reads and clears it, and both a short name and a description are available for any status code. .. literalinclude:: ../../test/f2003/hip/error_version.f03 :language: fortran Peer access =========== On a multi-GPU host, one device can address another device's memory once peer access is enabled between them. .. literalinclude:: ../../test/f2003/hip/peer_access.f03 :language: fortran hipfort-rocm-10.0.0/docs/tutorials/hipfft-examples.rst000066400000000000000000000146451524740623400230260ustar00rootroot00000000000000.. meta:: :description: hipFFT examples written with the hipFORT Fortran interfaces :keywords: hipFORT, ROCm, hipFFT, FFT, Fortran, examples, tutorials *************** hipFFT examples *************** `hipFFT `_ is a thin layer over rocFFT whose API follows cuFFT. hipFORT exposes it through the ``hipfort_hipfft`` module. Every program on this page is complete and self-contained, and is built and run as part of the hipFORT test suite. The Fortran 2008 tests live in ``test/f2008/hipfft`` and the equivalent Fortran 2003 sources, which use ``type(c_ptr)`` device pointers and explicit byte counts instead of Fortran array pointers, live in ``test/f2003/hipfft``. If you want direct access to rocFFT rather than a cuFFT-style interface, see :doc:`rocfft-examples`. Transform workflow ================== A hipFFT transform follows the same sequence as cuFFT: #. Create a plan with ``hipfftPlan1d``, ``hipfftPlan2d``, ``hipfftPlan3d`` or ``hipfftPlanMany``, passing the transform lengths, the transform type and the batch count. #. Run the transform with the ``hipfftExec`` routine matching the plan type: ``hipfftExecZ2Z`` and ``hipfftExecC2C`` for complex-to-complex, ``hipfftExecD2Z`` and ``hipfftExecR2C`` for real-to-complex, ``hipfftExecZ2D`` and ``hipfftExecC2R`` for complex-to-real. #. Release the plan with ``hipfftDestroy``. Keep the following conventions in mind: * hipFFT transforms are **unnormalized**. A forward transform followed by an inverse transform of length ``N`` returns ``N`` times the original data. * The transform type encodes the precision: ``HIPFFT_Z2Z`` and ``HIPFFT_D2Z`` are double precision, ``HIPFFT_C2C`` and ``HIPFFT_R2C`` are single. * Complex-to-complex transforms take a direction, ``HIPFFT_FORWARD`` or ``HIPFFT_BACKWARD``. Real transforms take their direction from the type. * Real forward transforms produce Hermitian-symmetric output, so only ``N/2 + 1`` complex values are stored. Size the complex buffer accordingly. * Multi-dimensional plans take lengths in C order, with the **last** dimension contiguous. This is the opposite of rocFFT, which takes the fastest-varying dimension first. * Every hipFFT call returns a status code. The programs wrap them in ``hipfftCheck`` from the ``hipfort_check`` module, which aborts on failure. Building and running ==================== The programs only need the ``hipfft`` and ``hip`` hipFORT components: .. code-block:: cmake find_package(hipfort REQUIRED COMPONENTS hip hipfft) add_executable(my_fft hipfft_c2c_1d_z.f08) target_link_libraries(my_fft PRIVATE hipfort::hipfft hipfort::hip) See :doc:`../how-to/using-hipfort` for the full set of build options. Complex-to-complex transform ============================ The simplest case: an in-place, single-batch, one-dimensional complex-to-complex transform in double precision. The program runs a forward transform followed by an inverse transform and checks that the result is ``N`` times the input, which demonstrates that hipFFT does not normalize. .. literalinclude:: ../../test/f2008/hipfft/hipfft_c2c_1d_z.f08 :language: fortran Use ``HIPFFT_C2C`` and ``complex(4)`` host data for a single precision transform, as in ``test/f2008/hipfft/hipfft_c2c_1d_c.f08``. Real-to-complex and complex-to-real transforms ============================================== Real transforms use ``HIPFFT_D2Z`` and ``HIPFFT_Z2D``. Because the spectrum of real data is Hermitian symmetric, the complex buffer holds ``N/2 + 1`` elements. .. literalinclude:: ../../test/f2008/hipfft/hipfft_r2c_c2r_1d_d.f08 :language: fortran ``test/f2008/hipfft/hipfft_r2c_c2r_1d_s.f08`` is the single precision equivalent, using ``HIPFFT_R2C`` and ``HIPFFT_C2R``. Multi-dimensional transforms ============================ A two-dimensional transform uses ``hipfftPlan2d``. The last dimension is contiguous, so a plan created as ``hipfftPlan2d(plan, Nx, Ny, ...)`` expects ``Ny`` to vary fastest in memory. .. literalinclude:: ../../test/f2008/hipfft/hipfft_c2c_2d_z.f08 :language: fortran ``test/f2008/hipfft/hipfft_c2c_3d_z.f08`` extends the same pattern to three dimensions with ``hipfftPlan3d``. Batched transforms ================== To transform many signals with one plan, use ``hipfftPlanMany`` and pass the batch count. The ``inembed`` and ``onembed`` arrays describe the memory layout; passing null pointers selects the contiguous default. .. literalinclude:: ../../test/f2008/hipfft/hipfft_c2c_1d_batched_z.f08 :language: fortran Advanced data layout ==================== ``hipfftPlanMany`` also describes strided and interleaved data. The stride is the distance between consecutive elements of one transform, and the distance is the gap between the start of consecutive transforms. This program batches a two-dimensional transform. .. literalinclude:: ../../test/f2008/hipfft/hipfft_planmany_2d_z2z.f08 :language: fortran Querying the work area size =========================== hipFFT needs scratch memory whose size depends on the transform. There are two ways to ask about it. ``hipfftEstimate1d`` and friends give a heuristic upper bound before a plan exists, which is useful for budgeting. ``hipfftGetSize1d`` and ``hipfftGetSize`` report the exact requirement of a plan that has already been created. .. literalinclude:: ../../test/f2008/hipfft/hipfft_estimate_getsize_d.f08 :language: fortran Managing the work area ====================== By default a plan allocates its own work area. Call ``hipfftSetAutoAllocation`` with ``0`` before building the plan to turn that off, then supply your own buffer with ``hipfftSetWorkArea``. This lets several plans share one allocation, or lets the application control when the memory is reserved. Plans built this way use ``hipfftCreate`` and ``hipfftMakePlanMany`` rather than ``hipfftPlanMany``, because the work area has to be configured between the two calls. .. literalinclude:: ../../test/f2008/hipfft/hipfft_makeplanmany_z.f08 :language: fortran Running on HIP streams ====================== By default hipFFT executes on the null stream. Bind a plan to an application-owned stream with ``hipfftSetStream`` to overlap independent transforms. Each stream has to be synchronized before its results are read back. This program runs two plans, each on its own stream, with different input harmonics so that a swapped stream would be visible in the output. .. literalinclude:: ../../test/f2008/hipfft/hipfft_setstream_z.f08 :language: fortran hipfort-rocm-10.0.0/docs/tutorials/hipfftw-examples.rst000066400000000000000000000123631524740623400232100ustar00rootroot00000000000000.. meta:: :description: hipFFTW examples written with the hipFORT Fortran interfaces :keywords: hipFORT, ROCm, hipFFTW, FFTW, FFT, Fortran, examples, tutorials **************** hipFFTW examples **************** hipFFTW is the FFTW3-compatible interface shipped with `hipFFT `_. The routine names, planner flags and calling sequence are those of FFTW3, so existing FFTW code moves across with little change. hipFORT exposes it through the ``hipfort_hipfftw`` module. The one difference that matters: the ``in`` and ``out`` arguments are **device** pointers. FFTW declares them ``void*``, so a pointer from ``hipMalloc`` passes straight through, but host arrays do not work. Every program on this page is complete and self-contained, and is built and run as part of the hipFORT test suite. The tests live in ``test/f2003/hipfftw``. Unlike the other FFT libraries there is no Fortran 2008 variant, because the FFTW API is pointer-based throughout and gains nothing from Fortran array pointers. For the cuFFT-style interface to the same library, see :doc:`hipfft-examples`. Transform workflow ================== A hipFFTW transform follows the FFTW3 sequence: #. Allocate device memory with ``hipMalloc``, or host-accessible memory with ``fftw_alloc_real`` and ``fftw_alloc_complex``. #. Build a plan with ``fftw_plan_dft_1d``, ``fftw_plan_dft_r2c_1d``, ``fftw_plan_many_dft`` or ``fftw_plan_guru_dft``. #. Run it with the matching ``fftw_execute_dft``, ``fftw_execute_dft_r2c`` or ``fftw_execute_dft_c2r``. #. Release the plan with ``fftw_destroy_plan``. Keep the following conventions in mind: * FFTW transforms are **unnormalized**. A forward transform followed by an inverse transform of length ``N`` returns ``N`` times the original data. * Planner flags are the standard FFTW values and come from the ``hipfort_hipfftw_enums`` module, which ``hipfort_hipfftw`` re-exports: ``FFTW_ESTIMATE``, ``FFTW_MEASURE``, ``FFTW_PATIENT``, ``FFTW_EXHAUSTIVE``, ``FFTW_WISDOM_ONLY``, and the direction flags ``FFTW_FORWARD`` and ``FFTW_BACKWARD``. Do not redeclare them locally; a local definition clashes with the use-associated one. * Real forward transforms produce Hermitian-symmetric output, so only ``N/2 + 1`` complex values are stored. * Multi-dimensional transforms use C row-major order, so the last dimension is contiguous. * The double precision routines are named ``fftw_*`` and the single precision ones ``fftwf_*``. Building and running ==================== The programs only need the ``hipfftw`` and ``hip`` hipFORT components: .. code-block:: cmake find_package(hipfort REQUIRED COMPONENTS hip hipfftw) add_executable(my_fft hipfftw_c2c.f03) target_link_libraries(my_fft PRIVATE hipfort::hipfftw hipfort::hip) See :doc:`../how-to/using-hipfort` for the full set of build options. Complex-to-complex transform ============================ A one-dimensional complex-to-complex transform. The plan is built with ``fftw_plan_dft_1d`` over two device pointers and executed once. The input is a sum of two harmonics, so the output has energy in exactly two bins. .. literalinclude:: ../../test/f2003/hipfftw/hipfftw_c2c.f03 :language: fortran Real-to-complex and complex-to-real transforms ============================================== ``fftw_plan_dft_r2c_1d`` and ``fftw_plan_dft_c2r_1d`` build the two halves of a real round trip. The complex side holds ``N/2 + 1`` elements. .. literalinclude:: ../../test/f2003/hipfftw/hipfftw_r2c_c2r.f03 :language: fortran Multi-dimensional transforms ============================ ``fftw_plan_dft_2d`` takes the dimensions in C order, so the second argument varies fastest in memory. .. literalinclude:: ../../test/f2003/hipfftw/hipfftw_dft_2d.f03 :language: fortran ``test/f2003/hipfftw/hipfftw_dft_3d.f03`` extends the same pattern to three dimensions with ``fftw_plan_dft_3d``. Batched transforms ================== The ``_many`` planners transform a batch of signals with one plan. The ``inembed`` and ``onembed`` arguments describe the memory layout, ``stride`` is the gap between elements of one transform and ``dist`` the gap between the start of consecutive transforms. This program covers the complex-to-complex, real-to-complex and complex-to-real cases. .. literalinclude:: ../../test/f2003/hipfftw/hipfftw_many.f03 :language: fortran The guru interface ================== The guru interface describes a transform as arrays of ``fftw_iodim`` descriptors, one per dimension, each giving a length and its input and output strides. It expresses layouts the simpler planners cannot. Note how the arrays are passed: the dummy arguments are scalar ``type(fftw_iodim)``, so the program passes the first element of each array and the callee receives the base address of the contiguous struct array. .. literalinclude:: ../../test/f2003/hipfftw/hipfftw_guru.f03 :language: fortran Allocating buffers ================== ``fftw_alloc_real`` and ``fftw_alloc_complex``, along with the ``fftwf_`` single precision forms, return correctly aligned host-accessible buffers that can be handed straight to a plan. Use ``c_f_pointer`` to get a Fortran array view, and release them with ``fftw_free``. .. literalinclude:: ../../test/f2003/hipfftw/hipfftw_alloc.f03 :language: fortran hipfort-rocm-10.0.0/docs/tutorials/hipsolver-examples.rst000066400000000000000000000171271524740623400235570ustar00rootroot00000000000000.. meta:: :description: hipSOLVER examples written with the hipFORT Fortran interfaces :keywords: hipFORT, ROCm, hipSOLVER, LAPACK, Fortran, examples, tutorials ****************** hipSOLVER examples ****************** `hipSOLVER `_ is a thin layer over rocSOLVER whose API follows cuSOLVER. hipFORT exposes it through the ``hipfort_hipsolver`` module. Every program on this page is complete and self-contained, and is built and run as part of the hipFORT test suite. The Fortran 2008 tests live in ``test/f2008/hipsolver`` and the equivalent Fortran 2003 sources, which use ``type(c_ptr)`` device pointers and explicit byte counts instead of Fortran array pointers, live in ``test/f2003/hipsolver``. If you want direct access to rocSOLVER rather than a cuSOLVER-style interface, see the :doc:`rocSOLVER examples `, where the equivalent programs are written against the ``hipfort_rocsolver`` module. Each routine is provided in the four LAPACK precisions where it has them: ``s`` (real single), ``d`` (real double), ``c`` (complex single), and ``z`` (complex double). This page shows the double-precision program of each group; the other precisions differ only in the host data type and the ``hipsolver`` prefix letter. Solver workflow =============== Unlike LAPACK, hipSOLVER routines need an explicit GPU workspace. A typical call follows the same sequence as cuSOLVER: #. Create a handle with ``hipsolverCreate``. #. Query the workspace size with the routine's ``_bufferSize`` companion (for example ``hipsolverDgetrf_bufferSize``), then allocate that many bytes on the device. #. Run the routine, passing the workspace and its size. #. Read back the device ``info`` output to check for success. #. Release the handle with ``hipsolverDestroy``. Keep the following conventions in mind: * **Column-major storage.** hipSOLVER matrices are column-major, which matches Fortran's native array layout, so a Fortran 2-D array maps directly onto a matrix with leading dimension ``lda = size(A, 1)``. * **An explicit workspace.** Most routines take a device work buffer and its length. Size it with the matching ``_bufferSize`` query rather than guessing; the buffer stays a bare ``type(c_ptr)`` in both dialects. * **The** ``info`` **output lives in device memory.** hipSOLVER writes the factorization status to a *device* pointer, so it must be backed by a device allocation, not a host scalar. For the batched routines ``info`` is an array of ``batch_count`` integers on the device. * **Enumerators select variants.** ``HIPSOLVER_FILL_MODE_UPPER`` / ``HIPSOLVER_FILL_MODE_LOWER`` choose the stored triangle, and ``HIPSOLVER_EIG_MODE_NOVECTOR`` / ``HIPSOLVER_EIG_MODE_VECTOR`` choose whether eigenvectors are computed. The SVD job arguments are ``character(c_char)`` job codes (``'N'``, ``'A'``, ``'S'``, ``'V'``) passed by value. * **Every call returns a status code.** The programs wrap hipSOLVER calls in ``hipsolverCheck`` and HIP calls in ``hipCheck`` from the ``hipfort_check`` module, both of which abort on failure. Building and running ==================== The programs only need the ``hipsolver`` and ``hip`` hipFORT components: .. code-block:: cmake find_package(hipfort REQUIRED COMPONENTS hip hipsolver) add_executable(my_solver hipsolver_dgetrf.f08) target_link_libraries(my_solver PRIVATE hipfort::hipsolver hipfort::hip) See :doc:`../how-to/using-hipfort` for the full set of build options. LU factorization and solve ========================== ``getrf`` computes the LU factorization ``A = P*L*U`` with partial pivoting, writing the factors in place over ``A`` and the pivot indices into ``ipiv``. The program queries the workspace with ``hipsolverDgetrf_bufferSize``, factorizes, and reconstructs ``L*U`` to confirm the result. .. literalinclude:: ../../test/f2008/hipsolver/hipsolver_dgetrf.f08 :language: fortran ``getrs`` uses the factors and pivots from ``getrf`` to solve ``A*X = B``. The program picks a known solution ``x``, forms ``b = A*x``, factorizes, solves, and checks that the recovered ``X`` matches ``x``. .. literalinclude:: ../../test/f2008/hipsolver/hipsolver_dgetrs.f08 :language: fortran Cholesky factorization and solve ================================ ``potrf`` computes the Cholesky factorization of a symmetric (or Hermitian) positive-definite matrix, writing the factor into the triangle chosen by the fill mode. The program uses ``HIPSOLVER_FILL_MODE_UPPER`` and checks the factor against the known Cholesky root. .. literalinclude:: ../../test/f2008/hipsolver/hipsolver_dpotrf.f08 :language: fortran ``potrs`` solves ``A*X = B`` from a ``potrf`` factorization. The program forms ``b = A*x`` for a known ``x`` and confirms the solve recovers it. .. literalinclude:: ../../test/f2008/hipsolver/hipsolver_dpotrs.f08 :language: fortran Batched Cholesky ================ ``potrfBatched`` factorizes many matrices with one call. The batched API takes ``A`` as an array of device pointers that itself lives in *device* memory: each matrix is allocated on the device, their device addresses are collected in a host array, and that array is copied to a device buffer whose address is passed as ``A``. ``info`` is a device array indexed by batch. .. literalinclude:: ../../test/f2008/hipsolver/hipsolver_dpotrfbatched.f08 :language: fortran QR factorization ================ ``geqrf`` computes ``A = Q*R``, storing ``R`` in the upper triangle of ``A`` and the Householder vectors that represent ``Q`` below it, with their scalar factors in ``tau``. .. literalinclude:: ../../test/f2008/hipsolver/hipsolver_dgeqrf.f08 :language: fortran ``Q`` is never formed explicitly by ``geqrf``. Two follow-on routines use its compact representation: ``orgqr`` (``ungqr`` for complex) generates the explicit orthogonal matrix ``Q``, and ``ormqr`` (``unmqr`` for complex) multiplies a given matrix by ``Q`` or ``Q**T`` without forming it. .. literalinclude:: ../../test/f2008/hipsolver/hipsolver_dorgqr.f08 :language: fortran .. literalinclude:: ../../test/f2008/hipsolver/hipsolver_dormqr.f08 :language: fortran Symmetric eigenvalues ===================== ``syevd`` (``heevd`` for Hermitian matrices) computes the eigenvalues, and optionally the eigenvectors, of a symmetric matrix with a divide-and-conquer algorithm. The ``HIPSOLVER_EIG_MODE_*`` argument selects whether eigenvectors are produced; the program requests eigenvalues only and checks their sum against the trace. .. literalinclude:: ../../test/f2008/hipsolver/hipsolver_dsyevd.f08 :language: fortran ``syevj``/``heevj`` solve the same problem with a Jacobi algorithm, which is often faster for small matrices. With ``HIPSOLVER_EIG_MODE_VECTOR`` the matrix is overwritten with the eigenvectors; the program confirms each eigenpair satisfies ``A*v = lambda*v``. .. literalinclude:: ../../test/f2008/hipsolver/hipsolver_dsyevj.f08 :language: fortran Singular value decomposition ============================ ``gesvd`` computes the singular value decomposition ``A = U*S*V**T``. The ``character(c_char)`` job codes choose which singular-vector matrices are computed. The program requests singular values only (``'N'``) and checks the convention-independent invariant ``sum(sigma_i**2) == ||A||_F**2``. .. literalinclude:: ../../test/f2008/hipsolver/hipsolver_dgesvd.f08 :language: fortran ``gesvdj`` computes the same decomposition with a Jacobi algorithm. The program requests all vectors and reconstructs ``A`` from the factors, which avoids the sign and order ambiguity of the singular vectors. .. literalinclude:: ../../test/f2008/hipsolver/hipsolver_dgesvdj.f08 :language: fortran hipfort-rocm-10.0.0/docs/tutorials/hipsparse-examples.rst000066400000000000000000000170301524740623400235330ustar00rootroot00000000000000.. meta:: :description: hipSPARSE examples written with the hipFORT Fortran interfaces :keywords: hipFORT, ROCm, hipSPARSE, sparse, Fortran, examples, tutorials ****************** hipSPARSE examples ****************** `hipSPARSE `_ is a thin layer over rocSPARSE whose API follows cuSPARSE. hipFORT exposes it through the ``hipfort_hipsparse`` module. Every program on this page is complete and self-contained, and is built and run as part of the hipFORT test suite. The Fortran 2008 sources live in ``test/f2008/hipsparse`` and the equivalent Fortran 2003 sources, which use ``type(c_ptr)`` device pointers and explicit byte counts instead of Fortran array pointers, live in ``test/f2003/hipsparse``. If you want direct access to rocSPARSE rather than a cuSPARSE-style interface, see the :doc:`rocSPARSE examples `, where the equivalent programs are written against the ``hipfort_rocsparse`` module. Where a routine has the four precisions, a program is provided for each: ``s`` (real single), ``d`` (real double), ``c`` (complex single), and ``z`` (complex double). This page shows the double-precision program of each group; the other precisions differ only in the host data type and the ``hipsparse`` prefix letter. Conventions =========== hipSPARSE follows a small number of conventions that recur in every program: * **Sparse matrix formats.** Most programs store the sparse matrix in CSR (compressed sparse row): a row-pointer array, a column-index array, and a values array. A few routines take COO (coordinate) row/column arrays. * **Zero-based indexing.** The programs use ``HIPSPARSE_INDEX_BASE_ZERO``, so CSR row pointers and column indices start at 0, matching the cuSPARSE samples. The Fortran host arrays that hold them are ordinary 1-based arrays whose *values* are 0-based. * **Two API generations.** The generic API (SpMV, SpMM, SDDMM, SpSV, SpSM) wraps the operands in matrix/vector descriptors (``hipsparseCreateCsr``, ``hipsparseCreateDnMat``, ``hipsparseCreateDnVec``) and runs in stages: query a workspace size, optionally preprocess/analyze, then compute. The older level-2/level-3 API (``csrsv2``, ``csrilu02``, ``gemvi``) uses an info handle and a matrix descriptor (``hipsparseCreateMatDescr``). * **Zero-size buffers.** When a workspace query returns 0, pass a null pointer, not an allocated one: hipSPARSE returns ``HIPSPARSE_STATUS_INVALID_VALUE`` if a non-null buffer is supplied for a zero-size workspace. The programs allocate the buffer only when the queried size is positive. * **Every call returns a status code.** The programs wrap hipSPARSE calls in ``hipsparseCheck`` and HIP calls in ``hipCheck`` from the ``hipfort_check`` module, both of which abort on failure. Building and running ==================== The programs only need the ``hipsparse`` and ``hip`` hipFORT components: .. code-block:: cmake find_package(hipfort REQUIRED COMPONENTS hip hipsparse) add_executable(my_sparse hipsparse_dspmv.f08) target_link_libraries(my_sparse PRIVATE hipfort::hipsparse hipfort::hip) See :doc:`../how-to/using-hipfort` for the full set of build options. Sparse matrix-vector and matrix-matrix products =============================================== ``SpMV`` multiplies a sparse matrix by a dense vector, ``y = alpha*A*x + beta*y``, using the generic API: a CSR descriptor for ``A`` and dense-vector descriptors for ``x`` and ``y``, run through the ``SpMV_bufferSize`` and ``SpMV`` stages. .. literalinclude:: ../../test/f2008/hipsparse/hipsparse_dspmv.f08 :language: fortran ``SpMM`` multiplies a sparse matrix by a dense matrix, ``C = alpha*A*B + beta*C``, with dense-matrix descriptors for ``B`` and ``C``. .. literalinclude:: ../../test/f2008/hipsparse/hipsparse_dspmm.f08 :language: fortran Sampled dense-dense matrix multiplication ========================================= ``SDDMM`` is the transpose of the SpMM data flow: the dense product ``A*B`` is evaluated only at the nonzero positions of a sparse ``C``, giving ``C = alpha * (A*B) .* spy(C) + beta*C``. The program uses dense descriptors for ``A`` and ``B``, a CSR descriptor for ``C``, and the three ``SDDMM_bufferSize`` / ``SDDMM_preprocess`` / ``SDDMM`` stages. .. literalinclude:: ../../test/f2008/hipsparse/hipsparse_dsddmm.f08 :language: fortran Sparse triangular solves ======================== The generic ``SpSV`` solves a sparse triangular system for a single right-hand side, and ``SpSM`` solves it for several right-hand sides at once. Both add an analysis stage between the buffer-size query and the solve. .. literalinclude:: ../../test/f2008/hipsparse/hipsparse_dsptrsv.f08 :language: fortran .. literalinclude:: ../../test/f2008/hipsparse/hipsparse_dsptrsm.f08 :language: fortran The older ``csrsv2`` triangular solve uses the info-handle API instead: create a matrix descriptor and a ``csrsv2`` info object, query the buffer size, run the analysis phase, then solve. .. literalinclude:: ../../test/f2008/hipsparse/hipsparse_dcsrsv2.f08 :language: fortran Sparse matrix-matrix multiplication =================================== ``csrgemm`` multiplies two sparse matrices, ``C = alpha*A*B``. Because the sparsity pattern of ``C`` is not known in advance, the routine runs in two passes: ``nnz`` first computes the number of nonzeros and the row pointers of ``C``, then the values pass fills the columns and values. .. literalinclude:: ../../test/f2008/hipsparse/hipsparse_dcsrgemm.f08 :language: fortran Incomplete-LU preconditioner ============================ ``csrilu02`` computes an incomplete LU factorization with zero fill-in, used as a preconditioner. It follows the info-handle pattern: a buffer-size query, an analysis phase that inspects the pattern, and the factorization itself, with a zero-pivot query to detect breakdown. .. literalinclude:: ../../test/f2008/hipsparse/hipsparse_dcsrilu02.f08 :language: fortran Tridiagonal solver ================== ``gtsv`` solves a tridiagonal system given its three diagonals. It is a direct banded solver rather than an iterative one. .. literalinclude:: ../../test/f2008/hipsparse/hipsparse_sgtsv.f08 :language: fortran Sparse vector operations ======================== ``gthr`` gathers the entries of a dense vector ``y`` at a set of indices into a compact sparse vector ``x_val``, and ``sctr`` scatters a sparse vector back into a dense one. They are the pack/unpack pair for the sparse-vector format. .. literalinclude:: ../../test/f2008/hipsparse/hipsparse_dgthr.f08 :language: fortran .. literalinclude:: ../../test/f2008/hipsparse/hipsparse_dsctr.f08 :language: fortran ``gemvi`` multiplies a dense matrix by a sparse vector, ``y = alpha*A*x + beta*y``, sizing its workspace with a ``gemvi_bufferSize`` query. .. literalinclude:: ../../test/f2008/hipsparse/hipsparse_dgemvi.f08 :language: fortran Format conversions ================== hipSPARSE converts between the sparse formats. ``csr2csc`` converts CSR to CSC, which is equivalent to transposing the sparse matrix. .. literalinclude:: ../../test/f2008/hipsparse/hipsparse_dcsr2csc.f08 :language: fortran ``csr2coo`` and ``coo2csr`` convert between the CSR row-pointer array and the COO row-index array, the compressed and expanded forms of the same row information. These are index-only conversions, so they have a single ``X`` (type-agnostic) entry point rather than one per precision. .. literalinclude:: ../../test/f2008/hipsparse/hipsparse_xcsr2coo.f08 :language: fortran .. literalinclude:: ../../test/f2008/hipsparse/hipsparse_xcoo2csr.f08 :language: fortran hipfort-rocm-10.0.0/docs/tutorials/rocfft-examples.rst000066400000000000000000000254711524740623400230300ustar00rootroot00000000000000.. meta:: :description: rocFFT examples written with the hipFORT Fortran interfaces :keywords: hipFORT, ROCm, rocFFT, FFT, Fortran, examples, tutorials *************** rocFFT examples *************** `rocFFT `_ is the AMD implementation of the fast Fourier transform for AMD GPUs. hipFORT exposes it through the ``hipfort_rocfft`` module, which mirrors the rocFFT C API one to one. Every program on this page is complete and self-contained, and is built and run as part of the hipFORT test suite. The Fortran 2008 sources live in ``test/f2008/rocfft`` and the equivalent Fortran 2003 sources, which use ``type(c_ptr)`` device pointers and explicit byte counts instead of Fortran array pointers, live in ``test/f2003/rocfft``. hipFFT offers the same functionality through an API that follows cuFFT; see the :doc:`hipFFT examples ` or, for FFTW3-compatible code, the :doc:`hipFFTW examples `. Most of the programs are Fortran counterparts of the C++ samples shipped with rocFFT in ``clients/samples/rocfft``: .. list-table:: :header-rows: 1 :widths: 45 55 * - rocFFT sample - hipFORT program * - ``rocfft_example_complexcomplex.cpp`` - `Complex-to-complex transform`_, `Out-of-place transforms`_, `Managing the work buffer`_ * - ``rocfft_example_realcomplex.cpp`` - `Real-to-complex and complex-to-real transforms`_, `In-place real transforms`_ * - ``rocfft_example_set_stream.cpp`` - `Running on HIP streams`_ * - ``rocfft_example_callback.cpp`` - `Callbacks`_, in part: registering a callback needs the address of a device function, which Fortran cannot take. The remaining programs cover material from the rocFFT how-to guides: `Normalizing with a scale factor`_, `Inspecting a plan`_ and `Reusing compiled kernels`_. Two areas have no Fortran counterpart. Distributed transforms, which the ``clients/samples/multi_gpu`` sample demonstrates, are built on the rocFFT field and brick API that is still an experimental preview, and MPI transforms need a rocFFT built with MPI support. The hipFORT interfaces for both (``rocfft_field_create``, ``rocfft_brick_create``, ``rocfft_plan_description_set_comm`` and friends) are generated and callable, but they are not exercised by the test suite. Transform workflow ================== A rocFFT transform always follows the same sequence: #. Call ``rocfft_setup`` once before any other rocFFT call. #. Optionally create a plan description with ``rocfft_plan_description_create`` to set a data layout, a scale factor, or other advanced properties. #. Create a plan with ``rocfft_plan_create``, passing the placement (in-place or not), the transform type, the precision, the rank, the transform lengths, and the batch size. #. Optionally create an execution info handle with ``rocfft_execution_info_create`` to supply a HIP stream or a work buffer. #. Run the transform with ``rocfft_execute``. #. Release the plan with ``rocfft_plan_destroy`` and call ``rocfft_cleanup`` when the application is done with rocFFT. Keep the following conventions in mind: * rocFFT transforms are **unnormalized**. A forward transform followed by an inverse transform of length ``N`` returns ``N`` times the original data, unless a scale factor is attached to one of the plans. * The ``lengths`` array passed to ``rocfft_plan_create`` starts with the fastest-varying dimension, which matches Fortran's column-major storage: for an ``Nx`` by ``Ny`` transform, ``lengths = [Nx, Ny]``. * Real forward transforms produce Hermitian-symmetric output, so only ``N/2 + 1`` complex values are stored. Size the complex buffer accordingly. * ``rocfft_execute`` takes *arrays* of buffer pointers. In Fortran you pass a ``type(c_ptr)`` expression, such as ``c_loc(dx)``, and the compiler passes its address. For in-place transforms the output argument is ``c_null_ptr``. * Every rocFFT call returns a status code. The programs wrap them in ``rocfftCheck`` from the ``hipfort_check`` module, which aborts on failure. Building and running ==================== The programs only need the ``rocfft`` and ``hip`` hipFORT components: .. code-block:: cmake find_package(hipfort REQUIRED COMPONENTS hip rocfft) add_executable(my_fft rocfft_c2c_1d_z.f08) target_link_libraries(my_fft PRIVATE hipfort::rocfft hipfort::hip) See :doc:`../how-to/using-hipfort` for the full set of build options. Complex-to-complex transform ============================ The simplest case: an in-place, single-batch, one-dimensional complex-to-complex transform in double precision. The program runs a forward transform followed by an inverse transform and checks that the result is ``N`` times the input, which demonstrates that rocFFT does not normalize. .. literalinclude:: ../../test/f2008/rocfft/rocfft_c2c_1d_z.f08 :language: fortran Use ``rocfft_precision_single`` and ``complex(4)`` host data for a single precision transform, as in ``test/f2008/rocfft/rocfft_c2c_1d_c.f08``. Real-to-complex and complex-to-real transforms ============================================== Real transforms use ``rocfft_transform_type_real_forward`` and ``rocfft_transform_type_real_inverse``. Because the spectrum of real data is Hermitian symmetric, the complex buffer holds ``N/2 + 1`` elements. .. literalinclude:: ../../test/f2008/rocfft/rocfft_r2c_c2r_1d_d.f08 :language: fortran In-place real transforms ======================== An in-place real transform reads real values and writes ``N/2 + 1`` complex values into the same allocation, so the real buffer must be padded to ``2*(N/2 + 1)`` reals: two extra reals in the contiguous dimension. The input and output array types are declared on a plan description with ``rocfft_plan_description_set_data_layout``. .. literalinclude:: ../../test/f2008/rocfft/rocfft_r2c_c2r_1d_inplace_d.f08 :language: fortran Multi-dimensional transforms ============================ A multi-dimensional transform only differs in the rank argument and the number of entries in the ``lengths`` array. The first entry is the fastest-varying dimension. .. literalinclude:: ../../test/f2008/rocfft/rocfft_c2c_2d_z.f08 :language: fortran ``test/f2008/rocfft/rocfft_c2c_3d_z.f08`` extends the same pattern to three dimensions. Batched transforms ================== To transform many signals with one plan, pass the batch count as the ``number_of_transforms`` argument and describe the memory layout with ``rocfft_plan_description_set_data_layout``. The distance argument gives the number of elements between the start of consecutive signals. .. literalinclude:: ../../test/f2008/rocfft/rocfft_c2c_1d_batched_z.f08 :language: fortran Out-of-place transforms ======================= With ``rocfft_placement_notinplace``, the result is written to a separate buffer that is passed as the third argument of ``rocfft_execute``. Note that rocFFT is allowed to overwrite the input buffer of an out-of-place transform, so do not rely on its contents afterwards. .. literalinclude:: ../../test/f2008/rocfft/rocfft_c2c_1d_notinplace_z.f08 :language: fortran Normalizing with a scale factor =============================== Instead of scaling the result with a separate kernel, attach a scale factor to a plan description. rocFFT multiplies every output element by that factor, so a factor of ``1/N`` on the inverse plan makes the round trip reproduce the input. .. literalinclude:: ../../test/f2008/rocfft/rocfft_scale_factor_z.f08 :language: fortran Managing the work buffer ======================== Large transforms need scratch memory. rocFFT allocates and frees it on every ``rocfft_execute`` call unless the application provides a buffer. Query the requirement with ``rocfft_plan_get_work_buffer_size`` and hand a buffer over with ``rocfft_execution_info_set_work_buffer`` to control its lifetime or to share one allocation between several plans. .. literalinclude:: ../../test/f2008/rocfft/rocfft_work_buffer_z.f08 :language: fortran Running on HIP streams ====================== By default rocFFT executes on the null stream. Associate an application-owned stream with an execution info handle to overlap independent transforms. The handle must be passed to every ``rocfft_execute`` call that should use the stream, and each stream has to be synchronized before its results are read back. This program runs two independent transforms on two streams. .. literalinclude:: ../../test/f2008/rocfft/rocfft_stream_z.f08 :language: fortran Callbacks ========= A load callback runs on every element rocFFT reads and a store callback on every element it writes, which folds pre- and post-processing into the transform. Both are registered on an execution info handle with ``rocfft_execution_info_set_load_callback`` and ``rocfft_execution_info_set_store_callback``, and both are given as arrays with one function pointer per brick of the field. A null array selects the default behaviour, a plain load or store, and clears any previous registration. ``shared_mem_bytes`` must be 0, since rocFFT allocates no shared memory for callbacks. The callback functions themselves have to be device functions, so a Fortran program can only use the default callbacks. .. literalinclude:: ../../test/f2008/rocfft/rocfft_callback_z.f08 :language: fortran Inspecting a plan ================= ``rocfft_plan_get_print`` writes a summary of a plan to stdout: the precision, the transform type, the placement, the array types, and the strides, offsets and distances that rocFFT derived from the plan description. It is the quickest way to confirm that a layout was described as intended. The call writes from C, so flush the Fortran output unit first to keep both streams in order. .. literalinclude:: ../../test/f2008/rocfft/rocfft_plan_print_z.f08 :language: fortran Reusing compiled kernels ======================== rocFFT ships kernels for common problems and compiles the rest when a plan is created. Those runtime-compiled kernels are cached in memory for the lifetime of the process. ``rocfft_cache_serialize`` copies the cache into a buffer that rocFFT allocates, which the application can store and hand to ``rocfft_cache_deserialize`` in a later process to avoid compiling the same kernels again. Release the buffer with ``rocfft_cache_buffer_free``. .. literalinclude:: ../../test/f2008/rocfft/rocfft_cache_z.f08 :language: fortran Setting the ``ROCFFT_RTC_CACHE_PATH`` environment variable to a writable file achieves the same result without any application code: rocFFT then persists compiled kernels there by itself. Querying the rocFFT version =========================== ``rocfft_get_version_string`` fills a C string buffer of at least 30 characters. Pass the address of the first element of a ``character(kind=c_char)`` array and the buffer capacity, then copy the result up to the terminating NUL. .. literalinclude:: ../../test/f2008/rocfft/rocfft_version.f08 :language: fortran hipfort-rocm-10.0.0/docs/tutorials/rocsolver-examples.rst000066400000000000000000000237571524740623400235700ustar00rootroot00000000000000.. meta:: :description: rocSOLVER examples written with the hipFORT Fortran interfaces :keywords: hipFORT, ROCm, rocSOLVER, LAPACK, Fortran, examples, tutorials ****************** rocSOLVER examples ****************** `rocSOLVER `_ is the AMD implementation of LAPACK for AMD GPUs. hipFORT exposes it through the ``hipfort_rocsolver`` module, which mirrors the rocSOLVER C API one to one. rocSOLVER is built on rocBLAS and reuses its handle type, so every program also uses the ``hipfort_rocblas`` module for ``rocblas_create_handle`` and the ``rocblas_*`` enumerators. Every program on this page is complete and self-contained, and is built and run as part of the hipFORT test suite. The Fortran 2008 sources live in ``test/f2008/rocsolver`` and the equivalent Fortran 2003 sources, which use ``type(c_ptr)`` device pointers and explicit byte counts instead of Fortran array pointers, live in ``test/f2003/rocsolver``. hipSOLVER offers the same functionality through an API that follows cuSOLVER; see the :doc:`hipSOLVER examples `. Each routine is provided in the four LAPACK precisions where it has them: ``s`` (real single), ``d`` (real double), ``c`` (complex single), and ``z`` (complex double). This page shows the double-precision program of each group; the other precisions differ only in the host data type and the ``rocsolver_`` prefix letter. Conventions =========== rocSOLVER follows a small number of conventions that recur in every program: * **Column-major storage.** rocSOLVER matrices are column-major, which matches Fortran's native array layout, so a Fortran 2-D array maps directly onto a rocSOLVER matrix with leading dimension ``lda = size(A, 1)``. * **The** ``info`` **output lives in device memory.** rocSOLVER writes the factorization status ``info`` to a *device* pointer, so the hipFORT binding types that argument as ``type(c_ptr)``. Back it with a device allocation and pass ``c_loc(dInfo)``; passing a host scalar faults on the GPU. For the batched routines ``info`` is an array of ``batch_count`` integers on the device. * **Pivots and scalar factors are device arrays.** Arguments such as ``ipiv`` (pivot indices) and ``tau`` (Householder scalars) are outputs written on the device and are passed as device buffers. * **rocBLAS enumerators select variants.** ``rocblas_operation_none`` / ``rocblas_operation_transpose`` choose whether a routine works on ``A`` or ``A**T``; ``rocblas_fill_upper`` / ``rocblas_fill_lower`` choose the stored triangle; ``rocblas_evect_*`` and ``rocblas_svect_*`` choose whether vectors are computed. * **Every call returns a status code.** The ``hipfort_check`` module provides ``hipCheck`` for HIP calls and ``rocsolverCheck`` for rocSOLVER calls; both abort on failure. Most of the programs below route rocSOLVER status codes through ``hipCheck`` as well. That works because both status enumerations use ``0`` for success, but prefer ``rocsolverCheck`` in new code so that a failure is reported as a rocSOLVER error rather than a HIP one. Building and running ==================== The programs need the ``rocsolver``, ``rocblas``, and ``hip`` hipFORT components: .. code-block:: cmake find_package(hipfort REQUIRED COMPONENTS hip rocblas rocsolver) add_executable(my_solver rocsolver_dgetrf.f08) target_link_libraries(my_solver PRIVATE hipfort::rocsolver hipfort::rocblas hipfort::hip) See :doc:`../how-to/using-hipfort` for the full set of build options. LU factorization and solve ========================== ``getrf`` computes the LU factorization ``A = P*L*U`` with partial pivoting, writing the factors in place over ``A`` and the pivot indices into ``ipiv``. The program factorizes a matrix and reconstructs ``L*U`` to confirm the result. .. literalinclude:: ../../test/f2008/rocsolver/rocsolver_dgetrf.f08 :language: fortran ``getrs`` uses the factors and pivots from ``getrf`` to solve ``A*X = B``. The program picks a known solution ``x``, forms ``b = A*x``, factorizes, solves, and checks that the recovered ``X`` matches ``x``. .. literalinclude:: ../../test/f2008/rocsolver/rocsolver_dgetrs.f08 :language: fortran The ``getrf_npvt`` variant factorizes without pivoting (valid when no row interchanges are needed, as for a diagonally dominant matrix), and ``getf2`` is the unblocked kernel with the same interface. See ``test/f2008/rocsolver/rocsolver_dgetrf_npvt.f08`` and ``rocsolver_dgetf2.f08``. Batched LU ========== rocSOLVER factorizes many matrices with one call in two forms. The *array-of-pointers* form, ``getrf_batched``, takes ``A`` as a device array of per-matrix device pointers, and ``ipiv`` and ``info`` as device arrays indexed by batch. .. literalinclude:: ../../test/f2008/rocsolver/rocsolver_dgetrf_batched.f08 :language: fortran The *strided-batched* form, ``getrf_strided_batched``, instead stores the matrices contiguously in one device buffer and locates each by a fixed stride, which avoids building a pointer array. See ``test/f2008/rocsolver/rocsolver_dgetrf_strided_batched.f08``. The 64-bit integer API ====================== The ``_64`` routines accept 64-bit problem dimensions, pivots, and ``info`` for problems that exceed the 32-bit range. ``getrf_64`` performs the same factorization as ``getrf`` with ``integer(c_int64_t)`` dimensions; the device buffers, including the int64 ``ipiv`` and ``info``, are passed as ``type(c_ptr)`` because the ``_64`` routines have no native-array overloads. .. literalinclude:: ../../test/f2008/rocsolver/rocsolver_dgetrf_64.f08 :language: fortran Cholesky factorization and solve ================================ ``potrf`` computes the Cholesky factorization of a symmetric (or Hermitian) positive-definite matrix, writing the factor into the triangle chosen by the fill mode. The program uses ``rocblas_fill_upper`` and checks the factor against the known Cholesky root. .. literalinclude:: ../../test/f2008/rocsolver/rocsolver_dpotrf.f08 :language: fortran ``potrs`` solves ``A*X = B`` from a ``potrf`` factorization, and ``posv`` combines the factorization and the solve in a single call. See ``test/f2008/rocsolver/rocsolver_dpotrs.f08`` and ``rocsolver_dposv.f08``. QR factorization ================ ``geqrf`` computes ``A = Q*R``, storing ``R`` in the upper triangle of ``A`` and the Householder vectors that represent ``Q`` below it, with their scalar factors in ``ipiv``/``tau``. .. literalinclude:: ../../test/f2008/rocsolver/rocsolver_dgeqrf.f08 :language: fortran ``Q`` is never formed explicitly by ``geqrf``. Two follow-on routines use its compact representation: ``orgqr`` (``ungqr`` for complex) generates the explicit orthogonal matrix ``Q``, and ``ormqr`` (``unmqr`` for complex) multiplies a given matrix by ``Q`` or ``Q**T`` without forming it. See ``test/f2008/rocsolver/rocsolver_dorgqr.f08`` and ``rocsolver_dormqr.f08``. Linear least squares ==================== ``gels`` solves the least-squares problem ``min || A*X - B ||`` (or the minimum-norm problem for underdetermined systems) using a QR or LQ factorization. The program solves a square nonsingular system and confirms the overwritten ``B`` recovers the known solution. .. literalinclude:: ../../test/f2008/rocsolver/rocsolver_dgels.f08 :language: fortran Symmetric eigenvalues ===================== ``syev`` (``heev`` for Hermitian matrices) computes the eigenvalues, and optionally the eigenvectors, of a symmetric matrix. The ``rocblas_evect_none``/``rocblas_evect_original`` argument selects whether eigenvectors are produced; the program requests eigenvalues only. .. literalinclude:: ../../test/f2008/rocsolver/rocsolver_dsyev.f08 :language: fortran ``syevd``/``heevd`` solve the same problem with a divide-and-conquer algorithm, and ``syevj``/``heevj`` with a Jacobi algorithm. See ``test/f2008/rocsolver/rocsolver_dsyevd.f08`` and ``rocsolver_dsyevj.f08``. Singular value decomposition ============================ ``gesvd`` computes the singular value decomposition ``A = U*S*V**T``. The ``rocblas_svect_*`` arguments choose which of the singular-vector matrices are computed. The program requests all vectors and reconstructs ``A`` from the factors (rocSOLVER returns ``V**T``). .. literalinclude:: ../../test/f2008/rocsolver/rocsolver_dgesvd.f08 :language: fortran ``gesvdj`` computes the same decomposition with a Jacobi algorithm, which is often faster for small matrices. See ``test/f2008/rocsolver/rocsolver_dgesvdj.f08``. Symmetric indefinite factorization ================================== ``sytrf`` computes the Bunch-Kaufman factorization of a symmetric indefinite matrix, and ``sytrs`` uses that factorization to solve ``A*X = B``. The program factorizes with ``rocblas_fill_upper`` and checks the recovered solution. .. literalinclude:: ../../test/f2008/rocsolver/rocsolver_dsytrs.f08 :language: fortran Triangular inverse ================== ``trtri`` inverts a triangular matrix in place. The program inverts an upper-triangular matrix and checks ``U * U^-1 == I``. .. literalinclude:: ../../test/f2008/rocsolver/rocsolver_dtrtri.f08 :language: fortran Reductions to condensed form ============================ Several rocSOLVER routines reduce a matrix to a condensed form used inside the eigenvalue and SVD algorithms. ``getrf`` aside, these are lower-level building blocks: * ``gebrd`` reduces a general matrix to bidiagonal form. * ``sytrd`` reduces a symmetric matrix to tridiagonal form, and ``latrd`` reduces a leading block of it. * ``sterf`` computes the eigenvalues of a symmetric tridiagonal matrix, and ``steqr``/``stedc`` compute its eigenvalues and eigenvectors. * ``larft`` forms the triangular factor of a block of Householder reflectors. .. literalinclude:: ../../test/f2008/rocsolver/rocsolver_dgebrd.f08 :language: fortran The tridiagonal eigenvalue solver ``sterf`` takes only the diagonal and off-diagonal of the tridiagonal matrix: .. literalinclude:: ../../test/f2008/rocsolver/rocsolver_dsterf.f08 :language: fortran See ``test/f2008/rocsolver`` for the ``sytrd``, ``latrd``, ``steqr``, ``stedc``, and ``larft`` programs. hipfort-rocm-10.0.0/docs/tutorials/rocsparse-examples.rst000066400000000000000000000231741524740623400235440ustar00rootroot00000000000000.. meta:: :description: rocSPARSE examples written with the hipFORT Fortran interfaces :keywords: hipFORT, ROCm, rocSPARSE, sparse, Fortran, examples, tutorials ****************** rocSPARSE examples ****************** `rocSPARSE `_ is the AMD implementation of sparse linear algebra for AMD GPUs. hipFORT exposes it through the ``hipfort_rocsparse`` module, which mirrors the rocSPARSE C API one to one. rocSPARSE reuses the rocBLAS handle type, so the programs that create a handle call ``rocsparse_create_handle`` from the same module. Every program on this page is complete and self-contained, and is built and run as part of the hipFORT test suite. The Fortran 2008 sources live in ``test/f2008/rocsparse`` and the equivalent Fortran 2003 sources, which use ``type(c_ptr)`` device pointers and explicit byte counts instead of Fortran array pointers, live in ``test/f2003/rocsparse``. hipSPARSE offers the same functionality through an API that follows cuSPARSE; see the :doc:`hipSPARSE examples `. Where a routine has the four precisions, a program is provided for each: ``s`` (real single), ``d`` (real double), ``c`` (complex single), and ``z`` (complex double). This page shows the double-precision program of each group; the other precisions differ only in the host data type and the ``rocsparse_`` prefix letter. Conventions =========== rocSPARSE follows a small number of conventions that recur in every program: * **Sparse matrix formats.** Most programs store the sparse matrix in CSR (compressed sparse row): a row-pointer array, a column-index array, and a values array. Block variants use BSR, and a few routines take COO (coordinate) row/column arrays. * **Zero-based indexing.** The programs use ``rocsparse_index_base_zero``, so CSR row pointers and column indices start at 0, matching the C samples. The Fortran host arrays that hold them are ordinary 1-based arrays whose *values* are 0-based. * **The generic API is descriptor- and stage-based.** The newer routines (SpMV, SpMM, SDDMM, SpSV, SpSM) wrap the operands in matrix/vector descriptors (``rocsparse_create_csr_descr``, ``rocsparse_create_dnmat_descr``, ``rocsparse_create_dnvec_descr``) and run in stages: query a workspace size, optionally preprocess/analyze, then compute. The descriptor constructors are ``c_ptr``-only (no array overloads), so device buffers are passed via ``c_loc(...)`` even in the Fortran 2008 programs. * **Scalars.** ``alpha`` and ``beta`` are passed by address (``c_loc(alpha)``) in the generic API, and as host scalars by reference in the older level-2/level-3 routines such as ``bsrmv`` and ``gemvi``. * **Every call returns a status code.** The programs wrap rocSPARSE calls in ``rocsparseCheck`` and HIP calls in ``hipCheck`` from the ``hipfort_check`` module, both of which abort on failure. Building and running ==================== The programs need the ``rocsparse``, ``rocblas``, and ``hip`` hipFORT components: .. code-block:: cmake find_package(hipfort REQUIRED COMPONENTS hip rocblas rocsparse) add_executable(my_sparse rocsparse_dspmv.f08) target_link_libraries(my_sparse PRIVATE hipfort::rocsparse hipfort::rocblas hipfort::hip) See :doc:`../how-to/using-hipfort` for the full set of build options. Sparse matrix-vector and matrix-matrix products =============================================== ``spmv`` multiplies a sparse matrix by a dense vector, ``y = alpha*A*x + beta*y``, using the generic API: a CSR descriptor for ``A`` and dense-vector descriptors for ``x`` and ``y``, run through the ``buffer_size`` and ``compute`` stages. .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_dspmv.f08 :language: fortran ``spmm`` multiplies a sparse matrix by a dense matrix, ``C = alpha*A*B + beta*C``, with dense-matrix descriptors for ``B`` and ``C`` and the three ``buffer_size`` / ``preprocess`` / ``compute`` stages. .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_dspmm.f08 :language: fortran Sampled dense-dense matrix multiplication ========================================= ``sddmm`` is the transpose of the SpMM data flow: the dense product ``A*B`` is evaluated only at the nonzero positions of a sparse ``C``, giving ``C = alpha * (A*B) .* spy(C) + beta*C``. It is the core primitive behind attention and graph-neural-network kernels. The program uses dense descriptors for ``A`` and ``B``, a CSR descriptor for ``C``, and the three sddmm stages. .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_dsddmm.f08 :language: fortran rocSPARSE also supports a batched SDDMM: the dense operands are strided-batched with ``rocsparse_dnmat_set_strided_batch`` and the sparse ``C`` shares one sparsity pattern across the batch with ``rocsparse_csr_set_strided_batch``. .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_dsddmm_batched.f08 :language: fortran Sparse triangular solves ======================== ``sptrsv`` solves a sparse triangular system ``op(A)*y = alpha*x`` for a single right-hand side. The generic API adds an analysis stage between the buffer-size query and the solve, which inspects the sparsity pattern once and can be reused. .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_dsptrsv.f08 :language: fortran ``sptrsm`` solves the same kind of system with several right-hand sides at once, taking a dense-matrix descriptor for the right-hand sides. .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_dsptrsm.f08 :language: fortran Sparse matrix arithmetic ======================== ``csrgemm`` multiplies two sparse matrices, ``C = alpha*A*B``. Because the sparsity pattern of ``C`` is not known in advance, the routine runs in two passes: ``nnz`` first computes the number of nonzeros and the row pointers of ``C``, then the values pass fills the columns and values. .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_dcsrgemm.f08 :language: fortran ``csrgeam`` adds two sparse matrices, ``C = alpha*A + beta*B``, with the same two-pass structure. .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_dcsrgeam.f08 :language: fortran Block-sparse matrix-vector products =================================== ``bsrmv`` multiplies a matrix stored in BSR (block sparse row) format by a dense vector. BSR groups the nonzeros into fixed-size dense blocks, which suits matrices with a natural block structure. The routine takes a matrix descriptor and a matrix-info handle. .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_dbsrmv.f08 :language: fortran ``gebsrmv`` is the general variant, allowing rectangular blocks with separate row and column block dimensions. .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_dgebsrmv.f08 :language: fortran Incomplete factorization preconditioners ======================================== Incomplete factorizations produce approximate factors that keep the sparsity of the input and are used as preconditioners. Each runs an analysis stage before the compute stage. ``csrilu0`` computes an incomplete LU factorization with zero fill-in; on a matrix with no fill-in (such as a tridiagonal one) it reproduces the exact LU, which the program checks. .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_dcsrilu0.f08 :language: fortran ``csric0`` is the incomplete Cholesky counterpart for a symmetric positive definite matrix. .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_dcsric0.f08 :language: fortran ``spildlt0`` computes an incomplete LDL\ :sup:`H` factorization through the generic descriptor API, with descriptor-create, set-input, analysis and compute stages, and a get-output query for the singularity status. .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_spildlt0.f08 :language: fortran Tridiagonal and pentadiagonal solvers ===================================== ``gtsv`` solves a tridiagonal system given its three diagonals. It is a direct banded solver rather than an iterative one. .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_sgtsv.f08 :language: fortran ``gpsv_interleaved_batch`` solves a batch of pentadiagonal systems whose data is interleaved across the batch, a layout that lets the GPU coalesce memory access across the independent systems. .. literalinclude:: ../../test/f2008/rocsparse/zgpsv_interleaved_batch.f08 :language: fortran Sparse vector operations ======================== ``gthr`` gathers the entries of a dense vector ``y`` at a set of indices into a compact sparse vector ``x_val``, and ``sctr`` scatters a sparse vector back into a dense one. They are the pack/unpack pair for the sparse-vector format. .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_dgthr.f08 :language: fortran .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_dsctr.f08 :language: fortran ``doti`` computes the dot product of a sparse vector with a dense one, and ``gemvi`` multiplies a dense matrix by a sparse vector, ``y = alpha*A*x + beta*y``. .. literalinclude:: ../../test/f2008/rocsparse/ddoti.f08 :language: fortran .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_dgemvi.f08 :language: fortran Format conversions ================== rocSPARSE converts between the sparse formats. ``csr2csc`` converts CSR to CSC, which is equivalent to transposing the sparse matrix. .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_dcsr2csc.f08 :language: fortran ``csr2coo`` and ``coo2csr`` convert between the CSR row-pointer array and the COO row-index array, the compressed and expanded forms of the same row information. .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_csr2coo.f08 :language: fortran .. literalinclude:: ../../test/f2008/rocsparse/rocsparse_coo2csr.f08 :language: fortran hipfort-rocm-10.0.0/lib/000077500000000000000000000000001524740623400147565ustar00rootroot00000000000000hipfort-rocm-10.0.0/lib/CMakeLists.txt000066400000000000000000000467251524740623400175340ustar00rootroot00000000000000# Copyright (c) 2020-2026 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. file(GLOB HIPFORT_SRC_HIP_F90 "${CMAKE_CURRENT_SOURCE_DIR}/hipfort/*.f90") file(GLOB HIPFORT_SRC_HIP_F90_UPPER "${CMAKE_CURRENT_SOURCE_DIR}/hipfort/*.F90") set(HIPFORT_SRC_HIP ${HIPFORT_SRC_HIP_F90} ${HIPFORT_SRC_HIP_F90_UPPER}) # Partition the sources by backend so each archive only carries what its backend # can actually resolve: # * the roc* API modules (rocBLAS/rocSOLVER/rocSPARSE/rocFFT/rocRAND) wrap # AMD-only libraries with no CUDA equivalent -> amdgcn only. Compiling them for # nvptx just adds unresolvable roc* symbols to the archive. Their *_enums # modules are kept in both backends: they carry only `enum, bind(c)` constants # (no external symbols) and hipfort_check uses the roc*_status enums for its # error-check helpers regardless of backend. # * hipfort_cuda_errors (the cudaError_t enum) is only used under USE_CUDA_NAMES # -> nvptx only. On amdgcn every `use hipfort_cuda_errors` is #ifdef'd out. # Everything else is common to both backends. set(HIPFORT_SRC_ROC "") foreach(_roclib rocblas rocsolver rocsparse rocfft rocrand) file(GLOB _rocfiles "${CMAKE_CURRENT_SOURCE_DIR}/hipfort/hipfort_${_roclib}.[fF]90") # API module only, not *_enums list(APPEND HIPFORT_SRC_ROC ${_rocfiles}) endforeach() file(GLOB HIPFORT_SRC_CUDA_ERRORS "${CMAKE_CURRENT_SOURCE_DIR}/hipfort/hipfort_cuda_errors.[fF]90") set(HIPFORT_SRC_COMMON ${HIPFORT_SRC_HIP}) list(REMOVE_ITEM HIPFORT_SRC_COMMON ${HIPFORT_SRC_ROC} ${HIPFORT_SRC_CUDA_ERRORS}) set(HIPFORT_SRC_AMDGCN ${HIPFORT_SRC_COMMON} ${HIPFORT_SRC_ROC}) # + AMD-only roc* set(HIPFORT_SRC_NVPTX ${HIPFORT_SRC_COMMON} ${HIPFORT_SRC_CUDA_ERRORS}) # + CUDA-only cuda_errors # The Fortran 2008 array interfaces (USE_FPOINTER_INTERFACES) default ON whenever # the compiler supports Fortran 2008. Exposed as a cache option so it can be forced # OFF for an old compiler, or one whose F2008 support is buggy (e.g. some Intel # releases) — the library then builds with plain C-binding interfaces only. set(_hipfort_fpointer_default OFF) if(CMAKE_Fortran_COMPILER_SUPPORTS_F08) set(_hipfort_fpointer_default ON) endif() option(HIPFORT_USE_FPOINTER_INTERFACES "Enable the Fortran 2008 array interfaces" ${_hipfort_fpointer_default}) # The F2008 interfaces cannot be built on a compiler without F2008 support. FORCE # the cache so the effective value is consistent in the test/ subdirectory too. if(HIPFORT_USE_FPOINTER_INTERFACES AND NOT CMAKE_Fortran_COMPILER_SUPPORTS_F08) message(WARNING "HIPFORT_USE_FPOINTER_INTERFACES was requested but ${CMAKE_Fortran_COMPILER} " "does not support Fortran 2008; disabling it (plain C-binding build).") set(HIPFORT_USE_FPOINTER_INTERFACES OFF CACHE BOOL "Enable the Fortran 2008 array interfaces" FORCE) endif() # Experimental: replace the per-rank array interfaces (rank_0..rank_N + full_rank) # with a single Fortran 2018 assumed-rank (dimension(..)) specific per routine. # One overload then accepts an actual argument of any rank. Opt-in and nested in # USE_FPOINTER_INTERFACES (the two are mutually exclusive in each generic). # Requires a Fortran 2018 compiler. option(HIPFORT_ASSUMED_RANK "Use the F2018 assumed-rank array interfaces" OFF) # The CUDA backend is built even on ROCm-only builds; turn it off if unused. option(HIPFORT_BUILD_NVPTX "Build the CUDA (nvptx) backend archive" ON) # Guard the opt-in: assumed-rank is nested in the F2008 interfaces and additionally # needs a Fortran 2018 compiler (c_loc() of a dimension(..) argument; see the # CMAKE_Fortran_COMPILER_SUPPORTS_F18 probe in the top-level CMakeLists.txt). If it # was requested but either prerequisite is missing, warn and fall back to the # per-rank interfaces (or plain C bindings if those are off too) rather than # failing the build. FORCE the cache so test/ sees the same effective value. if(HIPFORT_ASSUMED_RANK AND NOT (HIPFORT_USE_FPOINTER_INTERFACES AND CMAKE_Fortran_COMPILER_SUPPORTS_F18)) message(WARNING "HIPFORT_ASSUMED_RANK was requested but the Fortran 2018 assumed-rank " "interfaces are unavailable (they need a Fortran 2018 compiler and the F2008 " "interfaces enabled); disabling the assumed-rank interfaces (the build falls " "back to the per-rank F2008 interfaces, or the plain F2003 C bindings if " "HIPFORT_USE_FPOINTER_INTERFACES is off).") set(HIPFORT_ASSUMED_RANK OFF CACHE BOOL "Use the F2018 assumed-rank array interfaces" FORCE) endif() set(HIPFORT_ARCH "amdgcn") # amdgcn set(HIPFORT_LIB "hipfort-${HIPFORT_ARCH}") set(CMAKE_Fortran_MODULE_DIRECTORY ${CMAKE_BINARY_DIR}/include/hipfort/${HIPFORT_ARCH}) ADD_LIBRARY(${HIPFORT_LIB} STATIC ${HIPFORT_SRC_AMDGCN} ) target_include_directories(${HIPFORT_LIB} PUBLIC $ ) IF(HIPFORT_USE_FPOINTER_INTERFACES) target_compile_definitions(${HIPFORT_LIB} PRIVATE USE_FPOINTER_INTERFACES) IF(HIPFORT_ASSUMED_RANK) target_compile_definitions(${HIPFORT_LIB} PRIVATE USE_ASSUMED_RANK_INTERFACES) ENDIF(HIPFORT_ASSUMED_RANK) ENDIF(HIPFORT_USE_FPOINTER_INTERFACES) target_compile_definitions(${HIPFORT_LIB} PRIVATE _HIPFORT_ARCH='${HIPFORT_ARCH}') # Install Target hipfort-amdgcn # CMAKE_INSTALL_LIBDIR/INCLUDEDIR already carry the toolchain-specific # subdirectory (see HIPFORT_MULTITOOLCHAIN_LAYOUT in the top-level # CMakeLists.txt), so they must not be suffixed with FORTRAN_LIBRARY_SUBDIR # again -- doing so nests the archive and mod files one level too deep # (e.g. lib/fortran//fortran/). rocm_install_targets( TARGETS ${HIPFORT_LIB} EXPORT hipfort-amdgcn-targets LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} INCLUDE ${CMAKE_Fortran_MODULE_DIRECTORY} ) if(HIPFORT_BUILD_NVPTX) set(HIPFORT_ARCH "nvptx") # nvptx set(HIPFORT_LIB "hipfort-${HIPFORT_ARCH}") set(CMAKE_Fortran_MODULE_DIRECTORY ${CMAKE_BINARY_DIR}/include/hipfort/${HIPFORT_ARCH}) ADD_LIBRARY(${HIPFORT_LIB} STATIC ${HIPFORT_SRC_NVPTX} ) IF(HIPFORT_USE_FPOINTER_INTERFACES) target_compile_definitions(${HIPFORT_LIB} PRIVATE USE_FPOINTER_INTERFACES) IF(HIPFORT_ASSUMED_RANK) target_compile_definitions(${HIPFORT_LIB} PRIVATE USE_ASSUMED_RANK_INTERFACES) ENDIF(HIPFORT_ASSUMED_RANK) ENDIF(HIPFORT_USE_FPOINTER_INTERFACES) target_compile_definitions(${HIPFORT_LIB} PRIVATE USE_CUDA_NAMES) target_compile_definitions(${HIPFORT_LIB} PRIVATE _HIPFORT_ARCH='${HIPFORT_ARCH}') # Install Target hipfort-nvptx rocm_install_targets( TARGETS ${HIPFORT_LIB} EXPORT hipfort-nvptx-targets LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} INCLUDE ${CMAKE_Fortran_MODULE_DIRECTORY} ) rocm_install( EXPORT hipfort-nvptx-targets FILE hipfort-nvptx-targets.cmake NAMESPACE hipfort:: DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/hipfort ) endif() # Install include files marking as devel component rocm_install(DIRECTORY ${CMAKE_BINARY_DIR}/include/hipfort DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} COMPONENT devel) rocm_install( EXPORT hipfort-amdgcn-targets FILE hipfort-amdgcn-targets.cmake NAMESPACE hipfort:: DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/hipfort ) set(HIPFORT_BASE_LIB hipfort-amdgcn) macro(hipfort_add_component name imported_target) add_library(hipfort-${name} INTERFACE) add_library(hipfort::${name} ALIAS hipfort-${name}) set_target_properties(hipfort-${name} PROPERTIES EXPORT_NAME ${name} ) target_link_libraries(hipfort-${name} INTERFACE ${HIPFORT_BASE_LIB} ${imported_target}) # The archive is shared by every component, so CMake orders it after the ROCm # .so files and --as-needed drops them. This dependency puts the archive first. target_link_libraries(${HIPFORT_BASE_LIB} INTERFACE "$") rocm_install( TARGETS hipfort-${name} EXPORT hipfort-${name}-targets LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} ) rocm_install( EXPORT hipfort-${name}-targets FILE hipfort-${name}-targets.cmake NAMESPACE hipfort:: DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/hipfort ) endmacro() find_package(hip PATHS ${ROCM_PATH}) find_package(CUDAToolkit QUIET) if(HIP_PLATFORM STREQUAL "amd") if(hip_FOUND) hipfort_add_component(hip hip::host) else() message(STATUS "Skipping hipfort::hip target export") endif() find_package(rocprofiler-sdk-roctx PATHS ${ROCM_PATH}) if(rocprofiler-sdk-roctx_FOUND) hipfort_add_component(roctx rocprofiler-sdk-roctx::rocprofiler-sdk-roctx) else() message(STATUS "Skipping hipfort::roctx target export") endif() find_package(rocblas PATHS ${ROCM_PATH}) if(rocblas_FOUND) hipfort_add_component(rocblas roc::rocblas) else() message(STATUS "Skipping hipfort::rocblas target export") endif() find_package(hipblas PATHS ${ROCM_PATH}) if(hipblas_FOUND) hipfort_add_component(hipblas roc::hipblas) else() message(STATUS "Skipping hipfort::hipblas target export") endif() find_package(rocfft PATHS ${ROCM_PATH}) if(rocfft_FOUND) hipfort_add_component(rocfft roc::rocfft) else() message(STATUS "Skipping hipfort::rocfft target export") endif() find_package(hipfft PATHS ${ROCM_PATH}) if(hipfft_FOUND) hipfort_add_component(hipfft hip::hipfft) # hipFFTW: the FFTW3-compatible API. In some ROCm versions its symbols live # in a separate libhipfftw (hip::hipfftw target); in others they are folded # into libhipfft. Prefer the dedicated target when present. if(TARGET hip::hipfftw) hipfort_add_component(hipfftw hip::hipfftw) else() hipfort_add_component(hipfftw hip::hipfft) endif() else() message(STATUS "Skipping hipfort::hipfft target export") endif() find_package(rocrand PATHS ${ROCM_PATH}) if(rocrand_FOUND) hipfort_add_component(rocrand roc::rocrand) else() message(STATUS "Skipping hipfort::rocrand target export") endif() find_package(hiprand PATHS ${ROCM_PATH}) if(hiprand_FOUND) hipfort_add_component(hiprand hip::hiprand) else() message(STATUS "Skipping hipfort::hiprand target export") endif() find_package(rocsolver PATHS ${ROCM_PATH}) if(rocsolver_FOUND) hipfort_add_component(rocsolver roc::rocsolver) else() message(STATUS "Skipping hipfort::rocsolver target export") endif() find_package(hipsolver PATHS ${ROCM_PATH}) if(hipsolver_FOUND) hipfort_add_component(hipsolver roc::hipsolver) else() message(STATUS "Skipping hipfort::hipsolver target export") endif() find_package(rocsparse PATHS ${ROCM_PATH}) if(rocsparse_FOUND) hipfort_add_component(rocsparse roc::rocsparse) else() message(STATUS "Skipping hipfort::rocsparse target export") endif() find_package(hipsparse PATHS ${ROCM_PATH}) if(hipsparse_FOUND) hipfort_add_component(hipsparse roc::hipsparse) else() message(STATUS "Skipping hipfort::hipsparse target export") endif() include(CMakePackageConfigHelpers) configure_package_config_file( hipfort-config.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/hipfort-config.cmake INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/hipfort NO_CHECK_REQUIRED_COMPONENTS_MACRO ) write_basic_package_version_file( ${CMAKE_CURRENT_BINARY_DIR}/hipfort-config-version.cmake VERSION "${HIPFORT_VERSION_MAJOR}.${HIPFORT_VERSION_MINOR}.${HIPFORT_VERSION_PATCH}" COMPATIBILITY SameMajorVersion ) rocm_install( FILES ${CMAKE_CURRENT_BINARY_DIR}/hipfort-config.cmake ${CMAKE_CURRENT_BINARY_DIR}/hipfort-config-version.cmake DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/hipfort ) # With the multitoolchain layout the package files above live under # lib/fortran//cmake/hipfort, which is not on CMake's default # find_package search path. Also install a compiler-agnostic shim at the # standard lib/cmake/hipfort so `find_package(hipfort)` succeeds from the # install prefix (e.g. /opt/rocm); at use time it forwards to the toolchain # subdirectory matching the consumer's Fortran compiler. The version file is # compiler-independent and installed alongside so version checks still work. if(HIPFORT_MULTITOOLCHAIN_LAYOUT) # Plain install() (not rocm_install) because rocm_install does not support # RENAME; the file is still packaged by CPACK. install( FILES ${CMAKE_CURRENT_SOURCE_DIR}/hipfort-config-shim.cmake RENAME hipfort-config.cmake DESTINATION lib/cmake/hipfort ) install( FILES ${CMAKE_CURRENT_BINARY_DIR}/hipfort-config-version.cmake DESTINATION lib/cmake/hipfort ) endif() elseif(CUDAToolkit_FOUND AND TARGET hipfort-nvptx) # Only the hip* components exist here; roc* and the FFTW3 API have no CUDA counterpart. set(HIPFORT_BASE_LIB hipfort-nvptx) foreach(pair "hip:cudart" "hipblas:cublas" "hipfft:cufft" "hiprand:curand" "hipsolver:cusolver" "hipsparse:cusparse") string(REPLACE ":" ";" pair "${pair}") list(GET pair 0 _comp) list(GET pair 1 _cudalib) if(TARGET CUDA::${_cudalib}) hipfort_add_component(${_comp} CUDA::${_cudalib}) else() message(STATUS "Skipping hipfort::${_comp} target export (no CUDA::${_cudalib})") endif() endforeach() endif() # --------------------------------------------------------------------------- # HIPFORT_EXTENDED_TESTS: verify each backend static archive links into a shared # library with every symbol resolved. Each test runs # $FC -fPIC -shared -Wl,--whole-archive libhipfort-.a -Wl,--no-whole-archive # -Wl,--no-undefined -L <-l deps> -o libhipfort-.so # and fails (non-zero exit) on any unresolved symbol. A backend's test is only # added when all of its runtime libraries are found, so this is a no-op without # the corresponding stack. Override the lib directories with HIPFORT_ROCM_LIB_DIR # / HIPFORT_CUDA_LIB_DIR (e.g. to point nvptx at a non-default CUDA toolkit). if(HIPFORT_EXTENDED_TESTS) # amdflang/LLVMFlang emits absolute R_X86_64_64 relocations for its derived-type # module descriptors (e.g. in the *_types modules) that its default linker, # ld.lld, refuses in a shared object — and -fPIC does not change them (a flang # codegen limitation). Allow text relocations so the shared-link check still # validates symbol resolution; the flag is accepted by both ld.lld and GNU ld. # gfortran + GNU ld links these archives without it. set(_shared_ldflags "") if(CMAKE_Fortran_COMPILER_ID STREQUAL "LLVMFlang" OR CMAKE_Fortran_COMPILER_ID STREQUAL "Flang") set(_shared_ldflags -Wl,-z,notext) endif() # ---- amdgcn: link against the ROCm runtime libraries ---- if(TARGET hipfort-amdgcn) set(_amd_dir "${HIPFORT_ROCM_LIB_DIR}") if(NOT _amd_dir) set(_amd_dir "${ROCM_PATH}/lib") endif() # NB: the HIP runtime is libamdhip64, not "libhip". set(_amd_libs hipfftw hipfft rocfft hipsolver rocsolver hipblas rocblas rocrand hiprand hipsparse rocsparse amdhip64) set(_amd_ok TRUE) set(_amd_missing "") foreach(_l IN LISTS _amd_libs) unset(_amd_lib_${_l} CACHE) find_library(_amd_lib_${_l} NAMES ${_l} HINTS ${_amd_dir} NO_DEFAULT_PATH) if(NOT _amd_lib_${_l}) set(_amd_ok FALSE) list(APPEND _amd_missing ${_l}) endif() endforeach() if(_amd_ok) set(_amd_lflags "") foreach(_l IN LISTS _amd_libs) list(APPEND _amd_lflags "-l${_l}") endforeach() add_test(NAME hipfort_shared_link_amdgcn COMMAND ${CMAKE_Fortran_COMPILER} -fPIC -shared ${_shared_ldflags} -Wl,--whole-archive $ -Wl,--no-whole-archive -Wl,--no-undefined -L${_amd_dir} ${_amd_lflags} -o ${CMAKE_CURRENT_BINARY_DIR}/libhipfort-amdgcn.so) message(STATUS "HIPFORT_EXTENDED_TESTS: added amdgcn shared-link test (libs in ${_amd_dir})") else() message(STATUS "HIPFORT_EXTENDED_TESTS: skipping amdgcn shared-link test; missing in ${_amd_dir}: ${_amd_missing}") endif() endif() # ---- nvptx: link against the CUDA runtime libraries ---- if(TARGET hipfort-nvptx) set(_cuda_dir "${HIPFORT_CUDA_LIB_DIR}") if(NOT _cuda_dir) find_package(CUDAToolkit QUIET) if(CUDAToolkit_FOUND) set(_cuda_dir "${CUDAToolkit_LIBRARY_DIR}") endif() endif() # Only the CUDA math/runtime libraries are needed: the whole-archive shared # link references solely the C symbols the archive's wrappers actually *call* # (the bind(C) interface bodies alone emit no reference). That set is entirely # runtime (cuda*/cublas*/...); the ~50 CUDA driver-API (cu*) routines are only # declared, never called here, so libcuda is not required. (The exhaustive # test_hip symbol test *does* call them and links the driver stub itself.) set(_cuda_libs cufft cusolver cublas curand cusparse cudart) set(_cuda_ok FALSE) set(_cuda_missing "") if(_cuda_dir) set(_cuda_ok TRUE) foreach(_l IN LISTS _cuda_libs) unset(_cuda_lib_${_l} CACHE) find_library(_cuda_lib_${_l} NAMES ${_l} HINTS ${_cuda_dir} NO_DEFAULT_PATH) if(NOT _cuda_lib_${_l}) set(_cuda_ok FALSE) list(APPEND _cuda_missing ${_l}) endif() endforeach() endif() if(_cuda_ok) set(_cuda_lflags "") foreach(_l IN LISTS _cuda_libs) list(APPEND _cuda_lflags "-l${_l}") endforeach() add_test(NAME hipfort_shared_link_nvptx COMMAND ${CMAKE_Fortran_COMPILER} -fPIC -shared ${_shared_ldflags} -Wl,--whole-archive $ -Wl,--no-whole-archive -Wl,--no-undefined -L${_cuda_dir} ${_cuda_lflags} -o ${CMAKE_CURRENT_BINARY_DIR}/libhipfort-nvptx.so) message(STATUS "HIPFORT_EXTENDED_TESTS: added nvptx shared-link test (libs in ${_cuda_dir})") else() message(STATUS "HIPFORT_EXTENDED_TESTS: skipping nvptx shared-link test; CUDA libraries not found (set HIPFORT_CUDA_LIB_DIR). missing: ${_cuda_missing}") endif() endif() endif() hipfort-rocm-10.0.0/lib/hipfort-config-shim.cmake000066400000000000000000000034501524740623400216360ustar00rootroot00000000000000# hipfort package shim. # # Installed at /lib/cmake/hipfort/hipfort-config.cmake when hipfort is # built with HIPFORT_MULTITOOLCHAIN_LAYOUT=ON. Fortran .mod files are # compiler-specific, so the real hipfort package files are installed under a # compiler-specific subdirectory, /lib/fortran//cmake/hipfort, # which is not on CMake's default find_package search path. This shim lets # `find_package(hipfort)` succeed from the install prefix (e.g. /opt/rocm) by # forwarding to the subdirectory that matches the consuming project's Fortran # compiler. It resolves the compiler at use time, so every toolchain install can # write the same shim without conflict. if(NOT CMAKE_Fortran_COMPILER) set(hipfort_FOUND FALSE) set(hipfort_NOT_FOUND_MESSAGE "hipfort requires the Fortran language to be enabled before find_package(hipfort); add Fortran to project(...) or call enable_language(Fortran).") return() endif() get_filename_component(_hipfort_fc "${CMAKE_Fortran_COMPILER}" NAME) get_filename_component(_hipfort_prefix "${CMAKE_CURRENT_LIST_DIR}/../../.." ABSOLUTE) set(_hipfort_real "${_hipfort_prefix}/lib/fortran/${_hipfort_fc}/cmake/hipfort/hipfort-config.cmake") if(NOT EXISTS "${_hipfort_real}") file(GLOB _hipfort_toolchains RELATIVE "${_hipfort_prefix}/lib/fortran" "${_hipfort_prefix}/lib/fortran/*") set(hipfort_FOUND FALSE) set(hipfort_NOT_FOUND_MESSAGE "hipfort is not installed for the Fortran compiler '${_hipfort_fc}'. Available toolchains: ${_hipfort_toolchains}. Rebuild hipfort with this compiler, or set hipfort_DIR to the matching lib/fortran//cmake/hipfort directory.") unset(_hipfort_fc) unset(_hipfort_prefix) unset(_hipfort_real) return() endif() include("${_hipfort_real}") unset(_hipfort_fc) unset(_hipfort_prefix) unset(_hipfort_real) hipfort-rocm-10.0.0/lib/hipfort-config.cmake.in000066400000000000000000000041351524740623400213060ustar00rootroot00000000000000# Copyright (c) 2023-2026 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. @PACKAGE_INIT@ include(CMakeFindDependencyMacro) set(_hipfort_supported_components hip roctx rocblas rocfft rocrand rocsolver rocsparse hipblas hipfft hipfftw hiprand hipsolver hipsparse) # Most components map 1:1 to a ROCm package of the same name. A few do not: # hipfftw is provided by the hipfft package (there is no standalone hipfftw # package), and roctx by rocprofiler-sdk-roctx. set(_hipfort_hipfftw_dependency hipfft) set(_hipfort_roctx_dependency rocprofiler-sdk-roctx) include("${CMAKE_CURRENT_LIST_DIR}/hipfort-amdgcn-targets.cmake") foreach(_comp ${hipfort_FIND_COMPONENTS}) if (NOT _comp IN_LIST _hipfort_supported_components) set(hipfort_FOUND False) set(hipfort_NOT_FOUND_MESSAGE "Unsupported component: ${_comp}") continue() endif() include("${CMAKE_CURRENT_LIST_DIR}/hipfort-${_comp}-targets.cmake") if(DEFINED _hipfort_${_comp}_dependency) find_dependency(${_hipfort_${_comp}_dependency}) else() find_dependency(${_comp}) endif() endforeach() hipfort-rocm-10.0.0/lib/hipfort/000077500000000000000000000000001524740623400164315ustar00rootroot00000000000000hipfort-rocm-10.0.0/lib/hipfort/hipfort.F90000066400000000000000000020557001524740623400203750ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort #ifdef USE_CUDA_NAMES use hipfort_cuda_errors #endif use hipfort_enums use hipfort_types use hipfort_hipmalloc use hipfort_hipmemcpy use hipfort_hiphostregister use hipfort_auxiliary implicit none interface hipCreateChannelDesc #ifdef USE_CUDA_NAMES function hipCreateChannelDesc_(x,y,z,w,f) bind(c, name="cudaCreateChannelDesc") #else function hipCreateChannelDesc_(x,y,z,w,f) bind(c, name="hipCreateChannelDesc") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none type(hipChannelFormatDesc) :: hipCreateChannelDesc_ integer(c_int),value :: x integer(c_int),value :: y integer(c_int),value :: z integer(c_int),value :: w integer(kind(hipChannelFormatKindSigned)),value :: f end function end interface !> @defgroup API HIP API !> !> !> Defines the HIP API. See the individual sections for more information. !> !> !> @defgroup Driver Initialization and Version !> !> This section describes the initializtion and version functions of HIP runtime API. !> !> !> !> @brief Explicitly initializes the HIP runtime. !> !> @param [in] flags Initialization flag, should be zero. !> !> Most HIP APIs implicitly initialize the HIP runtime. !> This API provides control over the timing of the initialization. !> !> @note Applications that use fork() should not initialize the HIP runtime !> before the fork when the child process will continue executing HIP code !> without an immediate exec(). Instead, the parent and child processes should !> initialize HIP independently after fork(). Inheriting HIP runtime state !> across fork() may lead to undefined behavior or initialization failures. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipInit function hipInit_(flags) bind(c, name="hipInit") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipInit_ integer(c_int),value :: flags end function end interface #endif !> @brief Returns the approximate HIP driver version. !> !> @param [out] driverVersion driver version !> !> HIP driver version shows up in the format: !> HIP_VERSION_MAJOR * 10000000 + HIP_VERSION_MINOR * 100000 + HIP_VERSION_PATCH. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @warning The HIP driver version does not correspond to an exact CUDA driver revision. !> On AMD platform, the API returns the HIP driver version, while on NVIDIA platform, it calls !> the corresponding CUDA runtime API and returns the CUDA driver version. !> There is no mapping/correlation between HIP driver version and CUDA driver version. !> !> @see hipRuntimeGetVersion interface hipDriverGetVersion #ifdef USE_CUDA_NAMES function hipDriverGetVersion_(driverVersion) bind(c, name="cudaDriverGetVersion") #else function hipDriverGetVersion_(driverVersion) bind(c, name="hipDriverGetVersion") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDriverGetVersion_ integer(c_int) :: driverVersion end function end interface !> @brief Returns the approximate HIP Runtime version. !> !> @param [out] runtimeVersion HIP runtime version !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @warning The version definition of HIP runtime is different from CUDA. !> On AMD platform, the function returns HIP runtime version, !> while on NVIDIA platform, it returns CUDA runtime version. !> And there is no mapping/correlation between HIP version and CUDA version. !> !> @see hipDriverGetVersion interface hipRuntimeGetVersion #ifdef USE_CUDA_NAMES function hipRuntimeGetVersion_(runtimeVersion) bind(c, name="cudaRuntimeGetVersion") #else function hipRuntimeGetVersion_(runtimeVersion) bind(c, name="hipRuntimeGetVersion") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipRuntimeGetVersion_ integer(c_int) :: runtimeVersion end function end interface !> @brief Returns a handle to a compute device !> @param [out] device Handle of device !> @param [in] ordinal Device ordinal !> !> @returns `hipSuccess`, `hipErrorInvalidDevice` #ifndef USE_CUDA_NAMES interface hipDeviceGet function hipDeviceGet_(device,ordinal) bind(c, name="hipDeviceGet") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceGet_ integer(c_int) :: device integer(c_int),value :: ordinal end function end interface #endif !> @brief Returns the compute capability of the device !> @param [out] major Major compute capability version number !> @param [out] minor Minor compute capability version number !> @param [in] device Device ordinal !> !> @returns `hipSuccess`, `hipErrorInvalidDevice` #ifndef USE_CUDA_NAMES interface hipDeviceComputeCapability function hipDeviceComputeCapability_(major,minor,device) & bind(c, name="hipDeviceComputeCapability") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceComputeCapability_ integer(c_int) :: major integer(c_int) :: minor integer(c_int),value :: device end function end interface #endif !> @brief Returns an identifer string for the device. !> @param [out] name String of the device name !> @param [in] len Maximum length of string to store in device name !> @param [in] device Device ordinal !> !> @returns `hipSuccess`, `hipErrorInvalidDevice` #ifndef USE_CUDA_NAMES interface hipDeviceGetName function hipDeviceGetName_(name,len,device) bind(c, name="hipDeviceGetName") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceGetName_ type(c_ptr),value :: name integer(c_int),value :: len integer(c_int),value :: device end function end interface #endif !> @brief Returns an UUID for the device.[BETA] !> @param [out] uuid UUID for the device !> @param [in] device device ordinal !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue`, !> `hipErrorNotInitialized`, !> `hipErrorDeinitialized` interface hipDeviceGetUuid #ifdef USE_CUDA_NAMES function hipDeviceGetUuid_(uuid,device) bind(c, name="cuDeviceGetUuid") #else function hipDeviceGetUuid_(uuid,device) bind(c, name="hipDeviceGetUuid") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipDeviceGetUuid_ type(hipUUID) :: uuid integer(c_int),value :: device end function end interface !> @brief Returns a value for attribute of link between two devices !> @param [out] value Pointer of the value for the attrubute !> @param [in] attr enum of hipDeviceP2PAttr to query !> @param [in] srcDevice The source device of the link !> @param [in] dstDevice The destination device of the link !> !> @returns `hipSuccess`, `hipErrorInvalidDevice` interface hipDeviceGetP2PAttribute #ifdef USE_CUDA_NAMES function hipDeviceGetP2PAttribute_(myValue,attr,srcDevice,dstDevice) & bind(c, name="cudaDeviceGetP2PAttribute") #else function hipDeviceGetP2PAttribute_(myValue,attr,srcDevice,dstDevice) & bind(c, name="hipDeviceGetP2PAttribute") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceGetP2PAttribute_ type(c_ptr),value :: myValue integer(kind(hipDevP2PAttrPerformanceRank)),value :: attr integer(c_int),value :: srcDevice integer(c_int),value :: dstDevice end function end interface !> @brief Returns a PCI Bus Id string for the device, overloaded to take int device ID. !> @param [out] pciBusId The string of PCI Bus Id format for the device !> @param [in] len Maximum length of string !> @param [in] device The device ordinal !> !> @returns `hipSuccess`, `hipErrorInvalidDevice` interface hipDeviceGetPCIBusId #ifdef USE_CUDA_NAMES function hipDeviceGetPCIBusId_(pciBusId,len,device) bind(c, name="cudaDeviceGetPCIBusId") #else function hipDeviceGetPCIBusId_(pciBusId,len,device) bind(c, name="hipDeviceGetPCIBusId") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceGetPCIBusId_ type(c_ptr),value :: pciBusId integer(c_int),value :: len integer(c_int),value :: device end function end interface !> @brief Returns a handle to a compute device. !> @param [out] device The handle of the device !> @param [in] pciBusId The string of PCI Bus Id for the device !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue` interface hipDeviceGetByPCIBusId #ifdef USE_CUDA_NAMES function hipDeviceGetByPCIBusId_(device,pciBusId) bind(c, name="cudaDeviceGetByPCIBusId") #else function hipDeviceGetByPCIBusId_(device,pciBusId) bind(c, name="hipDeviceGetByPCIBusId") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceGetByPCIBusId_ integer(c_int) :: device type(c_ptr),value :: pciBusId end function end interface !> @brief Returns the total amount of memory on the device. !> @param [out] bytes The size of memory in bytes, on the device !> @param [in] device The ordinal of the device !> !> @returns `hipSuccess`, `hipErrorInvalidDevice` #ifndef USE_CUDA_NAMES interface hipDeviceTotalMem function hipDeviceTotalMem_(bytes,device) bind(c, name="hipDeviceTotalMem") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceTotalMem_ integer(c_size_t) :: bytes integer(c_int),value :: device end function end interface #endif !> @defgroup Device Device Management !> !> This section describes the device management functions of HIP runtime API. !> !> !> @brief Waits on all active streams on current device !> !> When this command is invoked, the host thread gets blocked until all the commands associated !> with streams associated with the device. HIP does not support multiple blocking modes (yet!). !> !> @returns `hipSuccess` !> !> @see hipSetDevice, hipDeviceReset interface hipDeviceSynchronize #ifdef USE_CUDA_NAMES function hipDeviceSynchronize_() bind(c, name="cudaDeviceSynchronize") #else function hipDeviceSynchronize_() bind(c, name="hipDeviceSynchronize") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceSynchronize_ end function end interface !> @brief The state of current device is discarded and updated to a fresh state. !> !> Calling this function deletes all streams created, memory allocated, kernels running, events !> created. Make sure that no other thread is using the device or streams, memory, kernels, !> events !> associated with the current device. !> !> @returns `hipSuccess` !> !> @see hipDeviceSynchronize interface hipDeviceReset #ifdef USE_CUDA_NAMES function hipDeviceReset_() bind(c, name="cudaDeviceReset") #else function hipDeviceReset_() bind(c, name="hipDeviceReset") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceReset_ end function end interface !> @brief Set default device to be used for subsequent hip API calls from this thread. !> !> @param[in] deviceId - Valid device in range 0...`hipGetDeviceCount()`. !> !> Sets @p device as the default device for the calling host thread. Valid device id's are 0... !> (`hipGetDeviceCount()`-1). !> !> Many HIP APIs implicitly use the "default device" : !> !> - Any device memory subsequently allocated from this host thread (using hipMalloc) will be !> allocated on device. !> - Any streams or events created from this host thread will be associated with device. !> - Any kernels launched from this host thread (using hipLaunchKernel) will be executed on !> device !> (unless a specific stream is specified, in which case the device associated with that stream !> will !> be used). !> !> This function may be called from any host thread. Multiple host threads may use the same !> device. !> This function does no synchronization with the previous or new device, and has very little !> runtime overhead. Applications can use hipSetDevice to quickly switch the default device !> before !> making a HIP runtime call which uses the default device. !> !> The default device is stored in thread-local-storage for each thread. !> Thread-pool implementations may inherit the default device of the previous thread. A good !> practice is to always call hipSetDevice at the start of HIP coding sequency to establish a !> known !> standard device. !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorNoDevice` !> !> @see `hipGetDevice`, `hipGetDeviceCount` interface hipSetDevice #ifdef USE_CUDA_NAMES function hipSetDevice_(deviceId) bind(c, name="cudaSetDevice") #else function hipSetDevice_(deviceId) bind(c, name="hipSetDevice") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipSetDevice_ integer(c_int),value :: deviceId end function end interface !> @brief Set a list of devices that can be used. !> !> @param[in] device_arr - List of devices to try !> @param[in] len - Number of devices in specified list !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue` !> !> @see `hipGetDevice`, `hipGetDeviceCount`. `hipSetDevice`. `hipGetDeviceProperties`. !> `hipSetDeviceFlags`. `hipChooseDevice` interface hipSetValidDevices #ifdef USE_CUDA_NAMES function hipSetValidDevices_(device_arr,len) bind(c, name="cudaSetValidDevices") #else function hipSetValidDevices_(device_arr,len) bind(c, name="hipSetValidDevices") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipSetValidDevices_ type(c_ptr),value :: device_arr integer(c_int),value :: len end function end interface !> @brief Return the default device id for the calling host thread. !> !> @param [out] deviceId *device is written with the default device !> !> HIP maintains an default device for each thread using thread-local-storage. !> This device is used implicitly for HIP runtime APIs called by this thread. !> hipGetDevice returns in * @p device the default device for the calling host thread. !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue` !> !> @see hipSetDevice, hipGetDevicesizeBytes interface hipGetDevice #ifdef USE_CUDA_NAMES function hipGetDevice_(deviceId) bind(c, name="cudaGetDevice") #else function hipGetDevice_(deviceId) bind(c, name="hipGetDevice") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGetDevice_ integer(c_int) :: deviceId end function end interface !> @brief Return number of compute-capable devices. !> !> @param [out] count Returns number of compute-capable devices. !> !> @returns `hipSuccess`, `hipErrorNoDevice` !> !> !> Returns in @p *count the number of devices that have ability to run compute commands. If there !> are no such devices, then `hipGetDeviceCount` will return `hipErrorNoDevice`. If 1 or more !> devices can be found, then hipGetDeviceCount returns `hipSuccess`. interface hipGetDeviceCount #ifdef USE_CUDA_NAMES function hipGetDeviceCount_(count) bind(c, name="cudaGetDeviceCount") #else function hipGetDeviceCount_(count) bind(c, name="hipGetDeviceCount") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGetDeviceCount_ integer(c_int) :: count end function end interface !> @brief Query for a specific device attribute. !> !> @param [out] pi pointer to value to return !> @param [in] attr attribute to query !> @param [in] deviceId which device to query for information !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue` interface hipDeviceGetAttribute #ifdef USE_CUDA_NAMES function hipDeviceGetAttribute_(pi,attr,deviceId) bind(c, name="cudaDeviceGetAttribute") #else function hipDeviceGetAttribute_(pi,attr,deviceId) bind(c, name="hipDeviceGetAttribute") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceGetAttribute_ integer(c_int) :: pi integer(kind(hipDeviceAttributeCudaCompatibleBegin)),value :: attr integer(c_int),value :: deviceId end function end interface !> @brief Returns the default memory pool of the specified device !> !> @param [out] mem_pool Default memory pool to return !> @param [in] device Device index for query the default memory pool !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @see hipDeviceGetDefaultMemPool, hipMallocAsync, hipMemPoolTrimTo, hipMemPoolGetAttribute, !> hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess, hipMemPoolGetAccess !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. interface hipDeviceGetDefaultMemPool #ifdef USE_CUDA_NAMES function hipDeviceGetDefaultMemPool_(mem_pool,device) & bind(c, name="cudaDeviceGetDefaultMemPool") #else function hipDeviceGetDefaultMemPool_(mem_pool,device) bind(c, name="hipDeviceGetDefaultMemPool") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceGetDefaultMemPool_ type(c_ptr) :: mem_pool integer(c_int),value :: device end function end interface !> @brief Sets the current memory pool of a device !> !> The memory pool must be local to the specified device. !> @p hipMallocAsync allocates from the current mempool of the provided stream's device. !> By default, a device's current memory pool is its default memory pool. !> !> @note Use @p hipMallocFromPoolAsync for asynchronous memory allocations from a device !> different than the one the stream runs on. !> !> @param [in] device Device index for the update !> @param [in] mem_pool Memory pool for update as the current on the specified device !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidDevice`, `hipErrorNotSupported` !> !> @see hipDeviceGetDefaultMemPool, hipMallocAsync, hipMemPoolTrimTo, hipMemPoolGetAttribute, !> hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess, hipMemPoolGetAccess !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. interface hipDeviceSetMemPool #ifdef USE_CUDA_NAMES function hipDeviceSetMemPool_(device,mem_pool) bind(c, name="cudaDeviceSetMemPool") #else function hipDeviceSetMemPool_(device,mem_pool) bind(c, name="hipDeviceSetMemPool") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceSetMemPool_ integer(c_int),value :: device type(c_ptr),value :: mem_pool end function end interface !> @brief Gets the current memory pool for the specified device !> !> Returns the last pool provided to @p hipDeviceSetMemPool for this device !> or the device's default memory pool if @p hipDeviceSetMemPool has never been called. !> By default the current mempool is the default mempool for a device, !> otherwise the returned pool must have been set with @p hipDeviceSetMemPool. !> !> @param [out] mem_pool Current memory pool on the specified device !> @param [in] device Device index to query the current memory pool !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @see hipDeviceGetDefaultMemPool, hipMallocAsync, hipMemPoolTrimTo, hipMemPoolGetAttribute, !> hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess, hipMemPoolGetAccess !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. interface hipDeviceGetMemPool #ifdef USE_CUDA_NAMES function hipDeviceGetMemPool_(mem_pool,device) bind(c, name="cudaDeviceGetMemPool") #else function hipDeviceGetMemPool_(mem_pool,device) bind(c, name="hipDeviceGetMemPool") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceGetMemPool_ type(c_ptr) :: mem_pool integer(c_int),value :: device end function end interface !> @brief Gets the maximum width for 1D linear textures on the specified device !> !> This function queries the maximum width, in elements, of 1D linear textures that can be !> allocated !> on the specified device. The maximum width depends on the texture element size and the !> hardware !> limitations of the device. !> !> @param [out] max_width Maximum width, in elements, of 1D linear textures that the device can !> support !> @param [in] desc Requested channel format !> @param [in] device Device index to query for maximum 1D texture width !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidDevice` !> !> @see hipDeviceGetAttribute, hipMalloc, hipTexRefSetAddressMode interface hipDeviceGetTexture1DLinearMaxWidth #ifdef USE_CUDA_NAMES function hipDeviceGetTexture1DLinearMaxWidth_(max_width,desc,device) & bind(c, name="cudaDeviceGetTexture1DLinearMaxWidth") #else function hipDeviceGetTexture1DLinearMaxWidth_(max_width,desc,device) & bind(c, name="hipDeviceGetTexture1DLinearMaxWidth") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipDeviceGetTexture1DLinearMaxWidth_ type(c_ptr),value :: max_width type(hipChannelFormatDesc) :: desc integer(c_int),value :: device end function end interface !> @brief Set L1/Shared cache partition. !> !> @param [in] cacheConfig Cache configuration !> !> @returns `hipSuccess`, `hipErrorNotInitialized`, `hipErrorNotSupported` !> !> Note: AMD devices do not support reconfigurable cache. This API is not implemented !> on AMD platform. If the function is called, it will return hipErrorNotSupported. interface hipDeviceSetCacheConfig #ifdef USE_CUDA_NAMES function hipDeviceSetCacheConfig_(cacheConfig) bind(c, name="cudaDeviceSetCacheConfig") #else function hipDeviceSetCacheConfig_(cacheConfig) bind(c, name="hipDeviceSetCacheConfig") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceSetCacheConfig_ integer(kind(hipFuncCachePreferNone)),value :: cacheConfig end function end interface !> @brief Get Cache configuration for a specific Device !> !> @param [out] cacheConfig Pointer of cache configuration !> !> @returns `hipSuccess`, `hipErrorNotInitialized` !> Note: AMD devices do not support reconfigurable cache. This hint is ignored !> on these architectures. interface hipDeviceGetCacheConfig #ifdef USE_CUDA_NAMES function hipDeviceGetCacheConfig_(cacheConfig) bind(c, name="cudaDeviceGetCacheConfig") #else function hipDeviceGetCacheConfig_(cacheConfig) bind(c, name="hipDeviceGetCacheConfig") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceGetCacheConfig_ type(c_ptr),value :: cacheConfig end function end interface !> @brief Gets resource limits of current device !> !> The function queries the size of limit value, as required by the input enum value hipLimit_t, !> which can be either `hipLimitStackSize`, or `hipLimitMallocHeapSize`. Any other input as !> default, the function will return `hipErrorUnsupportedLimit`. !> !> @param [out] pValue Returns the size of the limit in bytes !> @param [in] limit The limit to query !> !> @returns `hipSuccess`, `hipErrorUnsupportedLimit`, `hipErrorInvalidValue` interface hipDeviceGetLimit #ifdef USE_CUDA_NAMES function hipDeviceGetLimit_(pValue,limit) bind(c, name="cudaDeviceGetLimit") #else function hipDeviceGetLimit_(pValue,limit) bind(c, name="hipDeviceGetLimit") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceGetLimit_ integer(c_size_t) :: pValue integer(kind(hipLimitStackSize)),value :: limit end function end interface !> @brief Sets resource limits of current device. !> !> As the input enum limit, !> `hipLimitStackSize` sets the limit value of the stack size on the current GPU device, per !> thread. !> The limit size can get via hipDeviceGetLimit. The size is in units of 256 dwords, up to the !> limit !> (128K - 16). !> !> `hipLimitMallocHeapSize` sets the limit value of the heap used by the malloc()/free() !> calls. For limit size, use the `hipDeviceGetLimit` API. !> !> Any other input as default, the funtion will return hipErrorUnsupportedLimit. !> !> @param [in] limit Enum of hipLimit_t to set !> @param [in] value The size of limit value in bytes !> !> @returns `hipSuccess`, `hipErrorUnsupportedLimit`, `hipErrorInvalidValue` interface hipDeviceSetLimit #ifdef USE_CUDA_NAMES function hipDeviceSetLimit_(limit,myValue) bind(c, name="cudaDeviceSetLimit") #else function hipDeviceSetLimit_(limit,myValue) bind(c, name="hipDeviceSetLimit") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceSetLimit_ integer(kind(hipLimitStackSize)),value :: limit integer(c_size_t),value :: myValue end function end interface !> @brief Returns bank width of shared memory for current device !> !> @param [out] pConfig The pointer of the bank width for shared memory !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotInitialized` !> !> Note: AMD devices and some Nvidia GPUS do not support shared cache banking, and the hint is !> ignored on those architectures. interface hipDeviceGetSharedMemConfig #ifdef USE_CUDA_NAMES function hipDeviceGetSharedMemConfig_(pConfig) bind(c, name="cudaDeviceGetSharedMemConfig") #else function hipDeviceGetSharedMemConfig_(pConfig) bind(c, name="hipDeviceGetSharedMemConfig") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceGetSharedMemConfig_ type(c_ptr),value :: pConfig end function end interface !> @brief Gets the flags set for current device !> !> @param [out] flags Pointer of the flags !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue` interface hipGetDeviceFlags #ifdef USE_CUDA_NAMES function hipGetDeviceFlags_(flags) bind(c, name="cudaGetDeviceFlags") #else function hipGetDeviceFlags_(flags) bind(c, name="hipGetDeviceFlags") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGetDeviceFlags_ integer(c_int) :: flags end function end interface !> @brief The bank width of shared memory on current device is set !> !> @param [in] config Configuration for the bank width of shared memory !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotInitialized` !> !> Note: AMD devices and some Nvidia GPUS do not support shared cache banking, and the hint is !> ignored on those architectures. interface hipDeviceSetSharedMemConfig #ifdef USE_CUDA_NAMES function hipDeviceSetSharedMemConfig_(config) bind(c, name="cudaDeviceSetSharedMemConfig") #else function hipDeviceSetSharedMemConfig_(config) bind(c, name="hipDeviceSetSharedMemConfig") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceSetSharedMemConfig_ integer(kind(hipSharedMemBankSizeDefault)),value :: config end function end interface !> @brief The current device behavior is changed according to the flags passed. !> !> @param [in] flags Flag to set on the current device !> !> The schedule flags impact how HIP waits for the completion of a command running on a device. !> !> `hipDeviceScheduleSpin` : HIP runtime will actively spin in the thread which submitted !> the work until the command completes. This offers the lowest latency, but will consume a CPU !> core and may increase power. !> !> `hipDeviceScheduleYield` : The HIP runtime will yield the CPU to system so that other !> tasks can use it. This may increase latency to detect the completion but will consume less !> power and is friendlier to other tasks in the system. !> !> `hipDeviceScheduleBlockingSync` : On ROCm platform, this is a synonym for !> hipDeviceScheduleYield. !> !> `hipDeviceScheduleAuto` : This is the default value if the input 'flags' is zero. !> Uses a heuristic to select between Spin and Yield modes. If the number of HIP contexts is !> greater than the number of logical processors in the system, uses Spin scheduling, otherwise !> uses Yield scheduling. !> !> `hipDeviceMapHost` : Allows mapping host memory. On ROCm, this is always allowed and !> the flag is ignored. !> !> `hipDeviceLmemResizeToMax` : This flag is silently ignored on ROCm. !> !> @returns `hipSuccess`, `hipErrorNoDevice`, `hipErrorInvalidDevice`, !> `hipErrorSetOnActiveProcess` interface hipSetDeviceFlags #ifdef USE_CUDA_NAMES function hipSetDeviceFlags_(flags) bind(c, name="cudaSetDeviceFlags") #else function hipSetDeviceFlags_(flags) bind(c, name="hipSetDeviceFlags") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipSetDeviceFlags_ integer(c_int),value :: flags end function end interface !> @brief Device which matches hipDeviceProp_t is returned !> !> @param [out] device Pointer of the device !> @param [in] prop Pointer of the properties !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipChooseDeviceR0600 #ifdef USE_CUDA_NAMES function hipChooseDeviceR0600_(device,prop) bind(c, name="cudaChooseDevice") #else function hipChooseDeviceR0600_(device,prop) bind(c, name="hipChooseDeviceR0600") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipChooseDeviceR0600_ type(c_ptr),value :: device type(hipDeviceProp_t) :: prop end function end interface !> @brief Returns the link type and hop count between two devices !> !> @param [in] device1 Ordinal for device1 !> @param [in] device2 Ordinal for device2 !> @param [out] linktype Returns the link type (See hsa_amd_link_info_type_t) between the two !> devices !> @param [out] hopcount Returns the hop count between the two devices !> !> Queries and returns the HSA link type and the hop count between the two specified devices. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipExtGetLinkTypeAndHopCount function hipExtGetLinkTypeAndHopCount_(device1,device2,linktype,hopcount) & bind(c, name="hipExtGetLinkTypeAndHopCount") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipExtGetLinkTypeAndHopCount_ integer(c_int),value :: device1 integer(c_int),value :: device2 integer(c_int32_t) :: linktype integer(c_int32_t) :: hopcount end function end interface #endif !> @brief Gets an interprocess memory handle for an existing device memory !> allocation !> !> Takes a pointer to the base of an existing device memory allocation created !> with hipMalloc and exports it for use in another process. This is a !> lightweight operation and may be called multiple times on an allocation !> without adverse effects. !> !> If a region of memory is freed with hipFree and a subsequent call !> to hipMalloc returns memory with the same device address, !> hipIpcGetMemHandle will return a unique handle for the !> new memory. !> !> @param handle - Pointer to user allocated hipIpcMemHandle to return !> the handle in. !> @param devPtr - Base pointer to previously allocated device memory !> !> @returns `hipSuccess`, `hipErrorInvalidHandle`, `hipErrorOutOfMemory`, `hipErrorMapFailed` !> !> @note This IPC memory related feature API on Windows may behave differently from Linux. interface hipIpcGetMemHandle #ifdef USE_CUDA_NAMES function hipIpcGetMemHandle_(handle,devPtr) bind(c, name="cudaIpcGetMemHandle") #else function hipIpcGetMemHandle_(handle,devPtr) bind(c, name="hipIpcGetMemHandle") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipIpcGetMemHandle_ type(hipIpcMemHandle_t) :: handle type(c_ptr),value :: devPtr end function end interface !> @brief Opens an interprocess memory handle exported from another process !> and returns a device pointer usable in the local process. !> !> Maps memory exported from another process with hipIpcGetMemHandle into !> the current device address space. For contexts on different devices !> hipIpcOpenMemHandle can attempt to enable peer access between the !> devices as if the user called hipDeviceEnablePeerAccess. This behavior is !> controlled by the hipIpcMemLazyEnablePeerAccess flag. !> hipDeviceCanAccessPeer can determine if a mapping is possible. !> !> Contexts that may open hipIpcMemHandles are restricted in the following way. !> hipIpcMemHandles from each device in a given process may only be opened !> by one context per device per other process. !> !> Memory returned from hipIpcOpenMemHandle must be freed with !> hipIpcCloseMemHandle. !> !> Calling hipFree on an exported memory region before calling !> hipIpcCloseMemHandle in the importing context will result in undefined !> behavior. !> !> @param devPtr - Returned device pointer !> @param handle - hipIpcMemHandle to open !> @param flags - Flags for this operation. Must be specified as hipIpcMemLazyEnablePeerAccess !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidContext`, !> `hipErrorInvalidDevicePointer` !> !> @note During multiple processes, using the same memory handle opened by the current context, !> there is no guarantee that the same device poiter will be returned in @p *devPtr. !> This is diffrent from CUDA. !> @note This IPC memory related feature API on Windows may behave differently from Linux. interface hipIpcOpenMemHandle #ifdef USE_CUDA_NAMES function hipIpcOpenMemHandle_(devPtr,handle,flags) bind(c, name="cudaIpcOpenMemHandle") #else function hipIpcOpenMemHandle_(devPtr,handle,flags) bind(c, name="hipIpcOpenMemHandle") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipIpcOpenMemHandle_ type(c_ptr) :: devPtr type(hipIpcMemHandle_t),value :: handle integer(c_int),value :: flags end function end interface !> @brief Close memory mapped with hipIpcOpenMemHandle !> !> Unmaps memory returnd by hipIpcOpenMemHandle. The original allocation !> in the exporting process as well as imported mappings in other processes !> will be unaffected. !> !> Any resources used to enable peer access will be freed if this is the !> last mapping using them. !> !> @param devPtr - Device pointer returned by hipIpcOpenMemHandle !> !> @returns `hipSuccess`, `hipErrorMapFailed`, `hipErrorInvalidHandle` !> !> @note This IPC memory related feature API on Windows may behave differently from Linux. interface hipIpcCloseMemHandle #ifdef USE_CUDA_NAMES function hipIpcCloseMemHandle_(devPtr) bind(c, name="cudaIpcCloseMemHandle") #else function hipIpcCloseMemHandle_(devPtr) bind(c, name="hipIpcCloseMemHandle") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipIpcCloseMemHandle_ type(c_ptr),value :: devPtr end function end interface !> @brief Gets an opaque interprocess handle for an event. !> !> This opaque handle may be copied into other processes and opened with hipIpcOpenEventHandle. !> Then hipEventRecord, hipEventSynchronize, hipStreamWaitEvent and hipEventQuery may be used in !> either process. Operations on the imported event after the exported event has been freed with !> hipEventDestroy will result in undefined behavior. !> !> @param[out] handle - Pointer to hipIpcEventHandle to return the opaque event handle !> @param[in] event - Event allocated with hipEventInterprocess and hipEventDisableTiming flags !> !> @returns `hipSuccess`, `hipErrorInvalidConfiguration`, `hipErrorInvalidValue` !> !> @note This IPC event related feature API is currently applicable on Linux. interface hipIpcGetEventHandle #ifdef USE_CUDA_NAMES function hipIpcGetEventHandle_(handle,event) bind(c, name="cudaIpcGetEventHandle") #else function hipIpcGetEventHandle_(handle,event) bind(c, name="hipIpcGetEventHandle") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipIpcGetEventHandle_ type(hipIpcEventHandle_t) :: handle type(c_ptr),value :: event end function end interface !> @brief Opens an interprocess event handles. !> !> Opens an interprocess event handle exported from another process with hipIpcGetEventHandle. !> The !> returned hipEvent_t behaves like a locally created event with the hipEventDisableTiming flag !> specified. This event need be freed with hipEventDestroy. Operations on the imported event !> after !> the exported event has been freed with hipEventDestroy will result in undefined behavior. If !> the !> function is called within the same process where handle is returned by hipIpcGetEventHandle, !> it !> will return hipErrorInvalidContext. !> !> @param[out] event - Pointer to hipEvent_t to return the event !> @param[in] handle - The opaque interprocess handle to open !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidContext` !> !> @note This IPC event related feature API is currently applicable on Linux. interface hipIpcOpenEventHandle #ifdef USE_CUDA_NAMES function hipIpcOpenEventHandle_(event,handle) bind(c, name="cudaIpcOpenEventHandle") #else function hipIpcOpenEventHandle_(event,handle) bind(c, name="hipIpcOpenEventHandle") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipIpcOpenEventHandle_ type(c_ptr) :: event type(hipIpcEventHandle_t),value :: handle end function end interface !> @defgroup Execution Execution Control !> !> This section describes the execution control functions of HIP runtime API. !> !> !> !> @brief Set attribute for a specific function !> !> @param [in] func Pointer of the function !> @param [in] attr Attribute to set !> @param [in] value Value to set !> !> @returns `hipSuccess`, `hipErrorInvalidDeviceFunction`, `hipErrorInvalidValue` !> !> Note: AMD devices and some Nvidia GPUS do not support shared cache banking, and the hint is !> ignored on those architectures. interface hipFuncSetAttribute #ifdef USE_CUDA_NAMES function hipFuncSetAttribute_(func,attr,myValue) bind(c, name="cudaFuncSetAttribute") #else function hipFuncSetAttribute_(func,attr,myValue) bind(c, name="hipFuncSetAttribute") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipFuncSetAttribute_ type(c_ptr),value :: func integer(kind(hipFuncAttributeMaxDynamicSharedMemorySize)),value :: attr integer(c_int),value :: myValue end function end interface !> @brief Set attribute for a specific kernel !> !> @param [in] attrib Attribute to set !> @param [in] value Value to set !> @param [in] kernel Kernel to set attribute for !> @param [in] dev Device kernel execute on !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidHandle`, !> `hipErrorInvalidDevice`, `hipErrorInvalidDeviceFunction`, `hipErrorMissingConfiguration` !> Note: AMD devices and some Nvidia GPUS do not support reconfigurable cache. This hint is !> ignored !> on those architectures. #ifndef USE_CUDA_NAMES interface hipKernelSetAttribute function hipKernelSetAttribute_(attrib,myValue,kernel,dev) bind(c, name="hipKernelSetAttribute") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipKernelSetAttribute_ integer(kind(HIP_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK)),value :: attrib integer(c_int),value :: myValue type(c_ptr),value :: kernel integer(c_int),value :: dev end function end interface #endif !> @brief Function will be extracted for specific kernel !> !> @param [out] pFunc Pointer to function handle for the kernel !> @param [in] kernel kernel to get handle for !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotFound` #ifndef USE_CUDA_NAMES interface hipKernelGetFunction function hipKernelGetFunction_(pFunc,kernel) bind(c, name="hipKernelGetFunction") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipKernelGetFunction_ type(c_ptr) :: pFunc type(c_ptr),value :: kernel end function end interface #endif !> @brief Set Cache configuration for a specific function !> !> @param [in] func Pointer of the function. !> @param [in] config Configuration to set. !> !> @returns `hipSuccess`, `hipErrorNotInitialized` !> Note: AMD devices and some Nvidia GPUS do not support reconfigurable cache. This hint is !> ignored !> on those architectures. interface hipFuncSetCacheConfig #ifdef USE_CUDA_NAMES function hipFuncSetCacheConfig_(func,config) bind(c, name="cudaFuncSetCacheConfig") #else function hipFuncSetCacheConfig_(func,config) bind(c, name="hipFuncSetCacheConfig") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipFuncSetCacheConfig_ type(c_ptr),value :: func integer(kind(hipFuncCachePreferNone)),value :: config end function end interface !> @brief Set shared memory configuation for a specific function !> !> @param [in] func Pointer of the function !> @param [in] config Configuration !> !> @returns `hipSuccess`, `hipErrorInvalidDeviceFunction`, `hipErrorInvalidValue` !> !> Note: AMD devices and some Nvidia GPUS do not support shared cache banking, and the hint is !> ignored on those architectures. interface hipFuncSetSharedMemConfig #ifdef USE_CUDA_NAMES function hipFuncSetSharedMemConfig_(func,config) bind(c, name="cudaFuncSetSharedMemConfig") #else function hipFuncSetSharedMemConfig_(func,config) bind(c, name="hipFuncSetSharedMemConfig") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipFuncSetSharedMemConfig_ type(c_ptr),value :: func integer(kind(hipSharedMemBankSizeDefault)),value :: config end function end interface !> ------------------------------------------------------------------------------------------------- !> ------------------------------------------------------------------------------------------------- !> @defgroup Error Error Handling !> !> This section describes the error handling functions of HIP runtime API. !> !> !> @brief Return last error returned by any HIP runtime API call and resets the stored error code !> to !> `hipSuccess` !> !> @returns return code from last HIP called from the active host thread !> !> Returns the last error that has been returned by any of the runtime calls in the same host !> thread, and then resets the saved error to `hipSuccess`. !> !> @see hipGetErrorString, hipGetLastError, hipPeakAtLastError, hipError_t interface hipGetLastError #ifdef USE_CUDA_NAMES function hipGetLastError_() bind(c, name="cudaGetLastError") #else function hipGetLastError_() bind(c, name="hipGetLastError") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGetLastError_ end function end interface !> @brief Return last error returned by any HIP runtime API call and resets the stored error code !> to !> `hipSuccess` !> !> @returns return code from last HIP called from the active host thread !> !> Returns the last error that has been returned by any of the runtime calls in the same host !> thread, and then resets the saved error to `hipSuccess`. !> !> @see hipGetErrorString, hipGetLastError, hipPeakAtLastError, hipError_t #ifndef USE_CUDA_NAMES interface hipExtGetLastError function hipExtGetLastError_() bind(c, name="hipExtGetLastError") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipExtGetLastError_ end function end interface #endif !> @brief Return last error returned by any HIP runtime API call. !> !> @returns `hipSuccess` !> !> Returns the last error that has been returned by any of the runtime calls in the same host !> thread. Unlike hipGetLastError, this function does not reset the saved error code. !> !> @see hipGetErrorString, hipGetLastError, hipPeakAtLastError, hipError_t interface hipPeekAtLastError #ifdef USE_CUDA_NAMES function hipPeekAtLastError_() bind(c, name="cudaPeekAtLastError") #else function hipPeekAtLastError_() bind(c, name="hipPeekAtLastError") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipPeekAtLastError_ end function end interface !> @brief Return hip error as text string form. !> !> @param hip_error - Error code to convert to name. !> @returns const char pointer to the NULL-terminated error name !> !> @see hipGetErrorString, hipGetLastError, hipPeakAtLastError, hipError_t interface hipGetErrorName #ifdef USE_CUDA_NAMES function hipGetErrorName_(hip_error) bind(c, name="cudaGetErrorName") #else function hipGetErrorName_(hip_error) bind(c, name="hipGetErrorName") #endif use iso_c_binding use hipfort_enums implicit none type(c_ptr) :: hipGetErrorName_ integer(kind(hipSuccess)),value :: hip_error end function end interface !> @brief Return handy text string message to explain the error which occurred !> !> @param hipError - Error code to convert to string. !> @returns const char pointer to the NULL-terminated error string !> !> @see hipGetErrorName, hipGetLastError, hipPeakAtLastError, hipError_t interface hipGetErrorString #ifdef USE_CUDA_NAMES function hipGetErrorString_(hipError) bind(c, name="cudaGetErrorString") #else function hipGetErrorString_(hipError) bind(c, name="hipGetErrorString") #endif use iso_c_binding use hipfort_enums implicit none type(c_ptr) :: hipGetErrorString_ integer(kind(hipSuccess)),value :: hipError end function end interface !> @brief Return hip error as text string form. !> !> @param [in] hipError Error code to convert to string. !> @param [out] errorString char pointer to the NULL-terminated error string !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @see hipGetErrorName, hipGetLastError, hipPeakAtLastError, hipError_t #ifndef USE_CUDA_NAMES interface hipDrvGetErrorName function hipDrvGetErrorName_(hipError,errorString) bind(c, name="hipDrvGetErrorName") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDrvGetErrorName_ integer(kind(hipSuccess)),value :: hipError type(c_ptr) :: errorString end function end interface #endif !> @brief Return handy text string message to explain the error which occurred !> !> @param [in] hipError Error code to convert to string. !> @param [out] errorString char pointer to the NULL-terminated error string !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @see hipGetErrorName, hipGetLastError, hipPeakAtLastError, hipError_t #ifndef USE_CUDA_NAMES interface hipDrvGetErrorString function hipDrvGetErrorString_(hipError,errorString) bind(c, name="hipDrvGetErrorString") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDrvGetErrorString_ integer(kind(hipSuccess)),value :: hipError type(c_ptr) :: errorString end function end interface #endif !> @brief Creates an asynchronous stream. !> !> @param[out] stream - Valid pointer to hipStream_t. This function writes the memory with the !> newly created stream. !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> Creates a new asynchronous stream with its associated current device. The @p stream returns an !> opaque handle that can be used to reference the newly created stream in subsequent hipStream* !> commands. The stream is allocated on the heap and will remain allocated even if the handle !> goes !> out-of-scope. To release the memory used by the stream, the application must call !> hipStreamDestroy. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @see hipStreamCreateWithFlags, hipStreamCreateWithPriority, hipStreamSynchronize, !> hipStreamWaitEvent, hipStreamDestroy interface hipStreamCreate #ifdef USE_CUDA_NAMES function hipStreamCreate_(stream) bind(c, name="cudaStreamCreate") #else function hipStreamCreate_(stream) bind(c, name="hipStreamCreate") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamCreate_ type(c_ptr) :: stream end function end interface !> @brief Creates an asynchronous stream with flag. !> !> @param[out] stream - Pointer to new stream !> @param[in] flags - Parameters to control stream creation !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> Creates a new asynchronous stream with its associated current device. @p stream returns an !> opaque handle that can be used to reference the newly created stream in subsequent hipStream* !> commands. The stream is allocated on the heap and will remain allocated even if the handle !> goes out-of-scope. To release the memory used by the stream, application must call !> hipStreamDestroy. !> !> The @p flags parameter controls behavior of the stream. The valid values are !> `hipStreamDefault` !> and `hipStreamNonBlocking`. !> !> @see hipStreamCreate, hipStreamCreateWithPriority, hipStreamSynchronize, hipStreamWaitEvent, !> hipStreamDestroy. interface hipStreamCreateWithFlags #ifdef USE_CUDA_NAMES function hipStreamCreateWithFlags_(stream,flags) bind(c, name="cudaStreamCreateWithFlags") #else function hipStreamCreateWithFlags_(stream,flags) bind(c, name="hipStreamCreateWithFlags") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamCreateWithFlags_ type(c_ptr) :: stream integer(c_int),value :: flags end function end interface !> @brief Creates an asynchronous stream with the specified priority. !> !> @param[out] stream - Pointer to new stream !> @param[in] flags - Parameters to control stream creation !> @param[in] priority - Priority of the stream. Lower numbers represent higher priorities. !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> Creates a new asynchronous stream with the specified priority, with its associated current !> device. !> @p stream returns an opaque handle that can be used to reference the newly created stream in !> subsequent hipStream* commands. The stream is allocated on the heap and will remain allocated !> even if the handle goes out-of-scope. To release the memory used by the stream, application !> must !> call hipStreamDestroy. !> !> The @p flags parameter controls behavior of the stream. The valid values are !> `hipStreamDefault` !> and `hipStreamNonBlocking`. !> !> @see hipStreamCreate, hipStreamSynchronize, hipStreamWaitEvent, hipStreamDestroy interface hipStreamCreateWithPriority #ifdef USE_CUDA_NAMES function hipStreamCreateWithPriority_(stream,flags,priority) & bind(c, name="cudaStreamCreateWithPriority") #else function hipStreamCreateWithPriority_(stream,flags,priority) & bind(c, name="hipStreamCreateWithPriority") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamCreateWithPriority_ type(c_ptr) :: stream integer(c_int),value :: flags integer(c_int),value :: priority end function end interface !> @brief Returns numerical values that correspond to the least and greatest stream priority. !> !> @param[in, out] leastPriority - Pointer in which a value corresponding to least priority !> is returned. !> @param[in, out] greatestPriority - Pointer in which a value corresponding to greatest priority !> is returned. !> @returns `hipSuccess` !> !> Returns in *leastPriority and *greatestPriority the numerical values that correspond to the !> least and greatest stream priority respectively. Stream priorities follow a convention where !> lower numbers imply greater priorities. The range of meaningful stream priorities is given by !> [*leastPriority,*greatestPriority]. If the user attempts to create a stream with a priority !> value that is outside the meaningful range as specified by this API, the priority is !> automatically clamped to within the valid range. !> !> @warning This API is under development on AMD GPUs and simply returns `hipSuccess`. interface hipDeviceGetStreamPriorityRange #ifdef USE_CUDA_NAMES function hipDeviceGetStreamPriorityRange_(leastPriority,greatestPriority) & bind(c, name="cudaDeviceGetStreamPriorityRange") #else function hipDeviceGetStreamPriorityRange_(leastPriority,greatestPriority) & bind(c, name="hipDeviceGetStreamPriorityRange") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceGetStreamPriorityRange_ integer(c_int) :: leastPriority integer(c_int) :: greatestPriority end function end interface !> @brief Destroys the specified stream. !> !> @param[in] stream - Stream identifier !> @returns `hipSuccess` `hipErrorInvalidHandle` !> !> Destroys the specified stream. !> !> If commands are still executing on the specified stream, some may complete execution before !> the !> queue is deleted. !> !> The queue may be destroyed while some commands are still inflight, or may wait for all !> commands !> queued to the stream before destroying it. !> !> @see hipStreamCreate, hipStreamCreateWithFlags, hipStreamCreateWithPriority, hipStreamQuery, !> hipStreamWaitEvent, hipStreamSynchronize interface hipStreamDestroy #ifdef USE_CUDA_NAMES function hipStreamDestroy_(stream) bind(c, name="cudaStreamDestroy") #else function hipStreamDestroy_(stream) bind(c, name="hipStreamDestroy") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamDestroy_ type(c_ptr),value :: stream end function end interface !> @brief Returns `hipSuccess` if all of the operations in the specified @p stream have !> completed, or !> `hipErrorNotReady` if not. !> !> @param[in] stream - Stream to query !> !> @returns `hipSuccess`, `hipErrorNotReady`, `hipErrorInvalidHandle` !> !> This is thread-safe and returns a snapshot of the current state of the queue. However, if !> other !> host threads are sending work to the stream, the status may change immediately after the !> function !> is called. It is typically used for debug. !> !> @see hipStreamCreate, hipStreamCreateWithFlags, hipStreamCreateWithPriority, !> hipStreamWaitEvent, !> hipStreamSynchronize, hipStreamDestroy interface hipStreamQuery #ifdef USE_CUDA_NAMES function hipStreamQuery_(stream) bind(c, name="cudaStreamQuery") #else function hipStreamQuery_(stream) bind(c, name="hipStreamQuery") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamQuery_ type(c_ptr),value :: stream end function end interface !> @brief Waits for all commands in the stream to complete. !> !> @param[in] stream - Stream identifier. !> !> @returns `hipSuccess`, `hipErrorInvalidHandle` !> !> This command is host-synchronous : the host will block until all operations on the specified !> stream with its associated device are completed. On multiple device systems, the @p stream is !> associated with its device, no need to call hipSetDevice before this API. !> !> This command follows standard null-stream semantics. Specifying the null stream will cause the !> command to wait for other streams on the same device to complete all pending operations. !> !> This command honors the `hipDeviceScheduleBlockingSync` flag, which controls whether the wait !> is !> active or blocking. !> !> @see hipStreamCreate, hipStreamCreateWithFlags, hipStreamCreateWithPriority, !> hipStreamWaitEvent, !> hipStreamDestroy interface hipStreamSynchronize #ifdef USE_CUDA_NAMES function hipStreamSynchronize_(stream) bind(c, name="cudaStreamSynchronize") #else function hipStreamSynchronize_(stream) bind(c, name="hipStreamSynchronize") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamSynchronize_ type(c_ptr),value :: stream end function end interface !> @brief Makes the specified compute stream wait for the specified event !> !> @param[in] stream - Stream to make wait !> @param[in] event - Event to wait on !> @param[in] flags - Parameters to control the operation !> !> @returns `hipSuccess`, `hipErrorInvalidHandle`, `hipErrorInvalidValue`, !> `hipErrorStreamCaptureIsolation` !> !> This function inserts a wait operation into the specified stream. !> All future work submitted to @p stream will wait until @p event reports completion before !> beginning execution. !> !> Flags include: !> hipEventWaitDefault: Default event creation flag. !> hipEventWaitExternal: Wait is captured in the graph as an external event node when !> performing stream capture !> !> This function only waits for commands in the current stream to complete. Notably, this !> function !> does not implicitly wait for commands in the default stream to complete, even if the specified !> stream is created with hipStreamNonBlocking = 0. !> !> @see hipStreamCreate, hipStreamCreateWithFlags, hipStreamCreateWithPriority, !> hipStreamSynchronize, hipStreamDestroy interface hipStreamWaitEvent #ifdef USE_CUDA_NAMES function hipStreamWaitEvent_(stream,event,flags) bind(c, name="cudaStreamWaitEvent") #else function hipStreamWaitEvent_(stream,event,flags) bind(c, name="hipStreamWaitEvent") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamWaitEvent_ type(c_ptr),value :: stream type(c_ptr),value :: event integer(c_int),value :: flags end function end interface !> @brief Returns flags associated with this stream. !> !> @param[in] stream - Stream to be queried !> @param[in,out] flags - Pointer to an unsigned integer in which the stream's flags are returned !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidHandle`. !> !> @see hipStreamCreateWithFlags interface hipStreamGetFlags #ifdef USE_CUDA_NAMES function hipStreamGetFlags_(stream,flags) bind(c, name="cudaStreamGetFlags") #else function hipStreamGetFlags_(stream,flags) bind(c, name="hipStreamGetFlags") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamGetFlags_ type(c_ptr),value :: stream integer(c_int) :: flags end function end interface !> @brief Queries the Id of a stream. !> !> @param[in] stream - Stream to be queried !> flags - Pointer to an unsigned long long in which the stream's id is returned !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidHandle`. !> !> @see hipStreamCreateWithFlags, hipStreamGetFlags, hipStreamCreateWithPriority, !> hipStreamGetPriority interface hipStreamGetId #ifdef USE_CUDA_NAMES function hipStreamGetId_(stream,streamId) bind(c, name="cudaStreamGetId") #else function hipStreamGetId_(stream,streamId) bind(c, name="hipStreamGetId") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamGetId_ type(c_ptr),value :: stream type(c_ptr),value :: streamId end function end interface !> @brief Queries the priority of a stream. !> !> @param[in] stream - Stream to be queried !> @param[in,out] priority - Pointer to an unsigned integer in which the stream's priority is !> returned !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidHandle`. !> !> @see hipStreamCreateWithPriority interface hipStreamGetPriority #ifdef USE_CUDA_NAMES function hipStreamGetPriority_(stream,priority) bind(c, name="cudaStreamGetPriority") #else function hipStreamGetPriority_(stream,priority) bind(c, name="hipStreamGetPriority") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamGetPriority_ type(c_ptr),value :: stream integer(c_int) :: priority end function end interface !> @brief Gets the device associated with the stream. !> !> @param[in] stream - Stream to be queried !> @param[out] device - Device associated with the stream !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorContextIsDestroyed`, !> `hipErrorInvalidHandle`, !> `hipErrorNotInitialized`, `hipErrorDeinitialized`, `hipErrorInvalidContext` !> !> @see hipStreamCreate, hipStreamDestroy, hipDeviceGetStreamPriorityRange interface hipStreamGetDevice #ifdef USE_CUDA_NAMES function hipStreamGetDevice_(stream,device) bind(c, name="cudaStreamGetDevice") #else function hipStreamGetDevice_(stream,device) bind(c, name="hipStreamGetDevice") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamGetDevice_ type(c_ptr),value :: stream integer(c_int) :: device end function end interface !> @brief Creates an asynchronous stream with the specified CU mask. !> !> @param[out] stream - Pointer to new stream !> @param[in] cuMaskSize - Size of CU mask bit array passed in. !> @param[in] cuMask - Bit-vector representing the CU mask. Each active bit represents using one !> CU. !> The first 32 bits represent the first 32 CUs, and so on. If its size is greater than physical !> CU number (i.e., multiProcessorCount member of hipDeviceProp_t), the extra elements are !> ignored. !> It is user's responsibility to make sure the input is meaningful. !> @returns `hipSuccess`, `hipErrorInvalidHandle`, `hipErrorInvalidValue` !> !> Creates a new asynchronous stream with the specified CU mask. @p stream returns an opaque !> handle that can be used to reference the newly created stream in subsequent hipStream* !> commands. !> The stream is allocated on the heap and will remain allocated even if the handle goes !> out-of-scope. To release the memory used by the stream, application must call !> hipStreamDestroy. !> !> @see hipStreamCreate, hipStreamSynchronize, hipStreamWaitEvent, hipStreamDestroy #ifndef USE_CUDA_NAMES interface hipExtStreamCreateWithCUMask function hipExtStreamCreateWithCUMask_(stream,cuMaskSize,cuMask) & bind(c, name="hipExtStreamCreateWithCUMask") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipExtStreamCreateWithCUMask_ type(c_ptr) :: stream integer(c_int32_t),value :: cuMaskSize type(c_ptr),value :: cuMask end function end interface #endif !> @brief Gets CU mask associated with an asynchronous stream !> !> @param[in] stream - Stream to be queried !> @param[in] cuMaskSize - Number of the block of memories (uint32_t *) allocated by user !> @param[out] cuMask - Pointer to a pre-allocated block of memories (uint32_t *) in which !> the stream's CU mask is returned. The CU mask is returned in a chunck of 32 bits where !> each active bit represents one active CU. !> @returns `hipSuccess`, `hipErrorInvalidHandle`, `hipErrorInvalidValue` !> !> @see hipStreamCreate, hipStreamSynchronize, hipStreamWaitEvent, hipStreamDestroy #ifndef USE_CUDA_NAMES interface hipExtStreamGetCUMask function hipExtStreamGetCUMask_(stream,cuMaskSize,cuMask) bind(c, name="hipExtStreamGetCUMask") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipExtStreamGetCUMask_ type(c_ptr),value :: stream integer(c_int32_t),value :: cuMaskSize type(c_ptr),value :: cuMask end function end interface #endif !> @brief Adds a callback to be called on the host after all currently enqueued items in the !> stream !> have completed. For each hipStreamAddCallback call, a callback will be executed exactly once. !> The callback will block later work in the stream until it is finished. !> !> @param[in] stream - Stream to add callback to !> @param[in] callback - The function to call once preceding stream operations are complete !> @param[in] userData - User specified data to be passed to the callback function !> @param[in] flags - Reserved for future use, must be 0 !> @returns `hipSuccess`, `hipErrorInvalidHandle`, `hipErrorNotSupported` !> !> @see hipStreamCreate, hipStreamCreateWithFlags, hipStreamQuery, hipStreamSynchronize, !> hipStreamWaitEvent, hipStreamDestroy, hipStreamCreateWithPriority interface hipStreamAddCallback #ifdef USE_CUDA_NAMES function hipStreamAddCallback_(stream,callback,userData,flags) & bind(c, name="cudaStreamAddCallback") #else function hipStreamAddCallback_(stream,callback,userData,flags) & bind(c, name="hipStreamAddCallback") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamAddCallback_ type(c_ptr),value :: stream type(c_funptr),value :: callback type(c_ptr),value :: userData integer(c_int),value :: flags end function end interface !> @brief Sets stream attribute. Updated attribute is applied to work submitted to the stream. !> @param[in] stream - Stream to set attributes to !> @param[in] attr - Attribute ID for the attribute to set !> @param[in] myValue - Attribute value for the attribute to set !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidResourceHandle` interface hipStreamSetAttribute #ifdef USE_CUDA_NAMES function hipStreamSetAttribute_(stream,attr,myValue) bind(c, name="cudaStreamSetAttribute") #else function hipStreamSetAttribute_(stream,attr,myValue) bind(c, name="hipStreamSetAttribute") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamSetAttribute_ type(c_ptr),value :: stream integer(kind(hipLaunchAttributeIgnore)),value :: attr type(c_ptr),value :: myValue end function end interface !> @brief queries stream attribute. !> @param[in] stream - Stream to geet attributes from !> @param[in] attr - Attribute ID for the attribute to query !> value - Attribute value output !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidResourceHandle` interface hipStreamGetAttribute #ifdef USE_CUDA_NAMES function hipStreamGetAttribute_(stream,attr,value_out) bind(c, name="cudaStreamGetAttribute") #else function hipStreamGetAttribute_(stream,attr,value_out) bind(c, name="hipStreamGetAttribute") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamGetAttribute_ type(c_ptr),value :: stream integer(kind(hipLaunchAttributeIgnore)),value :: attr type(c_ptr),value :: value_out end function end interface !> @brief Copies attributes from source stream to destination stream. !> @param[in] dst - Destination stream !> @param[in] src - Source stream !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipStreamCopyAttributes #ifdef USE_CUDA_NAMES function hipStreamCopyAttributes_(dst,src) bind(c, name="cudaStreamCopyAttributes") #else function hipStreamCopyAttributes_(dst,src) bind(c, name="hipStreamCopyAttributes") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamCopyAttributes_ type(c_ptr),value :: dst type(c_ptr),value :: src end function end interface !> @brief Enqueues a wait command to the stream.[BETA] !> !> @param [in] stream - Stream identifier !> @param [in] ptr - Pointer to memory object allocated using `hipMallocSignalMemory` flag !> @param [in] value - Value to be used in compare operation !> @param [in] flags - Defines the compare operation, supported values are !> `hipStreamWaitValueGte` !> `hipStreamWaitValueEq`, `hipStreamWaitValueAnd` and `hipStreamWaitValueNor` !> @param [in] mask - Mask to be applied on value at memory before it is compared with value, !> default value is set to enable every bit !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> Enqueues a wait command to the stream, all operations enqueued on this stream after this, will !> not execute until the defined wait condition is true. !> !> `hipStreamWaitValueGte`: waits until *ptr&mask >= value !> !> `hipStreamWaitValueEq` : waits until *ptr&mask == value !> !> `hipStreamWaitValueAnd`: waits until ((*ptr&mask) & value) != 0 !> !> `hipStreamWaitValueNor`: waits until ~((*ptr&mask) | (value&mask)) != 0 !> !> @note when using `hipStreamWaitValueNor`, mask is applied on both 'value' and '*ptr'. !> !> @note Support for `hipStreamWaitValue32` can be queried using 'hipDeviceGetAttribute()' and !> 'hipDeviceAttributeCanUseStreamWaitValue' flag. !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @see hipExtMallocWithFlags, hipFree, hipStreamWaitValue64, hipStreamWriteValue64, !> hipStreamWriteValue32, hipDeviceGetAttribute interface hipStreamWaitValue32 #ifdef USE_CUDA_NAMES function hipStreamWaitValue32_(stream,ptr,myValue,flags,mask) & bind(c, name="cuStreamWaitValue32") #else function hipStreamWaitValue32_(stream,ptr,myValue,flags,mask) & bind(c, name="hipStreamWaitValue32") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamWaitValue32_ type(c_ptr),value :: stream type(c_ptr),value :: ptr integer(c_int32_t),value :: myValue integer(c_int),value :: flags integer(c_int32_t),value :: mask end function end interface !> @brief Enqueues a wait command to the stream.[BETA] !> !> @param [in] stream - Stream identifier !> @param [in] ptr - Pointer to memory object allocated using 'hipMallocSignalMemory' flag !> @param [in] value - Value to be used in compare operation !> @param [in] flags - Defines the compare operation, supported values are !> `hipStreamWaitValueGte` !> `hipStreamWaitValueEq`, `hipStreamWaitValueAnd` and `hipStreamWaitValueNor`. !> @param [in] mask - Mask to be applied on value at memory before it is compared with value !> default value is set to enable every bit !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> Enqueues a wait command to the stream, all operations enqueued on this stream after this, will !> not execute until the defined wait condition is true. !> !> `hipStreamWaitValueGte`: waits until *ptr&mask >= value !> !> `hipStreamWaitValueEq` : waits until *ptr&mask == value !> !> `hipStreamWaitValueAnd`: waits until ((*ptr&mask) & value) != 0 !> !> `hipStreamWaitValueNor`: waits until ~((*ptr&mask) | (value&mask)) != 0 !> !> @note when using `hipStreamWaitValueNor`, mask is applied on both 'value' and '*ptr'. !> !> @note Support for hipStreamWaitValue64 can be queried using 'hipDeviceGetAttribute()' and !> 'hipDeviceAttributeCanUseStreamWaitValue' flag. !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @see hipExtMallocWithFlags, hipFree, hipStreamWaitValue32, hipStreamWriteValue64, !> hipStreamWriteValue32, hipDeviceGetAttribute interface hipStreamWaitValue64 #ifdef USE_CUDA_NAMES function hipStreamWaitValue64_(stream,ptr,myValue,flags,mask) & bind(c, name="cuStreamWaitValue64") #else function hipStreamWaitValue64_(stream,ptr,myValue,flags,mask) & bind(c, name="hipStreamWaitValue64") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamWaitValue64_ type(c_ptr),value :: stream type(c_ptr),value :: ptr integer(c_int64_t),value :: myValue integer(c_int),value :: flags integer(c_int64_t),value :: mask end function end interface !> @brief Enqueues a write command to the stream.[BETA] !> !> @param [in] stream - Stream identifier !> @param [in] ptr - Pointer to a GPU accessible memory object !> @param [in] value - Value to be written !> @param [in] flags - reserved, ignored for now, will be used in future releases !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> Enqueues a write command to the stream, write operation is performed after all earlier !> commands !> on this stream have completed the execution. !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @see hipExtMallocWithFlags, hipFree, hipStreamWriteValue32, hipStreamWaitValue32, !> hipStreamWaitValue64 #ifndef USE_CUDA_NAMES interface hipStreamWriteValue32 function hipStreamWriteValue32_(stream,ptr,myValue,flags) bind(c, name="hipStreamWriteValue32") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamWriteValue32_ type(c_ptr),value :: stream type(c_ptr),value :: ptr integer(c_int32_t),value :: myValue integer(c_int),value :: flags end function end interface #endif !> @brief Enqueues a write command to the stream.[BETA] !> !> @param [in] stream - Stream identifier !> @param [in] ptr - Pointer to a GPU accessible memory object !> @param [in] value - Value to be written !> @param [in] flags - reserved, ignored for now, will be used in future releases !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> Enqueues a write command to the stream, write operation is performed after all earlier !> commands !> on this stream have completed the execution. !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @see hipExtMallocWithFlags, hipFree, hipStreamWriteValue32, hipStreamWaitValue32, !> hipStreamWaitValue64 #ifndef USE_CUDA_NAMES interface hipStreamWriteValue64 function hipStreamWriteValue64_(stream,ptr,myValue,flags) bind(c, name="hipStreamWriteValue64") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamWriteValue64_ type(c_ptr),value :: stream type(c_ptr),value :: ptr integer(c_int64_t),value :: myValue integer(c_int),value :: flags end function end interface #endif !> @brief Enqueues an array of stream memory operations in the stream.[BETA] !> !> @param [in] stream - Stream identifier !> @param [in] count - The number of operations in the array. Must be less than 256 !> @param [in] paramArray - The types and parameters of the individual operations. !> @param [in] flags - Reserved for future expansion; must be 0. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> Batch operations to synchronize the stream via memory operations. !> !> @warning This API is marked as beta, meaning, while this is feature complete, !> it is still open to changes and may have outstanding issues. !> !> @see hipStreamWriteValue32, hipStreamWaitValue32, !> hipStreamWaitValue64. hipStreamWriteValue64 interface hipStreamBatchMemOp #ifdef USE_CUDA_NAMES function hipStreamBatchMemOp_(stream,count,paramArray,flags) bind(c, name="cuStreamBatchMemOp") #else function hipStreamBatchMemOp_(stream,count,paramArray,flags) bind(c, name="hipStreamBatchMemOp") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamBatchMemOp_ type(c_ptr),value :: stream integer(c_int),value :: count type(c_ptr),value :: paramArray integer(c_int),value :: flags end function end interface !> @brief Creates a batch memory operation node and adds it to a graph.[BETA] !> !> @param [out] phGraphNode - Returns the newly created node !> @param [in] hGraph - Graph to which to add the node !> @param [in] dependencies - Dependencies of the node !> @param [in] numDependencies - Number of dependencies !> @param [in] nodeParams - Parameters for the node !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @warning This API is marked as beta, meaning, while this is feature complete, !> it is still open to changes and may have outstanding issues. !> !> @see hipStreamWriteValue32, hipStreamWaitValue32, !> hipStreamWaitValue64. hipStreamWriteValue64, hipStreamBatchMemOp interface hipGraphAddBatchMemOpNode #ifdef USE_CUDA_NAMES function hipGraphAddBatchMemOpNode_(phGraphNode,hGraph,dependencies,numDependencies, & nodeParams) & bind(c, name="cuGraphAddBatchMemOpNode") #else function hipGraphAddBatchMemOpNode_(phGraphNode,hGraph,dependencies,numDependencies, & nodeParams) & bind(c, name="hipGraphAddBatchMemOpNode") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphAddBatchMemOpNode_ type(c_ptr) :: phGraphNode type(c_ptr),value :: hGraph type(c_ptr) :: dependencies integer(c_size_t),value :: numDependencies type(hipBatchMemOpNodeParams) :: nodeParams end function end interface !> @brief Returns a batch mem op node's parameters.[BETA] !> !> @param [in] hNode - Node to get the parameters for !> @param [in] nodeParams_out - Pointer to return the parameters !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> Returns the parameters of batch mem op node hNode in nodeParams_out. !> The paramArray returned in nodeParams_out is owned by the node. !> This memory remains valid until the node is destroyed or its parameters are modified, !> and should not be modified directly. !> !> @warning This API is marked as beta, meaning, while this is feature complete, !> it is still open to changes and may have outstanding issues. !> !> @see hipStreamWriteValue32, hipStreamWaitValue32, !> hipStreamWaitValue64. hipStreamWriteValue64. hipGraphBatchMemOpNodeSetParams interface hipGraphBatchMemOpNodeGetParams #ifdef USE_CUDA_NAMES function hipGraphBatchMemOpNodeGetParams_(hNode,nodeParams_out) & bind(c, name="cuGraphBatchMemOpNodeGetParams") #else function hipGraphBatchMemOpNodeGetParams_(hNode,nodeParams_out) & bind(c, name="hipGraphBatchMemOpNodeGetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphBatchMemOpNodeGetParams_ type(c_ptr),value :: hNode type(hipBatchMemOpNodeParams) :: nodeParams_out end function end interface !> @brief Sets the batch mem op node's parameters.[BETA] !> !> @param [in] hNode - Node to set the parameters for !> @param [in] nodeParams - Parameters to copy !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> Sets the parameters of batch mem op node hNode to nodeParams. !> !> @warning This API is marked as beta, meaning, while this is feature complete, !> it is still open to changes and may have outstanding issues. !> !> @see hipStreamWriteValue32, hipStreamWaitValue32, !> hipStreamWaitValue64. hipStreamWriteValue64, hipGraphBatchMemOpNodeGetParams interface hipGraphBatchMemOpNodeSetParams #ifdef USE_CUDA_NAMES function hipGraphBatchMemOpNodeSetParams_(hNode,nodeParams) & bind(c, name="cuGraphBatchMemOpNodeSetParams") #else function hipGraphBatchMemOpNodeSetParams_(hNode,nodeParams) & bind(c, name="hipGraphBatchMemOpNodeSetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphBatchMemOpNodeSetParams_ type(c_ptr),value :: hNode type(hipBatchMemOpNodeParams) :: nodeParams end function end interface !> @brief Sets the parameters for a batch mem op node in the given graphExec.[BETA] !> !> @param [in] hGraphExec - The executable graph in which to set the specified node !> @param [in] hNode - Batch mem op node from the graph from which graphExec was instantiated !> @param [in] nodeParams - Updated Parameters to set !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> Sets the parameters of a batch mem op node in an executable graph hGraphExec. !> The node is identified by the corresponding node hNode in the non-executable graph, !> from which the executable graph was instantiated. !> !> @warning This API is marked as beta, meaning, while this is feature complete, !> it is still open to changes and may have outstanding issues. !> !> @see hipStreamWriteValue32, hipStreamWaitValue32, !> hipStreamWaitValue64. hipStreamWriteValue64, hipStreamBatchMemOp interface hipGraphExecBatchMemOpNodeSetParams #ifdef USE_CUDA_NAMES function hipGraphExecBatchMemOpNodeSetParams_(hGraphExec,hNode,nodeParams) & bind(c, name="cuGraphExecBatchMemOpNodeSetParams") #else function hipGraphExecBatchMemOpNodeSetParams_(hGraphExec,hNode,nodeParams) & bind(c, name="hipGraphExecBatchMemOpNodeSetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphExecBatchMemOpNodeSetParams_ type(c_ptr),value :: hGraphExec type(c_ptr),value :: hNode type(hipBatchMemOpNodeParams) :: nodeParams end function end interface !> ------------------------------------------------------------------------------------------------- !> ------------------------------------------------------------------------------------------------- !> @defgroup Event Event Management !> !> This section describes the event management functions of HIP runtime API. !> !> !> @brief Create an event with the specified flags !> !> @param[out] event - Returns the newly created event. !> @param[in] flags - Flags to control event behavior. Valid values are `hipEventDefault`, !> `hipEventBlockingSync`, `hipEventDisableTiming`, `hipEventInterprocess` !> `hipEventDefault` : Default flag. The event will use active synchronization and will support !> timing. Blocking synchronization provides lowest possible latency at the expense of dedicating !> a !> CPU to poll on the event. !> `hipEventBlockingSync` : The event will use blocking synchronization : if hipEventSynchronize !> is !> called on this event, the thread will block until the event completes. This can increase !> latency !> for the synchroniation but can result in lower power and more resources for other CPU threads. !> `hipEventDisableTiming` : Disable recording of timing information. Events created with this !> flag !> would not record profiling data and provide best performance if used for synchronization. !> `hipEventInterprocess` : The event can be used as an interprocess event. hipEventDisableTiming !> flag also must be set when hipEventInterprocess flag is set. !> `hipEventDisableSystemFence` : Disable acquire and release system scope fence. This may !> improve performance but device memory may not be visible to the host and other devices !> if this flag is set. !> !> @returns `hipSuccess`, `hipErrorNotInitialized`, `hipErrorInvalidValue`, !> `hipErrorLaunchFailure`, `hipErrorOutOfMemory` !> !> @see hipEventCreate, hipEventSynchronize, hipEventDestroy, hipEventElapsedTime interface hipEventCreateWithFlags #ifdef USE_CUDA_NAMES function hipEventCreateWithFlags_(event,flags) bind(c, name="cudaEventCreateWithFlags") #else function hipEventCreateWithFlags_(event,flags) bind(c, name="hipEventCreateWithFlags") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipEventCreateWithFlags_ type(c_ptr) :: event integer(c_int),value :: flags end function end interface !> Create an event !> !> @param[out] event - Returns the newly created event. !> !> @returns `hipSuccess`, `hipErrorNotInitialized`, `hipErrorInvalidValue`, !> `hipErrorLaunchFailure`, `hipErrorOutOfMemory` !> !> @see hipEventCreateWithFlags, hipEventRecord, hipEventQuery, hipEventSynchronize, !> hipEventDestroy, hipEventElapsedTime interface hipEventCreate #ifdef USE_CUDA_NAMES function hipEventCreate_(event) bind(c, name="cudaEventCreate") #else function hipEventCreate_(event) bind(c, name="hipEventCreate") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipEventCreate_ type(c_ptr) :: event end function end interface !> @brief Record an event in the specified stream. !> !> @param[in] event - event to record. !> @param[in] stream - stream in which to record event. !> @param[in] flags - parameter for operations !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotInitialized`, !> `hipErrorInvalidHandle`, `hipErrorLaunchFailure` !> !> hipEventQuery() or hipEventSynchronize() must be used to determine when the event !> transitions from "recording" (after hipEventRecord() is called) to "recorded" !> (when timestamps are set, if requested). !> !> Events which are recorded in a non-NULL stream will transition to !> from recording to "recorded" state when they reach the head of !> the specified stream, after all previous !> commands in that stream have completed executing. !> !> Flags include: !> hipEventRecordDefault: Default event creation flag. !> hipEventRecordExternal: Event is captured in the graph as an external event node when !> performing stream capture !> !> If hipEventRecord() has been previously called on this event, then this call will overwrite !> any !> existing state in event. !> !> If this function is called on an event that is currently being recorded, results are undefined !> - either outstanding recording may save state into the event, and the order is not guaranteed. !> !> @note: If this function is not called before use hipEventQuery() or hipEventSynchronize(), !> `hipSuccess` is returned, meaning no pending event in the stream. !> !> @see hipEventCreate, hipEventCreateWithFlags, hipEventQuery, hipEventSynchronize, !> hipEventDestroy, hipEventElapsedTime interface hipEventRecordWithFlags #ifdef USE_CUDA_NAMES function hipEventRecordWithFlags_(event,stream,flags) bind(c, name="cudaEventRecordWithFlags") #else function hipEventRecordWithFlags_(event,stream,flags) bind(c, name="hipEventRecordWithFlags") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipEventRecordWithFlags_ type(c_ptr),value :: event type(c_ptr),value :: stream integer(c_int),value :: flags end function end interface interface hipEventRecord #ifdef USE_CUDA_NAMES function hipEventRecord_(event,stream) bind(c, name="cudaEventRecord") #else function hipEventRecord_(event,stream) bind(c, name="hipEventRecord") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipEventRecord_ type(c_ptr),value :: event type(c_ptr),value :: stream end function end interface !> @brief Destroy the specified event. !> !> @param[in] event - Event to destroy. !> @returns `hipSuccess`, `hipErrorNotInitialized`, `hipErrorInvalidValue`, !> `hipErrorLaunchFailure` !> !> Releases memory associated with the event. If the event is recording but has not completed !> recording when hipEventDestroy() is called, the function will return immediately and the !> completion_future resources will be released later, when the hipDevice is synchronized. !> !> @see hipEventCreate, hipEventCreateWithFlags, hipEventQuery, hipEventSynchronize, !> hipEventRecord, !> hipEventElapsedTime !> !> @returns `hipSuccess` interface hipEventDestroy #ifdef USE_CUDA_NAMES function hipEventDestroy_(event) bind(c, name="cudaEventDestroy") #else function hipEventDestroy_(event) bind(c, name="hipEventDestroy") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipEventDestroy_ type(c_ptr),value :: event end function end interface !> @brief Wait for an event to complete. !> !> This function will block until the event is ready, waiting for all previous work in the !> stream !> specified when event was recorded with hipEventRecord(). !> !> If hipEventRecord() has not been called on @p event, this function returns `hipSuccess` when !> no !> event is captured. !> !> !> @param[in] event - Event on which to wait. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotInitialized`, !> `hipErrorInvalidHandle`, `hipErrorLaunchFailure` !> !> @see hipEventCreate, hipEventCreateWithFlags, hipEventQuery, hipEventDestroy, hipEventRecord, !> hipEventElapsedTime interface hipEventSynchronize #ifdef USE_CUDA_NAMES function hipEventSynchronize_(event) bind(c, name="cudaEventSynchronize") #else function hipEventSynchronize_(event) bind(c, name="hipEventSynchronize") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipEventSynchronize_ type(c_ptr),value :: event end function end interface !> @brief Return the elapsed time between two events. !> !> @param[out] ms - : Return time between start and stop in ms. !> @param[in] start - : Start event. !> @param[in] myStop - : Stop event. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotReady`, `hipErrorInvalidHandle`, !> `hipErrorNotInitialized`, `hipErrorLaunchFailure` !> !> Computes the elapsed time between two events. Time is computed in ms, with !> a resolution of approximately 1 us. !> !> Events which are recorded in a NULL stream will block until all commands !> on all other streams complete execution, and then record the timestamp. !> !> Events which are recorded in a non-NULL stream will record their timestamp !> when they reach the head of the specified stream, after all previous !> commands in that stream have completed executing. Thus the time that !> the event recorded may be significantly after the host calls hipEventRecord(). !> !> If hipEventRecord() has not been called on either event, then `hipErrorInvalidHandle` is !> returned. If hipEventRecord() has been called on both events, but the timestamp has not yet !> been !> recorded on one or both events (that is, hipEventQuery() would return `hipErrorNotReady` on at !> least one of the events), then `hipErrorNotReady` is returned. !> !> @see hipEventCreate, hipEventCreateWithFlags, hipEventQuery, hipEventDestroy, hipEventRecord, !> hipEventSynchronize interface hipEventElapsedTime #ifdef USE_CUDA_NAMES function hipEventElapsedTime_(ms,start,myStop) bind(c, name="cudaEventElapsedTime") #else function hipEventElapsedTime_(ms,start,myStop) bind(c, name="hipEventElapsedTime") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipEventElapsedTime_ real(c_float) :: ms type(c_ptr),value :: start type(c_ptr),value :: myStop end function end interface !> @brief Query event status !> !> @param[in] event - Event to query. !> @returns `hipSuccess`, `hipErrorNotReady`, `hipErrorInvalidHandle`, `hipErrorInvalidValue`, !> `hipErrorNotInitialized`, `hipErrorLaunchFailure` !> !> Query the status of the specified event. This function will return `hipSuccess` if all !> commands in the appropriate stream (specified to hipEventRecord()) have completed. If any !> execution has not completed, then `hipErrorNotReady` is returned. !> !> @note This API returns `hipSuccess`, if hipEventRecord() is not called before this API. !> !> @see hipEventCreate, hipEventCreateWithFlags, hipEventRecord, hipEventDestroy, !> hipEventSynchronize, hipEventElapsedTime interface hipEventQuery #ifdef USE_CUDA_NAMES function hipEventQuery_(event) bind(c, name="cudaEventQuery") #else function hipEventQuery_(event) bind(c, name="hipEventQuery") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipEventQuery_ type(c_ptr),value :: event end function end interface !> @brief Sets information on the specified pointer.[BETA] !> !> @param [in] value Sets pointer attribute value !> @param [in] attribute Attribute to set !> @param [in] ptr Pointer to set attributes for !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue` !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. interface hipPointerSetAttribute #ifdef USE_CUDA_NAMES function hipPointerSetAttribute_(myValue,attribute,ptr) bind(c, name="cuPointerSetAttribute") #else function hipPointerSetAttribute_(myValue,attribute,ptr) bind(c, name="hipPointerSetAttribute") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipPointerSetAttribute_ type(c_ptr),value :: myValue integer(kind(HIP_POINTER_ATTRIBUTE_CONTEXT)),value :: attribute type(c_ptr),value :: ptr end function end interface !> @brief Returns attributes for the specified pointer !> !> @param [out] attributes attributes for the specified pointer !> @param [in] ptr pointer to get attributes for !> !> The output parameter 'attributes' has a member named 'type' that describes what memory the !> pointer is associated with, such as device memory, host memory, managed memory, and others. !> Otherwise, the API cannot handle the pointer and returns `hipErrorInvalidValue`. !> !> @note The unrecognized memory type is unsupported to keep the HIP functionality backward !> compatibility due to `hipMemoryType` enum values. !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue` !> !> @note The current behavior of this HIP API corresponds to the CUDA API before version 11.0. !> !> @see hipPointerGetAttribute interface hipPointerGetAttributes #ifdef USE_CUDA_NAMES function hipPointerGetAttributes_(attributes,ptr) bind(c, name="cudaPointerGetAttributes") #else function hipPointerGetAttributes_(attributes,ptr) bind(c, name="hipPointerGetAttributes") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipPointerGetAttributes_ type(hipPointerAttribute_t) :: attributes type(c_ptr),value :: ptr end function end interface !> @brief Returns information about the specified pointer.[BETA] !> !> @param [in, out] data Returned pointer attribute value !> @param [in] attribute Attribute to query for !> @param [in] ptr Pointer to get attributes for !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue` !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @see hipPointerGetAttributes #ifndef USE_CUDA_NAMES interface hipPointerGetAttribute function hipPointerGetAttribute_(myData,attribute,ptr) bind(c, name="hipPointerGetAttribute") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipPointerGetAttribute_ type(c_ptr),value :: myData integer(kind(HIP_POINTER_ATTRIBUTE_CONTEXT)),value :: attribute type(c_ptr),value :: ptr end function end interface #endif !> @brief Returns information about the specified pointer.[BETA] !> !> @param [in] numAttributes number of attributes to query for !> @param [in] attributes attributes to query for !> @param [in, out] data a two-dimensional containing pointers to memory locations !> where the result of each attribute query will be written to !> @param [in] ptr pointer to get attributes for !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue` !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @see hipPointerGetAttribute #ifndef USE_CUDA_NAMES interface hipDrvPointerGetAttributes function hipDrvPointerGetAttributes_(numAttributes,attributes,myData,ptr) & bind(c, name="hipDrvPointerGetAttributes") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDrvPointerGetAttributes_ integer(c_int),value :: numAttributes type(c_ptr),value :: attributes type(c_ptr) :: myData type(c_ptr),value :: ptr end function end interface #endif !> ------------------------------------------------------------------------------------------------- !> ------------------------------------------------------------------------------------------------- !> @defgroup External External Resource Interoperability !> !> @ingroup API !> !> This section describes the external resource interoperability functions of HIP runtime API. !> !> !> !> @brief Imports an external semaphore. !> !> @param[out] extSem_out - External semaphores to be waited on !> @param[in] semHandleDesc - Semaphore import handle descriptor !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue` !> !> @see !> !> @note This API is currently not supported on Linux. interface hipImportExternalSemaphore #ifdef USE_CUDA_NAMES function hipImportExternalSemaphore_(extSem_out,semHandleDesc) & bind(c, name="cudaImportExternalSemaphore") #else function hipImportExternalSemaphore_(extSem_out,semHandleDesc) & bind(c, name="hipImportExternalSemaphore") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipImportExternalSemaphore_ type(c_ptr) :: extSem_out type(hipExternalSemaphoreHandleDesc) :: semHandleDesc end function end interface !> @brief Signals a set of external semaphore objects. !> !> @param[in] extSemArray - External semaphores to be waited on !> @param[in] paramsArray - Array of semaphore parameters !> @param[in] numExtSems - Number of semaphores to wait on !> @param[in] stream - Stream to enqueue the wait operations in !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue` !> !> @see !> !> @note This API is currently not supported on Linux. interface hipSignalExternalSemaphoresAsync #ifdef USE_CUDA_NAMES function hipSignalExternalSemaphoresAsync_(extSemArray,paramsArray,numExtSems,stream) & bind(c, name="cudaSignalExternalSemaphoresAsync") #else function hipSignalExternalSemaphoresAsync_(extSemArray,paramsArray,numExtSems,stream) & bind(c, name="hipSignalExternalSemaphoresAsync") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipSignalExternalSemaphoresAsync_ type(c_ptr) :: extSemArray type(hipExternalSemaphoreSignalParams) :: paramsArray integer(c_int),value :: numExtSems type(c_ptr),value :: stream end function end interface !> @brief Waits on a set of external semaphore objects !> !> @param[in] extSemArray - External semaphores to be waited on !> @param[in] paramsArray - Array of semaphore parameters !> @param[in] numExtSems - Number of semaphores to wait on !> @param[in] stream - Stream to enqueue the wait operations in !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue` !> !> @see !> !> @note This API is currently not supported on Linux. interface hipWaitExternalSemaphoresAsync #ifdef USE_CUDA_NAMES function hipWaitExternalSemaphoresAsync_(extSemArray,paramsArray,numExtSems,stream) & bind(c, name="cudaWaitExternalSemaphoresAsync") #else function hipWaitExternalSemaphoresAsync_(extSemArray,paramsArray,numExtSems,stream) & bind(c, name="hipWaitExternalSemaphoresAsync") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipWaitExternalSemaphoresAsync_ type(c_ptr) :: extSemArray type(hipExternalSemaphoreWaitParams) :: paramsArray integer(c_int),value :: numExtSems type(c_ptr),value :: stream end function end interface !> @brief Destroys an external semaphore object and releases any references to the underlying !> resource. Any outstanding signals or waits must have completed before the semaphore is !> destroyed. !> !> @param[in] extSem - handle to an external memory object !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue` !> !> @see !> !> @note This API is currently not supported on Linux. interface hipDestroyExternalSemaphore #ifdef USE_CUDA_NAMES function hipDestroyExternalSemaphore_(extSem) bind(c, name="cudaDestroyExternalSemaphore") #else function hipDestroyExternalSemaphore_(extSem) bind(c, name="hipDestroyExternalSemaphore") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDestroyExternalSemaphore_ type(c_ptr),value :: extSem end function end interface !> @brief Imports an external memory object. !> !> @param[out] extMem_out - Returned handle to an external memory object !> @param[in] memHandleDesc - Memory import handle descriptor !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue` !> !> @see interface hipImportExternalMemory #ifdef USE_CUDA_NAMES function hipImportExternalMemory_(extMem_out,memHandleDesc) & bind(c, name="cudaImportExternalMemory") #else function hipImportExternalMemory_(extMem_out,memHandleDesc) & bind(c, name="hipImportExternalMemory") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipImportExternalMemory_ type(c_ptr) :: extMem_out type(hipExternalMemoryHandleDesc) :: memHandleDesc end function end interface !> @brief Maps a buffer onto an imported memory object. !> !> @param[out] devPtr - Returned device pointer to buffer !> @param[in] extMem - Handle to external memory object !> @param[in] bufferDesc - Buffer descriptor !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue` !> !> @see interface hipExternalMemoryGetMappedBuffer #ifdef USE_CUDA_NAMES function hipExternalMemoryGetMappedBuffer_(devPtr,extMem,bufferDesc) & bind(c, name="cudaExternalMemoryGetMappedBuffer") #else function hipExternalMemoryGetMappedBuffer_(devPtr,extMem,bufferDesc) & bind(c, name="hipExternalMemoryGetMappedBuffer") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipExternalMemoryGetMappedBuffer_ type(c_ptr) :: devPtr type(c_ptr),value :: extMem type(hipExternalMemoryBufferDesc) :: bufferDesc end function end interface !> @brief Destroys an external memory object. !> !> @param[in] extMem - External memory object to be destroyed !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue` !> !> @see interface hipDestroyExternalMemory #ifdef USE_CUDA_NAMES function hipDestroyExternalMemory_(extMem) bind(c, name="cudaDestroyExternalMemory") #else function hipDestroyExternalMemory_(extMem) bind(c, name="hipDestroyExternalMemory") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDestroyExternalMemory_ type(c_ptr),value :: extMem end function end interface !> @brief Maps a mipmapped array onto an external memory object. !> !> @param[out] mipmap - mipmapped array to return !> @param[in] extMem - external memory object handle !> @param[in] mipmapDesc - external mipmapped array descriptor !> !> Returned mipmapped array must be freed using hipFreeMipmappedArray. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidResourceHandle` !> !> @see hipImportExternalMemory, hipDestroyExternalMemory, hipExternalMemoryGetMappedBuffer, !> hipFreeMipmappedArray interface hipExternalMemoryGetMappedMipmappedArray #ifdef USE_CUDA_NAMES function hipExternalMemoryGetMappedMipmappedArray_(mipmap,extMem,mipmapDesc) & bind(c, name="cudaExternalMemoryGetMappedMipmappedArray") #else function hipExternalMemoryGetMappedMipmappedArray_(mipmap,extMem,mipmapDesc) & bind(c, name="hipExternalMemoryGetMappedMipmappedArray") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipExternalMemoryGetMappedMipmappedArray_ type(c_ptr) :: mipmap type(c_ptr),value :: extMem type(hipExternalMemoryMipmappedArrayDesc) :: mipmapDesc end function end interface !> @brief Allocate memory on the default accelerator !> !> @param[out] ptr - Pointer to the allocated memory !> @param[in] sizeBytes - Requested memory size !> @param[in] flags - Type of memory allocation !> !> If requested memory size is 0, no memory is allocated, *ptr returns nullptr, and `hipSuccess` !> is returned. !> !> The memory allocation flag should be either `hipDeviceMallocDefault`, !> `hipDeviceMallocFinegrained`, `hipDeviceMallocUncached`, or `hipMallocSignalMemory`. !> If the flag is any other value, the API returns `hipErrorInvalidValue`. !> !> @returns `hipSuccess`, `hipErrorOutOfMemory`, `hipErrorInvalidValue` (bad context, null *ptr) !> !> @see hipMallocPitch, hipFree, hipMallocArray, hipFreeArray, hipMalloc3D, hipMalloc3DArray, !> hipHostFree, hiHostMalloc #ifndef USE_CUDA_NAMES interface hipExtMallocWithFlags function hipExtMallocWithFlags_(ptr,sizeBytes,flags) bind(c, name="hipExtMallocWithFlags") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipExtMallocWithFlags_ type(c_ptr) :: ptr integer(c_size_t),value :: sizeBytes integer(c_int),value :: flags end function end interface #endif !> @brief Allocate pinned host memory [Deprecated] !> !> @param[out] ptr - Pointer to the allocated host pinned memory !> @param[in] mySize - Requested memory size !> !> If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned. !> !> @returns `hipSuccess`, `hipErrorOutOfMemory` !> !> @warning This API is deprecated, use hipHostMalloc() instead interface hipMallocHost #ifdef USE_CUDA_NAMES function hipMallocHost_(ptr,mySize) bind(c, name="cudaMallocHost") #else function hipMallocHost_(ptr,mySize) bind(c, name="hipMallocHost") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMallocHost_ type(c_ptr) :: ptr integer(c_size_t),value :: mySize end function end interface !> @brief Allocate pinned host memory [Deprecated] !> !> @param[out] ptr - Pointer to the allocated host pinned memory !> @param[in] mySize - Requested memory size !> !> If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned. !> !> @returns `hipSuccess`, `hipErrorOutOfMemory` !> !> @warning This API is deprecated, use hipHostMalloc() instead #ifndef USE_CUDA_NAMES interface hipMemAllocHost function hipMemAllocHost_(ptr,mySize) bind(c, name="hipMemAllocHost") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemAllocHost_ type(c_ptr) :: ptr integer(c_size_t),value :: mySize end function end interface #endif !> @brief Prefetches memory to the specified destination device using HIP. !> !> @param [in] dev_ptr pointer to be prefetched !> @param [in] count size in bytes for prefetching !> @param [in] device destination device to prefetch to !> @param [in] stream stream to enqueue prefetch operation !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. #ifndef USE_CUDA_NAMES interface hipMemPrefetchAsync function hipMemPrefetchAsync_(dev_ptr,count,device,stream) bind(c, name="hipMemPrefetchAsync") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemPrefetchAsync_ type(c_ptr),value :: dev_ptr integer(c_size_t),value :: count integer(c_int),value :: device type(c_ptr),value :: stream end function end interface #endif !> @brief Prefetches memory to the specified destination device using HIP. !> !> @param [in] dev_ptr pointer to be prefetched !> @param [in] count size in bytes for prefetching !> @param [in] location destination location to prefetch to !> @param [in] flags flags for future use, must be zero now. !> @param [in] stream stream to enqueue prefetch operation !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemPrefetchAsync_v2 #ifdef USE_CUDA_NAMES function hipMemPrefetchAsync_v2_(dev_ptr,count,location,flags,stream) & bind(c, name="cuMemPrefetchAsync_v2") #else function hipMemPrefetchAsync_v2_(dev_ptr,count,location,flags,stream) & bind(c, name="hipMemPrefetchAsync_v2") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemPrefetchAsync_v2_ type(c_ptr),value :: dev_ptr integer(c_size_t),value :: count type(hipMemLocation),value :: location integer(c_int),value :: flags type(c_ptr),value :: stream end function end interface !> @brief Prefetches a batch of memory ranges to the specified locations using HIP. !> !> @param [in] dev_ptrs pointers to the memory ranges to prefetch !> @param [in] sizes sizes in bytes of the memory ranges to prefetch !> @param [in] count number of memory ranges to prefetch !> @param [in] prefetch_locs locations to prefetch the memory ranges to !> @param [in] prefetch_loc_idxs indices of the memory ranges to prefetch !> @param [in] num_prefetch_locs number of locations to prefetch !> @param [in] flags flags for future use, must be zero now. !> @param [in] stream stream to enqueue the prefetch operation !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. #ifndef USE_CUDA_NAMES interface hipMemPrefetchBatchAsync function hipMemPrefetchBatchAsync_(dev_ptrs,sizes,count,prefetch_locs,prefetch_loc_idxs, & num_prefetch_locs,flags,stream) & bind(c, name="hipMemPrefetchBatchAsync") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemPrefetchBatchAsync_ type(c_ptr) :: dev_ptrs type(c_ptr),value :: sizes integer(c_size_t),value :: count type(hipMemLocation) :: prefetch_locs type(c_ptr),value :: prefetch_loc_idxs integer(c_size_t),value :: num_prefetch_locs integer(c_int64_t),value :: flags type(c_ptr),value :: stream end function end interface #endif !> @brief Discards a batch of memory ranges asynchronously. !> !> @param [in] dev_ptrs pointers to the memory ranges to discard !> @param [in] sizes sizes in bytes of the memory ranges to discard !> @param [in] count number of memory ranges to discard !> @param [in] flags flags for future use, must be zero now. !> @param [in] stream stream to enqueue the discard operation !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning Reading from a discarded range without first writing or prefetching !> to it will return an indeterminate value. !> @warning Concurrent reads, writes, or prefetches to discarded ranges result !> in undefined behavior. !> !> @note All memory ranges must be managed memory allocated via hipMallocManaged !> or system-allocated memory (if device supports pageable memory access). !> @note This API is implemented on Linux and requires XNACK to be enabled. !> @note This API is marked as beta, meaning, while this is feature complete, !> it is still open to changes and may have outstanding issues. !> !> @see hipMemPrefetchBatchAsync, hipMallocManaged #ifndef USE_CUDA_NAMES interface hipMemDiscardBatchAsync function hipMemDiscardBatchAsync_(dev_ptrs,sizes,count,flags,stream) & bind(c, name="hipMemDiscardBatchAsync") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemDiscardBatchAsync_ type(c_ptr) :: dev_ptrs type(c_ptr),value :: sizes integer(c_size_t),value :: count integer(c_int64_t),value :: flags type(c_ptr),value :: stream end function end interface #endif !> @brief Discards a batch of memory ranges asynchronously (driver API variant). !> !> @param [in] dptrs pointers to the memory ranges to discard !> @param [in] sizes sizes in bytes of the memory ranges to discard !> @param [in] count number of memory ranges to discard !> @param [in] flags flags for future use, must be zero now. !> @param [in] stream stream to enqueue the discard operation !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning Reading from a discarded range without first writing or prefetching !> to it will return an indeterminate value. !> !> @note This is the driver API variant that uses hipDeviceptr_t instead of void*. !> Both hipMemDiscardBatchAsync and hipDrvMemDiscardBatchAsync use the same !> internal implementation. !> !> @see hipMemDiscardBatchAsync, hipMemPrefetchBatchAsync, hipMallocManaged #ifndef USE_CUDA_NAMES interface hipDrvMemDiscardBatchAsync function hipDrvMemDiscardBatchAsync_(dptrs,sizes,count,flags,stream) & bind(c, name="hipDrvMemDiscardBatchAsync") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDrvMemDiscardBatchAsync_ type(c_ptr) :: dptrs type(c_ptr),value :: sizes integer(c_size_t),value :: count integer(c_int64_t),value :: flags type(c_ptr),value :: stream end function end interface #endif !> @brief Discards and prefetches a batch of memory ranges asynchronously. !> !> @param [in] dptrs pointers to the memory ranges !> @param [in] sizes sizes in bytes of the memory ranges !> @param [in] count number of memory ranges !> @param [in] prefetchLocs array of target locations for prefetching !> @param [in] prefetchLocIdxs indices mapping each range to a prefetch location !> @param [in] numPrefetchLocs number of unique prefetch locations !> @param [in] flags flags for future use, must be zero now. !> @param [in] stream stream to enqueue the operation !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> Semantically equivalent to calling @p hipMemDiscardBatchAsync followed by !> @p hipMemPrefetchBatchAsync, but combines both operations into a single !> command submission for reduced overhead. !> !> @warning Reading from a discarded range without first writing or prefetching !> to it will return an indeterminate value. !> !> @note All memory ranges must be managed memory allocated via hipMallocManaged !> or system-allocated memory (if device supports pageable memory access). !> @note This API is implemented on Linux and requires XNACK to be enabled. !> @note This API is marked as beta, meaning, while this is feature complete, !> it is still open to changes and may have outstanding issues. !> !> @see hipMemDiscardBatchAsync, hipMemPrefetchBatchAsync, hipMallocManaged #ifndef USE_CUDA_NAMES interface hipMemDiscardAndPrefetchBatchAsync function hipMemDiscardAndPrefetchBatchAsync_(dptrs,sizes,count,prefetchLocs,prefetchLocIdxs, & numPrefetchLocs,flags,stream) & bind(c, name="hipMemDiscardAndPrefetchBatchAsync") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemDiscardAndPrefetchBatchAsync_ type(c_ptr) :: dptrs type(c_ptr),value :: sizes integer(c_size_t),value :: count type(hipMemLocation) :: prefetchLocs type(c_ptr),value :: prefetchLocIdxs integer(c_size_t),value :: numPrefetchLocs integer(c_int64_t),value :: flags type(c_ptr),value :: stream end function end interface #endif !> @brief Discards and prefetches a batch of memory ranges asynchronously (driver API variant). !> !> @param [in] dptrs pointers to the memory ranges !> @param [in] sizes sizes in bytes of the memory ranges !> @param [in] count number of memory ranges !> @param [in] prefetchLocs array of target locations for prefetching !> @param [in] prefetchLocIdxs indices mapping each range to a prefetch location !> @param [in] numPrefetchLocs number of unique prefetch locations !> @param [in] flags flags for future use, must be zero now. !> @param [in] stream stream to enqueue the operation !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @note This is the driver API variant that uses hipDeviceptr_t instead of void*. !> !> @see hipMemDiscardAndPrefetchBatchAsync, hipMemDiscardBatchAsync, hipMemPrefetchBatchAsync #ifndef USE_CUDA_NAMES interface hipDrvMemDiscardAndPrefetchBatchAsync function hipDrvMemDiscardAndPrefetchBatchAsync_(dptrs,sizes,count,prefetchLocs, & prefetchLocIdxs,numPrefetchLocs,flags,stream) & bind(c, name="hipDrvMemDiscardAndPrefetchBatchAsync") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipDrvMemDiscardAndPrefetchBatchAsync_ type(c_ptr) :: dptrs type(c_ptr),value :: sizes integer(c_size_t),value :: count type(hipMemLocation) :: prefetchLocs type(c_ptr),value :: prefetchLocIdxs integer(c_size_t),value :: numPrefetchLocs integer(c_int64_t),value :: flags type(c_ptr),value :: stream end function end interface #endif !> @brief Advise about the usage of a given memory range to HIP. !> !> @param [in] dev_ptr pointer to memory to set the advice for !> @param [in] count size in bytes of the memory range, it should be CPU page size alligned. !> @param [in] advice advice to be applied for the specified memory range !> @param [in] device device to apply the advice for !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> This HIP API advises about the usage to be applied on unified memory allocation in the !> range starting from the pointer address devPtr, with the size of count bytes. !> The memory range must refer to managed memory allocated via the API hipMallocManaged, and the !> range will be handled with proper round down and round up respectively in the driver to !> be aligned to CPU page size, the same way as corresponding CUDA API behaves in CUDA version !> 8.0 !> and afterwards. !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. #ifndef USE_CUDA_NAMES interface hipMemAdvise function hipMemAdvise_(dev_ptr,count,advice,device) bind(c, name="hipMemAdvise") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemAdvise_ type(c_ptr),value :: dev_ptr integer(c_size_t),value :: count integer(kind(hipMemAdviseSetReadMostly)),value :: advice integer(c_int),value :: device end function end interface #endif !> @brief Advise about the usage of a given memory range to HIP. !> !> @param [in] dev_ptr pointer to memory to set the advice for !> @param [in] count size in bytes of the memory range, it should be CPU page size alligned. !> @param [in] advice advice to be applied for the specified memory range !> @param [in] location location to apply the advice for !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> This HIP API advises about the usage to be applied on unified memory allocation in the !> range starting from the pointer address devPtr, with the size of count bytes. !> The memory range must refer to managed memory allocated via the API hipMallocManaged, and the !> range will be handled with proper round down and round up respectively in the driver to !> be aligned to CPU page size, the same way as corresponding CUDA API behaves in CUDA version !> 8.0 !> and afterwards. !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemAdvise_v2 #ifdef USE_CUDA_NAMES function hipMemAdvise_v2_(dev_ptr,count,advice,location) bind(c, name="cuMemAdvise_v2") #else function hipMemAdvise_v2_(dev_ptr,count,advice,location) bind(c, name="hipMemAdvise_v2") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemAdvise_v2_ type(c_ptr),value :: dev_ptr integer(c_size_t),value :: count integer(kind(hipMemAdviseSetReadMostly)),value :: advice type(hipMemLocation),value :: location end function end interface !> @brief Query an attribute of a given memory range in HIP. !> !> @param [in,out] data a pointer to a memory location where the result of each !> attribute query will be written to !> @param [in] data_size the size of data !> @param [in] attribute the attribute to query !> @param [in] dev_ptr start of the range to query !> @param [in] count size of the range to query !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemRangeGetAttribute #ifdef USE_CUDA_NAMES function hipMemRangeGetAttribute_(myData,data_size,attribute,dev_ptr,count) & bind(c, name="cudaMemRangeGetAttribute") #else function hipMemRangeGetAttribute_(myData,data_size,attribute,dev_ptr,count) & bind(c, name="hipMemRangeGetAttribute") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemRangeGetAttribute_ type(c_ptr),value :: myData integer(c_size_t),value :: data_size integer(kind(hipMemRangeAttributeReadMostly)),value :: attribute type(c_ptr),value :: dev_ptr integer(c_size_t),value :: count end function end interface !> @brief Query attributes of a given memory range in HIP. !> !> @param [in,out] data a two-dimensional array containing pointers to memory locations !> where the result of each attribute query will be written to !> @param [in] data_sizes an array, containing the sizes of each result !> @param [in] attributes the attribute to query !> @param [in] num_attributes an array of attributes to query (numAttributes and the number !> of attributes in this array should match) !> @param [in] dev_ptr start of the range to query !> @param [in] count size of the range to query !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemRangeGetAttributes #ifdef USE_CUDA_NAMES function hipMemRangeGetAttributes_(myData,data_sizes,attributes,num_attributes,dev_ptr,count) & bind(c, name="cudaMemRangeGetAttributes") #else function hipMemRangeGetAttributes_(myData,data_sizes,attributes,num_attributes,dev_ptr,count) & bind(c, name="hipMemRangeGetAttributes") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemRangeGetAttributes_ type(c_ptr) :: myData type(c_ptr),value :: data_sizes type(c_ptr),value :: attributes integer(c_size_t),value :: num_attributes type(c_ptr),value :: dev_ptr integer(c_size_t),value :: count end function end interface !> @brief Attach memory to a stream asynchronously in HIP. !> !> @param [in] stream - stream in which to enqueue the attach operation !> @param [in] dev_ptr - pointer to memory (must be a pointer to managed memory or !> to a valid host-accessible region of system-allocated memory) !> @param [in] length - length of memory (defaults to zero) !> @param [in] flags - must be one of hipMemAttachGlobal, hipMemAttachHost or !> hipMemAttachSingle (defaults to hipMemAttachSingle) !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @warning This API is under development. Currently it is a no-operation (NOP) !> function on AMD GPUs and returns `hipSuccess`. interface hipStreamAttachMemAsync #ifdef USE_CUDA_NAMES function hipStreamAttachMemAsync_(stream,dev_ptr,length,flags) & bind(c, name="cudaStreamAttachMemAsync") #else function hipStreamAttachMemAsync_(stream,dev_ptr,length,flags) & bind(c, name="hipStreamAttachMemAsync") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamAttachMemAsync_ type(c_ptr),value :: stream type(c_ptr),value :: dev_ptr integer(c_size_t),value :: length integer(c_int),value :: flags end function end interface !> @brief Allocates memory with stream ordered semantics !> !> Inserts a memory allocation operation into @p stream. !> A pointer to the allocated memory is returned immediately in *dptr. !> The allocation must not be accessed until the allocation operation completes. !> The allocation comes from the memory pool associated with the stream's device. !> !> @note The default memory pool of a device contains device memory from that device. !> @note Basic stream ordering allows future work submitted into the same stream to use the !> allocation. Stream query, stream synchronize, and HIP events can be used to guarantee that !> the allocation operation completes before work submitted in a separate stream runs. !> @note During stream capture, this function results in the creation of an allocation node. !> In this case, the allocation is owned by the graph instead of the memory pool. The memory !> pool's properties are used to set the node's creation parameters. !> !> @param [out] dev_ptr Returned device pointer of memory allocation !> @param [in] size Number of bytes to allocate !> @param [in] stream The stream establishing the stream ordering contract and !> the memory pool to allocate from !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported`, `hipErrorOutOfMemory` !> !> @see hipMallocFromPoolAsync, hipFreeAsync, hipMemPoolTrimTo, hipMemPoolGetAttribute, !> hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess, hipMemPoolGetAccess !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMallocAsync #ifdef USE_CUDA_NAMES function hipMallocAsync_(dev_ptr,mySize,stream) bind(c, name="cudaMallocAsync") #else function hipMallocAsync_(dev_ptr,mySize,stream) bind(c, name="hipMallocAsync") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMallocAsync_ type(c_ptr) :: dev_ptr integer(c_size_t),value :: mySize type(c_ptr),value :: stream end function end interface !> @brief Frees memory with stream ordered semantics !> !> Inserts a free operation into @p stream. !> The allocation must not be used after stream execution reaches the free. !> After this API returns, accessing the memory from any subsequent work launched on the GPU !> or querying its pointer attributes results in undefined behavior. !> !> @note During stream capture, this function results in the creation of a free node and !> must therefore be passed the address of a graph allocation. !> !> @param [in] dev_ptr Pointer to device memory to free !> @param [in] stream The stream, where the destruciton will occur according to the execution !> order !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @see hipMallocFromPoolAsync, hipMallocAsync, hipMemPoolTrimTo, hipMemPoolGetAttribute, !> hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess, hipMemPoolGetAccess !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipFreeAsync #ifdef USE_CUDA_NAMES function hipFreeAsync_(dev_ptr,stream) bind(c, name="cudaFreeAsync") #else function hipFreeAsync_(dev_ptr,stream) bind(c, name="hipFreeAsync") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipFreeAsync_ type(c_ptr),value :: dev_ptr type(c_ptr),value :: stream end function end interface !> @brief Releases freed memory back to the OS !> !> Releases memory back to the OS until the pool contains fewer than @p min_bytes_to_keep !> reserved bytes, or there is no more memory that the allocator can safely release. !> The allocator cannot release OS allocations that back outstanding asynchronous allocations. !> The OS allocations may happen at different granularity from the user allocations. !> !> @note Allocations that have not been freed count as outstanding. !> @note Allocations that have been asynchronously freed but whose completion has !> not been observed on the host (eg. by a synchronize) can count as outstanding. !> !> @param[in] mem_pool - The memory pool to trim allocations !> @param[in] min_bytes_to_hold - If the pool has less than min_bytes_to_hold reserved, !> then the TrimTo operation is a no-op. Otherwise the memory pool will contain !> at least min_bytes_to_hold bytes reserved after the operation. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @see hipMallocFromPoolAsync, hipMallocAsync, hipFreeAsync, hipMemPoolGetAttribute, !> hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess, hipMemPoolGetAccess !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemPoolTrimTo #ifdef USE_CUDA_NAMES function hipMemPoolTrimTo_(mem_pool,min_bytes_to_hold) bind(c, name="cudaMemPoolTrimTo") #else function hipMemPoolTrimTo_(mem_pool,min_bytes_to_hold) bind(c, name="hipMemPoolTrimTo") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemPoolTrimTo_ type(c_ptr),value :: mem_pool integer(c_size_t),value :: min_bytes_to_hold end function end interface !> @brief Sets attributes of a memory pool !> !> Supported attributes are: !> - @p hipMemPoolAttrReleaseThreshold: (value type = cuuint64_t) !> Amount of reserved memory in bytes to hold onto before trying !> to release memory back to the OS. When more than the release !> threshold bytes of memory are held by the memory pool, the !> allocator will try to release memory back to the OS on the !> next call to stream, event or context synchronize. (default !> 0) !> - @p hipMemPoolReuseFollowEventDependencies: (value type = int) !> Allow @p hipMallocAsync to use memory asynchronously freed !> in another stream as long as a stream ordering dependency !> of the allocating stream on the free action exists. !> HIP events and null stream interactions can create the !> required !> stream ordered dependencies. (default enabled) !> - @p hipMemPoolReuseAllowOpportunistic: (value type = int) !> Allow reuse of already completed frees when there is no !> dependency between the free and allocation. (default enabled) !> - @p hipMemPoolReuseAllowInternalDependencies: (value type = int) !> Allow @p hipMallocAsync to insert new stream dependencies !> in order to establish the stream ordering required to reuse !> a piece of memory released by @p hipFreeAsync (default !> enabled). !> !> @param [in] mem_pool The memory pool to modify !> @param [in] attr The attribute to modify !> @param [in] value Pointer to the value to assign !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @see hipMallocFromPoolAsync, hipMallocAsync, hipFreeAsync, hipMemPoolGetAttribute, !> hipMemPoolTrimTo, hipDeviceSetMemPool, hipMemPoolSetAccess, hipMemPoolGetAccess !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemPoolSetAttribute #ifdef USE_CUDA_NAMES function hipMemPoolSetAttribute_(mem_pool,attr,myValue) bind(c, name="cudaMemPoolSetAttribute") #else function hipMemPoolSetAttribute_(mem_pool,attr,myValue) bind(c, name="hipMemPoolSetAttribute") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemPoolSetAttribute_ type(c_ptr),value :: mem_pool integer(kind(hipMemPoolReuseFollowEventDependencies)),value :: attr type(c_ptr),value :: myValue end function end interface !> @brief Gets attributes of a memory pool !> !> Supported attributes are: !> - @p hipMemPoolAttrReleaseThreshold: (value type = cuuint64_t) !> Amount of reserved memory in bytes to hold onto before trying !> to release memory back to the OS. When more than the release !> threshold bytes of memory are held by the memory pool, the !> allocator will try to release memory back to the OS on the !> next call to stream, event or context synchronize. (default !> 0) !> - @p hipMemPoolReuseFollowEventDependencies: (value type = int) !> Allow @p hipMallocAsync to use memory asynchronously freed !> in another stream as long as a stream ordering dependency !> of the allocating stream on the free action exists. !> HIP events and null stream interactions can create the !> required !> stream ordered dependencies. (default enabled) !> - @p hipMemPoolReuseAllowOpportunistic: (value type = int) !> Allow reuse of already completed frees when there is no !> dependency between the free and allocation. (default enabled) !> - @p hipMemPoolReuseAllowInternalDependencies: (value type = int) !> Allow @p hipMallocAsync to insert new stream dependencies !> in order to establish the stream ordering required to reuse !> a piece of memory released by @p hipFreeAsync (default !> enabled). !> !> @param [in] mem_pool The memory pool to get attributes of !> @param [in] attr The attribute to get !> @param [in] value Retrieved value !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @see hipMallocFromPoolAsync, hipMallocAsync, hipFreeAsync, !> hipMemPoolTrimTo, hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess, !> hipMemPoolGetAccess !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemPoolGetAttribute #ifdef USE_CUDA_NAMES function hipMemPoolGetAttribute_(mem_pool,attr,myValue) bind(c, name="cudaMemPoolGetAttribute") #else function hipMemPoolGetAttribute_(mem_pool,attr,myValue) bind(c, name="hipMemPoolGetAttribute") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemPoolGetAttribute_ type(c_ptr),value :: mem_pool integer(kind(hipMemPoolReuseFollowEventDependencies)),value :: attr type(c_ptr),value :: myValue end function end interface !> @brief Controls visibility of the specified pool between devices !> !> @param [in] mem_pool Memory pool for acccess change !> @param [in] desc_list Array of access descriptors. Each descriptor instructs the access to !> enable for a single gpu !> @param [in] count Number of descriptors in the map array. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @see hipMallocFromPoolAsync, hipMallocAsync, hipFreeAsync, hipMemPoolGetAttribute, !> hipMemPoolTrimTo, hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolGetAccess !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemPoolSetAccess #ifdef USE_CUDA_NAMES function hipMemPoolSetAccess_(mem_pool,desc_list,count) bind(c, name="cudaMemPoolSetAccess") #else function hipMemPoolSetAccess_(mem_pool,desc_list,count) bind(c, name="hipMemPoolSetAccess") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemPoolSetAccess_ type(c_ptr),value :: mem_pool type(hipMemAccessDesc) :: desc_list integer(c_size_t),value :: count end function end interface !> @brief Returns the accessibility of a pool from a device !> !> Returns the accessibility of the pool's memory from the specified location. !> !> @param [out] flags Accessibility of the memory pool from the specified location/device !> @param [in] mem_pool Memory pool being queried !> @param [in] location Location/device for memory pool access !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @see hipMallocFromPoolAsync, hipMallocAsync, hipFreeAsync, hipMemPoolGetAttribute, !> hipMemPoolTrimTo, hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemPoolGetAccess #ifdef USE_CUDA_NAMES function hipMemPoolGetAccess_(flags,mem_pool,location) bind(c, name="cudaMemPoolGetAccess") #else function hipMemPoolGetAccess_(flags,mem_pool,location) bind(c, name="hipMemPoolGetAccess") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemPoolGetAccess_ type(c_ptr),value :: flags type(c_ptr),value :: mem_pool type(hipMemLocation) :: location end function end interface !> @brief Creates a memory pool !> !> Creates a HIP memory pool and returns the handle in @p mem_pool. The @p pool_props determines !> the properties of the pool such as the backing device and IPC capabilities. !> !> By default, the memory pool will be accessible from the device it is allocated on. !> !> @param [out] mem_pool Contains createed memory pool !> @param [in] pool_props Memory pool properties !> !> @note Specifying hipMemHandleTypeNone creates a memory pool that will not support IPC. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @see hipMallocFromPoolAsync, hipMallocAsync, hipFreeAsync, hipMemPoolGetAttribute, !> hipMemPoolDestroy, hipMemPoolTrimTo, hipDeviceSetMemPool, hipMemPoolSetAttribute, !> hipMemPoolSetAccess, hipMemPoolGetAccess !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemPoolCreate #ifdef USE_CUDA_NAMES function hipMemPoolCreate_(mem_pool,pool_props) bind(c, name="cudaMemPoolCreate") #else function hipMemPoolCreate_(mem_pool,pool_props) bind(c, name="hipMemPoolCreate") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemPoolCreate_ type(c_ptr) :: mem_pool type(hipMemPoolProps) :: pool_props end function end interface !> @brief Destroys the specified memory pool !> !> If any pointers obtained from this pool haven't been freed or !> the pool has free operations that haven't completed !> when @p hipMemPoolDestroy is invoked, the function will return immediately and the !> resources associated with the pool will be released automatically !> once there are no more outstanding allocations. !> !> Destroying the current mempool of a device sets the default mempool of !> that device as the current mempool for that device. !> !> @param [in] mem_pool Memory pool for destruction !> !> @note A device's default memory pool cannot be destroyed. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @see hipMallocFromPoolAsync, hipMallocAsync, hipFreeAsync, hipMemPoolGetAttribute, !> hipMemPoolCreate hipMemPoolTrimTo, hipDeviceSetMemPool, hipMemPoolSetAttribute, !> hipMemPoolSetAccess, hipMemPoolGetAccess !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemPoolDestroy #ifdef USE_CUDA_NAMES function hipMemPoolDestroy_(mem_pool) bind(c, name="cudaMemPoolDestroy") #else function hipMemPoolDestroy_(mem_pool) bind(c, name="hipMemPoolDestroy") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemPoolDestroy_ type(c_ptr),value :: mem_pool end function end interface !> @brief Allocates memory from a specified pool with stream ordered semantics. !> !> Inserts an allocation operation into @p stream. !> A pointer to the allocated memory is returned immediately in @p dev_ptr. !> The allocation must not be accessed until the allocation operation completes. !> The allocation comes from the specified memory pool. !> !> @note The specified memory pool may be from a device different than that of the specified @p !> stream. !> !> Basic stream ordering allows future work submitted into the same stream to use the allocation. !> Stream query, stream synchronize, and HIP events can be used to guarantee that the allocation !> operation completes before work submitted in a separate stream runs. !> !> @note During stream capture, this function results in the creation of an allocation node. In !> this !> case, the allocation is owned by the graph instead of the memory pool. The memory pool's !> properties are used to set the node's creation parameters. !> !> @param [out] dev_ptr Returned device pointer !> @param [in] size Number of bytes to allocate !> @param [in] mem_pool The pool to allocate from !> @param [in] stream The stream establishing the stream ordering semantic !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported`, `hipErrorOutOfMemory` !> !> @see hipMallocAsync, hipFreeAsync, hipMemPoolGetAttribute, hipMemPoolCreate !> hipMemPoolTrimTo, hipDeviceSetMemPool, hipMemPoolSetAttribute, hipMemPoolSetAccess, !> hipMemPoolGetAccess, !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMallocFromPoolAsync #ifdef USE_CUDA_NAMES function hipMallocFromPoolAsync_(dev_ptr,mySize,mem_pool,stream) & bind(c, name="cudaMallocFromPoolAsync") #else function hipMallocFromPoolAsync_(dev_ptr,mySize,mem_pool,stream) & bind(c, name="hipMallocFromPoolAsync") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMallocFromPoolAsync_ type(c_ptr) :: dev_ptr integer(c_size_t),value :: mySize type(c_ptr),value :: mem_pool type(c_ptr),value :: stream end function end interface !> @brief Exports a memory pool to the requested handle type. !> !> Given an IPC capable mempool, create an OS handle to share the pool with another process. !> A recipient process can convert the shareable handle into a mempool with @p !> hipMemPoolImportFromShareableHandle. Individual pointers can then be shared with the @p !> hipMemPoolExportPointer and @p hipMemPoolImportPointer APIs. The implementation of what the !> shareable handle is and how it can be transferred is defined by the requested handle type. !> !> @note To create an IPC capable mempool, create a mempool with a @p hipMemAllocationHandleType !> other than @p hipMemHandleTypeNone. !> !> @param [out] shared_handle Pointer to the location in which to store the requested handle !> @param [in] mem_pool Pool to export !> @param [in] handle_type The type of handle to create !> @param [in] flags Must be 0 !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorOutOfMemory` !> !> @see hipMemPoolImportFromShareableHandle !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemPoolExportToShareableHandle #ifdef USE_CUDA_NAMES function hipMemPoolExportToShareableHandle_(shared_handle,mem_pool,handle_type,flags) & bind(c, name="cudaMemPoolExportToShareableHandle") #else function hipMemPoolExportToShareableHandle_(shared_handle,mem_pool,handle_type,flags) & bind(c, name="hipMemPoolExportToShareableHandle") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemPoolExportToShareableHandle_ type(c_ptr),value :: shared_handle type(c_ptr),value :: mem_pool integer(kind(hipMemHandleTypeNone)),value :: handle_type integer(c_int),value :: flags end function end interface !> @brief Imports a memory pool from a shared handle. !> !> Specific allocations can be imported from the imported pool with @p hipMemPoolImportPointer. !> !> @note Imported memory pools do not support creating new allocations. !> As such imported memory pools may not be used in @p hipDeviceSetMemPool !> or @p hipMallocFromPoolAsync calls. !> !> @param [out] mem_pool Returned memory pool !> @param [in] shared_handle OS handle of the pool to open !> @param [in] handle_type The type of handle being imported !> @param [in] flags Must be 0 !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorOutOfMemory` !> !> @see hipMemPoolExportToShareableHandle !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemPoolImportFromShareableHandle #ifdef USE_CUDA_NAMES function hipMemPoolImportFromShareableHandle_(mem_pool,shared_handle,handle_type,flags) & bind(c, name="cudaMemPoolImportFromShareableHandle") #else function hipMemPoolImportFromShareableHandle_(mem_pool,shared_handle,handle_type,flags) & bind(c, name="hipMemPoolImportFromShareableHandle") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemPoolImportFromShareableHandle_ type(c_ptr) :: mem_pool type(c_ptr),value :: shared_handle integer(kind(hipMemHandleTypeNone)),value :: handle_type integer(c_int),value :: flags end function end interface !> @brief Export data to share a memory pool allocation between processes. !> !> Constructs @p export_data for sharing a specific allocation from an already shared memory !> pool. !> The recipient process can import the allocation with the @p hipMemPoolImportPointer api. !> The data is not a handle and may be shared through any IPC mechanism. !> !> @param[out] export_data - Returned export data !> @param[in] dev_ptr - Pointer to memory being exported !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorOutOfMemory` !> !> @see hipMemPoolImportPointer !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemPoolExportPointer #ifdef USE_CUDA_NAMES function hipMemPoolExportPointer_(export_data,dev_ptr) bind(c, name="cudaMemPoolExportPointer") #else function hipMemPoolExportPointer_(export_data,dev_ptr) bind(c, name="hipMemPoolExportPointer") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemPoolExportPointer_ type(hipMemPoolPtrExportData) :: export_data type(c_ptr),value :: dev_ptr end function end interface !> @brief Import a memory pool allocation from another process. !> !> Returns in @p dev_ptr a pointer to the imported memory. !> The imported memory must not be accessed before the allocation operation completes !> in the exporting process. The imported memory must be freed from all importing processes !> before !> being freed in the exporting process. The pointer may be freed with @p hipFree !> or @p hipFreeAsync. If @p hipFreeAsync is used, the free must be completed !> on the importing process before the free operation on the exporting process. !> !> @note The @p hipFreeAsync api may be used in the exporting process before !> the @p hipFreeAsync operation completes in its stream as long as the !> @p hipFreeAsync in the exporting process specifies a stream with !> a stream dependency on the importing process's @p hipFreeAsync. !> !> @param [out] dev_ptr Pointer to imported memory !> @param [in] mem_pool Memory pool from which to import a pointer !> @param [in] export_data Data specifying the memory to import !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotInitialized`, `hipErrorOutOfMemory` !> !> @see hipMemPoolExportPointer !> !> @warning This API is marked as Beta. While this feature is complete, it can !> change and might have outstanding issues. !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemPoolImportPointer #ifdef USE_CUDA_NAMES function hipMemPoolImportPointer_(dev_ptr,mem_pool,export_data) & bind(c, name="cudaMemPoolImportPointer") #else function hipMemPoolImportPointer_(dev_ptr,mem_pool,export_data) & bind(c, name="hipMemPoolImportPointer") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemPoolImportPointer_ type(c_ptr) :: dev_ptr type(c_ptr),value :: mem_pool type(hipMemPoolPtrExportData) :: export_data end function end interface !> @brief Sets memory pool for memory location and allocation type. #ifndef USE_CUDA_NAMES interface hipMemSetMemPool function hipMemSetMemPool_(location,myType,pool) bind(c, name="hipMemSetMemPool") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemSetMemPool_ type(hipMemLocation) :: location integer(kind(hipMemAllocationTypeInvalid)),value :: myType type(c_ptr),value :: pool end function end interface #endif !> @brief Retrieves memory pool for memory location and allocation type. #ifndef USE_CUDA_NAMES interface hipMemGetMemPool function hipMemGetMemPool_(pool,location,myType) bind(c, name="hipMemGetMemPool") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemGetMemPool_ type(c_ptr) :: pool type(hipMemLocation) :: location integer(kind(hipMemAllocationTypeInvalid)),value :: myType end function end interface #endif !> @brief Returns the default memory pool for a given location and allocation type !> !> @param [out] memPool Returned memory pool !> @param [in] location location type for which to get the default memory pool, !> currently only hipMemLocationTypeDevice is supported !> @param [in] type allocation type for which to get the default memory pool, !> currently only hipMemAllocationTypePinned & hipMemAllocationTypeManaged are supported !> !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipMemGetDefaultMemPool function hipMemGetDefaultMemPool_(memPool,location,myType) & bind(c, name="hipMemGetDefaultMemPool") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemGetDefaultMemPool_ type(c_ptr) :: memPool type(hipMemLocation) :: location integer(kind(hipMemAllocationTypeInvalid)),value :: myType end function end interface #endif !> @brief Allocate device accessible page locked host memory !> !> @param[out] ptr - Pointer to the allocated host pinned memory !> @param[in] mySize - Requested memory size in bytes !> @param[in] flags - Type of host memory allocation see below !> !> If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned. !> !> Flags: !> - `hipHostAllocDefault` Default pinned memory allocation on the host. !> - `hipHostAllocPortable` Memory is considered allocated by all contexts. !> - `hipHostAllocMapped` Map the allocation into the address space for the current device. !> - `hipHostAllocWriteCombined` Allocates the memory as write-combined. !> - `hipHostAllocUncached` Allocate the host memory on extended fine grained access system !> memory pool !> !> @return `hipSuccess`, `hipErrorOutOfMemory`, `hipErrorInvalidValue` interface hipHostAlloc #ifdef USE_CUDA_NAMES function hipHostAlloc_(ptr,mySize,flags) bind(c, name="cudaHostAlloc") #else function hipHostAlloc_(ptr,mySize,flags) bind(c, name="hipHostAlloc") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipHostAlloc_ type(c_ptr) :: ptr integer(c_size_t),value :: mySize integer(c_int),value :: flags end function end interface !> Allocates at least width (in bytes) * height bytes of linear memory !> Padding may occur to ensure alighnment requirements are met for the given row !> The change in width size due to padding will be returned in *pitch. !> Currently the alignment is set to 128 bytes !> !> @param[out] ptr - Pointer to the allocated device memory !> @param[out] pitch - Pitch for allocation (in bytes) !> @param[in] width - Requested pitched allocation width (in bytes) !> @param[in] height - Requested pitched allocation height !> !> If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned. !> !> @returns Error code !> !> @see hipMalloc, hipFree, hipMallocArray, hipFreeArray, hipHostFree, hipMalloc3D, !> hipMalloc3DArray, hipHostMalloc interface hipMallocPitch #ifdef USE_CUDA_NAMES function hipMallocPitch_(ptr,pitch,width,height) bind(c, name="cudaMallocPitch") #else function hipMallocPitch_(ptr,pitch,width,height) bind(c, name="hipMallocPitch") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMallocPitch_ type(c_ptr) :: ptr integer(c_size_t) :: pitch integer(c_size_t),value :: width integer(c_size_t),value :: height end function end interface !> Allocates at least width (in bytes) * height bytes of linear memory !> Padding may occur to ensure alighnment requirements are met for the given row !> The change in width size due to padding will be returned in *pitch. !> Currently the alignment is set to 128 bytes !> !> @param[out] dptr - Pointer to the allocated device memory !> @param[out] pitch - Pitch for allocation (in bytes) !> @param[in] widthInBytes - Requested pitched allocation width (in bytes) !> @param[in] height - Requested pitched allocation height !> @param[in] elementSizeBytes - The size of element bytes, should be 4, 8 or 16 !> !> If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned. !> The intended usage of pitch is as a separate parameter of the allocation, used to compute !> addresses within the 2D array. Given the row and column of an array element of type T, the !> address is computed as: T* pElement = (T*)((char*)BaseAddress + Row * Pitch) + Column; !> !> @returns Error code !> !> @see hipMalloc, hipFree, hipMallocArray, hipFreeArray, hipHostFree, hipMalloc3D, !> hipMalloc3DArray, hipHostMalloc #ifndef USE_CUDA_NAMES interface hipMemAllocPitch function hipMemAllocPitch_(dptr,pitch,widthInBytes,height,elementSizeBytes) & bind(c, name="hipMemAllocPitch") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemAllocPitch_ type(c_ptr) :: dptr integer(c_size_t) :: pitch integer(c_size_t),value :: widthInBytes integer(c_size_t),value :: height integer(c_int),value :: elementSizeBytes end function end interface #endif !> @brief Frees page-locked memory !> This API performs an implicit hipDeviceSynchronize() call. !> If pointer is NULL, the hip runtime is initialized and hipSuccess is returned. !> !> @param[in] ptr - Pointer to memory to be freed !> @returns `hipSuccess`, !> `hipErrorInvalidValue` (if pointer is invalid, including device pointers allocated !> with hipMalloc) interface hipFreeHost #ifdef USE_CUDA_NAMES function hipFreeHost_(ptr) bind(c, name="cudaFreeHost") #else function hipFreeHost_(ptr) bind(c, name="hipFreeHost") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipFreeHost_ type(c_ptr),value :: ptr end function end interface !> @brief Memory copy on the stream. !> It allows single or multiple devices to do memory copy on single or multiple streams. !> The operation is akin to hipMemcpyAsync + hipStreamSynchronize. !> Since it is a sync API, it is not allowed during graph capture. !> !> @param[out] dst - Data being copy to !> @param[in] src - Data being copy from !> @param[in] sizeBytes - Data size in bytes !> @param[in] myKind - Kind of transfer !> @param[in] stream - Valid stream !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorUnknown`, !> `hipErrorContextIsDestroyed` !> !> @see hipMemcpy, hipStreamCreate, hipStreamSynchronize, hipStreamDestroy, hipSetDevice, !> hipLaunchKernelGGL #ifndef USE_CUDA_NAMES interface hipMemcpyWithStream function hipMemcpyWithStream_(dst,src,sizeBytes,myKind,stream) & bind(c, name="hipMemcpyWithStream") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyWithStream_ type(c_ptr),value :: dst type(c_ptr),value :: src integer(c_size_t),value :: sizeBytes integer(kind(hipMemcpyHostToHost)),value :: myKind type(c_ptr),value :: stream end function end interface #endif !> @brief Copy data from Host to Device !> !> @param[out] dst - Data being copy to !> @param[in] src - Data being copy from !> @param[in] sizeBytes - Data size in bytes !> !> @returns `hipSuccess`, `hipErrorDeinitialized`, `hipErrorNotInitialized`, !> `hipErrorInvalidContext`, !> `hipErrorInvalidValue` !> !> @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost, !> hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA, !> hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD, !> hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync, !> hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo, !> hipMemHostAlloc, hipMemHostGetDevicePointer #ifndef USE_CUDA_NAMES interface hipMemcpyHtoD function hipMemcpyHtoD_(dst,src,sizeBytes) bind(c, name="hipMemcpyHtoD") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyHtoD_ type(c_ptr),value :: dst type(c_ptr),value :: src integer(c_size_t),value :: sizeBytes end function end interface #endif !> @brief Copy data from Device to Host !> !> @param[out] dst - Data being copy to !> @param[in] src - Data being copy from !> @param[in] sizeBytes - Data size in bytes !> !> @returns `hipSuccess`, `hipErrorDeinitialized`, `hipErrorNotInitialized`, !> `hipErrorInvalidContext`, !> `hipErrorInvalidValue` !> !> @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost, !> hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA, !> hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD, !> hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync, !> hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo, !> hipMemHostAlloc, hipMemHostGetDevicePointer #ifndef USE_CUDA_NAMES interface hipMemcpyDtoH function hipMemcpyDtoH_(dst,src,sizeBytes) bind(c, name="hipMemcpyDtoH") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyDtoH_ type(c_ptr),value :: dst type(c_ptr),value :: src integer(c_size_t),value :: sizeBytes end function end interface #endif !> @brief Copy data from Device to Device !> !> @param[out] dst - Data being copy to !> @param[in] src - Data being copy from !> @param[in] sizeBytes - Data size in bytes !> !> @returns `hipSuccess`, `hipErrorDeinitialized`, `hipErrorNotInitialized`, !> `hipErrorInvalidContext`, !> `hipErrorInvalidValue` !> !> @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost, !> hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA, !> hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD, !> hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync, !> hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo, !> hipMemHostAlloc, hipMemHostGetDevicePointer #ifndef USE_CUDA_NAMES interface hipMemcpyDtoD function hipMemcpyDtoD_(dst,src,sizeBytes) bind(c, name="hipMemcpyDtoD") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyDtoD_ type(c_ptr),value :: dst type(c_ptr),value :: src integer(c_size_t),value :: sizeBytes end function end interface #endif !> @brief Copies from one 1D array to device memory. !> !> @param[out] dstDevice - Destination device pointer !> @param[in] srcArray - Source array !> @param[in] srcOffset - Offset in bytes of source array !> @param[in] ByteCount - Size of memory copy in bytes !> !> @returns `hipSuccess`, `hipErrorDeinitialized`, `hipErrorNotInitialized`, !> `hipErrorInvalidContext`, !> `hipErrorInvalidValue` !> !> @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost, !> hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA, !> hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD, !> hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync, !> hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo, !> hipMemHostAlloc, hipMemHostGetDevicePointer interface hipMemcpyAtoD #ifdef USE_CUDA_NAMES function hipMemcpyAtoD_(dstDevice,srcArray,srcOffset,ByteCount) bind(c, name="cuMemcpyAtoD") #else function hipMemcpyAtoD_(dstDevice,srcArray,srcOffset,ByteCount) bind(c, name="hipMemcpyAtoD") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyAtoD_ type(c_ptr),value :: dstDevice type(c_ptr),value :: srcArray integer(c_size_t),value :: srcOffset integer(c_size_t),value :: ByteCount end function end interface !> @brief Copies from device memory to a 1D array. !> !> @param[out] dstArray - Destination array !> @param[in] dstOffset - Offset in bytes of destination array !> @param[in] srcDevice - Source device pointer !> @param[in] ByteCount - Size of memory copy in bytes !> !> @returns `hipSuccess`, `hipErrorDeinitialized`, `hipErrorNotInitialized`, !> `hipErrorInvalidContext`, !> `hipErrorInvalidValue` !> !> @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost, !> hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA, !> hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD, !> hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync, !> hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo, !> hipMemHostAlloc, hipMemHostGetDevicePointer interface hipMemcpyDtoA #ifdef USE_CUDA_NAMES function hipMemcpyDtoA_(dstArray,dstOffset,srcDevice,ByteCount) bind(c, name="cuMemcpyDtoA") #else function hipMemcpyDtoA_(dstArray,dstOffset,srcDevice,ByteCount) bind(c, name="hipMemcpyDtoA") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyDtoA_ type(c_ptr),value :: dstArray integer(c_size_t),value :: dstOffset type(c_ptr),value :: srcDevice integer(c_size_t),value :: ByteCount end function end interface !> @brief Copies from one 1D array to another. !> !> @param[out] dstArray - Destination array !> @param[in] dstOffset - Offset in bytes of destination array !> @param[in] srcArray - Source array !> @param[in] srcOffset - Offset in bytes of source array !> @param[in] ByteCount - Size of memory copy in bytes !> !> @returns `hipSuccess`, `hipErrorDeinitialized`, `hipErrorNotInitialized`, !> `hipErrorInvalidContext`, !> `hipErrorInvalidValue` !> !> @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost, !> hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA, !> hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD, !> hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync, !> hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo, !> hipMemHostAlloc, hipMemHostGetDevicePointer interface hipMemcpyAtoA #ifdef USE_CUDA_NAMES function hipMemcpyAtoA_(dstArray,dstOffset,srcArray,srcOffset,ByteCount) & bind(c, name="cuMemcpyAtoA") #else function hipMemcpyAtoA_(dstArray,dstOffset,srcArray,srcOffset,ByteCount) & bind(c, name="hipMemcpyAtoA") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyAtoA_ type(c_ptr),value :: dstArray integer(c_size_t),value :: dstOffset type(c_ptr),value :: srcArray integer(c_size_t),value :: srcOffset integer(c_size_t),value :: ByteCount end function end interface !> @brief Copy data from Host to Device asynchronously !> !> @param[out] dst - Data being copy to !> @param[in] src - Data being copy from !> @param[in] sizeBytes - Data size in bytes !> @param[in] stream - Stream identifier !> !> @returns `hipSuccess`, `hipErrorDeinitialized`, `hipErrorNotInitialized`, !> `hipErrorInvalidContext`, !> `hipErrorInvalidValue` !> !> @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost, !> hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA, !> hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD, !> hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync, !> hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo, !> hipMemHostAlloc, hipMemHostGetDevicePointer #ifndef USE_CUDA_NAMES interface hipMemcpyHtoDAsync function hipMemcpyHtoDAsync_(dst,src,sizeBytes,stream) bind(c, name="hipMemcpyHtoDAsync") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyHtoDAsync_ type(c_ptr),value :: dst type(c_ptr),value :: src integer(c_size_t),value :: sizeBytes type(c_ptr),value :: stream end function end interface #endif !> @brief Copy data from Device to Host asynchronously !> !> @param[out] dst - Data being copy to !> @param[in] src - Data being copy from !> @param[in] sizeBytes - Data size in bytes !> @param[in] stream - Stream identifier !> !> @returns `hipSuccess`, `hipErrorDeinitialized`, `hipErrorNotInitialized`, !> `hipErrorInvalidContext`, !> `hipErrorInvalidValue` !> !> @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost, !> hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA, !> hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD, !> hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync, !> hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo, !> hipMemHostAlloc, hipMemHostGetDevicePointer #ifndef USE_CUDA_NAMES interface hipMemcpyDtoHAsync function hipMemcpyDtoHAsync_(dst,src,sizeBytes,stream) bind(c, name="hipMemcpyDtoHAsync") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyDtoHAsync_ type(c_ptr),value :: dst type(c_ptr),value :: src integer(c_size_t),value :: sizeBytes type(c_ptr),value :: stream end function end interface #endif !> @brief Copy data from Device to Device asynchronously !> !> @param[out] dst - Data being copy to !> @param[in] src - Data being copy from !> @param[in] sizeBytes - Data size in bytes !> @param[in] stream - Stream identifier !> !> @returns `hipSuccess`, `hipErrorDeinitialized`, `hipErrorNotInitialized`, !> `hipErrorInvalidContext`, !> `hipErrorInvalidValue` !> !> @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost, !> hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA, !> hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD, !> hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync, !> hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo, !> hipMemHostAlloc, hipMemHostGetDevicePointer #ifndef USE_CUDA_NAMES interface hipMemcpyDtoDAsync function hipMemcpyDtoDAsync_(dst,src,sizeBytes,stream) bind(c, name="hipMemcpyDtoDAsync") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyDtoDAsync_ type(c_ptr),value :: dst type(c_ptr),value :: src integer(c_size_t),value :: sizeBytes type(c_ptr),value :: stream end function end interface #endif !> @brief Copies from one 1D array to host memory. !> !> @param[out] dstHost - Destination pointer !> @param[in] srcArray - Source array !> @param[in] srcOffset - Offset in bytes of source array !> @param[in] ByteCount - Size of memory copy in bytes !> @param[in] stream - Stream identifier !> !> @returns `hipSuccess`, `hipErrorDeinitialized`, `hipErrorNotInitialized`, !> `hipErrorInvalidContext`, !> `hipErrorInvalidValue` !> !> @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost, !> hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA, !> hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD, !> hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync, !> hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo, !> hipMemHostAlloc, hipMemHostGetDevicePointer interface hipMemcpyAtoHAsync #ifdef USE_CUDA_NAMES function hipMemcpyAtoHAsync_(dstHost,srcArray,srcOffset,ByteCount,stream) & bind(c, name="cuMemcpyAtoHAsync") #else function hipMemcpyAtoHAsync_(dstHost,srcArray,srcOffset,ByteCount,stream) & bind(c, name="hipMemcpyAtoHAsync") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyAtoHAsync_ type(c_ptr),value :: dstHost type(c_ptr),value :: srcArray integer(c_size_t),value :: srcOffset integer(c_size_t),value :: ByteCount type(c_ptr),value :: stream end function end interface !> @brief Copies from host memory to a 1D array. !> !> @param[out] dstArray - Destination array !> @param[in] dstOffset - Offset in bytes of destination array !> @param[in] srcHost - Source host pointer !> @param[in] ByteCount - Size of memory copy in bytes !> @param[in] stream - Stream identifier !> !> @returns `hipSuccess`, `hipErrorDeinitialized`, `hipErrorNotInitialized`, !> `hipErrorInvalidContext`, !> `hipErrorInvalidValue` !> !> @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost, !> hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA, !> hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD, !> hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync, !> hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo, !> hipMemHostAlloc, hipMemHostGetDevicePointer interface hipMemcpyHtoAAsync #ifdef USE_CUDA_NAMES function hipMemcpyHtoAAsync_(dstArray,dstOffset,srcHost,ByteCount,stream) & bind(c, name="cuMemcpyHtoAAsync") #else function hipMemcpyHtoAAsync_(dstArray,dstOffset,srcHost,ByteCount,stream) & bind(c, name="hipMemcpyHtoAAsync") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyHtoAAsync_ type(c_ptr),value :: dstArray integer(c_size_t),value :: dstOffset type(c_ptr),value :: srcHost integer(c_size_t),value :: ByteCount type(c_ptr),value :: stream end function end interface !> @brief Returns a global pointer from a module. !> @ingroup Module !> !> Returns in *dptr and *bytes the pointer and size of the global of name name located in module !> hmod. If no variable of that name exists, it returns hipErrorNotFound. Both parameters dptr !> and !> bytes are optional. If one of them is NULL, it is ignored and hipSuccess is returned. !> !> @param[out] dptr - Returns global device pointer !> @param[out] bytes - Returns global size in bytes !> @param[in] hmod - Module to retrieve global from !> @param[in] name - Name of global to retrieve !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotFound`, `hipErrorInvalidContext` #ifndef USE_CUDA_NAMES interface hipModuleGetGlobal function hipModuleGetGlobal_(dptr,bytes,hmod,name) bind(c, name="hipModuleGetGlobal") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipModuleGetGlobal_ type(c_ptr) :: dptr integer(c_size_t) :: bytes type(c_ptr),value :: hmod type(c_ptr),value :: name end function end interface #endif !> @brief Gets device pointer associated with symbol on the device. !> !> @param[out] devPtr - pointer to the device associated the symbole !> @param[in] symbol - pointer to the symbole of the device !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGetSymbolAddress #ifdef USE_CUDA_NAMES function hipGetSymbolAddress_(devPtr,symbol) bind(c, name="cudaGetSymbolAddress") #else function hipGetSymbolAddress_(devPtr,symbol) bind(c, name="hipGetSymbolAddress") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGetSymbolAddress_ type(c_ptr) :: devPtr type(c_ptr),value :: symbol end function end interface !> @brief Gets the size of the given symbol on the device. !> !> @param[in] symbol - pointer to the device symbole !> @param[out] mySize - pointer to the size !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGetSymbolSize #ifdef USE_CUDA_NAMES function hipGetSymbolSize_(mySize,symbol) bind(c, name="cudaGetSymbolSize") #else function hipGetSymbolSize_(mySize,symbol) bind(c, name="hipGetSymbolSize") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGetSymbolSize_ integer(c_size_t) :: mySize type(c_ptr),value :: symbol end function end interface !> @brief Gets the pointer of requested HIP driver function. !> !> @param[in] symbol - The Symbol name of the driver function to request. !> @param[out] pfn - Output pointer to the requested driver function. !> @param[in] hipVersion - The HIP version for the requested driver function symbol. !> HIP version is defined as 100*version_major + version_minor. For example, in HIP 6.1, the !> hipversion is 601, for the symbol function "hipGetDeviceProperties", the specified hipVersion !> 601 !> is greater or equal to the version 600, the symbol function will be handle properly as backend !> compatible function. !> !> @param[in] flags - Currently only default flag is suppported. !> @param[out] symbolStatus - Optional enumeration for returned status of searching for symbol !> driver !> function based on the input hipVersion. !> !> Returns hipSuccess if the returned pfn is addressed to the pointer of found driver function. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`. interface hipGetProcAddress #ifdef USE_CUDA_NAMES function hipGetProcAddress_(symbol,pfn,hipVersion,flags,symbolStatus) & bind(c, name="cuGetProcAddress") #else function hipGetProcAddress_(symbol,pfn,hipVersion,flags,symbolStatus) & bind(c, name="hipGetProcAddress") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGetProcAddress_ type(c_ptr),value :: symbol type(c_ptr) :: pfn integer(c_int),value :: hipVersion integer(c_int64_t),value :: flags type(c_ptr),value :: symbolStatus end function end interface !> @brief Copies data to the given symbol on the device. !> Symbol HIP APIs allow a kernel to define a device-side data symbol which can be accessed on !> the host side. The symbol can be in __constant or device space. !> Note that the symbol name needs to be encased in the HIP_SYMBOL macro. !> This also applies to hipMemcpyFromSymbol, hipGetSymbolAddress, and hipGetSymbolSize. !> For detailed usage, see the !> href="https://rocm.docs.amd.com/projects/HIP/en/latest/how-to/hip_porting_guide.html#memcpytosymbol">memcpyToSymbol !> example in the HIP Porting Guide. !> !> !> @param[out] symbol - pointer to the device symbole !> @param[in] src - pointer to the source address !> @param[in] sizeBytes - size in bytes to copy !> @param[in] offset - offset in bytes from start of symbole !> @param[in] myKind - type of memory transfer !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipMemcpyToSymbol #ifdef USE_CUDA_NAMES function hipMemcpyToSymbol_(symbol,src,sizeBytes,offset,myKind) & bind(c, name="cudaMemcpyToSymbol") #else function hipMemcpyToSymbol_(symbol,src,sizeBytes,offset,myKind) & bind(c, name="hipMemcpyToSymbol") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyToSymbol_ type(c_ptr),value :: symbol type(c_ptr),value :: src integer(c_size_t),value :: sizeBytes integer(c_size_t),value :: offset integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface !> @brief Copies data to the given symbol on the device asynchronously. !> !> @param[out] symbol - pointer to the device symbole !> @param[in] src - pointer to the source address !> @param[in] sizeBytes - size in bytes to copy !> @param[in] offset - offset in bytes from start of symbole !> @param[in] myKind - type of memory transfer !> @param[in] stream - stream identifier !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipMemcpyToSymbolAsync #ifdef USE_CUDA_NAMES function hipMemcpyToSymbolAsync_(symbol,src,sizeBytes,offset,myKind,stream) & bind(c, name="cudaMemcpyToSymbolAsync") #else function hipMemcpyToSymbolAsync_(symbol,src,sizeBytes,offset,myKind,stream) & bind(c, name="hipMemcpyToSymbolAsync") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyToSymbolAsync_ type(c_ptr),value :: symbol type(c_ptr),value :: src integer(c_size_t),value :: sizeBytes integer(c_size_t),value :: offset integer(kind(hipMemcpyHostToHost)),value :: myKind type(c_ptr),value :: stream end function end interface !> @brief Copies data from the given symbol on the device. !> !> @param[out] dst - Returns pointer to destinition memory address !> @param[in] symbol - Pointer to the symbole address on the device !> @param[in] sizeBytes - Size in bytes to copy !> @param[in] offset - Offset in bytes from the start of symbole !> @param[in] myKind - Type of memory transfer !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipMemcpyFromSymbol #ifdef USE_CUDA_NAMES function hipMemcpyFromSymbol_(dst,symbol,sizeBytes,offset,myKind) & bind(c, name="cudaMemcpyFromSymbol") #else function hipMemcpyFromSymbol_(dst,symbol,sizeBytes,offset,myKind) & bind(c, name="hipMemcpyFromSymbol") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyFromSymbol_ type(c_ptr),value :: dst type(c_ptr),value :: symbol integer(c_size_t),value :: sizeBytes integer(c_size_t),value :: offset integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface !> @brief Copies data from the given symbol on the device asynchronously. !> !> @param[out] dst - Returns pointer to destinition memory address !> @param[in] symbol - pointer to the symbole address on the device !> @param[in] sizeBytes - size in bytes to copy !> @param[in] offset - offset in bytes from the start of symbole !> @param[in] myKind - type of memory transfer !> @param[in] stream - stream identifier !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipMemcpyFromSymbolAsync #ifdef USE_CUDA_NAMES function hipMemcpyFromSymbolAsync_(dst,symbol,sizeBytes,offset,myKind,stream) & bind(c, name="cudaMemcpyFromSymbolAsync") #else function hipMemcpyFromSymbolAsync_(dst,symbol,sizeBytes,offset,myKind,stream) & bind(c, name="hipMemcpyFromSymbolAsync") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyFromSymbolAsync_ type(c_ptr),value :: dst type(c_ptr),value :: symbol integer(c_size_t),value :: sizeBytes integer(c_size_t),value :: offset integer(kind(hipMemcpyHostToHost)),value :: myKind type(c_ptr),value :: stream end function end interface !> @brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the !> constant !> byte value value. !> !> @param[out] dst - Data being filled !> @param[in] myValue - Value to be set !> @param[in] sizeBytes - Data size in bytes !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotInitialized` interface hipMemset #ifdef USE_CUDA_NAMES function hipMemset_(dst,myValue,sizeBytes) bind(c, name="cudaMemset") #else function hipMemset_(dst,myValue,sizeBytes) bind(c, name="hipMemset") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemset_ type(c_ptr),value :: dst integer(c_int),value :: myValue integer(c_size_t),value :: sizeBytes end function end interface !> @brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the !> constant !> byte value value. !> !> @param[out] dest - Data ptr to be filled !> @param[in] myValue - Value to be set !> @param[in] count - Number of values to be set !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotInitialized` #ifndef USE_CUDA_NAMES interface hipMemsetD8 function hipMemsetD8_(dest,myValue,count) bind(c, name="hipMemsetD8") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemsetD8_ type(c_ptr),value :: dest character(c_char),value :: myValue integer(c_size_t),value :: count end function end interface #endif !> @brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the !> constant !> byte value value. !> !> hipMemsetD8Async() is asynchronous with respect to the host, so the call may return before the !> memset is complete. The operation can optionally be associated to a stream by passing a !> non-zero !> stream argument. If stream is non-zero, the operation may overlap with operations in other !> streams. !> !> @param[out] dest - Data ptr to be filled !> @param[in] myValue - Constant value to be set !> @param[in] count - Number of values to be set !> @param[in] stream - Stream identifier !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotInitialized` #ifndef USE_CUDA_NAMES interface hipMemsetD8Async function hipMemsetD8Async_(dest,myValue,count,stream) bind(c, name="hipMemsetD8Async") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemsetD8Async_ type(c_ptr),value :: dest character(c_char),value :: myValue integer(c_size_t),value :: count type(c_ptr),value :: stream end function end interface #endif !> @brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the !> constant !> short value value. !> !> @param[out] dest - Data ptr to be filled !> @param[in] myValue - Constant value to be set !> @param[in] count - Number of values to be set !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotInitialized` #ifndef USE_CUDA_NAMES interface hipMemsetD16 function hipMemsetD16_(dest,myValue,count) bind(c, name="hipMemsetD16") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemsetD16_ type(c_ptr),value :: dest integer(c_short),value :: myValue integer(c_size_t),value :: count end function end interface #endif !> @brief Fills the first sizeBytes bytes of the memory area pointed to by dest with the !> constant !> short value value. !> !> hipMemsetD16Async() is asynchronous with respect to the host, so the call may return before !> the !> memset is complete. The operation can optionally be associated to a stream by passing a !> non-zero !> stream argument. If stream is non-zero, the operation may overlap with operations in other !> streams. !> !> @param[out] dest - Data ptr to be filled !> @param[in] myValue - Constant value to be set !> @param[in] count - Number of values to be set !> @param[in] stream - Stream identifier !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotInitialized` #ifndef USE_CUDA_NAMES interface hipMemsetD16Async function hipMemsetD16Async_(dest,myValue,count,stream) bind(c, name="hipMemsetD16Async") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemsetD16Async_ type(c_ptr),value :: dest integer(c_short),value :: myValue integer(c_size_t),value :: count type(c_ptr),value :: stream end function end interface #endif !> @brief Fills the memory area pointed to by dest with the constant integer !> value for specified number of times. !> !> @param[out] dest - Data being filled !> @param[in] myValue - Constant value to be set !> @param[in] count - Number of values to be set !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotInitialized` #ifndef USE_CUDA_NAMES interface hipMemsetD32 function hipMemsetD32_(dest,myValue,count) bind(c, name="hipMemsetD32") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemsetD32_ type(c_ptr),value :: dest integer(c_int),value :: myValue integer(c_size_t),value :: count end function end interface #endif !> @brief Fills the first sizeBytes bytes of the memory area pointed to by dev with the constant !> byte value value. !> !> hipMemsetAsync() is asynchronous with respect to the host, so the call may return before the !> memset is complete. The operation can optionally be associated to a stream by passing a !> non-zero !> stream argument. If stream is non-zero, the operation may overlap with operations in other !> streams. !> !> @param[out] dst - Pointer to device memory !> @param[in] myValue - Value to set for each byte of specified memory !> @param[in] sizeBytes - Size in bytes to set !> @param[in] stream - Stream identifier !> @return `hipSuccess`, `hipErrorInvalidValue` interface hipMemsetAsync #ifdef USE_CUDA_NAMES function hipMemsetAsync_(dst,myValue,sizeBytes,stream) bind(c, name="cudaMemsetAsync") #else function hipMemsetAsync_(dst,myValue,sizeBytes,stream) bind(c, name="hipMemsetAsync") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemsetAsync_ type(c_ptr),value :: dst integer(c_int),value :: myValue integer(c_size_t),value :: sizeBytes type(c_ptr),value :: stream end function end interface !> @brief Fills the memory area pointed to by dev with the constant integer !> value for specified number of times. !> !> hipMemsetD32Async() is asynchronous with respect to the host, so the call may return before !> the !> memset is complete. The operation can optionally be associated to a stream by passing a !> non-zero !> stream argument. If stream is non-zero, the operation may overlap with operations in other !> streams. !> !> @param[out] dst - Pointer to device memory !> @param[in] myValue - Value to set for each byte of specified memory !> @param[in] count - Number of values to be set !> @param[in] stream - Stream identifier !> @return `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipMemsetD32Async function hipMemsetD32Async_(dst,myValue,count,stream) bind(c, name="hipMemsetD32Async") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemsetD32Async_ type(c_ptr),value :: dst integer(c_int),value :: myValue integer(c_size_t),value :: count type(c_ptr),value :: stream end function end interface #endif !> @brief Fills the memory area pointed to by dst with the constant value. !> !> @param[out] dst - Pointer to 2D device memory !> @param[in] pitch - Pitch size in bytes of 2D device memory, unused if height equals 1 !> @param[in] myValue - Constant value to set for each byte of specified memory !> @param[in] width - Width size in bytes in 2D memory !> @param[in] height - Height size in bytes in 2D memory !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipMemset2D #ifdef USE_CUDA_NAMES function hipMemset2D_(dst,pitch,myValue,width,height) bind(c, name="cudaMemset2D") #else function hipMemset2D_(dst,pitch,myValue,width,height) bind(c, name="hipMemset2D") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemset2D_ type(c_ptr),value :: dst integer(c_size_t),value :: pitch integer(c_int),value :: myValue integer(c_size_t),value :: width integer(c_size_t),value :: height end function end interface !> @brief Fills asynchronously the memory area pointed to by dst with the constant value. !> !> @param[in] dst - Pointer to 2D device memory !> @param[in] pitch - Pitch size in bytes of 2D device memory, unused if height equals 1 !> @param[in] myValue - Value to set for each byte of specified memory !> @param[in] width - Width size in bytes in 2D memory !> @param[in] height - Height size in bytes in 2D memory !> @param[in] stream - Stream identifier !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipMemset2DAsync #ifdef USE_CUDA_NAMES function hipMemset2DAsync_(dst,pitch,myValue,width,height,stream) & bind(c, name="cudaMemset2DAsync") #else function hipMemset2DAsync_(dst,pitch,myValue,width,height,stream) & bind(c, name="hipMemset2DAsync") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemset2DAsync_ type(c_ptr),value :: dst integer(c_size_t),value :: pitch integer(c_int),value :: myValue integer(c_size_t),value :: width integer(c_size_t),value :: height type(c_ptr),value :: stream end function end interface !> @brief Fills synchronously the memory area pointed to by pitchedDevPtr with the constant !> value. !> !> @param[in] pitchedDevPtr - Pointer to pitched device memory !> @param[in] myValue - Value to set for each byte of specified memory !> @param[in] extent - Size parameters for width field in bytes in device memory !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipMemset3D #ifdef USE_CUDA_NAMES function hipMemset3D_(pitchedDevPtr,myValue,extent) bind(c, name="cudaMemset3D") #else function hipMemset3D_(pitchedDevPtr,myValue,extent) bind(c, name="hipMemset3D") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemset3D_ type(hipPitchedPtr),value :: pitchedDevPtr integer(c_int),value :: myValue type(hipExtent),value :: extent end function end interface !> @brief Fills asynchronously the memory area pointed to by pitchedDevPtr with the constant !> value. !> !> @param[in] pitchedDevPtr - Pointer to pitched device memory !> @param[in] myValue - Value to set for each byte of specified memory !> @param[in] extent - Size parameters for width field in bytes in device memory !> @param[in] stream - Stream identifier !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipMemset3DAsync #ifdef USE_CUDA_NAMES function hipMemset3DAsync_(pitchedDevPtr,myValue,extent,stream) & bind(c, name="cudaMemset3DAsync") #else function hipMemset3DAsync_(pitchedDevPtr,myValue,extent,stream) bind(c, name="hipMemset3DAsync") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemset3DAsync_ type(hipPitchedPtr),value :: pitchedDevPtr integer(c_int),value :: myValue type(hipExtent),value :: extent type(c_ptr),value :: stream end function end interface !> @brief Fills 2D memory range of 'width' 8-bit values synchronously to the specified char !> value. !> Height specifies numbers of rows to set and dstPitch speicifies the number of bytes between !> each !> row. !> @param[in] dst - Pointer to device memory !> @param[in] dstPitch - Pitch of dst device pointer !> @param[in] myValue - value to set !> @param[in] width - Width of row !> @param[in] height - Number of rows !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipMemsetD2D8 #ifdef USE_CUDA_NAMES function hipMemsetD2D8_(dst,dstPitch,myValue,width,height) bind(c, name="cuMemsetD2D8") #else function hipMemsetD2D8_(dst,dstPitch,myValue,width,height) bind(c, name="hipMemsetD2D8") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemsetD2D8_ type(c_ptr),value :: dst integer(c_size_t),value :: dstPitch character(c_char),value :: myValue integer(c_size_t),value :: width integer(c_size_t),value :: height end function end interface !> @brief Fills 2D memory range of 'width' 8-bit values asynchronously to the specified char !> value. !> Height specifies numbers of rows to set and dstPitch speicifies the number of bytes between !> each !> row. !> @param[in] dst - Pointer to device memory !> @param[in] dstPitch - Pitch of dst device pointer !> @param[in] myValue - value to set !> @param[in] width - Width of row !> @param[in] height - Number of rows !> @param[in] stream - Stream Identifier !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipMemsetD2D8Async #ifdef USE_CUDA_NAMES function hipMemsetD2D8Async_(dst,dstPitch,myValue,width,height,stream) & bind(c, name="cuMemsetD2D8Async") #else function hipMemsetD2D8Async_(dst,dstPitch,myValue,width,height,stream) & bind(c, name="hipMemsetD2D8Async") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemsetD2D8Async_ type(c_ptr),value :: dst integer(c_size_t),value :: dstPitch character(c_char),value :: myValue integer(c_size_t),value :: width integer(c_size_t),value :: height type(c_ptr),value :: stream end function end interface !> @brief Fills 2D memory range of 'width' 16-bit values synchronously to the specified short !> value. Height specifies numbers of rows to set and dstPitch speicifies the number of bytes !> between each row. !> @param[in] dst - Pointer to device memory !> @param[in] dstPitch - Pitch of dst device pointer !> @param[in] myValue - value to set !> @param[in] width - Width of row !> @param[in] height - Number of rows !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipMemsetD2D16 #ifdef USE_CUDA_NAMES function hipMemsetD2D16_(dst,dstPitch,myValue,width,height) bind(c, name="cuMemsetD2D16") #else function hipMemsetD2D16_(dst,dstPitch,myValue,width,height) bind(c, name="hipMemsetD2D16") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemsetD2D16_ type(c_ptr),value :: dst integer(c_size_t),value :: dstPitch integer(c_short),value :: myValue integer(c_size_t),value :: width integer(c_size_t),value :: height end function end interface !> @brief Fills 2D memory range of 'width' 16-bit values asynchronously to the specified short !> value. Height specifies numbers of rows to set and dstPitch speicifies the number of bytes !> between each row. !> @param[in] dst - Pointer to device memory !> @param[in] dstPitch - Pitch of dst device pointer !> @param[in] myValue - value to set !> @param[in] width - Width of row !> @param[in] height - Number of rows !> @param[in] stream - Stream Identifier !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipMemsetD2D16Async #ifdef USE_CUDA_NAMES function hipMemsetD2D16Async_(dst,dstPitch,myValue,width,height,stream) & bind(c, name="cuMemsetD2D16Async") #else function hipMemsetD2D16Async_(dst,dstPitch,myValue,width,height,stream) & bind(c, name="hipMemsetD2D16Async") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemsetD2D16Async_ type(c_ptr),value :: dst integer(c_size_t),value :: dstPitch integer(c_short),value :: myValue integer(c_size_t),value :: width integer(c_size_t),value :: height type(c_ptr),value :: stream end function end interface !> @brief Fills 2D memory range of 'width' 32-bit values synchronously to the specified int !> value. !> Height specifies numbers of rows to set and dstPitch speicifies the number of bytes between !> each !> row. !> @param[in] dst - Pointer to device memory !> @param[in] dstPitch - Pitch of dst device pointer !> @param[in] myValue - value to set !> @param[in] width - Width of row !> @param[in] height - Number of rows !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipMemsetD2D32 #ifdef USE_CUDA_NAMES function hipMemsetD2D32_(dst,dstPitch,myValue,width,height) bind(c, name="cuMemsetD2D32") #else function hipMemsetD2D32_(dst,dstPitch,myValue,width,height) bind(c, name="hipMemsetD2D32") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemsetD2D32_ type(c_ptr),value :: dst integer(c_size_t),value :: dstPitch integer(c_int),value :: myValue integer(c_size_t),value :: width integer(c_size_t),value :: height end function end interface !> @brief Fills 2D memory range of 'width' 32-bit values asynchronously to the specified int !> value. Height specifies numbers of rows to set and dstPitch speicifies the number of bytes !> between each row. !> @param[in] dst - Pointer to device memory !> @param[in] dstPitch - Pitch of dst device pointer !> @param[in] myValue - value to set !> @param[in] width - Width of row !> @param[in] height - Number of rows !> @param[in] stream - Stream Identifier !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipMemsetD2D32Async #ifdef USE_CUDA_NAMES function hipMemsetD2D32Async_(dst,dstPitch,myValue,width,height,stream) & bind(c, name="cuMemsetD2D32Async") #else function hipMemsetD2D32Async_(dst,dstPitch,myValue,width,height,stream) & bind(c, name="hipMemsetD2D32Async") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemsetD2D32Async_ type(c_ptr),value :: dst integer(c_size_t),value :: dstPitch integer(c_int),value :: myValue integer(c_size_t),value :: width integer(c_size_t),value :: height type(c_ptr),value :: stream end function end interface !> @brief Query memory info. !> !> On ROCM, this function gets the actual free memory left on the current device, so supports !> the cases while running multi-workload (such as multiple processes, multiple threads, and !> multiple GPUs). !> !> @warning On Windows, the free memory only accounts for memory allocated by this process and !> may !> be optimistic. !> !> @param[out] free - Returns free memory on the current device in bytes !> @param[out] total - Returns total allocatable memory on the current device in bytes !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue` interface hipMemGetInfo #ifdef USE_CUDA_NAMES function hipMemGetInfo_(free,total) bind(c, name="cudaMemGetInfo") #else function hipMemGetInfo_(free,total) bind(c, name="hipMemGetInfo") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemGetInfo_ integer(c_size_t) :: free integer(c_size_t) :: total end function end interface !> @brief Get allocated memory size via memory pointer. !> !> This function gets the allocated shared virtual memory size from memory pointer. !> !> @param[in] ptr - Pointer to allocated memory !> @param[out] mySize - Returns the allocated memory size in bytes !> !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipMemPtrGetInfo function hipMemPtrGetInfo_(ptr,mySize) bind(c, name="hipMemPtrGetInfo") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemPtrGetInfo_ type(c_ptr),value :: ptr integer(c_size_t) :: mySize end function end interface #endif !> @brief Allocate an array on the device. !> !> @param[out] array - Pointer to allocated array in device memory !> @param[in] desc - Requested channel format !> @param[in] width - Requested array allocation width !> @param[in] height - Requested array allocation height !> @param[in] flags - Requested properties of allocated array !> @returns `hipSuccess`, `hipErrorOutOfMemory` !> !> @see hipMalloc, hipMallocPitch, hipFree, hipFreeArray, hipHostMalloc, hipHostFree interface hipMallocArray #ifdef USE_CUDA_NAMES function hipMallocArray_(array,desc,width,height,flags) bind(c, name="cudaMallocArray") #else function hipMallocArray_(array,desc,width,height,flags) bind(c, name="hipMallocArray") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMallocArray_ type(c_ptr) :: array type(hipChannelFormatDesc) :: desc integer(c_size_t),value :: width integer(c_size_t),value :: height integer(c_int),value :: flags end function end interface !> @brief Create an array memory pointer on the device. !> !> @param[out] pHandle - Pointer to the array memory !> @param[in] pAllocateArray - Requested array desciptor !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @see hipMallocArray, hipArrayDestroy, hipFreeArray #ifndef USE_CUDA_NAMES interface hipArrayCreate function hipArrayCreate_(pHandle,pAllocateArray) bind(c, name="hipArrayCreate") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipArrayCreate_ type(c_ptr) :: pHandle type(HIP_ARRAY_DESCRIPTOR) :: pAllocateArray end function end interface #endif !> @brief Destroy an array memory pointer on the device. !> !> @param[in] array - Pointer to the array memory !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @see hipArrayCreate, hipArrayDestroy, hipFreeArray #ifndef USE_CUDA_NAMES interface hipArrayDestroy function hipArrayDestroy_(array) bind(c, name="hipArrayDestroy") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipArrayDestroy_ type(c_ptr),value :: array end function end interface #endif !> @brief Create a 3D array memory pointer on the device. !> !> @param[out] array - Pointer to the 3D array memory !> @param[in] pAllocateArray - Requested array desciptor !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @see hipMallocArray, hipArrayDestroy, hipFreeArray #ifndef USE_CUDA_NAMES interface hipArray3DCreate function hipArray3DCreate_(array,pAllocateArray) bind(c, name="hipArray3DCreate") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipArray3DCreate_ type(c_ptr) :: array type(HIP_ARRAY3D_DESCRIPTOR) :: pAllocateArray end function end interface #endif !> @brief Create a 3D memory pointer on the device. !> !> @param[out] pitchedDevPtr - Pointer to the 3D memory !> @param[in] extent - Requested extent !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @see hipMallocPitch, hipMemGetInfo, hipFree interface hipMalloc3D #ifdef USE_CUDA_NAMES function hipMalloc3D_(pitchedDevPtr,extent) bind(c, name="cudaMalloc3D") #else function hipMalloc3D_(pitchedDevPtr,extent) bind(c, name="hipMalloc3D") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMalloc3D_ type(hipPitchedPtr) :: pitchedDevPtr type(hipExtent),value :: extent end function end interface !> @brief Frees an array on the device. !> !> @param[in] array - Pointer to array to free !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotInitialized` !> !> @see hipMalloc, hipMallocPitch, hipFree, hipMallocArray, hipHostMalloc, hipHostFree interface hipFreeArray #ifdef USE_CUDA_NAMES function hipFreeArray_(array) bind(c, name="cudaFreeArray") #else function hipFreeArray_(array) bind(c, name="hipFreeArray") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipFreeArray_ type(c_ptr),value :: array end function end interface !> @brief Allocate an array on the device. !> !> @param[out] array - Pointer to allocated array in device memory !> @param[in] desc - Requested channel format !> @param[in] extent - Requested array allocation width, height and depth !> @param[in] flags - Requested properties of allocated array !> @returns `hipSuccess`, `hipErrorOutOfMemory` !> !> @see hipMalloc, hipMallocPitch, hipFree, hipFreeArray, hipHostMalloc, hipHostFree interface hipMalloc3DArray #ifdef USE_CUDA_NAMES function hipMalloc3DArray_(array,desc,extent,flags) bind(c, name="cudaMalloc3DArray") #else function hipMalloc3DArray_(array,desc,extent,flags) bind(c, name="hipMalloc3DArray") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMalloc3DArray_ type(c_ptr) :: array type(hipChannelFormatDesc) :: desc type(hipExtent),value :: extent integer(c_int),value :: flags end function end interface !> @brief Gets info about the specified array !> !> @param[out] desc - Returned array type !> @param[out] extent - Returned array shape. 2D arrays will have depth of zero !> @param[out] flags - Returned array flags !> @param[in] array - The HIP array to get info for !> !> @returns `hipSuccess`, `hipErrorInvalidValue` `hipErrorInvalidHandle` !> !> @see hipArrayGetDescriptor, hipArray3DGetDescriptor interface hipArrayGetInfo #ifdef USE_CUDA_NAMES function hipArrayGetInfo_(desc,extent,flags,array) bind(c, name="cudaArrayGetInfo") #else function hipArrayGetInfo_(desc,extent,flags,array) bind(c, name="hipArrayGetInfo") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipArrayGetInfo_ type(hipChannelFormatDesc) :: desc type(hipExtent) :: extent type(c_ptr),value :: flags type(c_ptr),value :: array end function end interface !> @brief Gets a 1D or 2D array descriptor !> !> @param[out] pArrayDescriptor - Returned array descriptor !> @param[in] array - Array to get descriptor of !> !> @returns `hipSuccess`, `hipErrorDeinitialized`, `hipErrorNotInitialized`, !> `hipErrorInvalidContext`, !> `hipErrorInvalidValue` `hipErrorInvalidHandle` !> !> @see hipArray3DCreate, hipArray3DGetDescriptor, hipArrayCreate, hipArrayDestroy, hipMemAlloc, !> hipMemAllocHost, hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, !> hipMemcpy3D, hipMemcpy3DAsync, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH, !> hipMemcpyAtoHAsync, !> hipMemcpyDtoA, hipMemcpyDtoD, hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, !> hipMemcpyHtoA, hipMemcpyHtoAAsync, hipMemcpyHtoD, hipMemcpyHtoDAsync, hipMemFree, !> hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo, hipMemHostAlloc, !> hipMemHostGetDevicePointer, hipMemsetD8, hipMemsetD16, hipMemsetD32, hipArrayGetInfo interface hipArrayGetDescriptor #ifdef USE_CUDA_NAMES function hipArrayGetDescriptor_(pArrayDescriptor,array) bind(c, name="cuArrayGetDescriptor") #else function hipArrayGetDescriptor_(pArrayDescriptor,array) bind(c, name="hipArrayGetDescriptor") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipArrayGetDescriptor_ type(HIP_ARRAY_DESCRIPTOR) :: pArrayDescriptor type(c_ptr),value :: array end function end interface !> @brief Gets a 3D array descriptor !> !> @param[out] pArrayDescriptor - Returned 3D array descriptor !> @param[in] array - 3D array to get descriptor of !> !> @returns `hipSuccess`, `hipErrorDeinitialized`, `hipErrorNotInitialized`, !> `hipErrorInvalidContext`, !> `hipErrorInvalidValue` `hipErrorInvalidHandle`, `hipErrorContextIsDestroyed` !> !> @see hipArray3DCreate, hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, !> hipMemAllocHost, hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, !> hipMemcpy3D, hipMemcpy3DAsync, hipMemcpyAtoA, hipMemcpyAtoD, hipMemcpyAtoH, !> hipMemcpyAtoHAsync, !> hipMemcpyDtoA, hipMemcpyDtoD, hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, !> hipMemcpyHtoA, hipMemcpyHtoAAsync, hipMemcpyHtoD, hipMemcpyHtoDAsync, hipMemFree, !> hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo, hipMemHostAlloc, !> hipMemHostGetDevicePointer, hipMemsetD8, hipMemsetD16, hipMemsetD32, hipArrayGetInfo interface hipArray3DGetDescriptor #ifdef USE_CUDA_NAMES function hipArray3DGetDescriptor_(pArrayDescriptor,array) bind(c, name="cuArray3DGetDescriptor") #else function hipArray3DGetDescriptor_(pArrayDescriptor,array) & bind(c, name="hipArray3DGetDescriptor") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipArray3DGetDescriptor_ type(HIP_ARRAY3D_DESCRIPTOR) :: pArrayDescriptor type(c_ptr),value :: array end function end interface !> @brief Copies memory for 2D arrays. !> @param[in] pCopy - Parameters for the memory copy !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidPitchValue`, !> `hipErrorInvalidDevicePointer`, `hipErrorInvalidMemcpyDirection` !> !> @see hipMemcpy, hipMemcpy2D, hipMemcpyToArray, hipMemcpy2DToArray, hipMemcpyFromArray, !> hipMemcpyToSymbol, hipMemcpyAsync #ifndef USE_CUDA_NAMES interface hipMemcpyParam2D function hipMemcpyParam2D_(pCopy) bind(c, name="hipMemcpyParam2D") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemcpyParam2D_ type(hip_Memcpy2D) :: pCopy end function end interface #endif !> @brief Copies memory for 2D arrays. !> @param[in] pCopy - Parameters for the memory copy !> @param[in] stream - Stream to use !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidPitchValue`, !> `hipErrorInvalidDevicePointer`, `hipErrorInvalidMemcpyDirection` !> !> @see hipMemcpy, hipMemcpy2D, hipMemcpyToArray, hipMemcpy2DToArray, hipMemcpyFromArray, !> hipMemcpyToSymbol, hipMemcpyAsync #ifndef USE_CUDA_NAMES interface hipMemcpyParam2DAsync function hipMemcpyParam2DAsync_(pCopy,stream) bind(c, name="hipMemcpyParam2DAsync") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemcpyParam2DAsync_ type(hip_Memcpy2D) :: pCopy type(c_ptr),value :: stream end function end interface #endif !> @brief Copies data between host and device. !> !> @param[out] dst - Destination memory address !> @param[in] wOffset - Destination starting X offset !> @param[in] hOffset - Destination starting Y offset !> @param[in] src - Source memory address !> @param[in] spitch - Pitch of source memory !> @param[in] width - Width of matrix transfer (columns in bytes) !> @param[in] height - Height of matrix transfer (rows) !> @param[in] myKind - Type of transfer !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidPitchValue`, !> `hipErrorInvalidDevicePointer`, `hipErrorInvalidMemcpyDirection` !> !> @see hipMemcpy, hipMemcpyToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol, !> hipMemcpyAsync interface hipMemcpy2DToArray #ifdef USE_CUDA_NAMES function hipMemcpy2DToArray_(dst,wOffset,hOffset,src,spitch,width,height,myKind) & bind(c, name="cudaMemcpy2DToArray") #else function hipMemcpy2DToArray_(dst,wOffset,hOffset,src,spitch,width,height,myKind) & bind(c, name="hipMemcpy2DToArray") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpy2DToArray_ type(c_ptr),value :: dst integer(c_size_t),value :: wOffset integer(c_size_t),value :: hOffset type(c_ptr),value :: src integer(c_size_t),value :: spitch integer(c_size_t),value :: width integer(c_size_t),value :: height integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface !> @brief Copies data between host and device. !> !> @param[out] dst - Destination memory address !> @param[in] wOffset - Destination starting X offset !> @param[in] hOffset - Destination starting Y offset !> @param[in] src - Source memory address !> @param[in] spitch - Pitch of source memory !> @param[in] width - Width of matrix transfer (columns in bytes) !> @param[in] height - Height of matrix transfer (rows) !> @param[in] myKind - Type of transfer !> @param[in] stream - Accelerator view which the copy is being enqueued !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidPitchValue`, !> `hipErrorInvalidDevicePointer`, `hipErrorInvalidMemcpyDirection` !> !> @see hipMemcpy, hipMemcpyToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol, !> hipMemcpyAsync interface hipMemcpy2DToArrayAsync #ifdef USE_CUDA_NAMES function hipMemcpy2DToArrayAsync_(dst,wOffset,hOffset,src,spitch,width,height,myKind,stream) & bind(c, name="cudaMemcpy2DToArrayAsync") #else function hipMemcpy2DToArrayAsync_(dst,wOffset,hOffset,src,spitch,width,height,myKind,stream) & bind(c, name="hipMemcpy2DToArrayAsync") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpy2DToArrayAsync_ type(c_ptr),value :: dst integer(c_size_t),value :: wOffset integer(c_size_t),value :: hOffset type(c_ptr),value :: src integer(c_size_t),value :: spitch integer(c_size_t),value :: width integer(c_size_t),value :: height integer(kind(hipMemcpyHostToHost)),value :: myKind type(c_ptr),value :: stream end function end interface !> @brief Copies data between host and device. !> !> @param[out] dst - Destination memory address !> @param[in] wOffsetDst - Destination starting X offset !> @param[in] hOffsetDst - Destination starting Y offset !> @param[in] src - Source memory address !> @param[in] wOffsetSrc - Source starting X offset !> @param[in] hOffsetSrc - Source starting Y offset (columns in bytes) !> @param[in] width - Width of matrix transfer (columns in bytes) !> @param[in] height - Height of matrix transfer (rows) !> @param[in] myKind - Type of transfer !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidMemcpyDirection` !> !> @see hipMemcpy, hipMemcpyToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol, !> hipMemcpyAsync interface hipMemcpy2DArrayToArray #ifdef USE_CUDA_NAMES function hipMemcpy2DArrayToArray_(dst,wOffsetDst,hOffsetDst,src,wOffsetSrc,hOffsetSrc,width, & height,myKind) & bind(c, name="cudaMemcpy2DArrayToArray") #else function hipMemcpy2DArrayToArray_(dst,wOffsetDst,hOffsetDst,src,wOffsetSrc,hOffsetSrc,width, & height,myKind) & bind(c, name="hipMemcpy2DArrayToArray") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpy2DArrayToArray_ type(c_ptr),value :: dst integer(c_size_t),value :: wOffsetDst integer(c_size_t),value :: hOffsetDst type(c_ptr),value :: src integer(c_size_t),value :: wOffsetSrc integer(c_size_t),value :: hOffsetSrc integer(c_size_t),value :: width integer(c_size_t),value :: height integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface !> @brief Copies data between host and device [Deprecated] !> !> @ingroup MemoryD !> !> @param[out] dst - Destination memory address !> @param[in] wOffset - Destination starting X offset !> @param[in] hOffset - Destination starting Y offset !> @param[in] src - Source memory address !> @param[in] count - size in bytes to copy !> @param[in] myKind - Type of transfer !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidPitchValue`, !> `hipErrorInvalidDevicePointer`, `hipErrorInvalidMemcpyDirection` !> !> @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol, !> hipMemcpyAsync !> @warning This API is deprecated. interface hipMemcpyToArray #ifdef USE_CUDA_NAMES function hipMemcpyToArray_(dst,wOffset,hOffset,src,count,myKind) & bind(c, name="cudaMemcpyToArray") #else function hipMemcpyToArray_(dst,wOffset,hOffset,src,count,myKind) & bind(c, name="hipMemcpyToArray") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyToArray_ type(c_ptr),value :: dst integer(c_size_t),value :: wOffset integer(c_size_t),value :: hOffset type(c_ptr),value :: src integer(c_size_t),value :: count integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface !> @brief Copies data between host and device [Deprecated] !> !> @ingroup MemoryD !> !> @param[out] dst - Destination memory address !> @param[in] srcArray - Source memory address !> @param[in] wOffset - Source starting X offset !> @param[in] hOffset - Source starting Y offset !> @param[in] count - Size in bytes to copy !> @param[in] myKind - Type of transfer !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidPitchValue`, !> `hipErrorInvalidDevicePointer`, `hipErrorInvalidMemcpyDirection` !> !> @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol, !> hipMemcpyAsync !> @warning This API is deprecated. interface hipMemcpyFromArray #ifdef USE_CUDA_NAMES function hipMemcpyFromArray_(dst,srcArray,wOffset,hOffset,count,myKind) & bind(c, name="cudaMemcpyFromArray") #else function hipMemcpyFromArray_(dst,srcArray,wOffset,hOffset,count,myKind) & bind(c, name="hipMemcpyFromArray") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyFromArray_ type(c_ptr),value :: dst type(c_ptr),value :: srcArray integer(c_size_t),value :: wOffset integer(c_size_t),value :: hOffset integer(c_size_t),value :: count integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface !> @brief Copies data between host and device. !> !> @param[out] dst - Destination memory address !> @param[in] dpitch - Pitch of destination memory !> @param[in] src - Source memory address !> @param[in] wOffset - Source starting X offset !> @param[in] hOffset - Source starting Y offset !> @param[in] width - Width of matrix transfer (columns in bytes) !> @param[in] height - Height of matrix transfer (rows) !> @param[in] myKind - Type of transfer !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidPitchValue`, !> `hipErrorInvalidDevicePointer`, `hipErrorInvalidMemcpyDirection` !> !> @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol, !> hipMemcpyAsync interface hipMemcpy2DFromArray #ifdef USE_CUDA_NAMES function hipMemcpy2DFromArray_(dst,dpitch,src,wOffset,hOffset,width,height,myKind) & bind(c, name="cudaMemcpy2DFromArray") #else function hipMemcpy2DFromArray_(dst,dpitch,src,wOffset,hOffset,width,height,myKind) & bind(c, name="hipMemcpy2DFromArray") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpy2DFromArray_ type(c_ptr),value :: dst integer(c_size_t),value :: dpitch type(c_ptr),value :: src integer(c_size_t),value :: wOffset integer(c_size_t),value :: hOffset integer(c_size_t),value :: width integer(c_size_t),value :: height integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface !> @brief Copies data between host and device asynchronously. !> !> @param[out] dst - Destination memory address !> @param[in] dpitch - Pitch of destination memory !> @param[in] src - Source memory address !> @param[in] wOffset - Source starting X offset !> @param[in] hOffset - Source starting Y offset !> @param[in] width - Width of matrix transfer (columns in bytes) !> @param[in] height - Height of matrix transfer (rows) !> @param[in] myKind - Type of transfer !> @param[in] stream - Accelerator view which the copy is being enqueued !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidPitchValue`, !> `hipErrorInvalidDevicePointer`, `hipErrorInvalidMemcpyDirection` !> !> @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol, !> hipMemcpyAsync interface hipMemcpy2DFromArrayAsync #ifdef USE_CUDA_NAMES function hipMemcpy2DFromArrayAsync_(dst,dpitch,src,wOffset,hOffset,width,height,myKind,stream) & bind(c, name="cudaMemcpy2DFromArrayAsync") #else function hipMemcpy2DFromArrayAsync_(dst,dpitch,src,wOffset,hOffset,width,height,myKind,stream) & bind(c, name="hipMemcpy2DFromArrayAsync") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpy2DFromArrayAsync_ type(c_ptr),value :: dst integer(c_size_t),value :: dpitch type(c_ptr),value :: src integer(c_size_t),value :: wOffset integer(c_size_t),value :: hOffset integer(c_size_t),value :: width integer(c_size_t),value :: height integer(kind(hipMemcpyHostToHost)),value :: myKind type(c_ptr),value :: stream end function end interface !> @brief Copies data between host and device. !> !> @param[out] dst - Destination memory address !> @param[in] srcArray - Source array !> @param[in] srcOffset - Offset in bytes of source array !> @param[in] count - Size of memory copy in bytes !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidPitchValue`, !> `hipErrorInvalidDevicePointer`, `hipErrorInvalidMemcpyDirection` !> !> @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol, !> hipMemcpyAsync #ifndef USE_CUDA_NAMES interface hipMemcpyAtoH function hipMemcpyAtoH_(dst,srcArray,srcOffset,count) bind(c, name="hipMemcpyAtoH") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyAtoH_ type(c_ptr),value :: dst type(c_ptr),value :: srcArray integer(c_size_t),value :: srcOffset integer(c_size_t),value :: count end function end interface #endif !> @brief Copies data between host and device. !> !> @param[out] dstArray - Destination memory address !> @param[in] dstOffset - Offset in bytes of destination array !> @param[in] srcHost - Source host pointer !> @param[in] count - Size of memory copy in bytes !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidPitchValue`, !> `hipErrorInvalidDevicePointer`, `hipErrorInvalidMemcpyDirection` !> !> @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol, !> hipMemcpyAsync #ifndef USE_CUDA_NAMES interface hipMemcpyHtoA function hipMemcpyHtoA_(dstArray,dstOffset,srcHost,count) bind(c, name="hipMemcpyHtoA") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyHtoA_ type(c_ptr),value :: dstArray integer(c_size_t),value :: dstOffset type(c_ptr),value :: srcHost integer(c_size_t),value :: count end function end interface #endif !> @brief Copies data between host and device. !> !> @param[in] p - 3D memory copy parameters !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidPitchValue`, !> `hipErrorInvalidDevicePointer`, `hipErrorInvalidMemcpyDirection` !> !> @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol, !> hipMemcpyAsync interface hipMemcpy3D #ifdef USE_CUDA_NAMES function hipMemcpy3D_(p) bind(c, name="cudaMemcpy3D") #else function hipMemcpy3D_(p) bind(c, name="hipMemcpy3D") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemcpy3D_ type(hipMemcpy3DParms) :: p end function end interface !> @brief Copies data between host and device asynchronously. !> !> @param[in] p - 3D memory copy parameters !> @param[in] stream - Stream to use !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidPitchValue`, !> `hipErrorInvalidDevicePointer`, `hipErrorInvalidMemcpyDirection` !> !> @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol, !> hipMemcpyAsync interface hipMemcpy3DAsync #ifdef USE_CUDA_NAMES function hipMemcpy3DAsync_(p,stream) bind(c, name="cudaMemcpy3DAsync") #else function hipMemcpy3DAsync_(p,stream) bind(c, name="hipMemcpy3DAsync") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemcpy3DAsync_ type(hipMemcpy3DParms) :: p type(c_ptr),value :: stream end function end interface !> @brief Copies data between host and device. !> !> @param[in] pCopy - 3D memory copy parameters !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidPitchValue`, !> `hipErrorInvalidDevicePointer`, `hipErrorInvalidMemcpyDirection` !> !> @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol, !> hipMemcpyAsync #ifndef USE_CUDA_NAMES interface hipDrvMemcpy3D function hipDrvMemcpy3D_(pCopy) bind(c, name="hipDrvMemcpy3D") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipDrvMemcpy3D_ type(HIP_MEMCPY3D) :: pCopy end function end interface #endif !> @brief Copies data between host and device asynchronously. !> !> @param[in] pCopy - 3D memory copy parameters !> @param[in] stream - Stream to use !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidPitchValue`, !> `hipErrorInvalidDevicePointer`, `hipErrorInvalidMemcpyDirection` !> !> @see hipMemcpy, hipMemcpy2DToArray, hipMemcpy2D, hipMemcpyFromArray, hipMemcpyToSymbol, !> hipMemcpyAsync #ifndef USE_CUDA_NAMES interface hipDrvMemcpy3DAsync function hipDrvMemcpy3DAsync_(pCopy,stream) bind(c, name="hipDrvMemcpy3DAsync") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipDrvMemcpy3DAsync_ type(HIP_MEMCPY3D) :: pCopy type(c_ptr),value :: stream end function end interface #endif !> @brief Get information on memory allocations. !> !> @param [out] pbase - BAse pointer address !> @param [out] psize - Size of allocation !> @param [in] dptr- Device Pointer !> !> @returns `hipSuccess`, `hipErrorNotFound` !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, !> hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice #ifndef USE_CUDA_NAMES interface hipMemGetAddressRange function hipMemGetAddressRange_(pbase,psize,dptr) bind(c, name="hipMemGetAddressRange") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemGetAddressRange_ type(c_ptr) :: pbase integer(c_size_t) :: psize type(c_ptr),value :: dptr end function end interface #endif !> @brief Perform Batch of 1D copies !> !> @param [out] dsts - Array of destination pointers !> @param [in] srcs - Array of source pointers. !> @param [in] sizes - Array of sizes for memcpy operations !> @param [in] count - Size of dsts, srcs and sizes arrays !> @param [in] attrs - Array of memcpy attributes (not supported) !> @param [in] attrsIdxs - Array of indices to map attrs to copies (not supported) !> @param [in] numAttrs - Size of attrs and attrsIdxs arrays (not supported) !> @param [in] failIdx - Pointer to a location to return failure index inside the batch !> @param [in] stream - stream used to enqueue operations in. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipMemcpyBatchAsync #ifdef USE_CUDA_NAMES function hipMemcpyBatchAsync_(dsts,srcs,sizes,count,attrs,attrsIdxs,numAttrs,failIdx,stream) & bind(c, name="cudaMemcpyBatchAsync") #else function hipMemcpyBatchAsync_(dsts,srcs,sizes,count,attrs,attrsIdxs,numAttrs,failIdx,stream) & bind(c, name="hipMemcpyBatchAsync") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemcpyBatchAsync_ type(c_ptr) :: dsts type(c_ptr) :: srcs type(c_ptr),value :: sizes integer(c_size_t),value :: count type(hipMemcpyAttributes) :: attrs type(c_ptr),value :: attrsIdxs integer(c_size_t),value :: numAttrs type(c_ptr),value :: failIdx type(c_ptr),value :: stream end function end interface !> @brief Perform Batch of 3D copies !> !> @param [in] numOps - Total number of memcpy operations. !> @param [in] opList - Array of size numOps containing the actual memcpy operations. !> @param [in] failIdx - Pointer to a location to return the index of the copy where a failure !> - was encountered. !> @param [in] flags - Flags for future use, must be zero now. !> @param [in] stream - The stream to enqueue the operations in. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipMemcpy3DBatchAsync #ifdef USE_CUDA_NAMES function hipMemcpy3DBatchAsync_(numOps,opList,failIdx,flags,stream) & bind(c, name="cudaMemcpy3DBatchAsync") #else function hipMemcpy3DBatchAsync_(numOps,opList,failIdx,flags,stream) & bind(c, name="hipMemcpy3DBatchAsync") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemcpy3DBatchAsync_ integer(c_size_t),value :: numOps type(hipMemcpy3DBatchOp) :: opList type(c_ptr),value :: failIdx integer(c_int64_t),value :: flags type(c_ptr),value :: stream end function end interface !> @brief Performs 3D memory copies between devices !> This API is asynchronous with respect to host !> !> @param [in] p - Parameters for memory copy !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, hipErrorInvalidDevice interface hipMemcpy3DPeer #ifdef USE_CUDA_NAMES function hipMemcpy3DPeer_(p) bind(c, name="cudaMemcpy3DPeer") #else function hipMemcpy3DPeer_(p) bind(c, name="hipMemcpy3DPeer") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemcpy3DPeer_ type(hipMemcpy3DPeerParms) :: p end function end interface !> @brief Performs 3D memory copies between devices asynchronously !> !> @param [in] p - Parameters for memory copy !> @param [in] stream - Stream to enqueue operation in. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, hipErrorInvalidDevice interface hipMemcpy3DPeerAsync #ifdef USE_CUDA_NAMES function hipMemcpy3DPeerAsync_(p,stream) bind(c, name="cudaMemcpy3DPeerAsync") #else function hipMemcpy3DPeerAsync_(p,stream) bind(c, name="hipMemcpy3DPeerAsync") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemcpy3DPeerAsync_ type(hipMemcpy3DPeerParms) :: p type(c_ptr),value :: stream end function end interface !> @brief Returns the memory requirements of a HIP mipmapped array. !> !> @param[out] memoryRequirements - Pointer to hipArrayMemoryRequirements !> @param[in] mipmap - HIP mipmapped array to get the memory requirements of !> @param[in] device - Device to get the memory requirements for !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> Returns the memory requirements of a HIP mipmapped array in memoryRequirements. !> !> The returned value in hipArrayMemoryRequirements::size represents the total size of the HIP !> mipmapped array. The returned value in hipArrayMemoryRequirements::alignment represents the !> alignment necessary for mapping the HIP mipmapped array. #ifndef USE_CUDA_NAMES interface hipMipmappedArrayGetMemoryRequirements function hipMipmappedArrayGetMemoryRequirements_(memoryRequirements,mipmap,device) & bind(c, name="hipMipmappedArrayGetMemoryRequirements") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMipmappedArrayGetMemoryRequirements_ type(hipArrayMemoryRequirements) :: memoryRequirements type(c_ptr),value :: mipmap integer(c_int),value :: device end function end interface #endif !> ------------------------------------------------------------------------------------------------- !> ------------------------------------------------------------------------------------------------- !> @defgroup PeerToPeer PeerToPeer Device Memory Access !> !> @ingroup API !> This section describes the PeerToPeer device memory access functions of HIP runtime API. !> !> !> @brief Determines if a device can access a peer device's memory. !> !> @param [out] canAccessPeer - Returns the peer access capability (0 or 1) !> @param [in] deviceId - The device accessing the peer device memory. !> @param [in] peerDeviceId - Peer device where memory is physically located !> !> The value of @p canAccessPeer, !> !> Returns "1" if the specified @p deviceId is capable of directly accessing memory physically !> located on @p peerDeviceId, !> !> Returns "0" if the specified @p deviceId is not capable of directly accessing memory !> physically !> located on @p peerDeviceId. !> !> Returns "0" if @p deviceId == @p peerDeviceId, both are valid devices, !> however, a device is not a peer of itself. !> !> Returns `hipErrorInvalidDevice` if deviceId or peerDeviceId are not valid devices !> !> @returns `hipSuccess`, `hipErrorInvalidDevice` interface hipDeviceCanAccessPeer #ifdef USE_CUDA_NAMES function hipDeviceCanAccessPeer_(canAccessPeer,deviceId,peerDeviceId) & bind(c, name="cudaDeviceCanAccessPeer") #else function hipDeviceCanAccessPeer_(canAccessPeer,deviceId,peerDeviceId) & bind(c, name="hipDeviceCanAccessPeer") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceCanAccessPeer_ integer(c_int) :: canAccessPeer integer(c_int),value :: deviceId integer(c_int),value :: peerDeviceId end function end interface !> @brief Enables direct access to memory allocations on a peer device. !> !> When this API is successful, all memory allocations on peer device will be mapped into the !> address space of the current device. In addition, any future memory allocation on the !> peer device will remain accessible from the current device, until the access is disabled using !> hipDeviceDisablePeerAccess or device is reset using hipDeviceReset. !> !> @param [in] peerDeviceId - Peer device to enable direct access to from the current device !> @param [in] flags - Reserved for future use, must be zero !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue`, !> @returns `hipErrorPeerAccessAlreadyEnabled` if peer access is already enabled for this device. interface hipDeviceEnablePeerAccess #ifdef USE_CUDA_NAMES function hipDeviceEnablePeerAccess_(peerDeviceId,flags) & bind(c, name="cudaDeviceEnablePeerAccess") #else function hipDeviceEnablePeerAccess_(peerDeviceId,flags) & bind(c, name="hipDeviceEnablePeerAccess") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceEnablePeerAccess_ integer(c_int),value :: peerDeviceId integer(c_int),value :: flags end function end interface !> @brief Disables direct access to memory allocations on a peer device. !> !> If direct access to memory allocations on peer device has not been enabled yet from the !> current !> device, it returns `hipErrorPeerAccessNotEnabled`. !> !> @param [in] peerDeviceId Peer device to disable direct access to !> !> @returns `hipSuccess`, `hipErrorPeerAccessNotEnabled` interface hipDeviceDisablePeerAccess #ifdef USE_CUDA_NAMES function hipDeviceDisablePeerAccess_(peerDeviceId) bind(c, name="cudaDeviceDisablePeerAccess") #else function hipDeviceDisablePeerAccess_(peerDeviceId) bind(c, name="hipDeviceDisablePeerAccess") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceDisablePeerAccess_ integer(c_int),value :: peerDeviceId end function end interface !> @brief Copies memory between two peer accessible devices. !> !> @param [out] dst - Destination device pointer !> @param [in] dstDeviceId - Destination device !> @param [in] src - Source device pointer !> @param [in] srcDeviceId - Source device !> @param [in] sizeBytes - Size of memory copy in bytes !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidDevice` interface hipMemcpyPeer #ifdef USE_CUDA_NAMES function hipMemcpyPeer_(dst,dstDeviceId,src,srcDeviceId,sizeBytes) & bind(c, name="cudaMemcpyPeer") #else function hipMemcpyPeer_(dst,dstDeviceId,src,srcDeviceId,sizeBytes) bind(c, name="hipMemcpyPeer") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyPeer_ type(c_ptr),value :: dst integer(c_int),value :: dstDeviceId type(c_ptr),value :: src integer(c_int),value :: srcDeviceId integer(c_size_t),value :: sizeBytes end function end interface !> @brief Copies memory between two peer accessible devices asynchronously. !> !> @param [out] dst - Destination device pointer !> @param [in] dstDeviceId - Destination device !> @param [in] src - Source device pointer !> @param [in] srcDevice - Source device !> @param [in] sizeBytes - Size of memory copy in bytes !> @param [in] stream - Stream identifier !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidDevice` interface hipMemcpyPeerAsync #ifdef USE_CUDA_NAMES function hipMemcpyPeerAsync_(dst,dstDeviceId,src,srcDevice,sizeBytes,stream) & bind(c, name="cudaMemcpyPeerAsync") #else function hipMemcpyPeerAsync_(dst,dstDeviceId,src,srcDevice,sizeBytes,stream) & bind(c, name="hipMemcpyPeerAsync") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyPeerAsync_ type(c_ptr),value :: dst integer(c_int),value :: dstDeviceId type(c_ptr),value :: src integer(c_int),value :: srcDevice integer(c_size_t),value :: sizeBytes type(c_ptr),value :: stream end function end interface !> ------------------------------------------------------------------------------------------------- !> ------------------------------------------------------------------------------------------------- !> @defgroup ExecutionContext Execution Context Management !> !> This section describes execution context management functions of HIP runtime API. !> !> !> @brief Gets device resource of a given type for a device. !> !> @param [out] resource - Output device resource pointer !> @param [in] device - Device to get resource for !> @param [in] type - Type of resource to retrieve !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidResourceType`, !> `hipErrorInvalidDevice` #ifndef USE_CUDA_NAMES interface hipDeviceGetDevResource function hipDeviceGetDevResource_(device,resource,myType) & bind(c, name="hipDeviceGetDevResource") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipDeviceGetDevResource_ integer(c_int),value :: device type(hipDevResource) :: resource integer(kind(hipDevResourceTypeInvalid)),value :: myType end function end interface #endif !> @brief Splits SM resources into groups containing the specified number of SMs. !> !> @param [out] result - Output device resource pointer !> @param [in] nbGroups - The poiter specifying the number of groups !> @param [in] input - Valid input SM resource to be split !> @param [in] remainder - If the input resource cannot be evenly split among nbGroups, !> the remaining resourced are returned through this parameter. !> @param [in] flags - Flags specifying partition usage and constraints to apply when splitting !> the inout resource. !> @param [in] minCount - Specifies the minimum number of SMs required !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidResourceType`, !> `hipErrorInvalidDevice`, `hipErrorNotSupported` #ifndef USE_CUDA_NAMES interface hipDevSmResourceSplitByCount function hipDevSmResourceSplitByCount_(myResult,nbGroups,input,remainder,flags,minCount) & bind(c, name="hipDevSmResourceSplitByCount") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipDevSmResourceSplitByCount_ type(hipDevResource) :: myResult type(c_ptr),value :: nbGroups type(hipDevResource) :: input type(hipDevResource) :: remainder integer(c_int),value :: flags integer(c_int),value :: minCount end function end interface #endif !> @brief Splits SM resources into structured groups. !> !> @param [out] result - Output device resource pointer !> @param [in] nbGroups - The poiter specifying the number of groups !> @param [in] input - Valid input SM resource to be split !> @param [in] remainder - If the input resource cannot be evenly split among nbGroups, !> the remaining resourced are returned through this parameter. !> @param [in] flags - Flags specifying partition usage and constraints to apply when splitting !> the inout resource. !> @param [in] groupParams - Describes how the SM resources should be partitioned and assigned !> to the corresponding result entries. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidResourceType`, !> `hipErrorInvalidResourceConfiguration`, `hipErrorInvalidDevice` #ifndef USE_CUDA_NAMES interface hipDevSmResourceSplit function hipDevSmResourceSplit_(myResult,nbGroups,input,remainder,flags,groupParams) & bind(c, name="hipDevSmResourceSplit") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipDevSmResourceSplit_ type(hipDevResource) :: myResult integer(c_int),value :: nbGroups type(hipDevResource) :: input type(hipDevResource) :: remainder integer(c_int),value :: flags type(hipDevSmResourceGroupParams) :: groupParams end function end interface #endif !> @brief Generates a resource descriptor from one or more device resources. !> !> @param [out] phDesc - Output parameter that receives the generated resource descriptor !> @param [in] resources - Pointer of device resources to be included in the descriptor !> @param [in] nbResources - Number of resources specified !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidResourceType`, !> `hipErrorInvalidDevice` #ifndef USE_CUDA_NAMES interface hipDevResourceGenerateDesc function hipDevResourceGenerateDesc_(phDesc,resources,nbResources) & bind(c, name="hipDevResourceGenerateDesc") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipDevResourceGenerateDesc_ type(c_ptr) :: phDesc type(hipDevResource) :: resources integer(c_int),value :: nbResources end function end interface #endif !> @brief Creates a green context from a resource descriptor. !> !> @param [out] ctx - Output parameter that receives the handle to the created green context !> @param [in] desc - Resource descriptor generated via hipDevResourceGenerateDesc that specifies !> the set of resources to be used !> @param [in] device - Device on which the green context is created !> @param [in] flags - Flags controlling green context creation !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidDevice` #ifndef USE_CUDA_NAMES interface hipGreenCtxCreate function hipGreenCtxCreate_(ctx,desc,device,flags) bind(c, name="hipGreenCtxCreate") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGreenCtxCreate_ type(c_ptr) :: ctx type(c_ptr),value :: desc integer(c_int),value :: device integer(c_int),value :: flags end function end interface #endif !> @brief Destroys an execution context. !> !> @param [in] ctx - Execution context to destroy !> !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipExecutionCtxDestroy function hipExecutionCtxDestroy_(ctx) bind(c, name="hipExecutionCtxDestroy") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipExecutionCtxDestroy_ type(c_ptr),value :: ctx end function end interface #endif !> @brief Returns the default execution context for a device. !> !> @param [out] ctx - Output pointer for execution context !> @param [in] device - The device on which to receive the execution context !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidDevice`, `hipErrorOutOfMemory` #ifndef USE_CUDA_NAMES interface hipDeviceGetExecutionCtx function hipDeviceGetExecutionCtx_(ctx,device) bind(c, name="hipDeviceGetExecutionCtx") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceGetExecutionCtx_ type(c_ptr) :: ctx integer(c_int),value :: device end function end interface #endif !> @brief Creates a stream on an execution context with specified flags and priority !> !> @param [out] stream - Output pointer of the created stream !> @param [in] greenctx - Execution context used to create and initialize the stream !> @param [in] flags - Flags for stream creation !> @param [in] priority - Stream priority !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorOutOfMemory` #ifndef USE_CUDA_NAMES interface hipExecutionCtxStreamCreate function hipExecutionCtxStreamCreate_(stream,greenctx,flags,priority) & bind(c, name="hipExecutionCtxStreamCreate") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipExecutionCtxStreamCreate_ type(c_ptr) :: stream type(c_ptr),value :: greenctx integer(c_int),value :: flags integer(c_int),value :: priority end function end interface #endif !> @brief Returns the device resource of a given type for an execution context !> !> @param [out] resource - Output pointer that receives the structured device resource !> @param [in] ctx - Execution context to get resource for !> @param [in] type - Type of device resource !> !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipExecutionCtxGetDevResource function hipExecutionCtxGetDevResource_(ctx,resource,myType) & bind(c, name="hipExecutionCtxGetDevResource") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipExecutionCtxGetDevResource_ type(c_ptr),value :: ctx type(hipDevResource) :: resource integer(kind(hipDevResourceTypeInvalid)),value :: myType end function end interface #endif !> @brief Returns the device associated with an execution context !> !> @param [out] device - Returns device handle for the specified execution context !> @param [in] ctx - Execution context to obtain the device !> !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipExecutionCtxGetDevice function hipExecutionCtxGetDevice_(device,ctx) bind(c, name="hipExecutionCtxGetDevice") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipExecutionCtxGetDevice_ type(c_ptr),value :: device type(c_ptr),value :: ctx end function end interface #endif !> @brief Returns a unique identifier for an execution context !> !> @param [out] ctxId - Pointer to the context ID !> @param [in] ctx - Execution context to obtain the ID !> !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipExecutionCtxGetId function hipExecutionCtxGetId_(ctx,ctxId) bind(c, name="hipExecutionCtxGetId") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipExecutionCtxGetId_ type(c_ptr),value :: ctx type(c_ptr),value :: ctxId end function end interface #endif !> @brief Returns the device resource of a given type for a stream !> !> @param [out] resource - Pointer to the structured device resource !> @param [in] hStream - Stream to get resource for !> @param [in] type - Type of resource !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidResourceType`, !> `hipErrorInvalidHandle` #ifndef USE_CUDA_NAMES interface hipStreamGetDevResource function hipStreamGetDevResource_(hStream,resource,myType) & bind(c, name="hipStreamGetDevResource") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipStreamGetDevResource_ type(c_ptr),value :: hStream type(hipDevResource) :: resource integer(kind(hipDevResourceTypeInvalid)),value :: myType end function end interface #endif !> @brief Records an event on an execution context !> !> @param [out] event - Event to record !> @param [in] ctx - Execution context to record event for !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidHandle` #ifndef USE_CUDA_NAMES interface hipExecutionCtxRecordEvent function hipExecutionCtxRecordEvent_(ctx,event) bind(c, name="hipExecutionCtxRecordEvent") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipExecutionCtxRecordEvent_ type(c_ptr),value :: ctx type(c_ptr),value :: event end function end interface #endif !> @brief Blocks until all work on an execution context has completed !> !> @param [in] ctx - Execution context to synchronize !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidHandle` #ifndef USE_CUDA_NAMES interface hipExecutionCtxSynchronize function hipExecutionCtxSynchronize_(ctx) bind(c, name="hipExecutionCtxSynchronize") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipExecutionCtxSynchronize_ type(c_ptr),value :: ctx end function end interface #endif !> @brief Makes an execution context wait on an event !> !> @param [in] event - Event to wait on !> @param [in] ctx - Execution context to wait for !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidHandle` #ifndef USE_CUDA_NAMES interface hipExecutionCtxWaitEvent function hipExecutionCtxWaitEvent_(ctx,event) bind(c, name="hipExecutionCtxWaitEvent") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipExecutionCtxWaitEvent_ type(c_ptr),value :: ctx type(c_ptr),value :: event end function end interface #endif !> @brief Create a context and set it as current/default context !> !> @param [out] ctx Context to create !> @param [in] flags Context creation flags !> @param [in] device device handle !> !> @returns `hipSuccess` !> !> @see hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, hipCtxPushCurrent, !> hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice !> !> @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on !> the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipCtxCreate function hipCtxCreate_(ctx,flags,device) bind(c, name="hipCtxCreate") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipCtxCreate_ type(c_ptr) :: ctx integer(c_int),value :: flags integer(c_int),value :: device end function end interface #endif !> @brief Destroy a HIP context [Deprecated] !> !> @param [in] ctx Context to destroy !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @see hipCtxCreate, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent,hipCtxSetCurrent, !> hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize , hipCtxGetDevice !> !> @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on !> the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipCtxDestroy function hipCtxDestroy_(ctx) bind(c, name="hipCtxDestroy") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipCtxDestroy_ type(c_ptr),value :: ctx end function end interface #endif !> @brief Pop the current/default context and return the popped context [Deprecated] !> !> @param [out] ctx The current context to pop !> !> @returns `hipSuccess`, `hipErrorInvalidContext` !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxSetCurrent, hipCtxGetCurrent, !> hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice !> !> @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on !> the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipCtxPopCurrent function hipCtxPopCurrent_(ctx) bind(c, name="hipCtxPopCurrent") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipCtxPopCurrent_ type(c_ptr) :: ctx end function end interface #endif !> @brief Push the context to be set as current/ default context [Deprecated] !> !> @param [in] ctx The current context to push !> !> @returns `hipSuccess`, `hipErrorInvalidContext` !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, !> hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize , hipCtxGetDevice !> !> @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on !> the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipCtxPushCurrent function hipCtxPushCurrent_(ctx) bind(c, name="hipCtxPushCurrent") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipCtxPushCurrent_ type(c_ptr),value :: ctx end function end interface #endif !> @brief Set the passed context as current/default [Deprecated] !> !> @param [in] ctx The context to set as current !> !> @returns `hipSuccess`, `hipErrorInvalidContext` !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, !> hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize , hipCtxGetDevice !> !> @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on !> the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipCtxSetCurrent function hipCtxSetCurrent_(ctx) bind(c, name="hipCtxSetCurrent") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipCtxSetCurrent_ type(c_ptr),value :: ctx end function end interface #endif !> @brief Get the handle of the current/ default context [Deprecated] !> !> @param [out] ctx The context to get as current !> !> @returns `hipSuccess`, `hipErrorInvalidContext` !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxGetDevice, hipCtxGetFlags, hipCtxPopCurrent, !> hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice !> !> @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on !> the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipCtxGetCurrent function hipCtxGetCurrent_(ctx) bind(c, name="hipCtxGetCurrent") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipCtxGetCurrent_ type(c_ptr) :: ctx end function end interface #endif !> @brief Get the handle of the device associated with current/default context [Deprecated] !> !> @param [out] device The device from the current context !> !> @returns `hipSuccess`, `hipErrorInvalidContext` !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, !> hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize !> !> @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on !> the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipCtxGetDevice function hipCtxGetDevice_(device) bind(c, name="hipCtxGetDevice") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipCtxGetDevice_ integer(c_int) :: device end function end interface #endif !> @brief Returns the approximate HIP api version. !> !> @param [in] ctx Context to check [Deprecated] !> @param [out] apiVersion API version to get !> !> @returns `hipSuccess` !> !> @warning The HIP feature set does not correspond to an exact CUDA SDK api revision. !> This function always set *apiVersion to 4 as an approximation though HIP supports !> some features which were introduced in later CUDA SDK revisions. !> HIP apps code should not rely on the api revision number here and should !> use arch feature flags to test device capabilities or conditional compilation. !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxGetDevice, hipCtxGetFlags, hipCtxPopCurrent, !> hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice !> !> @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on !> the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipCtxGetApiVersion function hipCtxGetApiVersion_(ctx,apiVersion) bind(c, name="hipCtxGetApiVersion") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipCtxGetApiVersion_ type(c_ptr),value :: ctx integer(c_int) :: apiVersion end function end interface #endif !> @brief Get Cache configuration for a specific function [Deprecated] !> !> @param [out] cacheConfig Cache configuration !> !> @returns `hipSuccess` !> !> @warning AMD devices and some Nvidia GPUS do not support reconfigurable cache. This hint is !> ignored on those architectures. !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, !> hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice !> !> @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on !> the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipCtxGetCacheConfig function hipCtxGetCacheConfig_(cacheConfig) bind(c, name="hipCtxGetCacheConfig") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipCtxGetCacheConfig_ type(c_ptr),value :: cacheConfig end function end interface #endif !> @brief Set L1/Shared cache partition [Deprecated] !> !> @param [in] cacheConfig Cache configuration to set !> !> @return `hipSuccess` !> !> @warning AMD devices and some Nvidia GPUS do not support reconfigurable cache. This hint is !> ignored on those architectures. !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, !> hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice !> !> @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on !> the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipCtxSetCacheConfig function hipCtxSetCacheConfig_(cacheConfig) bind(c, name="hipCtxSetCacheConfig") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipCtxSetCacheConfig_ integer(kind(hipFuncCachePreferNone)),value :: cacheConfig end function end interface #endif !> @brief Set Shared memory bank configuration [Deprecated] !> !> @param [in] config Shared memory configuration to set !> !> @return `hipSuccess` !> !> @warning AMD devices and some Nvidia GPUS do not support shared cache banking, and the hint is !> ignored on those architectures. !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, !> hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice !> !> @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on !> the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipCtxSetSharedMemConfig function hipCtxSetSharedMemConfig_(config) bind(c, name="hipCtxSetSharedMemConfig") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipCtxSetSharedMemConfig_ integer(kind(hipSharedMemBankSizeDefault)),value :: config end function end interface #endif !> @brief Get Shared memory bank configuration [Deprecated] !> !> @param [out] pConfig Pointer of shared memory configuration !> !> @return `hipSuccess` !> !> @warning AMD devices and some Nvidia GPUS do not support shared cache banking, and the hint is !> ignored on those architectures. !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, !> hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice !> !> @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on !> the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipCtxGetSharedMemConfig function hipCtxGetSharedMemConfig_(pConfig) bind(c, name="hipCtxGetSharedMemConfig") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipCtxGetSharedMemConfig_ type(c_ptr),value :: pConfig end function end interface #endif !> @brief Blocks until the default context has completed all preceding requested tasks !> [Deprecated] !> !> @return `hipSuccess` !> !> @warning This function waits for all streams on the default context to complete execution, and !> then returns. !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, !> hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxGetDevice !> !> @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on !> the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipCtxSynchronize function hipCtxSynchronize_() bind(c, name="hipCtxSynchronize") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipCtxSynchronize_ end function end interface #endif !> @brief Return flags used for creating default context [Deprecated] !> !> @param [out] flags Pointer of flags !> !> @returns `hipSuccess` !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxPopCurrent, hipCtxGetCurrent, hipCtxGetCurrent, !> hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice !> !> @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on !> the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipCtxGetFlags function hipCtxGetFlags_(flags) bind(c, name="hipCtxGetFlags") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipCtxGetFlags_ integer(c_int) :: flags end function end interface #endif !> @brief Enables direct access to memory allocations in a peer context [Deprecated] !> !> Memory which already allocated on peer device will be mapped into the address space of the !> current device. In addition, all future memory allocations on peerDeviceId will be mapped into !> the address space of the current device when the memory is allocated. The peer memory remains !> accessible from the current device until a call to hipDeviceDisablePeerAccess or !> hipDeviceReset. !> !> !> @param [in] peerCtx Peer context !> @param [in] flags flags, need to set as 0 !> !> @returns `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidValue`, !> `hipErrorPeerAccessAlreadyEnabled` !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, !> hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice !> @warning PeerToPeer support is experimental. !> !> @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on !> the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipCtxEnablePeerAccess function hipCtxEnablePeerAccess_(peerCtx,flags) bind(c, name="hipCtxEnablePeerAccess") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipCtxEnablePeerAccess_ type(c_ptr),value :: peerCtx integer(c_int),value :: flags end function end interface #endif !> @brief Disable direct access from current context's virtual address space to memory !> allocations !> physically located on a peer context.Disables direct access to memory allocations in a peer !> context and unregisters any registered allocations [Deprecated] !> !> Returns `hipErrorPeerAccessNotEnabled` if direct access to memory on peerDevice has not yet !> been !> enabled from the current device. !> !> @param [in] peerCtx Peer context to be disabled !> !> @returns `hipSuccess`, `hipErrorPeerAccessNotEnabled` !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, !> hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice !> @warning PeerToPeer support is experimental. !> !> @warning This API is deprecated on the AMD platform, only for equivalent cuCtx driver API on !> the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipCtxDisablePeerAccess function hipCtxDisablePeerAccess_(peerCtx) bind(c, name="hipCtxDisablePeerAccess") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipCtxDisablePeerAccess_ type(c_ptr),value :: peerCtx end function end interface #endif !> @brief Get the state of the primary context [Deprecated] !> !> @param [in] dev Device to get primary context flags for !> @param [out] flags Pointer to store flags !> @param [out] active Pointer to store context state; 0 = inactive, 1 = active !> !> @returns `hipSuccess` !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, !> hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice !> !> @warning This API is deprecated on the AMD platform, only for equivalent driver API on the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipDevicePrimaryCtxGetState function hipDevicePrimaryCtxGetState_(dev,flags,active) & bind(c, name="hipDevicePrimaryCtxGetState") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDevicePrimaryCtxGetState_ integer(c_int),value :: dev integer(c_int) :: flags integer(c_int) :: active end function end interface #endif !> @brief Release the primary context on the GPU. !> !> @param [in] dev Device which primary context is released [Deprecated] !> !> @returns `hipSuccess` !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, !> hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice !> @warning This function return `hipSuccess` though doesn't release the primaryCtx by design on !> HIP/HIP-CLANG path. !> !> @warning This API is deprecated on the AMD platform, only for equivalent driver API on the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipDevicePrimaryCtxRelease function hipDevicePrimaryCtxRelease_(dev) bind(c, name="hipDevicePrimaryCtxRelease") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDevicePrimaryCtxRelease_ integer(c_int),value :: dev end function end interface #endif !> @brief Retain the primary context on the GPU [Deprecated] !> !> @param [out] pctx Returned context handle of the new context !> @param [in] dev Device which primary context is released !> !> @returns `hipSuccess` !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, !> hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice !> !> @warning This API is deprecated on the AMD platform, only for equivalent driver API on the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipDevicePrimaryCtxRetain function hipDevicePrimaryCtxRetain_(pctx,dev) bind(c, name="hipDevicePrimaryCtxRetain") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDevicePrimaryCtxRetain_ type(c_ptr) :: pctx integer(c_int),value :: dev end function end interface #endif !> @brief Resets the primary context on the GPU [Deprecated] !> !> @param [in] dev Device which primary context is reset !> !> @returns `hipSuccess` !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, !> hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice !> !> @warning This API is deprecated on the AMD platform, only for equivalent driver API on the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipDevicePrimaryCtxReset function hipDevicePrimaryCtxReset_(dev) bind(c, name="hipDevicePrimaryCtxReset") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDevicePrimaryCtxReset_ integer(c_int),value :: dev end function end interface #endif !> @brief Set flags for the primary context [Deprecated] !> !> @param [in] dev Device for which the primary context flags are set !> @param [in] flags New flags for the device !> !> @returns `hipSuccess`, `hipErrorContextAlreadyInUse` !> !> @see hipCtxCreate, hipCtxDestroy, hipCtxGetFlags, hipCtxPopCurrent, hipCtxGetCurrent, !> hipCtxSetCurrent, hipCtxPushCurrent, hipCtxSetCacheConfig, hipCtxSynchronize, hipCtxGetDevice !> !> @warning This API is deprecated on the AMD platform, only for equivalent driver API on the !> NVIDIA platform. #ifndef USE_CUDA_NAMES interface hipDevicePrimaryCtxSetFlags function hipDevicePrimaryCtxSetFlags_(dev,flags) bind(c, name="hipDevicePrimaryCtxSetFlags") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDevicePrimaryCtxSetFlags_ integer(c_int),value :: dev integer(c_int),value :: flags end function end interface #endif !> ------------------------------------------------------------------------------------------------- !> ------------------------------------------------------------------------------------------------- !> !> @defgroup Module Module Management !> !> @ingroup API !> This section describes the module management functions of HIP runtime API. !> !> !> !> @brief Loads fatbin object !> !> @param [in] fatbin fatbin to be loaded as a module !> @param [out] module Module !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidContext`, !> `hipErrorFileNotFound`, !> `hipErrorOutOfMemory`, `hipErrorSharedObjectInitFailed`, `hipErrorNotInitialized` interface hipModuleLoadFatBinary #ifdef USE_CUDA_NAMES function hipModuleLoadFatBinary_(myModule,fatbin) bind(c, name="cuModuleLoadFatBinary") #else function hipModuleLoadFatBinary_(myModule,fatbin) bind(c, name="hipModuleLoadFatBinary") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipModuleLoadFatBinary_ type(c_ptr) :: myModule type(c_ptr),value :: fatbin end function end interface !> @brief Loads code object from file into a module the currrent context. !> !> @param [in] fname Filename of code object to load !> !> @param [out] module Module !> !> @warning File/memory resources allocated in this function are released only in !> hipModuleUnload. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidContext`, !> `hipErrorFileNotFound`, !> `hipErrorOutOfMemory`, `hipErrorSharedObjectInitFailed`, `hipErrorNotInitialized` #ifndef USE_CUDA_NAMES interface hipModuleLoad function hipModuleLoad_(myModule,fname) bind(c, name="hipModuleLoad") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipModuleLoad_ type(c_ptr) :: myModule type(c_ptr),value :: fname end function end interface #endif !> @brief Frees the module !> !> @param [in] module Module to free !> !> @returns `hipSuccess`, `hipErrorInvalidResourceHandle` !> !> The module is freed, and the code objects associated with it are destroyed. #ifndef USE_CUDA_NAMES interface hipModuleUnload function hipModuleUnload_(myModule) bind(c, name="hipModuleUnload") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipModuleUnload_ type(c_ptr),value :: myModule end function end interface #endif !> @brief Function with kname will be extracted if present in module !> !> @param [in] module Module to get function from !> @param [in] kname Pointer to the name of function !> @param [out] function Pointer to function handle !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidContext`, !> `hipErrorNotInitialized`, !> `hipErrorNotFound`, #ifndef USE_CUDA_NAMES interface hipModuleGetFunction function hipModuleGetFunction_(myFunction,myModule,kname) bind(c, name="hipModuleGetFunction") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipModuleGetFunction_ type(c_ptr) :: myFunction type(c_ptr),value :: myModule type(c_ptr),value :: kname end function end interface #endif !> @brief Returns the number of functions within a module. !> !> @param [in] mod Module to get function count from !> @param [out] count function count from module !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidContext`, !> `hipErrorNotInitialized`, !> `hipErrorNotFound`, interface hipModuleGetFunctionCount #ifdef USE_CUDA_NAMES function hipModuleGetFunctionCount_(count,mod) bind(c, name="cuModuleGetFunctionCount") #else function hipModuleGetFunctionCount_(count,mod) bind(c, name="hipModuleGetFunctionCount") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipModuleGetFunctionCount_ integer(c_int) :: count type(c_ptr),value :: mod end function end interface !> @brief Returns information about a kernel. !> !> @param[out] pi - Returned attribute value !> @param[in] attrib - Attribute requested !> @param[in] kernel - Kernel to query attribute of !> @param[in] dev - Device to query attribute of !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidHandle`, !> `hipErrorInvalidDevice`, `hipErrorInvalidDeviceFunction`, `hipErrorMissingConfiguration` !> !> Returns in *pi the integer value of the attribute attrib for the kernel kernel for the !> requested !> device dev. The supported attributes are: !> - HIP_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK The maximum number of threads per block. This !> number depends on both the kernel and the requested device. !> - HIP_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES The size in bytes of statically-allocated shared memory !> per block required by this kernel. This does not include dynamically-allocated shared memory !> requested by the user at runtime. !> - HIP_FUNC_ATTRIBUTE_CONST_SIZE_BYTES The size in bytes of user-allocated constant memory !> required by this kernel. !> - HIP_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES The size in bytes of local memory used by each thread of !> this kernel. !> - HIP_FUNC_ATTRIBUTE_NUM_REGS The number of registers used by each thread of this kernel. !> - HIP_FUNC_ATTRIBUTE_PTX_VERSION The PTX virtual architecture version for which the kernel was !> compiled. This value is the major PTX version * 10 + the minor PTX version, so a PTX version !> 1.3 function would return the value 13. !> - HIP_FUNC_ATTRIBUTE_BINARY_VERSION The binary architecture version for which the kernel was !> compiled. This value is the major binary version * 10 + the minor binary version, so a binary !> version 1.3 function would return the value 13. !> - HIP_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES The maximum size in bytes of !> dynamically-allocated shared memory. !> - HIP_FUNC_ATTRIBUTE_CACHE_MODE_CA The attribute to indicate whether the kernel has been !> compiled with user specified option "-Xptxas --dlcm=ca" set. !> - HIP_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT Preferred shared memory-L1 cache split !> ratio in percent of total shared memory. !> !> @see hipLibraryLoadData, hipLibraryLoadFromFile, hipLibraryUnload, hipKernelSetAttribute, !> hipLibraryGetKernel, hipLaunchKernel, hipKernelGetFunction, hipLibraryGetModule, !> hipModuleGetFunction, hipFuncGetAttribute #ifndef USE_CUDA_NAMES interface hipKernelGetAttribute function hipKernelGetAttribute_(pi,attrib,kernel,dev) bind(c, name="hipKernelGetAttribute") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipKernelGetAttribute_ type(c_ptr),value :: pi integer(kind(HIP_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK)),value :: attrib type(c_ptr),value :: kernel integer(c_int),value :: dev end function end interface #endif !> @brief Load hip Library from inmemory object !> !> @param [out] library Output Library !> @param [in] code In memory object !> @param [in] jitOptions JIT options, CUDA only !> @param [in] jitOptionsValues JIT options values, CUDA only !> @param [in] numJitOptions Number of JIT options !> @param [in] libraryOptions Library options !> @param [in] libraryOptionValues Library options values !> @param [in] numLibraryOptions Number of library options !> @return `hipSuccess`, `hipErrorInvalidValue`, interface hipLibraryLoadData #ifdef USE_CUDA_NAMES function hipLibraryLoadData_(library,code,jitOptions,jitOptionsValues,numJitOptions, & libraryOptions,libraryOptionValues,numLibraryOptions) & bind(c, name="cudaLibraryLoadData") #else function hipLibraryLoadData_(library,code,jitOptions,jitOptionsValues,numJitOptions, & libraryOptions,libraryOptionValues,numLibraryOptions) & bind(c, name="hipLibraryLoadData") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipLibraryLoadData_ type(c_ptr) :: library type(c_ptr),value :: code type(c_ptr),value :: jitOptions type(c_ptr) :: jitOptionsValues integer(c_int),value :: numJitOptions type(c_ptr),value :: libraryOptions type(c_ptr) :: libraryOptionValues integer(c_int),value :: numLibraryOptions end function end interface !> @brief Load hip Library from file !> !> @param [out] library Output Library !> @param [in] fileName file which contains code object !> @param [in] jitOptions JIT options, CUDA only !> @param [in] jitOptionsValues JIT options values, CUDA only !> @param [in] numJitOptions Number of JIT options !> @param [in] libraryOptions Library options !> @param [in] libraryOptionValues Library options values !> @param [in] numLibraryOptions Number of library options !> @return `hipSuccess`, `hipErrorInvalidValue` interface hipLibraryLoadFromFile #ifdef USE_CUDA_NAMES function hipLibraryLoadFromFile_(library,fileName,jitOptions,jitOptionsValues,numJitOptions, & libraryOptions,libraryOptionValues,numLibraryOptions) & bind(c, name="cudaLibraryLoadFromFile") #else function hipLibraryLoadFromFile_(library,fileName,jitOptions,jitOptionsValues,numJitOptions, & libraryOptions,libraryOptionValues,numLibraryOptions) & bind(c, name="hipLibraryLoadFromFile") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipLibraryLoadFromFile_ type(c_ptr) :: library type(c_ptr),value :: fileName type(c_ptr),value :: jitOptions type(c_ptr) :: jitOptionsValues integer(c_int),value :: numJitOptions type(c_ptr),value :: libraryOptions type(c_ptr) :: libraryOptionValues integer(c_int),value :: numLibraryOptions end function end interface !> @brief Unload HIP Library !> !> @param [in] library Input created hip library !> @return `hipSuccess`, `hipErrorInvalidValue` interface hipLibraryUnload #ifdef USE_CUDA_NAMES function hipLibraryUnload_(library) bind(c, name="cudaLibraryUnload") #else function hipLibraryUnload_(library) bind(c, name="hipLibraryUnload") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipLibraryUnload_ type(c_ptr),value :: library end function end interface !> @brief Get Kernel object from library !> !> @param [out] pKernel Output kernel object !> @param [in] library Input hip library !> @param [in] name kernel name to be searched for !> @return `hipSuccess`, `hipErrorInvalidValue` interface hipLibraryGetKernel #ifdef USE_CUDA_NAMES function hipLibraryGetKernel_(pKernel,library,name) bind(c, name="cudaLibraryGetKernel") #else function hipLibraryGetKernel_(pKernel,library,name) bind(c, name="hipLibraryGetKernel") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipLibraryGetKernel_ type(c_ptr) :: pKernel type(c_ptr),value :: library type(c_ptr),value :: name end function end interface !> @brief Get Kernel count in library !> !> @param [out] count Count of kernels in library !> @param [in] library Input created hip library !> @return `hipSuccess`, `hipErrorInvalidValue` interface hipLibraryGetKernelCount #ifdef USE_CUDA_NAMES function hipLibraryGetKernelCount_(count,library) bind(c, name="cudaLibraryGetKernelCount") #else function hipLibraryGetKernelCount_(count,library) bind(c, name="hipLibraryGetKernelCount") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipLibraryGetKernelCount_ integer(c_int) :: count type(c_ptr),value :: library end function end interface !> @brief Get device pointer to a `__device__` global variable defined in a library. !> !> Returns the device pointer and size of the named global symbol within the !> library's code object. Mirrors CUDA's `cuLibraryGetGlobal` / !> `cudaLibraryGetGlobal`. Either `dptr` or `bytes` (but not both) may be NULL. !> !> @param [out] dptr Pointer to receive the device pointer, may be NULL. !> @param [out] bytes Pointer to receive the size in bytes, may be NULL. !> @param [in] library Input hip library handle. !> @param [in] name Name of the global symbol to look up. !> @return `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidResourceHandle`, !> `hipErrorNotFound` #ifndef USE_CUDA_NAMES interface hipLibraryGetGlobal function hipLibraryGetGlobal_(dptr,bytes,library,name) bind(c, name="hipLibraryGetGlobal") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipLibraryGetGlobal_ type(c_ptr) :: dptr type(c_ptr),value :: bytes type(c_ptr),value :: library type(c_ptr),value :: name end function end interface #endif !> @brief Get host pointer to a `__managed__` variable defined in a library. !> !> Returns the host-accessible managed pointer and size of the named managed !> symbol within the library's code object. Mirrors CUDA's !> `cuLibraryGetManaged` / `cudaLibraryGetManaged`. Either `dptr` or `bytes` !> (but not both) may be NULL. Returns `hipErrorNotFound` if the symbol does !> not exist or is not a `__managed__` variable. !> !> @param [out] dptr Pointer to receive the managed host pointer, may be NULL. !> @param [out] bytes Pointer to receive the size in bytes, may be NULL. !> @param [in] library Input hip library handle. !> @param [in] name Name of the managed symbol to look up. !> @return `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidResourceHandle`, !> `hipErrorNotFound` #ifndef USE_CUDA_NAMES interface hipLibraryGetManaged function hipLibraryGetManaged_(dptr,bytes,library,name) bind(c, name="hipLibraryGetManaged") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipLibraryGetManaged_ type(c_ptr) :: dptr type(c_ptr),value :: bytes type(c_ptr),value :: library type(c_ptr),value :: name end function end interface #endif !> @brief Retrieve kernel handles within a library !> !> @param [out] kernels Buffer for kernel handles !> @param [in] numKernels Maximum number of kernel handles to return to buffer !> @param [in] library Library handle to query from !> @return `hipSuccess`, `hipErrorInvalidValue` interface hipLibraryEnumerateKernels #ifdef USE_CUDA_NAMES function hipLibraryEnumerateKernels_(kernels,numKernels,library) & bind(c, name="cudaLibraryEnumerateKernels") #else function hipLibraryEnumerateKernels_(kernels,numKernels,library) & bind(c, name="hipLibraryEnumerateKernels") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipLibraryEnumerateKernels_ type(c_ptr) :: kernels integer(c_int),value :: numKernels type(c_ptr),value :: library end function end interface !> @brief Returns a Library Handle !> !> @param [out] library Returned Library handle !> @param [in] kernel Kernel to retrieve library Handle !> @return `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipKernelGetLibrary function hipKernelGetLibrary_(library,kernel) bind(c, name="hipKernelGetLibrary") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipKernelGetLibrary_ type(c_ptr) :: library type(c_ptr),value :: kernel end function end interface #endif !> @brief Returns a Kernel Name !> !> @param [out] name Returned Kernel Name !> @param [in] kernel Kernel handle to retrieve name !> @return `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipKernelGetName function hipKernelGetName_(name,kernel) bind(c, name="hipKernelGetName") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipKernelGetName_ type(c_ptr) :: name type(c_ptr),value :: kernel end function end interface #endif !> @brief Returns the offset and size of a kernel parameter !> !> @param [in] kernel Kernel handle to retrieve parameter info !> @param [in] paramIndex Index of the parameter !> @param [out] paramOffset returns the offset of the parameter !> @param [out] paramSize Optionally returns the size of the parameter !> !> @return `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipKernelGetParamInfo function hipKernelGetParamInfo_(kernel,paramIndex,paramOffset,paramSize) & bind(c, name="hipKernelGetParamInfo") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipKernelGetParamInfo_ type(c_ptr),value :: kernel integer(c_size_t),value :: paramIndex type(c_ptr),value :: paramOffset type(c_ptr),value :: paramSize end function end interface #endif !> @brief Find out attributes for a given function. !> @ingroup Execution !> @param [out] attr Attributes of funtion !> @param [in] func Pointer to the function handle !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidDeviceFunction` interface hipFuncGetAttributes #ifdef USE_CUDA_NAMES function hipFuncGetAttributes_(attr,func) bind(c, name="cudaFuncGetAttributes") #else function hipFuncGetAttributes_(attr,func) bind(c, name="hipFuncGetAttributes") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipFuncGetAttributes_ type(hipFuncAttributes) :: attr type(c_ptr),value :: func end function end interface !> @brief Find out a specific attribute for a given function. !> @ingroup Execution !> @param [out] value Pointer to the value !> @param [in] attrib Attributes of the given funtion !> @param [in] hfunc Function to get attributes from !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidDeviceFunction` #ifndef USE_CUDA_NAMES interface hipFuncGetAttribute function hipFuncGetAttribute_(myValue,attrib,hfunc) bind(c, name="hipFuncGetAttribute") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipFuncGetAttribute_ type(c_ptr),value :: myValue integer(kind(HIP_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK)),value :: attrib type(c_ptr),value :: hfunc end function end interface #endif !> @brief Gets pointer to device entry function that matches entry function symbolPtr. !> !> @param [out] functionPtr Device entry function !> @param [in] symbolPtr Pointer to device entry function to search for !> !> @returns `hipSuccess`, `hipErrorInvalidDeviceFunction` interface hipGetFuncBySymbol #ifdef USE_CUDA_NAMES function hipGetFuncBySymbol_(functionPtr,symbolPtr) bind(c, name="cudaGetFuncBySymbol") #else function hipGetFuncBySymbol_(functionPtr,symbolPtr) bind(c, name="hipGetFuncBySymbol") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGetFuncBySymbol_ type(c_ptr) :: functionPtr type(c_ptr),value :: symbolPtr end function end interface !> @brief Gets function pointer of a requested HIP API !> !> @param [in] symbol The API base name !> @param [out] funcPtr Pointer to the requested function !> @param [in] flags Flags for the search !> @param [out] driverStatus Optional returned status of the search !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGetDriverEntryPoint #ifdef USE_CUDA_NAMES function hipGetDriverEntryPoint_(symbol,funcPtr,flags,driverStatus) & bind(c, name="cudaGetDriverEntryPoint") #else function hipGetDriverEntryPoint_(symbol,funcPtr,flags,driverStatus) & bind(c, name="hipGetDriverEntryPoint") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGetDriverEntryPoint_ type(c_ptr),value :: symbol type(c_ptr) :: funcPtr integer(c_int64_t),value :: flags type(c_ptr),value :: driverStatus end function end interface !> @brief returns the handle of the texture reference with the name from the module. !> !> @param [in] hmod Module !> @param [in] name Pointer of name of texture reference !> @param [out] texRef Pointer of texture reference !> !> @returns `hipSuccess`, `hipErrorNotInitialized`, `hipErrorNotFound`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipModuleGetTexRef function hipModuleGetTexRef_(texRef,hmod,name) bind(c, name="hipModuleGetTexRef") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipModuleGetTexRef_ type(c_ptr) :: texRef type(c_ptr),value :: hmod type(c_ptr),value :: name end function end interface #endif !> @brief builds module from code object data which resides in host memory. !> !> The "image" is a pointer to the location of code object data. This data can be either !> a single code object or a fat binary (fatbin), which serves as the entry point for loading and !> launching device-specific kernel executions. !> !> By default, the following command generates a fatbin: !> !> "amdclang++ -O3 -c --offload-device-only --offload-arch= -o !> " !> !> For more details, refer to: !> href= !> "https://rocm.docs.amd.com/projects/HIP/en/latest/how-to/kernel_language_cpp_support.html#kernel-compilation"> !> Kernel Compilation in the HIP kernel language C++ support, or !> href="https://rocm.docs.amd.com/projects/HIP/en/latest/how-to/hip_rtc.html">HIP runtime !> compilation (HIP RTC). !> !> @param [in] image The pointer to the location of data !> @param [out] module Retuned module !> !> @returns hipSuccess, hipErrorNotInitialized, hipErrorOutOfMemory, hipErrorNotInitialized #ifndef USE_CUDA_NAMES interface hipModuleLoadData function hipModuleLoadData_(myModule,image) bind(c, name="hipModuleLoadData") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipModuleLoadData_ type(c_ptr) :: myModule type(c_ptr),value :: image end function end interface #endif !> @brief builds module from code object which resides in host memory. Image is pointer to that !> location. Options are not used. hipModuleLoadData is called. !> !> @param [in] image The pointer to the location of data !> @param [out] module Retuned module !> @param [in] numOptions Number of options !> @param [in] options Options for JIT !> @param [in] optionValues Option values for JIT !> !> @returns hipSuccess, hipErrorNotInitialized, hipErrorOutOfMemory, hipErrorNotInitialized #ifndef USE_CUDA_NAMES interface hipModuleLoadDataEx function hipModuleLoadDataEx_(myModule,image,numOptions,options,optionValues) & bind(c, name="hipModuleLoadDataEx") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipModuleLoadDataEx_ type(c_ptr) :: myModule type(c_ptr),value :: image integer(c_int),value :: numOptions type(c_ptr),value :: options type(c_ptr) :: optionValues end function end interface #endif !> @brief Adds bitcode data to be linked with options. !> @param [in] state hip link state !> @param [in] type Type of the input data or bitcode !> @param [in] data Input data which is null terminated !> @param [in] size Size of the input data !> @param [in] name Optional name for this input !> @param [in] numOptions Size of the options !> @param [in] options Array of options applied to this input !> @param [in] optionValues Array of option values cast to void* !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidHandle` !> !> If adding the file fails, it will !> @return `hipErrorInvalidConfiguration` !> !> @see hipError_t interface hipLinkAddData #ifdef USE_CUDA_NAMES function hipLinkAddData_(state,myType,myData,mySize,name,numOptions,options,optionValues) & bind(c, name="cuLinkAddData") #else function hipLinkAddData_(state,myType,myData,mySize,name,numOptions,options,optionValues) & bind(c, name="hipLinkAddData") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipLinkAddData_ type(c_ptr),value :: state integer(kind(hipJitInputCubin)),value :: myType type(c_ptr),value :: myData integer(c_size_t),value :: mySize type(c_ptr),value :: name integer(c_int),value :: numOptions type(c_ptr),value :: options type(c_ptr) :: optionValues end function end interface !> @brief Adds a file with bitcode to be linked with options. !> @param [in] state hip link state !> @param [in] type Type of the input data or bitcode !> @param [in] path Path to the input file where bitcode is present !> @param [in] numOptions Size of the options !> @param [in] options Array of options applied to this input !> @param [in] optionValues Array of option values cast to void* !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> If adding the file fails, it will !> @return `hipErrorInvalidConfiguration` !> !> @see hipError_t interface hipLinkAddFile #ifdef USE_CUDA_NAMES function hipLinkAddFile_(state,myType,path,numOptions,options,optionValues) & bind(c, name="cuLinkAddFile") #else function hipLinkAddFile_(state,myType,path,numOptions,options,optionValues) & bind(c, name="hipLinkAddFile") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipLinkAddFile_ type(c_ptr),value :: state integer(kind(hipJitInputCubin)),value :: myType type(c_ptr),value :: path integer(c_int),value :: numOptions type(c_ptr),value :: options type(c_ptr) :: optionValues end function end interface !> @brief Completes the linking of the given program. !> @param [in] state hip link state !> @param [out] hipBinOut Upon success, points to the output binary !> @param [out] sizeOut Size of the binary is stored (optional) !> !> @returns `hipSuccess` `hipErrorInvalidValue` !> !> If adding the data fails, it will !> @return `hipErrorInvalidConfiguration` !> !> @see hipError_t interface hipLinkComplete #ifdef USE_CUDA_NAMES function hipLinkComplete_(state,hipBinOut,sizeOut) bind(c, name="cuLinkComplete") #else function hipLinkComplete_(state,hipBinOut,sizeOut) bind(c, name="hipLinkComplete") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipLinkComplete_ type(c_ptr),value :: state type(c_ptr) :: hipBinOut type(c_ptr),value :: sizeOut end function end interface !> @brief Creates a linker instance with options. !> @param [in] numOptions Number of options !> @param [in] options Array of options !> @param [in] optionValues Array of option values cast to void* !> @param [out] stateOut hip link state created upon success !> !> @returns `hipSuccess` `hipErrorInvalidValue` `hipErrorInvalidConfiguration` !> !> @see hipSuccess interface hipLinkCreate #ifdef USE_CUDA_NAMES function hipLinkCreate_(numOptions,options,optionValues,stateOut) bind(c, name="cuLinkCreate") #else function hipLinkCreate_(numOptions,options,optionValues,stateOut) bind(c, name="hipLinkCreate") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipLinkCreate_ integer(c_int),value :: numOptions type(c_ptr),value :: options type(c_ptr) :: optionValues type(c_ptr) :: stateOut end function end interface !> @brief Deletes the linker instance. !> @param [in] state link state instance !> !> @returns `hipSuccess` `hipErrorInvalidValue` !> !> @see hipSuccess interface hipLinkDestroy #ifdef USE_CUDA_NAMES function hipLinkDestroy_(state) bind(c, name="cuLinkDestroy") #else function hipLinkDestroy_(state) bind(c, name="hipLinkDestroy") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipLinkDestroy_ type(c_ptr),value :: state end function end interface !> @brief launches kernel f with launch parameters and shared memory on stream with arguments !> passed !> to kernelparams or extra !> @ingroup Execution !> @param [in] f Kernel to launch. !> @param [in] gridDimX X grid dimension specified as multiple of blockDimX. !> @param [in] gridDimY Y grid dimension specified as multiple of blockDimY. !> @param [in] gridDimZ Z grid dimension specified as multiple of blockDimZ. !> @param [in] blockDimX X block dimensions specified in work-items !> @param [in] blockDimY Y grid dimension specified in work-items !> @param [in] blockDimZ Z grid dimension specified in work-items !> @param [in] sharedMemBytes Amount of dynamic shared memory to allocate for this kernel. The !> HIP-Clang compiler provides support for extern shared declarations. !> @param [in] stream Stream where the kernel should be dispatched. May be 0, in which case th !> default stream is used with associated synchronization rules. !> @param [in] kernelParams Kernel parameters to launch !> @param [in] extra Pointer to kernel arguments. These are passed directly to the kernel and !> must be in the memory layout and alignment expected by the kernel. !> All passed arguments must be naturally aligned according to their type. The memory address of !> each argument should be a multiple of its size in bytes. Please refer to !> hip_porting_driver_api.md for sample usage. !> !> Please note, HIP does not support kernel launch with total work items defined in dimension !> with !> size gridDim x blockDim >= 2^32. So gridDim.x * blockDim.x, gridDim.y * blockDim.y !> and gridDim.z * blockDim.z are always less than 2^32. !> !> @returns `hipSuccess`, `hipErrorNotInitialized`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipModuleLaunchKernel function hipModuleLaunchKernel_(f,gridDimX,gridDimY,gridDimZ,blockDimX,blockDimY,blockDimZ, & sharedMemBytes,stream,kernelParams,extra) & bind(c, name="hipModuleLaunchKernel") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipModuleLaunchKernel_ type(c_ptr),value :: f integer(c_int),value :: gridDimX integer(c_int),value :: gridDimY integer(c_int),value :: gridDimZ integer(c_int),value :: blockDimX integer(c_int),value :: blockDimY integer(c_int),value :: blockDimZ integer(c_int),value :: sharedMemBytes type(c_ptr),value :: stream type(c_ptr) :: kernelParams type(c_ptr),value :: extra end function end interface #endif !> \addtogroup ModuleCooperativeG Cooperative groups kernel launch of Module management. !> \ingroup Module !> !> !> @brief launches kernel f with launch parameters and shared memory on stream with arguments !> passed !> to kernelParams, where thread blocks can cooperate and synchronize as they execute !> !> @param [in] f Kernel to launch. !> @param [in] gridDimX X grid dimension specified as multiple of blockDimX. !> @param [in] gridDimY Y grid dimension specified as multiple of blockDimY. !> @param [in] gridDimZ Z grid dimension specified as multiple of blockDimZ. !> @param [in] blockDimX X block dimension specified in work-items. !> @param [in] blockDimY Y block dimension specified in work-items. !> @param [in] blockDimZ Z block dimension specified in work-items. !> @param [in] sharedMemBytes Amount of dynamic shared memory to allocate for this kernel. The !> HIP-Clang compiler provides support for extern shared declarations. !> @param [in] stream Stream where the kernel should be dispatched. May be 0, !> in which case the default stream is used with associated synchronization rules. !> @param [in] kernelParams A list of kernel arguments. !> !> Please note, HIP does not support kernel launch with total work items defined in dimension !> with !> size \f$ gridDim \cdot blockDim ≥ 2^{32} \f$. !> !> @returns `hipSuccess`, `hipErrorDeinitialized`, `hipErrorNotInitialized`, !> `hipErrorInvalidContext`, !> `hipErrorInvalidHandle`, `hipErrorInvalidImage`, `hipErrorInvalidValue`, !> `hipErrorInvalidConfiguration`, `hipErrorLaunchFailure`, `hipErrorLaunchOutOfResources`, !> `hipErrorLaunchTimeOut`, `hipErrorCooperativeLaunchTooLarge`, `hipErrorSharedObjectInitFailed` #ifndef USE_CUDA_NAMES interface hipModuleLaunchCooperativeKernel function hipModuleLaunchCooperativeKernel_(f,gridDimX,gridDimY,gridDimZ,blockDimX,blockDimY, & blockDimZ,sharedMemBytes,stream,kernelParams) & bind(c, name="hipModuleLaunchCooperativeKernel") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipModuleLaunchCooperativeKernel_ type(c_ptr),value :: f integer(c_int),value :: gridDimX integer(c_int),value :: gridDimY integer(c_int),value :: gridDimZ integer(c_int),value :: blockDimX integer(c_int),value :: blockDimY integer(c_int),value :: blockDimZ integer(c_int),value :: sharedMemBytes type(c_ptr),value :: stream type(c_ptr) :: kernelParams end function end interface #endif !> @brief Launches kernels on multiple devices where thread blocks can cooperate and !> synchronize as they execute. !> !> @param [in] launchParamsList List of launch parameters, one per device. !> @param [in] numDevices Size of the launchParamsList array. !> @param [in] flags Flags to control launch behavior. !> !> @returns `hipSuccess`, `hipErrorDeinitialized`, `hipErrorNotInitialized`, !> `hipErrorInvalidContext`, !> `hipErrorInvalidHandle`, `hipErrorInvalidImage`, `hipErrorInvalidValue`, !> `hipErrorInvalidConfiguration`, `hipErrorInvalidResourceHandle`, `hipErrorLaunchFailure`, !> `hipErrorLaunchOutOfResources`, `hipErrorLaunchTimeOut`, `hipErrorCooperativeLaunchTooLarge`, !> `hipErrorSharedObjectInitFailed` #ifndef USE_CUDA_NAMES interface hipModuleLaunchCooperativeKernelMultiDevice function hipModuleLaunchCooperativeKernelMultiDevice_(launchParamsList,numDevices,flags) & bind(c, name="hipModuleLaunchCooperativeKernelMultiDevice") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipModuleLaunchCooperativeKernelMultiDevice_ type(hipFunctionLaunchParams) :: launchParamsList integer(c_int),value :: numDevices integer(c_int),value :: flags end function end interface #endif !> @brief Launches kernel f with launch parameters and shared memory on stream with arguments !> passed !> to kernelparams or extra, where thread blocks can cooperate and synchronize as they execute. !> !> @param [in] f - Kernel to launch. !> @param [in] gridDim - Grid dimensions specified as multiple of blockDim. !> @param [in] blockDimX - Block dimensions specified in work-items !> @param [in] kernelParams - Pointer of arguments passed to the kernel. If the kernel has !> multiple !> parameters, 'kernelParams' should be array of pointers, each points the corresponding !> argument. !> @param [in] sharedMemBytes - Amount of dynamic shared memory to allocate for this kernel. The !> HIP-Clang compiler provides support for extern shared declarations. !> @param [in] stream - Stream where the kernel should be dispatched. May be 0, in which case th !> default stream is used with associated synchronization rules. !> !> Please note, HIP does not support kernel launch with total work items defined in dimension !> with !> size \f$ gridDim \cdot blockDim ≥ 2^{32} \f$. !> !> @returns `hipSuccess`, `hipErrorNotInitialized`, `hipErrorInvalidValue`, !> `hipErrorCooperativeLaunchTooLarge` interface hipLaunchCooperativeKernel #ifdef USE_CUDA_NAMES function hipLaunchCooperativeKernel_(f,gridDim,blockDimX,kernelParams,sharedMemBytes,stream) & bind(c, name="cudaLaunchCooperativeKernel") #else function hipLaunchCooperativeKernel_(f,gridDim,blockDimX,kernelParams,sharedMemBytes,stream) & bind(c, name="hipLaunchCooperativeKernel") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipLaunchCooperativeKernel_ type(c_ptr),value :: f type(dim3),value :: gridDim type(dim3),value :: blockDimX type(c_ptr) :: kernelParams integer(c_int),value :: sharedMemBytes type(c_ptr),value :: stream end function end interface !> @brief Launches kernels on multiple devices where thread blocks can cooperate and !> synchronize as they execute. !> !> @param [in] launchParamsList List of launch parameters, one per device. !> @param [in] numDevices Size of the launchParamsList array. !> @param [in] flags Flags to control launch behavior. !> !> @returns `hipSuccess`, `hipErrorNotInitialized`, `hipErrorInvalidValue`, !> `hipErrorCooperativeLaunchTooLarge` #ifndef USE_CUDA_NAMES interface hipLaunchCooperativeKernelMultiDevice function hipLaunchCooperativeKernelMultiDevice_(launchParamsList,numDevices,flags) & bind(c, name="hipLaunchCooperativeKernelMultiDevice") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipLaunchCooperativeKernelMultiDevice_ type(hipLaunchParams) :: launchParamsList integer(c_int),value :: numDevices integer(c_int),value :: flags end function end interface #endif !> @brief Launches kernels on multiple devices and guarantees all specified kernels are !> dispatched !> on respective streams before enqueuing any other work on the specified streams from any other !> threads !> @ingroup Execution !> @param [in] launchParamsList List of launch parameters, one per device. !> @param [in] numDevices Size of the launchParamsList array. !> @param [in] flags Flags to control launch behavior. !> !> @returns `hipSuccess`, `hipErrorNotInitialized`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipExtLaunchMultiKernelMultiDevice function hipExtLaunchMultiKernelMultiDevice_(launchParamsList,numDevices,flags) & bind(c, name="hipExtLaunchMultiKernelMultiDevice") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipExtLaunchMultiKernelMultiDevice_ type(hipLaunchParams) :: launchParamsList integer(c_int),value :: numDevices integer(c_int),value :: flags end function end interface #endif !> @brief Launches a HIP kernel using a generic function pointer and the specified configuration. !> @ingroup Execution !> !> This function is equivalent to hipLaunchKernelEx but accepts the kernel as a generic function !> pointer. !> !> @param [in] config Pointer to the kernel launch configuration structure. !> @param [in] fPtr Pointer to the device kernel function. !> @param [in] args Array of pointers to the kernel arguments. !> !> @returns `hipSuccess` if the kernel is launched successfully, otherwise an appropriate error !> code. interface hipLaunchKernelExC #ifdef USE_CUDA_NAMES function hipLaunchKernelExC_(config,fPtr,args) bind(c, name="cudaLaunchKernelExC") #else function hipLaunchKernelExC_(config,fPtr,args) bind(c, name="hipLaunchKernelExC") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipLaunchKernelExC_ type(hipLaunchConfig_t) :: config type(c_ptr),value :: fPtr type(c_ptr) :: args end function end interface !> @brief Launches a HIP kernel using the driver API with the specified configuration. !> @ingroup Execution !> !> This function dispatches the device kernel represented by a HIP function object. !> It passes both the kernel parameters and any extra configuration arguments to the kernel !> launch. !> !> @param [in] config Pointer to the kernel launch configuration structure. !> @param [in] f HIP function object representing the device kernel to be launched. !> @param [in] params Array of pointers to the kernel parameters. !> @param [in] extra Array of pointers for additional launch parameters or extra configuration !> data. !> !> @returns `hipSuccess` if the kernel is launched successfully, otherwise an appropriate error !> code. #ifndef USE_CUDA_NAMES interface hipDrvLaunchKernelEx function hipDrvLaunchKernelEx_(config,f,params,extra) bind(c, name="hipDrvLaunchKernelEx") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipDrvLaunchKernelEx_ type(HIP_LAUNCH_CONFIG) :: config type(c_ptr),value :: f type(c_ptr) :: params type(c_ptr),value :: extra end function end interface #endif !> @brief Returns a handle for the address range requested. !> !> This function returns a handle to a device pointer created using either hipMalloc set of APIs !> or through hipMemAddressReserve (as long as the ptr is mapped). !> !> @param [out] handle Ptr to the handle where the fd or other types will be returned. !> @param [in] dptr Device ptr for which we get the handle. !> @param [in] size Size of the address range. !> @param [in] handleType Type of the handle requested for the address range. !> @param [in] flags Any flags set regarding the handle requested. !> !> @returns `hipSuccess` if the kernel is launched successfully, otherwise an appropriate error !> code. interface hipMemGetHandleForAddressRange #ifdef USE_CUDA_NAMES function hipMemGetHandleForAddressRange_(handle,dptr,mySize,handleType,flags) & bind(c, name="cuMemGetHandleForAddressRange") #else function hipMemGetHandleForAddressRange_(handle,dptr,mySize,handleType,flags) & bind(c, name="hipMemGetHandleForAddressRange") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemGetHandleForAddressRange_ type(c_ptr),value :: handle type(c_ptr),value :: dptr integer(c_size_t),value :: mySize integer(kind(hipMemRangeHandleTypeDmaBufFd)),value :: handleType integer(c_int64_t),value :: flags end function end interface !> ------------------------------------------------------------------------------------------------- !> ------------------------------------------------------------------------------------------------- !> @defgroup Occupancy Occupancy !> !> This section describes the occupancy functions of HIP runtime API. !> !> !> !> @brief determine the grid and block sizes to achieves maximum occupancy for a kernel !> !> @param [out] gridSize minimum grid size for maximum potential occupancy !> @param [out] blockSize block size for maximum potential occupancy !> @param [in] f kernel function for which occupancy is calculated !> @param [in] dynSharedMemPerBlk dynamic shared memory usage (in bytes) intended for each block !> @param [in] blockSizeLimit the maximum block size for the kernel, use 0 for no limit !> !> Please note, HIP does not support kernel launch with total work items defined in dimension !> with !> size gridDim x blockDim >= 2^32. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipModuleOccupancyMaxPotentialBlockSize function hipModuleOccupancyMaxPotentialBlockSize_(gridSize,blockSize,f,dynSharedMemPerBlk, & blockSizeLimit) & bind(c, name="hipModuleOccupancyMaxPotentialBlockSize") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipModuleOccupancyMaxPotentialBlockSize_ integer(c_int) :: gridSize integer(c_int) :: blockSize type(c_ptr),value :: f integer(c_size_t),value :: dynSharedMemPerBlk integer(c_int),value :: blockSizeLimit end function end interface #endif !> @brief determine the grid and block sizes to achieves maximum occupancy for a kernel !> !> @param [out] gridSize minimum grid size for maximum potential occupancy !> @param [out] blockSize block size for maximum potential occupancy !> @param [in] f kernel function for which occupancy is calculated !> @param [in] dynSharedMemPerBlk dynamic shared memory usage (in bytes) intended for each block !> @param [in] blockSizeLimit the maximum block size for the kernel, use 0 for no limit !> @param [in] flags Extra flags for occupancy calculation (only default supported) !> !> Please note, HIP does not support kernel launch with total work items defined in dimension !> with !> size gridDim x blockDim >= 2^32. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipModuleOccupancyMaxPotentialBlockSizeWithFlags function hipModuleOccupancyMaxPotentialBlockSizeWithFlags_(gridSize,blockSize,f, & dynSharedMemPerBlk,blockSizeLimit,flags) & bind(c, name="hipModuleOccupancyMaxPotentialBlockSizeWithFlags") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipModuleOccupancyMaxPotentialBlockSizeWithFlags_ integer(c_int) :: gridSize integer(c_int) :: blockSize type(c_ptr),value :: f integer(c_size_t),value :: dynSharedMemPerBlk integer(c_int),value :: blockSizeLimit integer(c_int),value :: flags end function end interface #endif !> @brief Returns occupancy for a device function. !> !> @param [out] numBlocks Returned occupancy !> @param [in] f Kernel function (hipFunction) for which occupancy is calculated !> @param [in] blockSize Block size the kernel is intended to be launched with !> @param [in] dynSharedMemPerBlk Dynamic shared memory usage (in bytes) intended for each block !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipModuleOccupancyMaxActiveBlocksPerMultiprocessor function hipModuleOccupancyMaxActiveBlocksPerMultiprocessor_(numBlocks,f,blockSize, & dynSharedMemPerBlk) & bind(c, name="hipModuleOccupancyMaxActiveBlocksPerMultiprocessor") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipModuleOccupancyMaxActiveBlocksPerMultiprocessor_ integer(c_int) :: numBlocks type(c_ptr),value :: f integer(c_int),value :: blockSize integer(c_size_t),value :: dynSharedMemPerBlk end function end interface #endif !> @brief Returns occupancy for a device function. !> !> @param [out] numBlocks Returned occupancy !> @param [in] f Kernel function(hipFunction_t) for which occupancy is calculated !> @param [in] blockSize Block size the kernel is intended to be launched with !> @param [in] dynSharedMemPerBlk Dynamic shared memory usage (in bytes) intended for each block !> @param [in] flags Extra flags for occupancy calculation (only default supported) !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags function hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_(numBlocks,f,blockSize, & dynSharedMemPerBlk,flags) & bind(c, name="hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipModuleOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_ integer(c_int) :: numBlocks type(c_ptr),value :: f integer(c_int),value :: blockSize integer(c_size_t),value :: dynSharedMemPerBlk integer(c_int),value :: flags end function end interface #endif !> @brief Returns occupancy for a device function. !> !> @param [out] numBlocks Returned occupancy !> @param [in] f Kernel function for which occupancy is calculated !> @param [in] blockSize Block size the kernel is intended to be launched with !> @param [in] dynSharedMemPerBlk Dynamic shared memory usage (in bytes) intended for each block !> @returns `hipSuccess`, `hipErrorInvalidDeviceFunction`, `hipErrorInvalidValue` interface hipOccupancyMaxActiveBlocksPerMultiprocessor #ifdef USE_CUDA_NAMES function hipOccupancyMaxActiveBlocksPerMultiprocessor_(numBlocks,f,blockSize, & dynSharedMemPerBlk) & bind(c, name="cudaOccupancyMaxActiveBlocksPerMultiprocessor") #else function hipOccupancyMaxActiveBlocksPerMultiprocessor_(numBlocks,f,blockSize, & dynSharedMemPerBlk) & bind(c, name="hipOccupancyMaxActiveBlocksPerMultiprocessor") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipOccupancyMaxActiveBlocksPerMultiprocessor_ type(c_ptr),value :: numBlocks type(c_funptr),value :: f integer(c_int),value :: blockSize integer(c_size_t),value :: dynSharedMemPerBlk end function end interface !> @brief Returns occupancy for a device function. !> !> @param [out] numBlocks Returned occupancy !> @param [in] f Kernel function for which occupancy is calculated !> @param [in] blockSize Block size the kernel is intended to be launched with !> @param [in] dynSharedMemPerBlk Dynamic shared memory usage (in bytes) intended for each block !> @param [in] flags Extra flags for occupancy calculation (currently ignored) !> @returns `hipSuccess`, `hipErrorInvalidDeviceFunction`, `hipErrorInvalidValue` interface hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags #ifdef USE_CUDA_NAMES function hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_(numBlocks,f,blockSize, & dynSharedMemPerBlk,flags) & bind(c, name="cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags") #else function hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_(numBlocks,f,blockSize, & dynSharedMemPerBlk,flags) & bind(c, name="hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags_ type(c_ptr),value :: numBlocks type(c_funptr),value :: f integer(c_int),value :: blockSize integer(c_size_t),value :: dynSharedMemPerBlk integer(c_int),value :: flags end function end interface !> @brief determine the grid and block sizes to achieves maximum occupancy for a kernel !> !> @param [out] gridSize minimum grid size for maximum potential occupancy !> @param [out] blockSize block size for maximum potential occupancy !> @param [in] f kernel function for which occupancy is calculated !> @param [in] dynSharedMemPerBlk dynamic shared memory usage (in bytes) intended for each block !> @param [in] blockSizeLimit the maximum block size for the kernel, use 0 for no limit !> !> Please note, HIP does not support kernel launch with total work items defined in dimension !> with !> size gridDim x blockDim >= 2^32. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipOccupancyMaxPotentialBlockSize function hipOccupancyMaxPotentialBlockSize_(gridSize,blockSize,f,dynSharedMemPerBlk, & blockSizeLimit) & bind(c, name="hipOccupancyMaxPotentialBlockSize") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipOccupancyMaxPotentialBlockSize_ type(c_ptr),value :: gridSize type(c_ptr),value :: blockSize type(c_funptr),value :: f integer(c_size_t),value :: dynSharedMemPerBlk integer(c_int),value :: blockSizeLimit end function end interface #endif !> @brief Returns dynamic shared memory available per block when launching numBlocks blocks on !> SM. !> !> @ingroup Occupancy !> Returns in \p *dynamicSmemSize the maximum size of dynamic shared memory / !> to allow numBlocks blocks per SM. !> !> @param [out] dynamicSmemSize Returned maximum dynamic shared memory. !> @param [in] f Kernel function for which occupancy is calculated. !> @param [in] numBlocks Number of blocks to fit on SM !> @param [in] blockSize Size of the block !> !> @return `hipSuccess`, `hipErrorInvalidDevice`, `hipErrorInvalidDeviceFunction`, !> `hipErrorInvalidValue`, !> `hipErrorUnknown` interface hipOccupancyAvailableDynamicSMemPerBlock #ifdef USE_CUDA_NAMES function hipOccupancyAvailableDynamicSMemPerBlock_(dynamicSmemSize,f,numBlocks,blockSize) & bind(c, name="cudaOccupancyAvailableDynamicSMemPerBlock") #else function hipOccupancyAvailableDynamicSMemPerBlock_(dynamicSmemSize,f,numBlocks,blockSize) & bind(c, name="hipOccupancyAvailableDynamicSMemPerBlock") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipOccupancyAvailableDynamicSMemPerBlock_ type(c_ptr),value :: dynamicSmemSize type(c_funptr),value :: f integer(c_int),value :: numBlocks integer(c_int),value :: blockSize end function end interface !> @brief determines the amount of active kernel clusters can co-exist at the same time in a !> device !> !> @param [out] numClusters the amount of clusters !> @param [in] f kernel function for which occupancy is calculated !> @param [in] config pointer to the kernel launch configuration structure !> !> @returns `hipSuccess`, `hipErrorInvalidDeviceFunction`, hipErrorInvalidClusterSize, !> `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipOccupancyMaxActiveClusters function hipOccupancyMaxActiveClusters_(numClusters,f,config) & bind(c, name="hipOccupancyMaxActiveClusters") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipOccupancyMaxActiveClusters_ type(c_ptr),value :: numClusters type(c_funptr),value :: f type(hipLaunchConfig_t) :: config end function end interface #endif !> @brief returns the maximum cluster size (in number of blocks) that can run on the device !> !> @param [out] clusterSize the maximum cluster size !> @param [in] f kernel function for which occupancy is calculated !> @param [in] config pointer to the kernel launch configuration structure !> !> @returns `hipSuccess`, `hipErrorInvalidDeviceFunction`, hipErrorInvalidClusterSize, !> `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipOccupancyMaxPotentialClusterSize function hipOccupancyMaxPotentialClusterSize_(clusterSize,f,config) & bind(c, name="hipOccupancyMaxPotentialClusterSize") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipOccupancyMaxPotentialClusterSize_ type(c_ptr),value :: clusterSize type(c_funptr),value :: f type(hipLaunchConfig_t) :: config end function end interface #endif !> @brief Start recording of profiling information [Deprecated] !> When using this API, start the profiler with profiling disabled. (--startdisabled) !> @returns `hipErrorNotSupported` !> @warning hipProfilerStart API is deprecated, use roctracer/rocTX instead. interface hipProfilerStart #ifdef USE_CUDA_NAMES function hipProfilerStart_() bind(c, name="cudaProfilerStart") #else function hipProfilerStart_() bind(c, name="hipProfilerStart") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipProfilerStart_ end function end interface !> @brief Stop recording of profiling information [Deprecated] !> When using this API, start the profiler with profiling disabled. (--startdisabled) !> @returns `hipErrorNotSupported` !> @warning hipProfilerStart API is deprecated, use roctracer/rocTX instead. interface hipProfilerStop #ifdef USE_CUDA_NAMES function hipProfilerStop_() bind(c, name="cudaProfilerStop") #else function hipProfilerStop_() bind(c, name="hipProfilerStop") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipProfilerStop_ end function end interface !> ------------------------------------------------------------------------------------------------- !> ------------------------------------------------------------------------------------------------- !> @defgroup Clang Launch API to support the triple-chevron syntax !> !> This section describes the API to support the triple-chevron syntax. !> !> !> @brief Configure a kernel launch. !> !> @param [in] gridDim grid dimension specified as multiple of blockDim. !> @param [in] blockDim block dimensions specified in work-items !> @param [in] sharedMem Amount of dynamic shared memory to allocate for this kernel. The !> HIP-Clang compiler provides support for extern shared declarations. !> @param [in] stream Stream where the kernel should be dispatched. May be 0, in which case the !> default stream is used with associated synchronization rules. !> !> Please note, HIP does not support kernel launch with total work items defined in dimension !> with !> size gridDim x blockDim >= 2^32. !> !> @returns `hipSuccess`, `hipErrorNotInitialized`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipConfigureCall function hipConfigureCall_(gridDim,blockDim,sharedMem,stream) bind(c, name="hipConfigureCall") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipConfigureCall_ type(dim3),value :: gridDim type(dim3),value :: blockDim integer(c_size_t),value :: sharedMem type(c_ptr),value :: stream end function end interface #endif !> @brief Set a kernel argument. !> !> @returns `hipSuccess`, `hipErrorNotInitialized`, `hipErrorInvalidValue` !> !> @param [in] arg Pointer the argument in host memory. !> @param [in] size Size of the argument. !> @param [in] offset Offset of the argument on the argument stack. #ifndef USE_CUDA_NAMES interface hipSetupArgument function hipSetupArgument_(arg,mySize,offset) bind(c, name="hipSetupArgument") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipSetupArgument_ type(c_ptr),value :: arg integer(c_size_t),value :: mySize integer(c_size_t),value :: offset end function end interface #endif !> @brief Launch a kernel. !> !> @param [in] func Kernel to launch. !> !> @returns `hipSuccess`, `hipErrorNotInitialized`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipLaunchByPtr function hipLaunchByPtr_(func) bind(c, name="hipLaunchByPtr") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipLaunchByPtr_ type(c_ptr),value :: func end function end interface #endif !> @brief C compliant kernel launch API !> !> @param [in] function_address - Kernel stub function pointer. !> @param [in] numBlocks - Number of blocks. !> @param [in] dimBlocks - Dimension of a block !> @param [in] args - Pointer of arguments passed to the kernel. If the kernel has multiple !> parameters, 'args' should be array of pointers, each points the corresponding argument. !> @param [in] sharedMemBytes - Amount of dynamic shared memory to allocate for this kernel. The !> HIP-Clang compiler provides support for extern shared declarations. !> @param [in] stream - Stream where the kernel should be dispatched. May be 0, in which case th !> default stream is used with associated synchronization rules. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipLaunchKernel #ifdef USE_CUDA_NAMES function hipLaunchKernel_(function_address,numBlocks,dimBlocks,args,sharedMemBytes,stream) & bind(c, name="cudaLaunchKernel") #else function hipLaunchKernel_(function_address,numBlocks,dimBlocks,args,sharedMemBytes,stream) & bind(c, name="hipLaunchKernel") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipLaunchKernel_ type(c_ptr),value :: function_address type(dim3),value :: numBlocks type(dim3),value :: dimBlocks type(c_ptr) :: args integer(c_size_t),value :: sharedMemBytes type(c_ptr),value :: stream end function end interface !> @brief Enqueues a host function call in a stream. !> !> @param [in] stream - The stream to enqueue work in. !> @param [in] fn - The function to call once enqueued preceeding operations are complete. !> @param [in] userData - User-specified data to be passed to the function. !> !> @returns `hipSuccess`, `hipErrorInvalidResourceHandle`, `hipErrorInvalidValue`, !> `hipErrorNotSupported` !> !> The host function to call in this API will be executed after the preceding operations in !> the stream are complete. The function is a blocking operation that blocks operations in the !> stream that follow it, until the function is returned. !> Event synchronization and internal callback functions make sure enqueued operations will !> execute in order, in the stream. !> !> The host function must not make any HIP API calls. The host function is non-reentrant. It must !> not perform sychronization with any operation that may depend on other processing execution !> but is not enqueued to run earlier in the stream. !> !> Host functions that are enqueued respectively in different non-blocking streams can run !> concurrently. !> !> @warning This API is marked as beta, meaning, while this is feature complete, !> it is still open to changes and may have outstanding issues. interface hipLaunchHostFunc #ifdef USE_CUDA_NAMES function hipLaunchHostFunc_(stream,fn,userData) bind(c, name="cudaLaunchHostFunc") #else function hipLaunchHostFunc_(stream,fn,userData) bind(c, name="hipLaunchHostFunc") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipLaunchHostFunc_ type(c_ptr),value :: stream type(c_funptr),value :: fn type(c_ptr),value :: userData end function end interface !> Copies memory for 2D arrays. !> !> @param pCopy - Parameters for the memory copy !> !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipDrvMemcpy2DUnaligned function hipDrvMemcpy2DUnaligned_(pCopy) bind(c, name="hipDrvMemcpy2DUnaligned") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipDrvMemcpy2DUnaligned_ type(hip_Memcpy2D) :: pCopy end function end interface #endif !> @brief Launches kernel from the pointer address, with arguments and shared memory on stream. !> !> @param [in] function_address - Pointer to the Kernel to launch. !> @param [in] numBlocks - Number of blocks. !> @param [in] dimBlocks - Dimension of a block. !> @param [in] args - Pointer of arguments passed to the kernel. If the kernel has multiple !> parameters, 'args' should be array of pointers, each points the corresponding argument. !> @param [in] sharedMemBytes - Amount of dynamic shared memory to allocate for this kernel. !> HIP-Clang compiler provides support for extern shared declarations. !> @param [in] stream - Stream where the kernel should be dispatched. !> May be 0, in which case the default stream is used with associated synchronization rules. !> @param [in] startEvent - If non-null, specified event will be updated to track the start time !> of !> the kernel launch. The event must be created before calling this API. !> @param [in] stopEvent - If non-null, specified event will be updated to track the stop time of !> the kernel launch. The event must be created before calling this API. !> @param [in] flags - The value of hipExtAnyOrderLaunch, signifies if kernel can be !> launched in any order. !> @returns `hipSuccess`, `hipErrorNotInitialized`, `hipErrorInvalidValue`. #ifndef USE_CUDA_NAMES interface hipExtLaunchKernel function hipExtLaunchKernel_(function_address,numBlocks,dimBlocks,args,sharedMemBytes,stream, & startEvent,stopEvent,flags) & bind(c, name="hipExtLaunchKernel") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipExtLaunchKernel_ type(c_ptr),value :: function_address type(dim3),value :: numBlocks type(dim3),value :: dimBlocks type(c_ptr) :: args integer(c_size_t),value :: sharedMemBytes type(c_ptr),value :: stream type(c_ptr),value :: startEvent type(c_ptr),value :: stopEvent integer(c_int),value :: flags end function end interface #endif !> @brief Creates a texture object. !> !> @param [out] pTexObject pointer to the texture object to create !> @param [in] pResDesc pointer to resource descriptor !> @param [in] pTexDesc pointer to texture descriptor !> @param [in] pResViewDesc pointer to resource view descriptor !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported`, `hipErrorOutOfMemory` !> !> @note 3D linear filter isn't supported on GFX90A boards, on which the API @p !> hipCreateTextureObject will return hipErrorNotSupported. interface hipCreateTextureObject #ifdef USE_CUDA_NAMES function hipCreateTextureObject_(pTexObject,pResDesc,pTexDesc,pResViewDesc) & bind(c, name="cudaCreateTextureObject") #else function hipCreateTextureObject_(pTexObject,pResDesc,pTexDesc,pResViewDesc) & bind(c, name="hipCreateTextureObject") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipCreateTextureObject_ type(c_ptr) :: pTexObject type(hipResourceDesc) :: pResDesc type(hipTextureDesc) :: pTexDesc type(hipResourceViewDesc) :: pResViewDesc end function end interface !> @brief Destroys a texture object. !> !> @param [in] textureObject texture object to destroy !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipDestroyTextureObject #ifdef USE_CUDA_NAMES function hipDestroyTextureObject_(textureObject) bind(c, name="cudaDestroyTextureObject") #else function hipDestroyTextureObject_(textureObject) bind(c, name="hipDestroyTextureObject") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDestroyTextureObject_ type(c_ptr),value :: textureObject end function end interface !> @brief Gets the channel descriptor in an array. !> !> @param [in] desc pointer to channel format descriptor !> @param [out] array memory array on the device !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGetChannelDesc #ifdef USE_CUDA_NAMES function hipGetChannelDesc_(desc,array) bind(c, name="cudaGetChannelDesc") #else function hipGetChannelDesc_(desc,array) bind(c, name="hipGetChannelDesc") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGetChannelDesc_ type(hipChannelFormatDesc) :: desc type(c_ptr),value :: array end function end interface !> @brief Gets resource descriptor for the texture object. !> !> @param [out] pResDesc pointer to resource descriptor !> @param [in] textureObject texture object !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGetTextureObjectResourceDesc #ifdef USE_CUDA_NAMES function hipGetTextureObjectResourceDesc_(pResDesc,textureObject) & bind(c, name="cudaGetTextureObjectResourceDesc") #else function hipGetTextureObjectResourceDesc_(pResDesc,textureObject) & bind(c, name="hipGetTextureObjectResourceDesc") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGetTextureObjectResourceDesc_ type(hipResourceDesc) :: pResDesc type(c_ptr),value :: textureObject end function end interface !> @brief Gets resource view descriptor for the texture object. !> !> @param [out] pResViewDesc pointer to resource view descriptor !> @param [in] textureObject texture object !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGetTextureObjectResourceViewDesc #ifdef USE_CUDA_NAMES function hipGetTextureObjectResourceViewDesc_(pResViewDesc,textureObject) & bind(c, name="cudaGetTextureObjectResourceViewDesc") #else function hipGetTextureObjectResourceViewDesc_(pResViewDesc,textureObject) & bind(c, name="hipGetTextureObjectResourceViewDesc") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGetTextureObjectResourceViewDesc_ type(hipResourceViewDesc) :: pResViewDesc type(c_ptr),value :: textureObject end function end interface !> @brief Gets texture descriptor for the texture object. !> !> @param [out] pTexDesc pointer to texture descriptor !> @param [in] textureObject texture object !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGetTextureObjectTextureDesc #ifdef USE_CUDA_NAMES function hipGetTextureObjectTextureDesc_(pTexDesc,textureObject) & bind(c, name="cudaGetTextureObjectTextureDesc") #else function hipGetTextureObjectTextureDesc_(pTexDesc,textureObject) & bind(c, name="hipGetTextureObjectTextureDesc") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGetTextureObjectTextureDesc_ type(hipTextureDesc) :: pTexDesc type(c_ptr),value :: textureObject end function end interface !> @brief Creates a texture object. !> !> @param [out] pTexObject pointer to texture object to create !> @param [in] pResDesc pointer to resource descriptor !> @param [in] pTexDesc pointer to texture descriptor !> @param [in] pResViewDesc pointer to resource view descriptor !> !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipTexObjectCreate function hipTexObjectCreate_(pTexObject,pResDesc,pTexDesc,pResViewDesc) & bind(c, name="hipTexObjectCreate") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexObjectCreate_ type(c_ptr) :: pTexObject type(HIP_RESOURCE_DESC) :: pResDesc type(HIP_TEXTURE_DESC) :: pTexDesc type(HIP_RESOURCE_VIEW_DESC) :: pResViewDesc end function end interface #endif !> @brief Destroys a texture object. !> !> @param [in] texObject texture object to destroy !> !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipTexObjectDestroy function hipTexObjectDestroy_(texObject) bind(c, name="hipTexObjectDestroy") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipTexObjectDestroy_ type(c_ptr),value :: texObject end function end interface #endif !> @brief Gets resource descriptor of a texture object. !> !> @param [out] pResDesc pointer to resource descriptor !> @param [in] texObject texture object !> !> @returns `hipSuccess`, `hipErrorNotSupported`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipTexObjectGetResourceDesc function hipTexObjectGetResourceDesc_(pResDesc,texObject) & bind(c, name="hipTexObjectGetResourceDesc") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexObjectGetResourceDesc_ type(HIP_RESOURCE_DESC) :: pResDesc type(c_ptr),value :: texObject end function end interface #endif !> @brief Gets resource view descriptor of a texture object. !> !> @param [out] pResViewDesc pointer to resource view descriptor !> @param [in] texObject texture object !> !> @returns `hipSuccess`, `hipErrorNotSupported`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipTexObjectGetResourceViewDesc function hipTexObjectGetResourceViewDesc_(pResViewDesc,texObject) & bind(c, name="hipTexObjectGetResourceViewDesc") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexObjectGetResourceViewDesc_ type(HIP_RESOURCE_VIEW_DESC) :: pResViewDesc type(c_ptr),value :: texObject end function end interface #endif !> @brief Gets texture descriptor of a texture object. !> !> @param [out] pTexDesc pointer to texture descriptor !> @param [in] texObject texture object !> !> @returns `hipSuccess`, `hipErrorNotSupported`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipTexObjectGetTextureDesc function hipTexObjectGetTextureDesc_(pTexDesc,texObject) & bind(c, name="hipTexObjectGetTextureDesc") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexObjectGetTextureDesc_ type(HIP_TEXTURE_DESC) :: pTexDesc type(c_ptr),value :: texObject end function end interface #endif !> @brief Allocate a mipmapped array on the device. !> !> @param[out] mipmappedArray - Pointer to allocated mipmapped array in device memory !> @param[in] desc - Requested channel format !> @param[in] extent - Requested allocation size (width field in elements) !> @param[in] numLevels - Number of mipmap levels to allocate !> @param[in] flags - Flags for extensions !> !> @return `hipSuccess`, `hipErrorInvalidValue`, `hipErrorMemoryAllocation` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMallocMipmappedArray #ifdef USE_CUDA_NAMES function hipMallocMipmappedArray_(mipmappedArray,desc,extent,numLevels,flags) & bind(c, name="cudaMallocMipmappedArray") #else function hipMallocMipmappedArray_(mipmappedArray,desc,extent,numLevels,flags) & bind(c, name="hipMallocMipmappedArray") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMallocMipmappedArray_ type(c_ptr) :: mipmappedArray type(hipChannelFormatDesc) :: desc type(hipExtent),value :: extent integer(c_int),value :: numLevels integer(c_int),value :: flags end function end interface !> @brief Frees a mipmapped array on the device. !> !> @param[in] mipmappedArray - Pointer to mipmapped array to free !> !> @return `hipSuccess`, `hipErrorInvalidValue` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipFreeMipmappedArray #ifdef USE_CUDA_NAMES function hipFreeMipmappedArray_(mipmappedArray) bind(c, name="cudaFreeMipmappedArray") #else function hipFreeMipmappedArray_(mipmappedArray) bind(c, name="hipFreeMipmappedArray") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipFreeMipmappedArray_ type(c_ptr),value :: mipmappedArray end function end interface !> @brief Gets a mipmap level of a HIP mipmapped array. !> !> @param[out] levelArray - Returned mipmap level HIP array !> @param[in] mipmappedArray - HIP mipmapped array !> @param[in] level - Mipmap level !> !> @return `hipSuccess`, `hipErrorInvalidValue` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipGetMipmappedArrayLevel #ifdef USE_CUDA_NAMES function hipGetMipmappedArrayLevel_(levelArray,mipmappedArray,level) & bind(c, name="cudaGetMipmappedArrayLevel") #else function hipGetMipmappedArrayLevel_(levelArray,mipmappedArray,level) & bind(c, name="hipGetMipmappedArrayLevel") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGetMipmappedArrayLevel_ type(c_ptr) :: levelArray type(c_ptr),value :: mipmappedArray integer(c_int),value :: level end function end interface !> @brief Create a mipmapped array. !> !> @param [out] pHandle pointer to mipmapped array !> @param [in] pMipmappedArrayDesc mipmapped array descriptor !> @param [in] numMipmapLevels mipmap level !> !> @returns `hipSuccess`, `hipErrorNotSupported`, `hipErrorInvalidValue` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. #ifndef USE_CUDA_NAMES interface hipMipmappedArrayCreate function hipMipmappedArrayCreate_(pHandle,pMipmappedArrayDesc,numMipmapLevels) & bind(c, name="hipMipmappedArrayCreate") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMipmappedArrayCreate_ type(c_ptr) :: pHandle type(HIP_ARRAY3D_DESCRIPTOR) :: pMipmappedArrayDesc integer(c_int),value :: numMipmapLevels end function end interface #endif !> @brief Destroy a mipmapped array. !> !> @param [out] hMipmappedArray pointer to mipmapped array to destroy !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. #ifndef USE_CUDA_NAMES interface hipMipmappedArrayDestroy function hipMipmappedArrayDestroy_(hMipmappedArray) bind(c, name="hipMipmappedArrayDestroy") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMipmappedArrayDestroy_ type(c_ptr),value :: hMipmappedArray end function end interface #endif !> @brief Get a mipmapped array on a mipmapped level. !> !> @param [in] pLevelArray Pointer of array !> @param [out] hMipMappedArray Pointer of mipmapped array on the requested mipmap level !> @param [out] level Mipmap level !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. #ifndef USE_CUDA_NAMES interface hipMipmappedArrayGetLevel function hipMipmappedArrayGetLevel_(pLevelArray,hMipMappedArray,level) & bind(c, name="hipMipmappedArrayGetLevel") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMipmappedArrayGetLevel_ type(c_ptr) :: pLevelArray type(c_ptr),value :: hMipMappedArray integer(c_int),value :: level end function end interface #endif !> @brief Binds a mipmapped array to a texture [Deprecated] !> !> @param [in] tex pointer to the texture reference to bind !> @param [in] mipmappedArray memory mipmapped array on the device !> @param [in] desc opointer to the channel format !> !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipBindTextureToMipmappedArray function hipBindTextureToMipmappedArray_(tex,mipmappedArray,desc) & bind(c, name="hipBindTextureToMipmappedArray") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipBindTextureToMipmappedArray_ type(textureReference) :: tex type(c_ptr),value :: mipmappedArray type(hipChannelFormatDesc) :: desc end function end interface #endif !> @brief Gets the texture reference related with the symbol [Deprecated] !> !> @param [out] texref texture reference !> @param [in] symbol pointer to the symbol related with the texture for the reference !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipGetTextureReference function hipGetTextureReference_(texref,symbol) bind(c, name="hipGetTextureReference") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGetTextureReference_ type(c_ptr) :: texref type(c_ptr),value :: symbol end function end interface #endif !> @brief Gets the border color used by a texture reference [Deprecated] !> !> @param [out] pBorderColor Returned Type and Value of RGBA color. !> @param [in] texRef Texture reference. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> @warning This API is deprecated. interface hipTexRefGetBorderColor #ifdef USE_CUDA_NAMES function hipTexRefGetBorderColor_(pBorderColor,texRef) bind(c, name="cuTexRefGetBorderColor") #else function hipTexRefGetBorderColor_(pBorderColor,texRef) bind(c, name="hipTexRefGetBorderColor") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefGetBorderColor_ type(c_ptr),value :: pBorderColor type(textureReference) :: texRef end function end interface !> @brief Gets the array bound to a texture reference [Deprecated] !> !> !> @param [in] pArray Returned array. !> @param [in] texRef texture reference. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> @warning This API is deprecated. interface hipTexRefGetArray #ifdef USE_CUDA_NAMES function hipTexRefGetArray_(pArray,texRef) bind(c, name="cuTexRefGetArray") #else function hipTexRefGetArray_(pArray,texRef) bind(c, name="hipTexRefGetArray") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefGetArray_ type(c_ptr) :: pArray type(textureReference) :: texRef end function end interface !> @brief Sets address mode for a texture reference [Deprecated] !> !> @param [in] texRef texture reference. !> @param [in] dim Dimension of the texture. !> @param [in] am Value of the texture address mode. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefSetAddressMode function hipTexRefSetAddressMode_(texRef,dim,am) bind(c, name="hipTexRefSetAddressMode") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefSetAddressMode_ type(textureReference) :: texRef integer(c_int),value :: dim integer(kind(hipAddressModeWrap)),value :: am end function end interface #endif !> @brief Binds an array as a texture reference [Deprecated] !> !> @param [in] tex Pointer texture reference. !> @param [in] array Array to bind. !> @param [in] flags Flags should be set as HIP_TRSA_OVERRIDE_FORMAT, as a valid value. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefSetArray function hipTexRefSetArray_(tex,array,flags) bind(c, name="hipTexRefSetArray") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefSetArray_ type(textureReference) :: tex type(c_ptr),value :: array integer(c_int),value :: flags end function end interface #endif !> @brief Set filter mode for a texture reference [Deprecated] !> !> @param [in] texRef Pointer texture reference. !> @param [in] fm Value of texture filter mode. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefSetFilterMode function hipTexRefSetFilterMode_(texRef,fm) bind(c, name="hipTexRefSetFilterMode") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefSetFilterMode_ type(textureReference) :: texRef integer(kind(hipFilterModePoint)),value :: fm end function end interface #endif !> @brief Set flags for a texture reference [Deprecated] !> !> @param [in] texRef Pointer texture reference. !> @param [in] Flags Value of flags. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefSetFlags function hipTexRefSetFlags_(texRef,Flags) bind(c, name="hipTexRefSetFlags") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefSetFlags_ type(textureReference) :: texRef integer(c_int),value :: Flags end function end interface #endif !> @brief Set format for a texture reference [Deprecated] !> !> @param [in] texRef Pointer texture reference. !> @param [in] fmt Value of format. !> @param [in] NumPackedComponents Number of components per array. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefSetFormat function hipTexRefSetFormat_(texRef,fmt,NumPackedComponents) bind(c, name="hipTexRefSetFormat") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefSetFormat_ type(textureReference) :: texRef integer(kind(HIP_AD_FORMAT_UNSIGNED_INT8)),value :: fmt integer(c_int),value :: NumPackedComponents end function end interface #endif !> @brief Binds a memory area to a texture [Deprecated] !> !> @param [in] offset Offset in bytes. !> @param [in] tex Texture to bind. !> @param [in] devPtr Pointer of memory on the device. !> @param [in] desc Pointer of channel format descriptor. !> @param [in] size Size of memory in bites. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipBindTexture function hipBindTexture_(offset,tex,devPtr,desc,mySize) bind(c, name="hipBindTexture") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipBindTexture_ integer(c_size_t) :: offset type(textureReference) :: tex type(c_ptr),value :: devPtr type(hipChannelFormatDesc) :: desc integer(c_size_t),value :: mySize end function end interface #endif !> @brief Binds a 2D memory area to a texture [Deprecated] !> !> @param [in] offset Offset in bytes. !> @param [in] tex Texture to bind. !> @param [in] devPtr Pointer of 2D memory area on the device. !> @param [in] desc Pointer of channel format descriptor. !> @param [in] width Width in texel units. !> @param [in] height Height in texel units. !> @param [in] pitch Pitch in bytes. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipBindTexture2D function hipBindTexture2D_(offset,tex,devPtr,desc,width,height,pitch) & bind(c, name="hipBindTexture2D") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipBindTexture2D_ integer(c_size_t) :: offset type(textureReference) :: tex type(c_ptr),value :: devPtr type(hipChannelFormatDesc) :: desc integer(c_size_t),value :: width integer(c_size_t),value :: height integer(c_size_t),value :: pitch end function end interface #endif !> @brief Binds a memory area to a texture [Deprecated] !> !> @param [in] tex Pointer of texture reference. !> @param [in] array Array to bind. !> @param [in] desc Pointer of channel format descriptor. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipBindTextureToArray function hipBindTextureToArray_(tex,array,desc) bind(c, name="hipBindTextureToArray") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipBindTextureToArray_ type(textureReference) :: tex type(c_ptr),value :: array type(hipChannelFormatDesc) :: desc end function end interface #endif !> @brief Get the offset of the alignment in a texture [Deprecated] !> !> @param [in] offset Offset in bytes. !> @param [in] texref Pointer of texture reference. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipGetTextureAlignmentOffset function hipGetTextureAlignmentOffset_(offset,texref) & bind(c, name="hipGetTextureAlignmentOffset") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGetTextureAlignmentOffset_ integer(c_size_t) :: offset type(textureReference) :: texref end function end interface #endif !> @brief Unbinds a texture [Deprecated] !> !> @param [in] tex Texture to unbind. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipUnbindTexture function hipUnbindTexture_(tex) bind(c, name="hipUnbindTexture") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipUnbindTexture_ type(textureReference) :: tex end function end interface #endif !> @brief Gets the address for a texture reference [Deprecated] !> !> @param [out] dev_ptr Pointer of device address. !> @param [in] texRef Pointer of texture reference. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefGetAddress function hipTexRefGetAddress_(dev_ptr,texRef) bind(c, name="hipTexRefGetAddress") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefGetAddress_ type(c_ptr) :: dev_ptr type(textureReference) :: texRef end function end interface #endif !> @brief Gets the address mode for a texture reference [Deprecated] !> !> @param [out] pam Pointer of address mode. !> @param [in] texRef Pointer of texture reference. !> @param [in] dim Dimension. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefGetAddressMode function hipTexRefGetAddressMode_(pam,texRef,dim) bind(c, name="hipTexRefGetAddressMode") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefGetAddressMode_ type(c_ptr),value :: pam type(textureReference) :: texRef integer(c_int),value :: dim end function end interface #endif !> @brief Gets filter mode for a texture reference [Deprecated] !> !> @param [out] pfm Pointer of filter mode. !> @param [in] texRef Pointer of texture reference. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefGetFilterMode function hipTexRefGetFilterMode_(pfm,texRef) bind(c, name="hipTexRefGetFilterMode") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefGetFilterMode_ type(c_ptr),value :: pfm type(textureReference) :: texRef end function end interface #endif !> @brief Gets flags for a texture reference [Deprecated] !> !> @param [out] pFlags Pointer of flags. !> @param [in] texRef Pointer of texture reference. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefGetFlags function hipTexRefGetFlags_(pFlags,texRef) bind(c, name="hipTexRefGetFlags") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefGetFlags_ type(c_ptr),value :: pFlags type(textureReference) :: texRef end function end interface #endif !> @brief Gets texture format for a texture reference [Deprecated] !> !> @param [out] pFormat Pointer of the format. !> @param [out] pNumChannels Pointer of number of channels. !> @param [in] texRef Pointer of texture reference. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefGetFormat function hipTexRefGetFormat_(pFormat,pNumChannels,texRef) bind(c, name="hipTexRefGetFormat") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefGetFormat_ type(c_ptr),value :: pFormat type(c_ptr),value :: pNumChannels type(textureReference) :: texRef end function end interface #endif !> @brief Gets the maximum anisotropy for a texture reference [Deprecated] !> !> @param [out] pmaxAnsio Pointer of the maximum anisotropy. !> @param [in] texRef Pointer of texture reference. !> !> @returns `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefGetMaxAnisotropy function hipTexRefGetMaxAnisotropy_(pmaxAnsio,texRef) bind(c, name="hipTexRefGetMaxAnisotropy") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefGetMaxAnisotropy_ type(c_ptr),value :: pmaxAnsio type(textureReference) :: texRef end function end interface #endif !> @brief Gets the mipmap filter mode for a texture reference [Deprecated] !> !> @param [out] pfm Pointer of the mipmap filter mode. !> @param [in] texRef Pointer of texture reference. !> !> @returns `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefGetMipmapFilterMode function hipTexRefGetMipmapFilterMode_(pfm,texRef) bind(c, name="hipTexRefGetMipmapFilterMode") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefGetMipmapFilterMode_ type(c_ptr),value :: pfm type(textureReference) :: texRef end function end interface #endif !> @brief Gets the mipmap level bias for a texture reference [Deprecated] !> !> @param [out] pbias Pointer of the mipmap level bias. !> @param [in] texRef Pointer of texture reference. !> !> @returns `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefGetMipmapLevelBias function hipTexRefGetMipmapLevelBias_(pbias,texRef) bind(c, name="hipTexRefGetMipmapLevelBias") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefGetMipmapLevelBias_ type(c_ptr),value :: pbias type(textureReference) :: texRef end function end interface #endif !> @brief Gets the minimum and maximum mipmap level clamps for a texture reference [Deprecated] !> !> @param [out] pminMipmapLevelClamp Pointer of the minimum mipmap level clamp. !> @param [out] pmaxMipmapLevelClamp Pointer of the maximum mipmap level clamp. !> @param [in] texRef Pointer of texture reference. !> !> @returns `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefGetMipmapLevelClamp function hipTexRefGetMipmapLevelClamp_(pminMipmapLevelClamp,pmaxMipmapLevelClamp,texRef) & bind(c, name="hipTexRefGetMipmapLevelClamp") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefGetMipmapLevelClamp_ type(c_ptr),value :: pminMipmapLevelClamp type(c_ptr),value :: pmaxMipmapLevelClamp type(textureReference) :: texRef end function end interface #endif !> @brief Gets the mipmapped array bound to a texture reference [Deprecated] !> !> @param [out] pArray Pointer of the mipmapped array. !> @param [in] texRef Pointer of texture reference. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefGetMipMappedArray function hipTexRefGetMipMappedArray_(pArray,texRef) bind(c, name="hipTexRefGetMipMappedArray") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefGetMipMappedArray_ type(c_ptr) :: pArray type(textureReference) :: texRef end function end interface #endif !> @brief Sets an bound address for a texture reference [Deprecated] !> !> @param [out] ByteOffset Pointer of the offset in bytes. !> @param [in] texRef Pointer of texture reference. !> @param [in] dptr Pointer of device address to bind. !> @param [in] bytes Size in bytes. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefSetAddress function hipTexRefSetAddress_(ByteOffset,texRef,dptr,bytes) bind(c, name="hipTexRefSetAddress") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefSetAddress_ integer(c_size_t) :: ByteOffset type(textureReference) :: texRef type(c_ptr),value :: dptr integer(c_size_t),value :: bytes end function end interface #endif !> @brief Set a bind an address as a 2D texture reference [Deprecated] !> !> @param [in] texRef Pointer of texture reference. !> @param [in] desc Pointer of array descriptor. !> @param [in] dptr Pointer of device address to bind. !> @param [in] Pitch Pitch in bytes. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefSetAddress2D function hipTexRefSetAddress2D_(texRef,desc,dptr,Pitch) bind(c, name="hipTexRefSetAddress2D") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefSetAddress2D_ type(textureReference) :: texRef type(HIP_ARRAY_DESCRIPTOR) :: desc type(c_ptr),value :: dptr integer(c_size_t),value :: Pitch end function end interface #endif !> @brief Sets the maximum anisotropy for a texture reference [Deprecated] !> !> @param [in] texRef Pointer of texture reference. !> @param [out] maxAniso Value of the maximum anisotropy. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefSetMaxAnisotropy function hipTexRefSetMaxAnisotropy_(texRef,maxAniso) bind(c, name="hipTexRefSetMaxAnisotropy") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefSetMaxAnisotropy_ type(textureReference) :: texRef integer(c_int),value :: maxAniso end function end interface #endif !> @brief Sets border color for a texture reference [Deprecated] !> !> @param [in] texRef Pointer of texture reference. !> @param [in] pBorderColor Pointer of border color. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefSetBorderColor function hipTexRefSetBorderColor_(texRef,pBorderColor) bind(c, name="hipTexRefSetBorderColor") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefSetBorderColor_ type(textureReference) :: texRef type(c_ptr),value :: pBorderColor end function end interface #endif !> @brief Sets mipmap filter mode for a texture reference [Deprecated] !> !> @param [in] texRef Pointer of texture reference. !> @param [in] fm Value of filter mode. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefSetMipmapFilterMode function hipTexRefSetMipmapFilterMode_(texRef,fm) bind(c, name="hipTexRefSetMipmapFilterMode") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefSetMipmapFilterMode_ type(textureReference) :: texRef integer(kind(hipFilterModePoint)),value :: fm end function end interface #endif !> @brief Sets mipmap level bias for a texture reference [Deprecated] !> !> @param [in] texRef Pointer of texture reference. !> @param [in] bias Value of mipmap bias. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefSetMipmapLevelBias function hipTexRefSetMipmapLevelBias_(texRef,bias) bind(c, name="hipTexRefSetMipmapLevelBias") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefSetMipmapLevelBias_ type(textureReference) :: texRef real(c_float),value :: bias end function end interface #endif !> @brief Sets mipmap level clamp for a texture reference [Deprecated] !> !> @param [in] texRef Pointer of texture reference. !> @param [in] minMipMapLevelClamp Value of minimum mipmap level clamp. !> @param [in] maxMipMapLevelClamp Value of maximum mipmap level clamp. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefSetMipmapLevelClamp function hipTexRefSetMipmapLevelClamp_(texRef,minMipMapLevelClamp,maxMipMapLevelClamp) & bind(c, name="hipTexRefSetMipmapLevelClamp") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefSetMipmapLevelClamp_ type(textureReference) :: texRef real(c_float),value :: minMipMapLevelClamp real(c_float),value :: maxMipMapLevelClamp end function end interface #endif !> @brief Binds mipmapped array to a texture reference [Deprecated] !> !> @param [in] texRef Pointer of texture reference to bind. !> @param [in] mipmappedArray Pointer of mipmapped array to bind. !> @param [in] Flags Flags should be set as HIP_TRSA_OVERRIDE_FORMAT, as a valid value. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @warning This API is deprecated. #ifndef USE_CUDA_NAMES interface hipTexRefSetMipmappedArray function hipTexRefSetMipmappedArray_(texRef,mipmappedArray,Flags) & bind(c, name="hipTexRefSetMipmappedArray") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipTexRefSetMipmappedArray_ type(textureReference) :: texRef type(hipMipmappedArray) :: mipmappedArray integer(c_int),value :: Flags end function end interface #endif !> @defgroup Callback Callback Activity APIs !> !> This section describes the callback/Activity of HIP runtime API. !> !> !> @brief Returns HIP API name by ID. !> !> @param [in] id ID of HIP API !> !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipApiName function hipApiName_(id) bind(c, name="hipApiName") use iso_c_binding use hipfort_enums implicit none type(c_ptr) :: hipApiName_ integer(c_int32_t),value :: id end function end interface #endif !> @brief Returns kernel name reference by function name. !> !> @param [in] f Name of function !> !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipKernelNameRef function hipKernelNameRef_(f) bind(c, name="hipKernelNameRef") use iso_c_binding use hipfort_enums implicit none type(c_ptr) :: hipKernelNameRef_ type(c_ptr),value :: f end function end interface #endif !> @brief Retrives kernel for a given host pointer, unless stated otherwise. !> !> @param [in] hostFunction Pointer of host function. !> @param [in] stream Stream the kernel is executed on. !> !> @returns The name of the passed kernel function object, or nullptr. #ifndef USE_CUDA_NAMES interface hipKernelNameRefByPtr function hipKernelNameRefByPtr_(hostFunction,stream) bind(c, name="hipKernelNameRefByPtr") use iso_c_binding use hipfort_enums implicit none type(c_ptr) :: hipKernelNameRefByPtr_ type(c_ptr),value :: hostFunction type(c_ptr),value :: stream end function end interface #endif !> @brief Returns device ID on the stream. !> !> @param [in] stream Stream of device executed on. !> !> @returns The device ID on the stream. #ifndef USE_CUDA_NAMES interface hipGetStreamDeviceId function hipGetStreamDeviceId_(stream) bind(c, name="hipGetStreamDeviceId") use iso_c_binding use hipfort_enums implicit none integer(c_int) :: hipGetStreamDeviceId_ type(c_ptr),value :: stream end function end interface #endif !> @brief Begins graph capture on a stream. !> !> @param [in] stream - Stream to initiate capture. !> @param [in] mode - Controls the interaction of this capture sequence with other API calls that !> are not safe. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipStreamBeginCapture #ifdef USE_CUDA_NAMES function hipStreamBeginCapture_(stream,mode) bind(c, name="cudaStreamBeginCapture") #else function hipStreamBeginCapture_(stream,mode) bind(c, name="hipStreamBeginCapture") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamBeginCapture_ type(c_ptr),value :: stream integer(kind(hipStreamCaptureModeGlobal)),value :: mode end function end interface !> @brief Begins graph capture on a stream to an existing graph. !> !> @param [in] stream - Stream to initiate capture. !> @param [in] graph - Graph to capture into. !> @param [in] dependencies - Dependencies of the first node captured in the stream. Can be NULL !> if !> numDependencies is 0. !> @param [in] dependencyData - Optional array of data associated with each dependency. !> @param [in] numDependencies - Number of dependencies. !> @param [in] mode - Controls the interaction of this capture sequence with other API calls that !> are not safe. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @warning param "const hipGraphEdgeData* dependencyData" is currently not supported and has to !> be !> passed as nullptr. This API is marked as beta, meaning, while this is feature complete, it is !> still !> open to changes and may have outstanding issues. interface hipStreamBeginCaptureToGraph #ifdef USE_CUDA_NAMES function hipStreamBeginCaptureToGraph_(stream,graph,dependencies,dependencyData, & numDependencies,mode) & bind(c, name="cudaStreamBeginCaptureToGraph") #else function hipStreamBeginCaptureToGraph_(stream,graph,dependencies,dependencyData, & numDependencies,mode) & bind(c, name="hipStreamBeginCaptureToGraph") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipStreamBeginCaptureToGraph_ type(c_ptr),value :: stream type(c_ptr),value :: graph type(c_ptr) :: dependencies type(hipGraphEdgeData) :: dependencyData integer(c_size_t),value :: numDependencies integer(kind(hipStreamCaptureModeGlobal)),value :: mode end function end interface !> @brief Ends capture on a stream, returning the captured graph. !> !> @param [in] stream - Stream to end capture. !> @param [out] pGraph - Captured graph. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipStreamEndCapture #ifdef USE_CUDA_NAMES function hipStreamEndCapture_(stream,pGraph) bind(c, name="cudaStreamEndCapture") #else function hipStreamEndCapture_(stream,pGraph) bind(c, name="hipStreamEndCapture") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamEndCapture_ type(c_ptr),value :: stream type(c_ptr) :: pGraph end function end interface !> @brief Get capture status of a stream. !> !> @param [in] stream - Stream of which to get capture status from. !> @param [out] pCaptureStatus - Returns current capture status. !> @param [out] pId - Unique capture ID. !> !> @returns `hipSuccess`, `hipErrorStreamCaptureImplicit` #ifndef USE_CUDA_NAMES interface hipStreamGetCaptureInfo function hipStreamGetCaptureInfo_(stream,pCaptureStatus,pId) & bind(c, name="hipStreamGetCaptureInfo") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamGetCaptureInfo_ type(c_ptr),value :: stream type(c_ptr),value :: pCaptureStatus type(c_ptr),value :: pId end function end interface #endif !> @brief Get stream's capture state !> !> @param [in] stream - Stream of which to get capture status from. !> @param [out] captureStatus_out - Returns current capture status. !> @param [out] id_out - Unique capture ID. !> @param [out] graph_out - Returns the graph being captured into. !> @param [out] dependencies_out - Pointer to an array of nodes representing the graphs !> dependencies. !> @param [out] numDependencies_out - Returns size of the array returned in dependencies_out. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorStreamCaptureImplicit` #ifndef USE_CUDA_NAMES interface hipStreamGetCaptureInfo_v2 function hipStreamGetCaptureInfo_v2_(stream,captureStatus_out,id_out,graph_out, & dependencies_out,numDependencies_out) & bind(c, name="hipStreamGetCaptureInfo_v2") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamGetCaptureInfo_v2_ type(c_ptr),value :: stream type(c_ptr),value :: captureStatus_out type(c_ptr),value :: id_out type(c_ptr) :: graph_out type(c_ptr) :: dependencies_out type(c_ptr),value :: numDependencies_out end function end interface #endif !> @brief Get stream's capture state !> !> @param [in] stream - Stream of which to get capture status from. !> @param [out] pCaptureStatus - Returns current capture status. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorStreamCaptureImplicit` interface hipStreamIsCapturing #ifdef USE_CUDA_NAMES function hipStreamIsCapturing_(stream,pCaptureStatus) bind(c, name="cudaStreamIsCapturing") #else function hipStreamIsCapturing_(stream,pCaptureStatus) bind(c, name="hipStreamIsCapturing") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamIsCapturing_ type(c_ptr),value :: stream type(c_ptr),value :: pCaptureStatus end function end interface !> @brief Update the set of dependencies in a capturing stream !> !> @param [in] stream Stream that is being captured. !> @param [in] dependencies Pointer to an array of nodes to add/replace. !> @param [in] numDependencies Size of the dependencies array. !> @param [in] flags Flag to update dependency set. Should be one of the values !> in enum `hipStreamUpdateCaptureDependenciesFlags`. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorIllegalState` interface hipStreamUpdateCaptureDependencies #ifdef USE_CUDA_NAMES function hipStreamUpdateCaptureDependencies_(stream,dependencies,numDependencies,flags) & bind(c, name="cudaStreamUpdateCaptureDependencies") #else function hipStreamUpdateCaptureDependencies_(stream,dependencies,numDependencies,flags) & bind(c, name="hipStreamUpdateCaptureDependencies") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamUpdateCaptureDependencies_ type(c_ptr),value :: stream type(c_ptr) :: dependencies integer(c_size_t),value :: numDependencies integer(c_int),value :: flags end function end interface !> @brief Swaps the stream capture mode of a thread. !> !> @param [in] mode - Pointer to mode value to swap with the current mode. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipThreadExchangeStreamCaptureMode #ifdef USE_CUDA_NAMES function hipThreadExchangeStreamCaptureMode_(mode) & bind(c, name="cudaThreadExchangeStreamCaptureMode") #else function hipThreadExchangeStreamCaptureMode_(mode) & bind(c, name="hipThreadExchangeStreamCaptureMode") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipThreadExchangeStreamCaptureMode_ type(c_ptr),value :: mode end function end interface !> @brief Creates a graph !> !> @param [out] pGraph - pointer to graph to create. !> @param [in] flags - flags for graph creation, must be 0. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorMemoryAllocation` interface hipGraphCreate #ifdef USE_CUDA_NAMES function hipGraphCreate_(pGraph,flags) bind(c, name="cudaGraphCreate") #else function hipGraphCreate_(pGraph,flags) bind(c, name="hipGraphCreate") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphCreate_ type(c_ptr) :: pGraph integer(c_int),value :: flags end function end interface !> @brief Destroys a graph !> !> @param [in] graph - instance of graph to destroy. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphDestroy #ifdef USE_CUDA_NAMES function hipGraphDestroy_(graph) bind(c, name="cudaGraphDestroy") #else function hipGraphDestroy_(graph) bind(c, name="hipGraphDestroy") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphDestroy_ type(c_ptr),value :: graph end function end interface !> @brief Adds dependency edges to a graph. !> !> @param [in] graph - Instance of the graph to add dependencies to. !> @param [in] from - Pointer to the graph nodes with dependencies to add from. !> @param [in] to - Pointer to the graph nodes to add dependencies to. !> @param [in] numDependencies - Number of dependencies to add. !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipGraphAddDependencies function hipGraphAddDependencies_(graph,from,to,numDependencies) & bind(c, name="hipGraphAddDependencies") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphAddDependencies_ type(c_ptr),value :: graph type(c_ptr) :: from type(c_ptr) :: to integer(c_size_t),value :: numDependencies end function end interface #endif !> @brief Removes dependency edges from a graph. !> !> @param [in] graph - Instance of the graph to remove dependencies from. !> @param [in] from - Array of nodes that provide the dependencies. !> @param [in] to - Array of dependent nodes. !> @param [in] numDependencies - Number of dependencies to remove. !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipGraphRemoveDependencies function hipGraphRemoveDependencies_(graph,from,to,numDependencies) & bind(c, name="hipGraphRemoveDependencies") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphRemoveDependencies_ type(c_ptr),value :: graph type(c_ptr) :: from type(c_ptr) :: to integer(c_size_t),value :: numDependencies end function end interface #endif !> @brief Returns a graph's dependency edges. !> !> @param [in] graph - Instance of the graph to get the edges from. !> @param [out] from - Pointer to the graph nodes to return edge endpoints. !> @param [out] to - Pointer to the graph nodes to return edge endpoints. !> @param [out] numEdges - Returns number of edges. !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> from and to may both be NULL, in which case this function only returns the number of edges in !> numEdges. Otherwise, numEdges entries will be filled in. If numEdges is higher than the actual !> number of edges, the remaining entries in from and to will be set to NULL, and the number of !> edges actually returned will be written to numEdges. #ifndef USE_CUDA_NAMES interface hipGraphGetEdges function hipGraphGetEdges_(graph,from,to,numEdges) bind(c, name="hipGraphGetEdges") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphGetEdges_ type(c_ptr),value :: graph type(c_ptr) :: from type(c_ptr) :: to type(c_ptr),value :: numEdges end function end interface #endif !> @brief Returns a graph's nodes. !> !> @param [in] graph - Instance of graph to get the nodes from. !> @param [out] nodes - Pointer to return the graph nodes. !> @param [out] numNodes - Returns the number of graph nodes. !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> nodes may be NULL, in which case this function will return the number of nodes in numNodes. !> Otherwise, numNodes entries will be filled in. If numNodes is higher than the actual number of !> nodes, the remaining entries in nodes will be set to NULL, and the number of nodes actually !> obtained will be returned in numNodes. interface hipGraphGetNodes #ifdef USE_CUDA_NAMES function hipGraphGetNodes_(graph,nodes,numNodes) bind(c, name="cudaGraphGetNodes") #else function hipGraphGetNodes_(graph,nodes,numNodes) bind(c, name="hipGraphGetNodes") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphGetNodes_ type(c_ptr),value :: graph type(c_ptr) :: nodes type(c_ptr),value :: numNodes end function end interface !> @brief Returns a graph's root nodes. !> !> @param [in] graph - Instance of the graph to get the nodes from. !> @param [out] pRootNodes - Pointer to return the graph's root nodes. !> @param [out] pNumRootNodes - Returns the number of graph's root nodes. !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> pRootNodes may be NULL, in which case this function will return the number of root nodes in !> pNumRootNodes. Otherwise, pNumRootNodes entries will be filled in. If pNumRootNodes is higher !> than the actual number of root nodes, the remaining entries in pRootNodes will be set to NULL, !> and the number of nodes actually obtained will be returned in pNumRootNodes. interface hipGraphGetRootNodes #ifdef USE_CUDA_NAMES function hipGraphGetRootNodes_(graph,pRootNodes,pNumRootNodes) & bind(c, name="cudaGraphGetRootNodes") #else function hipGraphGetRootNodes_(graph,pRootNodes,pNumRootNodes) & bind(c, name="hipGraphGetRootNodes") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphGetRootNodes_ type(c_ptr),value :: graph type(c_ptr) :: pRootNodes type(c_ptr),value :: pNumRootNodes end function end interface !> @brief Returns a node's dependencies. !> !> @param [in] node - Graph node to get the dependencies from. !> @param [out] pDependencies - Pointer to return the dependencies. !> @param [out] pNumDependencies - Returns the number of graph node dependencies. !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> pDependencies may be NULL, in which case this function will return the number of dependencies !> in !> pNumDependencies. Otherwise, pNumDependencies entries will be filled in. If pNumDependencies !> is !> higher than the actual number of dependencies, the remaining entries in pDependencies will be !> set !> to NULL, and the number of nodes actually obtained will be returned in pNumDependencies. #ifndef USE_CUDA_NAMES interface hipGraphNodeGetDependencies function hipGraphNodeGetDependencies_(node,pDependencies,pNumDependencies) & bind(c, name="hipGraphNodeGetDependencies") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphNodeGetDependencies_ type(c_ptr),value :: node type(c_ptr) :: pDependencies type(c_ptr),value :: pNumDependencies end function end interface #endif !> @brief Returns a node's dependent nodes. !> !> @param [in] node - Graph node to get the dependent nodes from. !> @param [out] pDependentNodes - Pointer to return the graph dependent nodes. !> @param [out] pNumDependentNodes - Returns the number of graph node dependent nodes. !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> pDependentNodes may be NULL, in which case this function will return the number of dependent !> nodes in pNumDependentNodes. Otherwise, pNumDependentNodes entries will be filled in. If !> pNumDependentNodes is higher than the actual number of dependent nodes, the remaining entries !> in !> pDependentNodes will be set to NULL, and the number of nodes actually obtained will be !> returned !> in pNumDependentNodes. #ifndef USE_CUDA_NAMES interface hipGraphNodeGetDependentNodes function hipGraphNodeGetDependentNodes_(node,pDependentNodes,pNumDependentNodes) & bind(c, name="hipGraphNodeGetDependentNodes") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphNodeGetDependentNodes_ type(c_ptr),value :: node type(c_ptr) :: pDependentNodes type(c_ptr),value :: pNumDependentNodes end function end interface #endif !> @brief Returns a node's type. !> !> @param [in] node - Node to get type of. !> @param [out] pType - Returns the node's type. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphNodeGetType #ifdef USE_CUDA_NAMES function hipGraphNodeGetType_(node,pType) bind(c, name="cudaGraphNodeGetType") #else function hipGraphNodeGetType_(node,pType) bind(c, name="hipGraphNodeGetType") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphNodeGetType_ type(c_ptr),value :: node type(c_ptr),value :: pType end function end interface !> @brief Remove a node from the graph. !> !> @param [in] node - graph node to remove !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphDestroyNode #ifdef USE_CUDA_NAMES function hipGraphDestroyNode_(node) bind(c, name="cudaGraphDestroyNode") #else function hipGraphDestroyNode_(node) bind(c, name="hipGraphDestroyNode") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphDestroyNode_ type(c_ptr),value :: node end function end interface !> @brief Clones a graph. !> !> @param [out] pGraphClone - Returns newly created cloned graph. !> @param [in] originalGraph - original graph to clone from. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorMemoryAllocation` interface hipGraphClone #ifdef USE_CUDA_NAMES function hipGraphClone_(pGraphClone,originalGraph) bind(c, name="cudaGraphClone") #else function hipGraphClone_(pGraphClone,originalGraph) bind(c, name="hipGraphClone") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphClone_ type(c_ptr) :: pGraphClone type(c_ptr),value :: originalGraph end function end interface !> @brief Finds a cloned version of a node. !> !> @param [out] pNode - Returns the cloned node. !> @param [in] originalNode - original node handle. !> @param [in] clonedGraph - Cloned graph to query. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphNodeFindInClone #ifdef USE_CUDA_NAMES function hipGraphNodeFindInClone_(pNode,originalNode,clonedGraph) & bind(c, name="cudaGraphNodeFindInClone") #else function hipGraphNodeFindInClone_(pNode,originalNode,clonedGraph) & bind(c, name="hipGraphNodeFindInClone") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphNodeFindInClone_ type(c_ptr) :: pNode type(c_ptr),value :: originalNode type(c_ptr),value :: clonedGraph end function end interface !> @brief Creates an executable graph from a graph !> !> @param [out] pGraphExec - Pointer to instantiated executable graph. !> @param [in] graph - Instance of graph to instantiate. !> @param [out] pErrorNode - Pointer to error node. In case an error occured during !> graph instantiation, it could modify the corresponding node. !> @param [out] pLogBuffer - Pointer to log buffer. !> @param [out] bufferSize - Size of the log buffer. !> !> @returns `hipSuccess`, `hipErrorOutOfMemory` #ifndef USE_CUDA_NAMES interface hipGraphInstantiate function hipGraphInstantiate_(pGraphExec,graph,pErrorNode,pLogBuffer,bufferSize) & bind(c, name="hipGraphInstantiate") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphInstantiate_ type(c_ptr) :: pGraphExec type(c_ptr),value :: graph type(c_ptr) :: pErrorNode type(c_ptr),value :: pLogBuffer integer(c_size_t),value :: bufferSize end function end interface #endif !> @brief Creates an executable graph from a graph. !> !> @param [out] pGraphExec - Pointer to instantiated executable graph. !> @param [in] graph - Instance of graph to instantiate. !> @param [in] flags - Flags to control instantiation. !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @warning This API does not support any of flag and is behaving as hipGraphInstantiate. interface hipGraphInstantiateWithFlags #ifdef USE_CUDA_NAMES function hipGraphInstantiateWithFlags_(pGraphExec,graph,flags) & bind(c, name="cudaGraphInstantiateWithFlags") #else function hipGraphInstantiateWithFlags_(pGraphExec,graph,flags) & bind(c, name="hipGraphInstantiateWithFlags") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphInstantiateWithFlags_ type(c_ptr) :: pGraphExec type(c_ptr),value :: graph integer(c_int64_t),value :: flags end function end interface !> @brief Creates an executable graph from a graph. !> !> @param [out] pGraphExec - Pointer to instantiated executable graph. !> @param [in] graph - Instance of graph to instantiate. !> @param [in] instantiateParams - Graph instantiation Params !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphInstantiateWithParams #ifdef USE_CUDA_NAMES function hipGraphInstantiateWithParams_(pGraphExec,graph,instantiateParams) & bind(c, name="cudaGraphInstantiateWithParams") #else function hipGraphInstantiateWithParams_(pGraphExec,graph,instantiateParams) & bind(c, name="hipGraphInstantiateWithParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphInstantiateWithParams_ type(c_ptr) :: pGraphExec type(c_ptr),value :: graph type(hipGraphInstantiateParams) :: instantiateParams end function end interface !> @brief Launches an executable graph in the specified stream. !> !> @param [in] graphExec - Instance of executable graph to launch. !> @param [in] stream - Instance of stream in which to launch executable graph. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphLaunch #ifdef USE_CUDA_NAMES function hipGraphLaunch_(graphExec,stream) bind(c, name="cudaGraphLaunch") #else function hipGraphLaunch_(graphExec,stream) bind(c, name="hipGraphLaunch") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphLaunch_ type(c_ptr),value :: graphExec type(c_ptr),value :: stream end function end interface !> @brief Uploads an executable graph to a stream !> !> @param [in] graphExec - Instance of executable graph to be uploaded. !> @param [in] stream - Instance of stream to which the executable graph is uploaded to. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphUpload #ifdef USE_CUDA_NAMES function hipGraphUpload_(graphExec,stream) bind(c, name="cudaGraphUpload") #else function hipGraphUpload_(graphExec,stream) bind(c, name="hipGraphUpload") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphUpload_ type(c_ptr),value :: graphExec type(c_ptr),value :: stream end function end interface !> @brief Creates a kernel execution node and adds it to a graph. !> !> @param [out] pGraphNode - Pointer to kernel graph node that is created. !> @param [in] graph - Instance of graph to add the created node to. !> @param [in] pDependencies - Pointer to the dependencies on the kernel execution node. !> @param [in] numDependencies - Number of dependencies. !> @param [in] nodeParams - Pointer to the node parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue`. interface hipGraphAddNode #ifdef USE_CUDA_NAMES function hipGraphAddNode_(pGraphNode,graph,pDependencies,numDependencies,nodeParams) & bind(c, name="cudaGraphAddNode") #else function hipGraphAddNode_(pGraphNode,graph,pDependencies,numDependencies,nodeParams) & bind(c, name="hipGraphAddNode") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphAddNode_ type(c_ptr) :: pGraphNode type(c_ptr),value :: graph type(c_ptr) :: pDependencies integer(c_size_t),value :: numDependencies type(hipGraphNodeParams) :: nodeParams end function end interface !> @brief Return the flags of an executable graph. !> !> @param [in] graphExec - Executable graph to get the flags from. !> @param [out] flags - Flags used to instantiate this executable graph. !> @returns `hipSuccess`, `hipErrorInvalidValue`. interface hipGraphExecGetFlags #ifdef USE_CUDA_NAMES function hipGraphExecGetFlags_(graphExec,flags) bind(c, name="cudaGraphExecGetFlags") #else function hipGraphExecGetFlags_(graphExec,flags) bind(c, name="hipGraphExecGetFlags") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphExecGetFlags_ type(c_ptr),value :: graphExec type(c_ptr),value :: flags end function end interface !> @brief Updates parameters of a graph's node. !> !> @param [in] node - Instance of the node to set parameters for. !> @param [in] nodeParams - Pointer to the parameters to be set. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidDeviceFunction`, !> `hipErrorNotSupported`. interface hipGraphNodeSetParams #ifdef USE_CUDA_NAMES function hipGraphNodeSetParams_(node,nodeParams) bind(c, name="cudaGraphNodeSetParams") #else function hipGraphNodeSetParams_(node,nodeParams) bind(c, name="hipGraphNodeSetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphNodeSetParams_ type(c_ptr),value :: node type(hipGraphNodeParams) :: nodeParams end function end interface !> @brief Updates parameters of an executable graph's node. !> !> @param [in] graphExec - Instance of the executable graph. !> @param [in] node - Instance of the node to set parameters to. !> @param [in] nodeParams - Pointer to the parameters to be set. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidDeviceFunction`, !> `hipErrorNotSupported`. interface hipGraphExecNodeSetParams #ifdef USE_CUDA_NAMES function hipGraphExecNodeSetParams_(graphExec,node,nodeParams) & bind(c, name="cudaGraphExecNodeSetParams") #else function hipGraphExecNodeSetParams_(graphExec,node,nodeParams) & bind(c, name="hipGraphExecNodeSetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphExecNodeSetParams_ type(c_ptr),value :: graphExec type(c_ptr),value :: node type(hipGraphNodeParams) :: nodeParams end function end interface !> @brief Destroys an executable graph !> !> @param [in] graphExec - Instance of executable graph to destroy. !> !> @returns `hipSuccess`. interface hipGraphExecDestroy #ifdef USE_CUDA_NAMES function hipGraphExecDestroy_(graphExec) bind(c, name="cudaGraphExecDestroy") #else function hipGraphExecDestroy_(graphExec) bind(c, name="hipGraphExecDestroy") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphExecDestroy_ type(c_ptr),value :: graphExec end function end interface !> @brief Check whether an executable graph can be updated with a graph and perform the update if !> * !> possible. !> !> @param [in] hGraphExec - instance of executable graph to update. !> @param [in] hGraph - graph that contains the updated parameters. !> @param [in] hErrorNode_out - node which caused the permissibility check to forbid the update. !> @param [in] updateResult_out - Return code whether the graph update was performed. !> @returns `hipSuccess`, `hipErrorGraphExecUpdateFailure` interface hipGraphExecUpdate #ifdef USE_CUDA_NAMES function hipGraphExecUpdate_(hGraphExec,hGraph,hErrorNode_out,updateResult_out) & bind(c, name="cudaGraphExecUpdate") #else function hipGraphExecUpdate_(hGraphExec,hGraph,hErrorNode_out,updateResult_out) & bind(c, name="hipGraphExecUpdate") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphExecUpdate_ type(c_ptr),value :: hGraphExec type(c_ptr),value :: hGraph type(c_ptr) :: hErrorNode_out type(c_ptr),value :: updateResult_out end function end interface !> @brief Creates a kernel execution node and adds it to a graph. !> !> @param [out] pGraphNode - Pointer to graph node that is created !> @param [in] graph - Instance of graph to add the created node to. !> @param [in] pDependencies - Pointer to the dependencies of the kernel execution node. !> @param [in] numDependencies - The number of the dependencies. !> @param [in] pNodeParams - Pointer to the parameters of the kernel execution node. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidDeviceFunction` interface hipGraphAddKernelNode #ifdef USE_CUDA_NAMES function hipGraphAddKernelNode_(pGraphNode,graph,pDependencies,numDependencies,pNodeParams) & bind(c, name="cudaGraphAddKernelNode") #else function hipGraphAddKernelNode_(pGraphNode,graph,pDependencies,numDependencies,pNodeParams) & bind(c, name="hipGraphAddKernelNode") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphAddKernelNode_ type(c_ptr) :: pGraphNode type(c_ptr),value :: graph type(c_ptr) :: pDependencies integer(c_size_t),value :: numDependencies type(hipKernelNodeParams) :: pNodeParams end function end interface !> @brief Gets kernel node's parameters. !> !> @param [in] node - instance of the node to get parameters from. !> @param [out] pNodeParams - pointer to the parameters !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphKernelNodeGetParams #ifdef USE_CUDA_NAMES function hipGraphKernelNodeGetParams_(node,pNodeParams) & bind(c, name="cudaGraphKernelNodeGetParams") #else function hipGraphKernelNodeGetParams_(node,pNodeParams) & bind(c, name="hipGraphKernelNodeGetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphKernelNodeGetParams_ type(c_ptr),value :: node type(hipKernelNodeParams) :: pNodeParams end function end interface !> @brief Sets a kernel node's parameters. !> !> @param [in] node - Instance of the node to set parameters of. !> @param [in] pNodeParams - const pointer to the parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphKernelNodeSetParams #ifdef USE_CUDA_NAMES function hipGraphKernelNodeSetParams_(node,pNodeParams) & bind(c, name="cudaGraphKernelNodeSetParams") #else function hipGraphKernelNodeSetParams_(node,pNodeParams) & bind(c, name="hipGraphKernelNodeSetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphKernelNodeSetParams_ type(c_ptr),value :: node type(hipKernelNodeParams) :: pNodeParams end function end interface !> @brief Sets the parameters for a kernel node in the given graphExec. !> !> @param [in] hGraphExec - Instance of the executable graph with the node. !> @param [in] node - Instance of the node to set parameters of. !> @param [in] pNodeParams - const pointer to the kernel node parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphExecKernelNodeSetParams #ifdef USE_CUDA_NAMES function hipGraphExecKernelNodeSetParams_(hGraphExec,node,pNodeParams) & bind(c, name="cudaGraphExecKernelNodeSetParams") #else function hipGraphExecKernelNodeSetParams_(hGraphExec,node,pNodeParams) & bind(c, name="hipGraphExecKernelNodeSetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphExecKernelNodeSetParams_ type(c_ptr),value :: hGraphExec type(c_ptr),value :: node type(hipKernelNodeParams) :: pNodeParams end function end interface !> @brief Creates a memcpy node and adds it to a graph. !> !> @param [out] phGraphNode - Pointer to graph node that is created. !> @param [in] hGraph - Instance of graph to add the created node to. !> @param [in] dependencies - const pointer to the dependencies of the memcpy execution node. !> @param [in] numDependencies - The number of dependencies. !> @param [in] copyParams - const pointer to the parameters for the memory copy. !> @param [in] ctx - context related to current device. !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipDrvGraphAddMemcpyNode function hipDrvGraphAddMemcpyNode_(phGraphNode,hGraph,dependencies,numDependencies,copyParams, & ctx) & bind(c, name="hipDrvGraphAddMemcpyNode") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipDrvGraphAddMemcpyNode_ type(c_ptr) :: phGraphNode type(c_ptr),value :: hGraph type(c_ptr) :: dependencies integer(c_size_t),value :: numDependencies type(HIP_MEMCPY3D) :: copyParams type(c_ptr),value :: ctx end function end interface #endif !> @brief Creates a memcpy node and adds it to a graph. !> !> @param [out] pGraphNode - Pointer to graph node that is created. !> @param [in] graph - Instance of graph to add the created node to. !> @param [in] pDependencies - const pointer to the dependencies of the memcpy execution node. !> @param [in] numDependencies - The number of dependencies. !> @param [in] pCopyParams - const pointer to the parameters for the memory copy. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphAddMemcpyNode #ifdef USE_CUDA_NAMES function hipGraphAddMemcpyNode_(pGraphNode,graph,pDependencies,numDependencies,pCopyParams) & bind(c, name="cudaGraphAddMemcpyNode") #else function hipGraphAddMemcpyNode_(pGraphNode,graph,pDependencies,numDependencies,pCopyParams) & bind(c, name="hipGraphAddMemcpyNode") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphAddMemcpyNode_ type(c_ptr) :: pGraphNode type(c_ptr),value :: graph type(c_ptr) :: pDependencies integer(c_size_t),value :: numDependencies type(hipMemcpy3DParms) :: pCopyParams end function end interface !> @brief Gets a memcpy node's parameters. !> !> @param [in] node - instance of the node to get parameters from. !> @param [out] pNodeParams - pointer to the parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphMemcpyNodeGetParams #ifdef USE_CUDA_NAMES function hipGraphMemcpyNodeGetParams_(node,pNodeParams) & bind(c, name="cudaGraphMemcpyNodeGetParams") #else function hipGraphMemcpyNodeGetParams_(node,pNodeParams) & bind(c, name="hipGraphMemcpyNodeGetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphMemcpyNodeGetParams_ type(c_ptr),value :: node type(hipMemcpy3DParms) :: pNodeParams end function end interface !> @brief Sets a memcpy node's parameters. !> !> @param [in] node - instance of the node to set parameters to. !> @param [in] pNodeParams - const pointer to the parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphMemcpyNodeSetParams #ifdef USE_CUDA_NAMES function hipGraphMemcpyNodeSetParams_(node,pNodeParams) & bind(c, name="cudaGraphMemcpyNodeSetParams") #else function hipGraphMemcpyNodeSetParams_(node,pNodeParams) & bind(c, name="hipGraphMemcpyNodeSetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphMemcpyNodeSetParams_ type(c_ptr),value :: node type(hipMemcpy3DParms) :: pNodeParams end function end interface !> @brief Sets a node's attribute. !> !> @param [in] hNode - Instance of the node to set parameters of. !> @param [in] attr - The attribute type to be set. !> @param [in] value - const pointer to the parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphKernelNodeSetAttribute #ifdef USE_CUDA_NAMES function hipGraphKernelNodeSetAttribute_(hNode,attr,myValue) & bind(c, name="cudaGraphKernelNodeSetAttribute") #else function hipGraphKernelNodeSetAttribute_(hNode,attr,myValue) & bind(c, name="hipGraphKernelNodeSetAttribute") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphKernelNodeSetAttribute_ type(c_ptr),value :: hNode integer(kind(hipLaunchAttributeIgnore)),value :: attr type(c_ptr),value :: myValue end function end interface !> @brief Gets a node's attribute. !> !> @param [in] hNode - Instance of the node to set parameters of. !> @param [in] attr - The attribute type to be set. !> @param [in] value - const pointer to the parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphKernelNodeGetAttribute #ifdef USE_CUDA_NAMES function hipGraphKernelNodeGetAttribute_(hNode,attr,myValue) & bind(c, name="cudaGraphKernelNodeGetAttribute") #else function hipGraphKernelNodeGetAttribute_(hNode,attr,myValue) & bind(c, name="hipGraphKernelNodeGetAttribute") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphKernelNodeGetAttribute_ type(c_ptr),value :: hNode integer(kind(hipLaunchAttributeIgnore)),value :: attr type(c_ptr),value :: myValue end function end interface !> @brief Sets the parameters of a memcpy node in the given graphExec. !> !> @param [in] hGraphExec - Instance of the executable graph with the node. !> @param [in] node - Instance of the node to set parameters of. !> @param [in] pNodeParams - const pointer to the kernel node parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphExecMemcpyNodeSetParams #ifdef USE_CUDA_NAMES function hipGraphExecMemcpyNodeSetParams_(hGraphExec,node,pNodeParams) & bind(c, name="cudaGraphExecMemcpyNodeSetParams") #else function hipGraphExecMemcpyNodeSetParams_(hGraphExec,node,pNodeParams) & bind(c, name="hipGraphExecMemcpyNodeSetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphExecMemcpyNodeSetParams_ type(c_ptr),value :: hGraphExec type(c_ptr),value :: node type(hipMemcpy3DParms) :: pNodeParams end function end interface !> @brief Creates a 1D memcpy node and adds it to a graph. !> !> @param [out] pGraphNode - Pointer to graph node that is created. !> @param [in] graph - Instance of graph to add the created node to. !> @param [in] pDependencies - const pointer to the dependencies of the memcpy execution node. !> @param [in] numDependencies - The number of dependencies. !> @param [in] dst - Pointer to memory address of the destination. !> @param [in] src - Pointer to memory address of the source. !> @param [in] count - Size of the memory to copy. !> @param [in] kind - Type of memory copy. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphAddMemcpyNode1D #ifdef USE_CUDA_NAMES function hipGraphAddMemcpyNode1D_(pGraphNode,graph,pDependencies,numDependencies,dst,src, & count,myKind) & bind(c, name="cudaGraphAddMemcpyNode1D") #else function hipGraphAddMemcpyNode1D_(pGraphNode,graph,pDependencies,numDependencies,dst,src, & count,myKind) & bind(c, name="hipGraphAddMemcpyNode1D") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphAddMemcpyNode1D_ type(c_ptr) :: pGraphNode type(c_ptr),value :: graph type(c_ptr) :: pDependencies integer(c_size_t),value :: numDependencies type(c_ptr),value :: dst type(c_ptr),value :: src integer(c_size_t),value :: count integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface !> @brief Sets a memcpy node's parameters to perform a 1-dimensional copy. !> !> @param [in] node - Instance of the node to set parameters of. !> @param [in] dst - Pointer to memory address of the destination. !> @param [in] src - Pointer to memory address of the source. !> @param [in] count - Size of the memory to copy. !> @param [in] kind - Type of memory copy. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphMemcpyNodeSetParams1D #ifdef USE_CUDA_NAMES function hipGraphMemcpyNodeSetParams1D_(node,dst,src,count,myKind) & bind(c, name="cudaGraphMemcpyNodeSetParams1D") #else function hipGraphMemcpyNodeSetParams1D_(node,dst,src,count,myKind) & bind(c, name="hipGraphMemcpyNodeSetParams1D") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphMemcpyNodeSetParams1D_ type(c_ptr),value :: node type(c_ptr),value :: dst type(c_ptr),value :: src integer(c_size_t),value :: count integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface !> @brief Sets the parameters for a memcpy node in the given graphExec to perform a 1-dimensional !> copy. !> !> @param [in] hGraphExec - Instance of the executable graph with the node. !> @param [in] node - Instance of the node to set parameters of. !> @param [in] dst - Pointer to memory address of the destination. !> @param [in] src - Pointer to memory address of the source. !> @param [in] count - Size of the memory to copy. !> @param [in] kind - Type of memory copy. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphExecMemcpyNodeSetParams1D #ifdef USE_CUDA_NAMES function hipGraphExecMemcpyNodeSetParams1D_(hGraphExec,node,dst,src,count,myKind) & bind(c, name="cudaGraphExecMemcpyNodeSetParams1D") #else function hipGraphExecMemcpyNodeSetParams1D_(hGraphExec,node,dst,src,count,myKind) & bind(c, name="hipGraphExecMemcpyNodeSetParams1D") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphExecMemcpyNodeSetParams1D_ type(c_ptr),value :: hGraphExec type(c_ptr),value :: node type(c_ptr),value :: dst type(c_ptr),value :: src integer(c_size_t),value :: count integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface !> @brief Creates a memcpy node to copy from a symbol on the device and adds it to a graph. !> !> @param [out] pGraphNode - Pointer to graph node that is created. !> @param [in] graph - Instance of graph to add the created node to. !> @param [in] pDependencies - const pointer to the dependencies of the memcpy execution node. !> @param [in] numDependencies - Number of the dependencies. !> @param [in] dst - Pointer to memory address of the destination. !> @param [in] symbol - Device symbol address. !> @param [in] count - Size of the memory to copy. !> @param [in] offset - Offset from start of symbol in bytes. !> @param [in] kind - Type of memory copy. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphAddMemcpyNodeFromSymbol #ifdef USE_CUDA_NAMES function hipGraphAddMemcpyNodeFromSymbol_(pGraphNode,graph,pDependencies,numDependencies,dst, & symbol,count,offset,myKind) & bind(c, name="cudaGraphAddMemcpyNodeFromSymbol") #else function hipGraphAddMemcpyNodeFromSymbol_(pGraphNode,graph,pDependencies,numDependencies,dst, & symbol,count,offset,myKind) & bind(c, name="hipGraphAddMemcpyNodeFromSymbol") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphAddMemcpyNodeFromSymbol_ type(c_ptr) :: pGraphNode type(c_ptr),value :: graph type(c_ptr) :: pDependencies integer(c_size_t),value :: numDependencies type(c_ptr),value :: dst type(c_ptr),value :: symbol integer(c_size_t),value :: count integer(c_size_t),value :: offset integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface !> @brief Sets a memcpy node's parameters to copy from a symbol on the device. !> !> @param [in] node - Instance of the node to set parameters of. !> @param [in] dst - Pointer to memory address of the destination. !> @param [in] symbol - Device symbol address. !> @param [in] count - Size of the memory to copy. !> @param [in] offset - Offset from start of symbol in bytes. !> @param [in] kind - Type of memory copy. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphMemcpyNodeSetParamsFromSymbol #ifdef USE_CUDA_NAMES function hipGraphMemcpyNodeSetParamsFromSymbol_(node,dst,symbol,count,offset,myKind) & bind(c, name="cudaGraphMemcpyNodeSetParamsFromSymbol") #else function hipGraphMemcpyNodeSetParamsFromSymbol_(node,dst,symbol,count,offset,myKind) & bind(c, name="hipGraphMemcpyNodeSetParamsFromSymbol") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphMemcpyNodeSetParamsFromSymbol_ type(c_ptr),value :: node type(c_ptr),value :: dst type(c_ptr),value :: symbol integer(c_size_t),value :: count integer(c_size_t),value :: offset integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface !> @brief Sets the parameters for a memcpy node in the given graphExec to copy from a symbol on !> the !> * device. !> !> @param [in] hGraphExec - Instance of the executable graph with the node. !> @param [in] node - Instance of the node to set parameters of. !> @param [in] dst - Pointer to memory address of the destination. !> @param [in] symbol - Device symbol address. !> @param [in] count - Size of the memory to copy. !> @param [in] offset - Offset from start of symbol in bytes. !> @param [in] kind - Type of memory copy. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphExecMemcpyNodeSetParamsFromSymbol #ifdef USE_CUDA_NAMES function hipGraphExecMemcpyNodeSetParamsFromSymbol_(hGraphExec,node,dst,symbol,count,offset, & myKind) & bind(c, name="cudaGraphExecMemcpyNodeSetParamsFromSymbol") #else function hipGraphExecMemcpyNodeSetParamsFromSymbol_(hGraphExec,node,dst,symbol,count,offset, & myKind) & bind(c, name="hipGraphExecMemcpyNodeSetParamsFromSymbol") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphExecMemcpyNodeSetParamsFromSymbol_ type(c_ptr),value :: hGraphExec type(c_ptr),value :: node type(c_ptr),value :: dst type(c_ptr),value :: symbol integer(c_size_t),value :: count integer(c_size_t),value :: offset integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface !> @brief Creates a memcpy node to copy to a symbol on the device and adds it to a graph. !> !> @param [out] pGraphNode - Pointer to graph node that is created. !> @param [in] graph - Instance of graph to add the created node to. !> @param [in] pDependencies - const pointer to the dependencies on the memcpy execution node. !> @param [in] numDependencies - Number of dependencies. !> @param [in] symbol - Device symbol address. !> @param [in] src - Pointer to memory address of the src. !> @param [in] count - Size of the memory to copy. !> @param [in] offset - Offset from start of symbol in bytes. !> @param [in] kind - Type of memory copy. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphAddMemcpyNodeToSymbol #ifdef USE_CUDA_NAMES function hipGraphAddMemcpyNodeToSymbol_(pGraphNode,graph,pDependencies,numDependencies,symbol, & src,count,offset,myKind) & bind(c, name="cudaGraphAddMemcpyNodeToSymbol") #else function hipGraphAddMemcpyNodeToSymbol_(pGraphNode,graph,pDependencies,numDependencies,symbol, & src,count,offset,myKind) & bind(c, name="hipGraphAddMemcpyNodeToSymbol") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphAddMemcpyNodeToSymbol_ type(c_ptr) :: pGraphNode type(c_ptr),value :: graph type(c_ptr) :: pDependencies integer(c_size_t),value :: numDependencies type(c_ptr),value :: symbol type(c_ptr),value :: src integer(c_size_t),value :: count integer(c_size_t),value :: offset integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface !> @brief Sets a memcpy node's parameters to copy to a symbol on the device. !> !> @param [in] node - Instance of the node to set parameters of. !> @param [in] symbol - Device symbol address. !> @param [in] src - Pointer to memory address of the src. !> @param [in] count - Size of the memory to copy. !> @param [in] offset - Offset from start of symbol in bytes. !> @param [in] kind - Type of memory copy. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphMemcpyNodeSetParamsToSymbol #ifdef USE_CUDA_NAMES function hipGraphMemcpyNodeSetParamsToSymbol_(node,symbol,src,count,offset,myKind) & bind(c, name="cudaGraphMemcpyNodeSetParamsToSymbol") #else function hipGraphMemcpyNodeSetParamsToSymbol_(node,symbol,src,count,offset,myKind) & bind(c, name="hipGraphMemcpyNodeSetParamsToSymbol") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphMemcpyNodeSetParamsToSymbol_ type(c_ptr),value :: node type(c_ptr),value :: symbol type(c_ptr),value :: src integer(c_size_t),value :: count integer(c_size_t),value :: offset integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface !> @brief Sets the parameters for a memcpy node in the given graphExec to copy to a symbol on the !> device. !> @param [in] hGraphExec - Instance of the executable graph with the node. !> @param [in] node - Instance of the node to set parameters of. !> @param [in] symbol - Device symbol address. !> @param [in] src - Pointer to memory address of the src. !> @param [in] count - Size of the memory to copy. !> @param [in] offset - Offset from start of symbol in bytes. !> @param [in] kind - Type of memory copy. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphExecMemcpyNodeSetParamsToSymbol #ifdef USE_CUDA_NAMES function hipGraphExecMemcpyNodeSetParamsToSymbol_(hGraphExec,node,symbol,src,count,offset, & myKind) & bind(c, name="cudaGraphExecMemcpyNodeSetParamsToSymbol") #else function hipGraphExecMemcpyNodeSetParamsToSymbol_(hGraphExec,node,symbol,src,count,offset, & myKind) & bind(c, name="hipGraphExecMemcpyNodeSetParamsToSymbol") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphExecMemcpyNodeSetParamsToSymbol_ type(c_ptr),value :: hGraphExec type(c_ptr),value :: node type(c_ptr),value :: symbol type(c_ptr),value :: src integer(c_size_t),value :: count integer(c_size_t),value :: offset integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface !> @brief Creates a memset node and adds it to a graph. !> !> @param [out] pGraphNode - Pointer to graph node that is created. !> @param [in] graph - Instance of the graph to add the created node to. !> @param [in] pDependencies - const pointer to the dependencies on the memset execution node. !> @param [in] numDependencies - Number of dependencies. !> @param [in] pMemsetParams - const pointer to the parameters for the memory set. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphAddMemsetNode #ifdef USE_CUDA_NAMES function hipGraphAddMemsetNode_(pGraphNode,graph,pDependencies,numDependencies,pMemsetParams) & bind(c, name="cudaGraphAddMemsetNode") #else function hipGraphAddMemsetNode_(pGraphNode,graph,pDependencies,numDependencies,pMemsetParams) & bind(c, name="hipGraphAddMemsetNode") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphAddMemsetNode_ type(c_ptr) :: pGraphNode type(c_ptr),value :: graph type(c_ptr) :: pDependencies integer(c_size_t),value :: numDependencies type(hipMemsetParams) :: pMemsetParams end function end interface !> @brief Gets a memset node's parameters. !> !> @param [in] node - Instance of the node to get parameters of. !> @param [out] pNodeParams - Pointer to the parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphMemsetNodeGetParams #ifdef USE_CUDA_NAMES function hipGraphMemsetNodeGetParams_(node,pNodeParams) & bind(c, name="cudaGraphMemsetNodeGetParams") #else function hipGraphMemsetNodeGetParams_(node,pNodeParams) & bind(c, name="hipGraphMemsetNodeGetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphMemsetNodeGetParams_ type(c_ptr),value :: node type(hipMemsetParams) :: pNodeParams end function end interface !> @brief Sets a memset node's parameters. !> !> @param [in] node - Instance of the node to set parameters of. !> @param [in] pNodeParams - Pointer to the parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphMemsetNodeSetParams #ifdef USE_CUDA_NAMES function hipGraphMemsetNodeSetParams_(node,pNodeParams) & bind(c, name="cudaGraphMemsetNodeSetParams") #else function hipGraphMemsetNodeSetParams_(node,pNodeParams) & bind(c, name="hipGraphMemsetNodeSetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphMemsetNodeSetParams_ type(c_ptr),value :: node type(hipMemsetParams) :: pNodeParams end function end interface !> @brief Sets the parameters for a memset node in the given graphExec. !> !> @param [in] hGraphExec - Instance of the executable graph with the node. !> @param [in] node - Instance of the node to set parameters of. !> @param [in] pNodeParams - Pointer to the parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphExecMemsetNodeSetParams #ifdef USE_CUDA_NAMES function hipGraphExecMemsetNodeSetParams_(hGraphExec,node,pNodeParams) & bind(c, name="cudaGraphExecMemsetNodeSetParams") #else function hipGraphExecMemsetNodeSetParams_(hGraphExec,node,pNodeParams) & bind(c, name="hipGraphExecMemsetNodeSetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphExecMemsetNodeSetParams_ type(c_ptr),value :: hGraphExec type(c_ptr),value :: node type(hipMemsetParams) :: pNodeParams end function end interface !> @brief Creates a host execution node and adds it to a graph. !> !> @param [out] pGraphNode - Pointer to graph node that is created. !> @param [in] graph - Instance of the graph to add the created node to. !> @param [in] pDependencies - const pointer to the dependencies of the memset execution node. !> @param [in] numDependencies - Number of dependencies. !> @param [in] pNodeParams - Pointer to the parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphAddHostNode #ifdef USE_CUDA_NAMES function hipGraphAddHostNode_(pGraphNode,graph,pDependencies,numDependencies,pNodeParams) & bind(c, name="cudaGraphAddHostNode") #else function hipGraphAddHostNode_(pGraphNode,graph,pDependencies,numDependencies,pNodeParams) & bind(c, name="hipGraphAddHostNode") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphAddHostNode_ type(c_ptr) :: pGraphNode type(c_ptr),value :: graph type(c_ptr) :: pDependencies integer(c_size_t),value :: numDependencies type(hipHostNodeParams) :: pNodeParams end function end interface !> @brief Returns a host node's parameters. !> !> @param [in] node - Instance of the node to get parameters of. !> @param [out] pNodeParams - Pointer to the parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphHostNodeGetParams #ifdef USE_CUDA_NAMES function hipGraphHostNodeGetParams_(node,pNodeParams) bind(c, name="cudaGraphHostNodeGetParams") #else function hipGraphHostNodeGetParams_(node,pNodeParams) bind(c, name="hipGraphHostNodeGetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphHostNodeGetParams_ type(c_ptr),value :: node type(hipHostNodeParams) :: pNodeParams end function end interface !> @brief Sets a host node's parameters. !> !> @param [in] node - Instance of the node to set parameters of. !> @param [in] pNodeParams - Pointer to the parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphHostNodeSetParams #ifdef USE_CUDA_NAMES function hipGraphHostNodeSetParams_(node,pNodeParams) bind(c, name="cudaGraphHostNodeSetParams") #else function hipGraphHostNodeSetParams_(node,pNodeParams) bind(c, name="hipGraphHostNodeSetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphHostNodeSetParams_ type(c_ptr),value :: node type(hipHostNodeParams) :: pNodeParams end function end interface !> @brief Sets the parameters for a host node in the given graphExec. !> !> @param [in] hGraphExec - Instance of the executable graph with the node. !> @param [in] node - Instance of the node to set parameters of. !> @param [in] pNodeParams - Pointer to the parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphExecHostNodeSetParams #ifdef USE_CUDA_NAMES function hipGraphExecHostNodeSetParams_(hGraphExec,node,pNodeParams) & bind(c, name="cudaGraphExecHostNodeSetParams") #else function hipGraphExecHostNodeSetParams_(hGraphExec,node,pNodeParams) & bind(c, name="hipGraphExecHostNodeSetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphExecHostNodeSetParams_ type(c_ptr),value :: hGraphExec type(c_ptr),value :: node type(hipHostNodeParams) :: pNodeParams end function end interface !> @brief Creates a child graph node and adds it to a graph. !> !> @param [out] pGraphNode - Pointer to graph node that is created. !> @param [in] graph - Instance of the graph to add the created node. !> @param [in] pDependencies - const pointer to the dependencies of the memset execution node. !> @param [in] numDependencies - Number of dependencies. !> @param [in] childGraph - Graph to clone into this node !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphAddChildGraphNode #ifdef USE_CUDA_NAMES function hipGraphAddChildGraphNode_(pGraphNode,graph,pDependencies,numDependencies,childGraph) & bind(c, name="cudaGraphAddChildGraphNode") #else function hipGraphAddChildGraphNode_(pGraphNode,graph,pDependencies,numDependencies,childGraph) & bind(c, name="hipGraphAddChildGraphNode") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphAddChildGraphNode_ type(c_ptr) :: pGraphNode type(c_ptr),value :: graph type(c_ptr) :: pDependencies integer(c_size_t),value :: numDependencies type(c_ptr),value :: childGraph end function end interface !> @brief Gets a handle to the embedded graph of a child graph node. !> !> @param [in] node - Instance of the node to get child graph of. !> @param [out] pGraph - Pointer to get the graph. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphChildGraphNodeGetGraph #ifdef USE_CUDA_NAMES function hipGraphChildGraphNodeGetGraph_(node,pGraph) & bind(c, name="cudaGraphChildGraphNodeGetGraph") #else function hipGraphChildGraphNodeGetGraph_(node,pGraph) & bind(c, name="hipGraphChildGraphNodeGetGraph") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphChildGraphNodeGetGraph_ type(c_ptr),value :: node type(c_ptr) :: pGraph end function end interface !> @brief Updates node parameters in the child graph node in the given graphExec. !> !> @param [in] hGraphExec - instance of the executable graph with the node. !> @param [in] node - node from the graph which was used to instantiate graphExec. !> @param [in] childGraph - child graph with updated parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphExecChildGraphNodeSetParams #ifdef USE_CUDA_NAMES function hipGraphExecChildGraphNodeSetParams_(hGraphExec,node,childGraph) & bind(c, name="cudaGraphExecChildGraphNodeSetParams") #else function hipGraphExecChildGraphNodeSetParams_(hGraphExec,node,childGraph) & bind(c, name="hipGraphExecChildGraphNodeSetParams") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphExecChildGraphNodeSetParams_ type(c_ptr),value :: hGraphExec type(c_ptr),value :: node type(c_ptr),value :: childGraph end function end interface !> @brief Creates an empty node and adds it to a graph. !> !> @param [out] pGraphNode - Pointer to graph node that is created. !> @param [in] graph - Instance of the graph the node is added to. !> @param [in] pDependencies - const pointer to the node dependencies. !> @param [in] numDependencies - Number of dependencies. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphAddEmptyNode #ifdef USE_CUDA_NAMES function hipGraphAddEmptyNode_(pGraphNode,graph,pDependencies,numDependencies) & bind(c, name="cudaGraphAddEmptyNode") #else function hipGraphAddEmptyNode_(pGraphNode,graph,pDependencies,numDependencies) & bind(c, name="hipGraphAddEmptyNode") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphAddEmptyNode_ type(c_ptr) :: pGraphNode type(c_ptr),value :: graph type(c_ptr) :: pDependencies integer(c_size_t),value :: numDependencies end function end interface !> @brief Creates an event record node and adds it to a graph. !> !> @param [out] pGraphNode - Pointer to graph node that is created. !> @param [in] graph - Instance of the graph the node is added to. !> @param [in] pDependencies - const pointer to the node dependencies. !> @param [in] numDependencies - Number of dependencies. !> @param [in] event - Event of the node. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphAddEventRecordNode #ifdef USE_CUDA_NAMES function hipGraphAddEventRecordNode_(pGraphNode,graph,pDependencies,numDependencies,event) & bind(c, name="cudaGraphAddEventRecordNode") #else function hipGraphAddEventRecordNode_(pGraphNode,graph,pDependencies,numDependencies,event) & bind(c, name="hipGraphAddEventRecordNode") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphAddEventRecordNode_ type(c_ptr) :: pGraphNode type(c_ptr),value :: graph type(c_ptr) :: pDependencies integer(c_size_t),value :: numDependencies type(c_ptr),value :: event end function end interface !> @brief Returns the event associated with an event record node. !> !> @param [in] node - Instance of the node to get event of. !> @param [out] event_out - Pointer to return the event. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphEventRecordNodeGetEvent #ifdef USE_CUDA_NAMES function hipGraphEventRecordNodeGetEvent_(node,event_out) & bind(c, name="cudaGraphEventRecordNodeGetEvent") #else function hipGraphEventRecordNodeGetEvent_(node,event_out) & bind(c, name="hipGraphEventRecordNodeGetEvent") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphEventRecordNodeGetEvent_ type(c_ptr),value :: node type(c_ptr) :: event_out end function end interface !> @brief Sets an event record node's event. !> !> @param [in] node - Instance of the node to set event to. !> @param [in] event - Pointer to the event. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphEventRecordNodeSetEvent #ifdef USE_CUDA_NAMES function hipGraphEventRecordNodeSetEvent_(node,event) & bind(c, name="cudaGraphEventRecordNodeSetEvent") #else function hipGraphEventRecordNodeSetEvent_(node,event) & bind(c, name="hipGraphEventRecordNodeSetEvent") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphEventRecordNodeSetEvent_ type(c_ptr),value :: node type(c_ptr),value :: event end function end interface !> @brief Sets the event for an event record node in the given graphExec. !> !> @param [in] hGraphExec - instance of the executable graph with the node. !> @param [in] hNode - node from the graph which was used to instantiate graphExec. !> @param [in] event - pointer to the event. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphExecEventRecordNodeSetEvent #ifdef USE_CUDA_NAMES function hipGraphExecEventRecordNodeSetEvent_(hGraphExec,hNode,event) & bind(c, name="cudaGraphExecEventRecordNodeSetEvent") #else function hipGraphExecEventRecordNodeSetEvent_(hGraphExec,hNode,event) & bind(c, name="hipGraphExecEventRecordNodeSetEvent") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphExecEventRecordNodeSetEvent_ type(c_ptr),value :: hGraphExec type(c_ptr),value :: hNode type(c_ptr),value :: event end function end interface !> @brief Creates an event wait node and adds it to a graph. !> !> @param [out] pGraphNode - Pointer to graph node that is created. !> @param [in] graph - Instance of the graph the node to be added. !> @param [in] pDependencies - const pointer to the node dependencies. !> @param [in] numDependencies - Number of dependencies. !> @param [in] event - Event for the node. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphAddEventWaitNode #ifdef USE_CUDA_NAMES function hipGraphAddEventWaitNode_(pGraphNode,graph,pDependencies,numDependencies,event) & bind(c, name="cudaGraphAddEventWaitNode") #else function hipGraphAddEventWaitNode_(pGraphNode,graph,pDependencies,numDependencies,event) & bind(c, name="hipGraphAddEventWaitNode") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphAddEventWaitNode_ type(c_ptr) :: pGraphNode type(c_ptr),value :: graph type(c_ptr) :: pDependencies integer(c_size_t),value :: numDependencies type(c_ptr),value :: event end function end interface !> @brief Returns the event associated with an event wait node. !> !> @param [in] node - Instance of the node to get event of. !> @param [out] event_out - Pointer to return the event. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphEventWaitNodeGetEvent #ifdef USE_CUDA_NAMES function hipGraphEventWaitNodeGetEvent_(node,event_out) & bind(c, name="cudaGraphEventWaitNodeGetEvent") #else function hipGraphEventWaitNodeGetEvent_(node,event_out) & bind(c, name="hipGraphEventWaitNodeGetEvent") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphEventWaitNodeGetEvent_ type(c_ptr),value :: node type(c_ptr) :: event_out end function end interface !> @brief Sets an event wait node's event. !> !> @param [in] node - Instance of the node to set event of. !> @param [in] event - Pointer to the event. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphEventWaitNodeSetEvent #ifdef USE_CUDA_NAMES function hipGraphEventWaitNodeSetEvent_(node,event) & bind(c, name="cudaGraphEventWaitNodeSetEvent") #else function hipGraphEventWaitNodeSetEvent_(node,event) & bind(c, name="hipGraphEventWaitNodeSetEvent") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphEventWaitNodeSetEvent_ type(c_ptr),value :: node type(c_ptr),value :: event end function end interface !> @brief Sets the event for an event record node in the given graphExec. !> !> @param [in] hGraphExec - instance of the executable graph with the node. !> @param [in] hNode - node from the graph which was used to instantiate graphExec. !> @param [in] event - pointer to the event. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphExecEventWaitNodeSetEvent #ifdef USE_CUDA_NAMES function hipGraphExecEventWaitNodeSetEvent_(hGraphExec,hNode,event) & bind(c, name="cudaGraphExecEventWaitNodeSetEvent") #else function hipGraphExecEventWaitNodeSetEvent_(hGraphExec,hNode,event) & bind(c, name="hipGraphExecEventWaitNodeSetEvent") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphExecEventWaitNodeSetEvent_ type(c_ptr),value :: hGraphExec type(c_ptr),value :: hNode type(c_ptr),value :: event end function end interface !> @brief Creates a memory allocation node and adds it to a graph !> !> @param [out] pGraphNode - Pointer to the graph node to create and add to the graph !> @param [in] graph - Instance of the graph node to be added !> @param [in] pDependencies - Const pointer to the node dependencies !> @param [in] numDependencies - The number of dependencies !> @param [in, out] pNodeParams - Node parameters for memory allocation, returns a pointer to the !> allocated memory. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphAddMemAllocNode #ifdef USE_CUDA_NAMES function hipGraphAddMemAllocNode_(pGraphNode,graph,pDependencies,numDependencies,pNodeParams) & bind(c, name="cudaGraphAddMemAllocNode") #else function hipGraphAddMemAllocNode_(pGraphNode,graph,pDependencies,numDependencies,pNodeParams) & bind(c, name="hipGraphAddMemAllocNode") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphAddMemAllocNode_ type(c_ptr) :: pGraphNode type(c_ptr),value :: graph type(c_ptr) :: pDependencies integer(c_size_t),value :: numDependencies type(hipMemAllocNodeParams) :: pNodeParams end function end interface !> @brief Returns parameters for memory allocation node !> !> @param [in] node - Memory allocation node to query !> @param [out] pNodeParams - Parameters for the specified memory allocation node !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphMemAllocNodeGetParams #ifdef USE_CUDA_NAMES function hipGraphMemAllocNodeGetParams_(node,pNodeParams) & bind(c, name="cudaGraphMemAllocNodeGetParams") #else function hipGraphMemAllocNodeGetParams_(node,pNodeParams) & bind(c, name="hipGraphMemAllocNodeGetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphMemAllocNodeGetParams_ type(c_ptr),value :: node type(hipMemAllocNodeParams) :: pNodeParams end function end interface !> @brief Creates a memory free node and adds it to a graph !> !> @param [out] pGraphNode - Pointer to the graph node to create and add to the graph !> @param [in] graph - Instance of the graph node to be added !> @param [in] pDependencies - Const pointer to the node dependencies !> @param [in] numDependencies - The number of dependencies !> @param [in] dev_ptr - Pointer to the memory to be freed !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphAddMemFreeNode #ifdef USE_CUDA_NAMES function hipGraphAddMemFreeNode_(pGraphNode,graph,pDependencies,numDependencies,dev_ptr) & bind(c, name="cudaGraphAddMemFreeNode") #else function hipGraphAddMemFreeNode_(pGraphNode,graph,pDependencies,numDependencies,dev_ptr) & bind(c, name="hipGraphAddMemFreeNode") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphAddMemFreeNode_ type(c_ptr) :: pGraphNode type(c_ptr),value :: graph type(c_ptr) :: pDependencies integer(c_size_t),value :: numDependencies type(c_ptr),value :: dev_ptr end function end interface !> @brief Returns parameters for memory free node !> !> @param [in] node - Memory free node to query !> @param [out] dev_ptr - Device pointer of the specified memory free node !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphMemFreeNodeGetParams #ifdef USE_CUDA_NAMES function hipGraphMemFreeNodeGetParams_(node,dev_ptr) & bind(c, name="cudaGraphMemFreeNodeGetParams") #else function hipGraphMemFreeNodeGetParams_(node,dev_ptr) & bind(c, name="hipGraphMemFreeNodeGetParams") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphMemFreeNodeGetParams_ type(c_ptr),value :: node type(c_ptr),value :: dev_ptr end function end interface !> @brief Get the mem attribute for graphs. !> !> @param [in] device - Device to get attributes from !> @param [in] attr - Attribute type to be queried !> @param [out] value - Value of the queried attribute !> @returns `hipSuccess`, `hipErrorInvalidDevice` interface hipDeviceGetGraphMemAttribute #ifdef USE_CUDA_NAMES function hipDeviceGetGraphMemAttribute_(device,attr,myValue) & bind(c, name="cudaDeviceGetGraphMemAttribute") #else function hipDeviceGetGraphMemAttribute_(device,attr,myValue) & bind(c, name="hipDeviceGetGraphMemAttribute") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceGetGraphMemAttribute_ integer(c_int),value :: device integer(kind(hipGraphMemAttrUsedMemCurrent)),value :: attr type(c_ptr),value :: myValue end function end interface !> @brief Set the mem attribute for graphs. !> !> @param [in] device - Device to set attribute of. !> @param [in] attr - Attribute type to be set. !> @param [in] value - Value of the attribute. !> @returns `hipSuccess`, `hipErrorInvalidDevice` interface hipDeviceSetGraphMemAttribute #ifdef USE_CUDA_NAMES function hipDeviceSetGraphMemAttribute_(device,attr,myValue) & bind(c, name="cudaDeviceSetGraphMemAttribute") #else function hipDeviceSetGraphMemAttribute_(device,attr,myValue) & bind(c, name="hipDeviceSetGraphMemAttribute") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceSetGraphMemAttribute_ integer(c_int),value :: device integer(kind(hipGraphMemAttrUsedMemCurrent)),value :: attr type(c_ptr),value :: myValue end function end interface !> @brief Free unused memory reserved for graphs on a specific device and return it back to the !> OS. !> !> @param [in] device - Device for which memory should be trimmed !> @returns `hipSuccess`, `hipErrorInvalidDevice` interface hipDeviceGraphMemTrim #ifdef USE_CUDA_NAMES function hipDeviceGraphMemTrim_(device) bind(c, name="cudaDeviceGraphMemTrim") #else function hipDeviceGraphMemTrim_(device) bind(c, name="hipDeviceGraphMemTrim") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDeviceGraphMemTrim_ integer(c_int),value :: device end function end interface !> @brief Create an instance of userObject to manage lifetime of a resource. !> !> @param [out] object_out - pointer to instace of userobj. !> @param [in] ptr - pointer to pass to destroy function. !> @param [in] destroy - destroy callback to remove resource. !> @param [in] initialRefcount - reference to resource. !> @param [in] flags - flags passed to API. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipUserObjectCreate #ifdef USE_CUDA_NAMES function hipUserObjectCreate_(object_out,ptr,destroy,initialRefcount,flags) & bind(c, name="cudaUserObjectCreate") #else function hipUserObjectCreate_(object_out,ptr,destroy,initialRefcount,flags) & bind(c, name="hipUserObjectCreate") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipUserObjectCreate_ type(c_ptr) :: object_out type(c_ptr),value :: ptr type(c_funptr),value :: destroy integer(c_int),value :: initialRefcount integer(c_int),value :: flags end function end interface !> @brief Release number of references to resource. !> !> @param [in] object - pointer to instace of userobj. !> @param [in] count - reference to resource to be retained. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipUserObjectRelease #ifdef USE_CUDA_NAMES function hipUserObjectRelease_(object,count) bind(c, name="cudaUserObjectRelease") #else function hipUserObjectRelease_(object,count) bind(c, name="hipUserObjectRelease") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipUserObjectRelease_ type(c_ptr),value :: object integer(c_int),value :: count end function end interface !> @brief Retain number of references to resource. !> !> @param [in] object - pointer to instace of userobj. !> @param [in] count - reference to resource to be retained. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipUserObjectRetain #ifdef USE_CUDA_NAMES function hipUserObjectRetain_(object,count) bind(c, name="cudaUserObjectRetain") #else function hipUserObjectRetain_(object,count) bind(c, name="hipUserObjectRetain") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipUserObjectRetain_ type(c_ptr),value :: object integer(c_int),value :: count end function end interface !> @brief Retain user object for graphs. !> !> @param [in] graph - pointer to graph to retain the user object for. !> @param [in] object - pointer to instace of userobj. !> @param [in] count - reference to resource to be retained. !> @param [in] flags - flags passed to API. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphRetainUserObject #ifdef USE_CUDA_NAMES function hipGraphRetainUserObject_(graph,object,count,flags) & bind(c, name="cudaGraphRetainUserObject") #else function hipGraphRetainUserObject_(graph,object,count,flags) & bind(c, name="hipGraphRetainUserObject") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphRetainUserObject_ type(c_ptr),value :: graph type(c_ptr),value :: object integer(c_int),value :: count integer(c_int),value :: flags end function end interface !> @brief Release user object from graphs. !> !> @param [in] graph - pointer to graph to retain the user object for. !> @param [in] object - pointer to instace of userobj. !> @param [in] count - reference to resource to be retained. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphReleaseUserObject #ifdef USE_CUDA_NAMES function hipGraphReleaseUserObject_(graph,object,count) & bind(c, name="cudaGraphReleaseUserObject") #else function hipGraphReleaseUserObject_(graph,object,count) & bind(c, name="hipGraphReleaseUserObject") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphReleaseUserObject_ type(c_ptr),value :: graph type(c_ptr),value :: object integer(c_int),value :: count end function end interface !> @brief Write a DOT file describing graph structure. !> !> @param [in] graph - graph object for which DOT file has to be generated. !> @param [in] path - path to write the DOT file. !> @param [in] flags - Flags from hipGraphDebugDotFlags to get additional node information. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorOperatingSystem` interface hipGraphDebugDotPrint #ifdef USE_CUDA_NAMES function hipGraphDebugDotPrint_(graph,path,flags) bind(c, name="cudaGraphDebugDotPrint") #else function hipGraphDebugDotPrint_(graph,path,flags) bind(c, name="hipGraphDebugDotPrint") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphDebugDotPrint_ type(c_ptr),value :: graph type(c_ptr),value :: path integer(c_int),value :: flags end function end interface !> @brief Copies attributes from source node to destination node. !> !> Copies attributes from source node to destination node. !> Both node must have the same context. !> !> @param [out] hDst - Destination node. !> @param [in] hSrc - Source node. !> For list of attributes see `hipKernelNodeAttrID`. !> !> @returns `hipSuccess`, `hipErrorInvalidContext` interface hipGraphKernelNodeCopyAttributes #ifdef USE_CUDA_NAMES function hipGraphKernelNodeCopyAttributes_(hSrc,hDst) & bind(c, name="cudaGraphKernelNodeCopyAttributes") #else function hipGraphKernelNodeCopyAttributes_(hSrc,hDst) & bind(c, name="hipGraphKernelNodeCopyAttributes") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphKernelNodeCopyAttributes_ type(c_ptr),value :: hSrc type(c_ptr),value :: hDst end function end interface !> @brief Enables or disables the specified node in the given graphExec !> !> Sets hNode to be either enabled or disabled. Disabled nodes are functionally equivalent !> to empty nodes until they are reenabled. Existing node parameters are not affected by !> disabling/enabling the node. !> !> The node is identified by the corresponding hNode in the non-executable graph, from which the !> executable graph was instantiated. !> !> hNode must not have been removed from the original graph. !> !> @note Currently only kernel, memset and memcpy nodes are supported. !> !> @param [in] hGraphExec - The executable graph in which to set the specified node. !> @param [in] hNode - Node from the graph from which graphExec was instantiated. !> @param [in] isEnabled - Node is enabled if != 0, otherwise the node is disabled. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, interface hipGraphNodeSetEnabled #ifdef USE_CUDA_NAMES function hipGraphNodeSetEnabled_(hGraphExec,hNode,isEnabled) & bind(c, name="cudaGraphNodeSetEnabled") #else function hipGraphNodeSetEnabled_(hGraphExec,hNode,isEnabled) & bind(c, name="hipGraphNodeSetEnabled") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphNodeSetEnabled_ type(c_ptr),value :: hGraphExec type(c_ptr),value :: hNode integer(c_int),value :: isEnabled end function end interface !> @brief Query whether a node in the given graphExec is enabled !> !> Sets isEnabled to 1 if hNode is enabled, or 0 if it is disabled. !> !> The node is identified by the corresponding node in the non-executable graph, from which the !> executable graph was instantiated. !> !> hNode must not have been removed from the original graph. !> !> @note Currently only kernel, memset and memcpy nodes are supported. !> !> @param [in] hGraphExec - The executable graph in which to set the specified node. !> @param [in] hNode - Node from the graph from which graphExec was instantiated. !> @param [out] isEnabled - Location to return the enabled status of the node. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphNodeGetEnabled #ifdef USE_CUDA_NAMES function hipGraphNodeGetEnabled_(hGraphExec,hNode,isEnabled) & bind(c, name="cudaGraphNodeGetEnabled") #else function hipGraphNodeGetEnabled_(hGraphExec,hNode,isEnabled) & bind(c, name="hipGraphNodeGetEnabled") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphNodeGetEnabled_ type(c_ptr),value :: hGraphExec type(c_ptr),value :: hNode integer(c_int) :: isEnabled end function end interface !> @brief Creates a external semaphor wait node and adds it to a graph. !> !> @param [out] pGraphNode - pointer to the graph node to create. !> @param [in] graph - instance of the graph to add the created node. !> @param [in] pDependencies - const pointer to the dependencies on the memset execution node. !> @param [in] numDependencies - the number of the dependencies. !> @param [in] nodeParams -pointer to the parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphAddExternalSemaphoresWaitNode #ifdef USE_CUDA_NAMES function hipGraphAddExternalSemaphoresWaitNode_(pGraphNode,graph,pDependencies, & numDependencies,nodeParams) & bind(c, name="cudaGraphAddExternalSemaphoresWaitNode") #else function hipGraphAddExternalSemaphoresWaitNode_(pGraphNode,graph,pDependencies, & numDependencies,nodeParams) & bind(c, name="hipGraphAddExternalSemaphoresWaitNode") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphAddExternalSemaphoresWaitNode_ type(c_ptr) :: pGraphNode type(c_ptr),value :: graph type(c_ptr) :: pDependencies integer(c_size_t),value :: numDependencies type(hipExternalSemaphoreWaitNodeParams) :: nodeParams end function end interface !> @brief Creates a external semaphor signal node and adds it to a graph. !> !> @param [out] pGraphNode - pointer to the graph node to create. !> @param [in] graph - instance of the graph to add the created node. !> @param [in] pDependencies - const pointer to the dependencies on the memset execution node. !> @param [in] numDependencies - the number of the dependencies. !> @param [in] nodeParams -pointer to the parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphAddExternalSemaphoresSignalNode #ifdef USE_CUDA_NAMES function hipGraphAddExternalSemaphoresSignalNode_(pGraphNode,graph,pDependencies, & numDependencies,nodeParams) & bind(c, name="cudaGraphAddExternalSemaphoresSignalNode") #else function hipGraphAddExternalSemaphoresSignalNode_(pGraphNode,graph,pDependencies, & numDependencies,nodeParams) & bind(c, name="hipGraphAddExternalSemaphoresSignalNode") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphAddExternalSemaphoresSignalNode_ type(c_ptr) :: pGraphNode type(c_ptr),value :: graph type(c_ptr) :: pDependencies integer(c_size_t),value :: numDependencies type(hipExternalSemaphoreSignalNodeParams) :: nodeParams end function end interface !> @brief Updates node parameters in the external semaphore signal node. !> !> @param [in] hNode - Node from the graph from which graphExec was instantiated. !> @param [in] nodeParams - Pointer to the params to be set. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphExternalSemaphoresSignalNodeSetParams #ifdef USE_CUDA_NAMES function hipGraphExternalSemaphoresSignalNodeSetParams_(hNode,nodeParams) & bind(c, name="cudaGraphExternalSemaphoresSignalNodeSetParams") #else function hipGraphExternalSemaphoresSignalNodeSetParams_(hNode,nodeParams) & bind(c, name="hipGraphExternalSemaphoresSignalNodeSetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphExternalSemaphoresSignalNodeSetParams_ type(c_ptr),value :: hNode type(hipExternalSemaphoreSignalNodeParams) :: nodeParams end function end interface !> @brief Updates node parameters in the external semaphore wait node. !> !> @param [in] hNode - Node from the graph from which graphExec was instantiated. !> @param [in] nodeParams - Pointer to the params to be set. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphExternalSemaphoresWaitNodeSetParams #ifdef USE_CUDA_NAMES function hipGraphExternalSemaphoresWaitNodeSetParams_(hNode,nodeParams) & bind(c, name="cudaGraphExternalSemaphoresWaitNodeSetParams") #else function hipGraphExternalSemaphoresWaitNodeSetParams_(hNode,nodeParams) & bind(c, name="hipGraphExternalSemaphoresWaitNodeSetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphExternalSemaphoresWaitNodeSetParams_ type(c_ptr),value :: hNode type(hipExternalSemaphoreWaitNodeParams) :: nodeParams end function end interface !> @brief Returns external semaphore signal node params. !> !> @param [in] hNode - Node from the graph from which graphExec was instantiated. !> @param [out] params_out - Pointer to params. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphExternalSemaphoresSignalNodeGetParams #ifdef USE_CUDA_NAMES function hipGraphExternalSemaphoresSignalNodeGetParams_(hNode,params_out) & bind(c, name="cudaGraphExternalSemaphoresSignalNodeGetParams") #else function hipGraphExternalSemaphoresSignalNodeGetParams_(hNode,params_out) & bind(c, name="hipGraphExternalSemaphoresSignalNodeGetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphExternalSemaphoresSignalNodeGetParams_ type(c_ptr),value :: hNode type(hipExternalSemaphoreSignalNodeParams) :: params_out end function end interface !> @brief Returns external semaphore wait node params. !> !> @param [in] hNode - Node from the graph from which graphExec was instantiated. !> @param [out] params_out - Pointer to params. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphExternalSemaphoresWaitNodeGetParams #ifdef USE_CUDA_NAMES function hipGraphExternalSemaphoresWaitNodeGetParams_(hNode,params_out) & bind(c, name="cudaGraphExternalSemaphoresWaitNodeGetParams") #else function hipGraphExternalSemaphoresWaitNodeGetParams_(hNode,params_out) & bind(c, name="hipGraphExternalSemaphoresWaitNodeGetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphExternalSemaphoresWaitNodeGetParams_ type(c_ptr),value :: hNode type(hipExternalSemaphoreWaitNodeParams) :: params_out end function end interface !> @brief Updates node parameters in the external semaphore signal node in the given graphExec. !> !> @param [in] hGraphExec - The executable graph in which to set the specified node. !> @param [in] hNode - Node from the graph from which graphExec was instantiated. !> @param [in] nodeParams - Pointer to the params to be set. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphExecExternalSemaphoresSignalNodeSetParams #ifdef USE_CUDA_NAMES function hipGraphExecExternalSemaphoresSignalNodeSetParams_(hGraphExec,hNode,nodeParams) & bind(c, name="cudaGraphExecExternalSemaphoresSignalNodeSetParams") #else function hipGraphExecExternalSemaphoresSignalNodeSetParams_(hGraphExec,hNode,nodeParams) & bind(c, name="hipGraphExecExternalSemaphoresSignalNodeSetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphExecExternalSemaphoresSignalNodeSetParams_ type(c_ptr),value :: hGraphExec type(c_ptr),value :: hNode type(hipExternalSemaphoreSignalNodeParams) :: nodeParams end function end interface !> @brief Updates node parameters in the external semaphore wait node in the given graphExec. !> !> @param [in] hGraphExec - The executable graph in which to set the specified node. !> @param [in] hNode - Node from the graph from which graphExec was instantiated. !> @param [in] nodeParams - Pointer to the params to be set. !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphExecExternalSemaphoresWaitNodeSetParams #ifdef USE_CUDA_NAMES function hipGraphExecExternalSemaphoresWaitNodeSetParams_(hGraphExec,hNode,nodeParams) & bind(c, name="cudaGraphExecExternalSemaphoresWaitNodeSetParams") #else function hipGraphExecExternalSemaphoresWaitNodeSetParams_(hGraphExec,hNode,nodeParams) & bind(c, name="hipGraphExecExternalSemaphoresWaitNodeSetParams") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipGraphExecExternalSemaphoresWaitNodeSetParams_ type(c_ptr),value :: hGraphExec type(c_ptr),value :: hNode type(hipExternalSemaphoreWaitNodeParams) :: nodeParams end function end interface !> @brief Gets a memcpy node's parameters. !> !> @param [in] hNode - instance of the node to get parameters from. !> @param [out] nodeParams - pointer to the parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipDrvGraphMemcpyNodeGetParams function hipDrvGraphMemcpyNodeGetParams_(hNode,nodeParams) & bind(c, name="hipDrvGraphMemcpyNodeGetParams") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipDrvGraphMemcpyNodeGetParams_ type(c_ptr),value :: hNode type(HIP_MEMCPY3D) :: nodeParams end function end interface #endif !> @brief Sets a memcpy node's parameters. !> !> @param [in] hNode - instance of the node to Set parameters for. !> @param [out] nodeParams - pointer to the parameters. !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipDrvGraphMemcpyNodeSetParams function hipDrvGraphMemcpyNodeSetParams_(hNode,nodeParams) & bind(c, name="hipDrvGraphMemcpyNodeSetParams") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipDrvGraphMemcpyNodeSetParams_ type(c_ptr),value :: hNode type(HIP_MEMCPY3D) :: nodeParams end function end interface #endif !> @brief Creates a memset node and adds it to a graph. !> !> @param [out] phGraphNode - pointer to graph node to create. !> @param [in] hGraph - instance of graph to add the created node to. !> @param [in] dependencies - const pointer to the dependencies on the memset execution node. !> @param [in] numDependencies - number of the dependencies. !> @param [in] memsetParams - const pointer to the parameters for the memory set. !> @param [in] ctx - cotext related to current device. !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipDrvGraphAddMemsetNode function hipDrvGraphAddMemsetNode_(phGraphNode,hGraph,dependencies,numDependencies, & memsetParams,ctx) & bind(c, name="hipDrvGraphAddMemsetNode") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipDrvGraphAddMemsetNode_ type(c_ptr) :: phGraphNode type(c_ptr),value :: hGraph type(c_ptr) :: dependencies integer(c_size_t),value :: numDependencies type(hipMemsetParams) :: memsetParams type(c_ptr),value :: ctx end function end interface #endif !> @brief Creates a memory free node and adds it to a graph !> !> @param [out] phGraphNode - Pointer to the graph node to create and add to the graph !> @param [in] hGraph - Instance of the graph the node to be added !> @param [in] dependencies - Const pointer to the node dependencies !> @param [in] numDependencies - The number of dependencies !> @param [in] dptr - Pointer to the memory to be freed !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipDrvGraphAddMemFreeNode function hipDrvGraphAddMemFreeNode_(phGraphNode,hGraph,dependencies,numDependencies,dptr) & bind(c, name="hipDrvGraphAddMemFreeNode") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDrvGraphAddMemFreeNode_ type(c_ptr) :: phGraphNode type(c_ptr),value :: hGraph type(c_ptr) :: dependencies integer(c_size_t),value :: numDependencies type(c_ptr),value :: dptr end function end interface #endif !> @brief Sets the parameters for a memcpy node in the given graphExec. !> !> @param [in] hGraphExec - instance of the executable graph with the node. !> @param [in] hNode - instance of the node to set parameters to. !> @param [in] copyParams - const pointer to the memcpy node params. !> @param [in] ctx - cotext related to current device. !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipDrvGraphExecMemcpyNodeSetParams function hipDrvGraphExecMemcpyNodeSetParams_(hGraphExec,hNode,copyParams,ctx) & bind(c, name="hipDrvGraphExecMemcpyNodeSetParams") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipDrvGraphExecMemcpyNodeSetParams_ type(c_ptr),value :: hGraphExec type(c_ptr),value :: hNode type(HIP_MEMCPY3D) :: copyParams type(c_ptr),value :: ctx end function end interface #endif !> @brief Sets the parameters for a memset node in the given graphExec. !> !> @param [in] hGraphExec - instance of the executable graph with the node. !> @param [in] hNode - instance of the node to set parameters to. !> @param [in] memsetParams - pointer to the parameters. !> @param [in] ctx - cotext related to current device. !> @returns `hipSuccess`, `hipErrorInvalidValue` #ifndef USE_CUDA_NAMES interface hipDrvGraphExecMemsetNodeSetParams function hipDrvGraphExecMemsetNodeSetParams_(hGraphExec,hNode,memsetParams,ctx) & bind(c, name="hipDrvGraphExecMemsetNodeSetParams") use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipDrvGraphExecMemsetNodeSetParams_ type(c_ptr),value :: hGraphExec type(c_ptr),value :: hNode type(hipMemsetParams) :: memsetParams type(c_ptr),value :: ctx end function end interface #endif !> @brief Frees an address range reservation made via hipMemAddressReserve !> !> @param [in] devPtr - starting address of the range. !> @param [in] size - size of the range. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemAddressFree #ifdef USE_CUDA_NAMES function hipMemAddressFree_(devPtr,mySize) bind(c, name="cuMemAddressFree") #else function hipMemAddressFree_(devPtr,mySize) bind(c, name="hipMemAddressFree") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemAddressFree_ type(c_ptr),value :: devPtr integer(c_size_t),value :: mySize end function end interface !> @brief Reserves an address range !> !> @param [out] ptr - starting address of the reserved range. !> @param [in] size - size of the reservation. !> @param [in] alignment - alignment of the address. !> @param [in] addr - requested starting address of the range. !> @param [in] flags - currently unused, must be zero. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemAddressReserve #ifdef USE_CUDA_NAMES function hipMemAddressReserve_(ptr,mySize,alignment,addr,flags) & bind(c, name="cuMemAddressReserve") #else function hipMemAddressReserve_(ptr,mySize,alignment,addr,flags) & bind(c, name="hipMemAddressReserve") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemAddressReserve_ type(c_ptr) :: ptr integer(c_size_t),value :: mySize integer(c_size_t),value :: alignment type(c_ptr),value :: addr integer(c_int64_t),value :: flags end function end interface !> @brief Creates a memory handle for the allocation described by the properties and given size !> !> @param [out] handle - value of the returned handle. !> @param [in] size - size of the allocation. !> @param [in] prop - properties of the allocation. !> @param [in] flags - currently unused, must be zero. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> This API creates a memory allocation on the target device specified through the prop !> structure. !> The prop allocation type must be specified as either `hipMemAllocationTypePinned` or !> `hipMemAllocationTypeUncached`. !> The prop location type must be specified as `hipMemLocationTypeDevice` or !> `hipMemLocationTypeHost`. !> Any other value results in `hipErrorInvalidValue`. !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemCreate #ifdef USE_CUDA_NAMES function hipMemCreate_(handle,mySize,prop,flags) bind(c, name="cuMemCreate") #else function hipMemCreate_(handle,mySize,prop,flags) bind(c, name="hipMemCreate") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemCreate_ type(c_ptr) :: handle integer(c_size_t),value :: mySize type(hipMemAllocationProp) :: prop integer(c_int64_t),value :: flags end function end interface !> @brief Exports an allocation to a requested shareable handle type. !> !> @param [out] shareableHandle - value of the returned handle. !> @param [in] handle - handle to share. !> @param [in] handleType - type of the shareable handle. !> @param [in] flags - currently unused, must be zero. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemExportToShareableHandle #ifdef USE_CUDA_NAMES function hipMemExportToShareableHandle_(shareableHandle,handle,handleType,flags) & bind(c, name="cuMemExportToShareableHandle") #else function hipMemExportToShareableHandle_(shareableHandle,handle,handleType,flags) & bind(c, name="hipMemExportToShareableHandle") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemExportToShareableHandle_ type(c_ptr),value :: shareableHandle type(c_ptr),value :: handle integer(kind(hipMemHandleTypeNone)),value :: handleType integer(c_int64_t),value :: flags end function end interface !> @brief Get the access flags set for the given location and ptr. !> !> @param [out] flags - flags for this location. !> @param [in] location - target location. !> @param [in] ptr - address to check the access flags. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemGetAccess #ifdef USE_CUDA_NAMES function hipMemGetAccess_(flags,location,ptr) bind(c, name="cuMemGetAccess") #else function hipMemGetAccess_(flags,location,ptr) bind(c, name="hipMemGetAccess") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemGetAccess_ type(c_ptr),value :: flags type(hipMemLocation) :: location type(c_ptr),value :: ptr end function end interface !> @brief Calculates either the minimal or recommended granularity. !> !> @param [out] granularity - returned granularity. !> @param [in] prop - location properties. !> @param [in] option - determines which granularity to return. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemGetAllocationGranularity #ifdef USE_CUDA_NAMES function hipMemGetAllocationGranularity_(granularity,prop,option) & bind(c, name="cuMemGetAllocationGranularity") #else function hipMemGetAllocationGranularity_(granularity,prop,option) & bind(c, name="hipMemGetAllocationGranularity") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemGetAllocationGranularity_ type(c_ptr),value :: granularity type(hipMemAllocationProp) :: prop integer(kind(hipMemAllocationGranularityMinimum)),value :: option end function end interface !> @brief Retrieve the property structure of the given handle. !> !> @param [out] prop - properties of the given handle. !> @param [in] handle - handle to perform the query on. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemGetAllocationPropertiesFromHandle #ifdef USE_CUDA_NAMES function hipMemGetAllocationPropertiesFromHandle_(prop,handle) & bind(c, name="cuMemGetAllocationPropertiesFromHandle") #else function hipMemGetAllocationPropertiesFromHandle_(prop,handle) & bind(c, name="hipMemGetAllocationPropertiesFromHandle") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemGetAllocationPropertiesFromHandle_ type(hipMemAllocationProp) :: prop type(c_ptr),value :: handle end function end interface !> @brief Imports an allocation from a requested shareable handle type. !> !> @param [out] handle - returned value. !> @param [in] osHandle - shareable handle representing the memory allocation. !> @param [in] shHandleType - handle type. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemImportFromShareableHandle #ifdef USE_CUDA_NAMES function hipMemImportFromShareableHandle_(handle,osHandle,shHandleType) & bind(c, name="cuMemImportFromShareableHandle") #else function hipMemImportFromShareableHandle_(handle,osHandle,shHandleType) & bind(c, name="hipMemImportFromShareableHandle") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemImportFromShareableHandle_ type(c_ptr) :: handle type(c_ptr),value :: osHandle integer(kind(hipMemHandleTypeNone)),value :: shHandleType end function end interface !> @brief Maps an allocation handle to a reserved virtual address range. !> !> @param [in] ptr - address where the memory will be mapped. !> @param [in] size - size of the mapping. !> @param [in] offset - offset into the memory, currently must be zero. !> @param [in] handle - memory allocation to be mapped. !> @param [in] flags - currently unused, must be zero. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemMap #ifdef USE_CUDA_NAMES function hipMemMap_(ptr,mySize,offset,handle,flags) bind(c, name="cuMemMap") #else function hipMemMap_(ptr,mySize,offset,handle,flags) bind(c, name="hipMemMap") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemMap_ type(c_ptr),value :: ptr integer(c_size_t),value :: mySize integer(c_size_t),value :: offset type(c_ptr),value :: handle integer(c_int64_t),value :: flags end function end interface !> @brief Maps or unmaps subregions of sparse HIP arrays and sparse HIP mipmapped arrays. !> !> @param [in] mapInfoList - list of hipArrayMapInfo. !> @param [in] count - number of hipArrayMapInfo in mapInfoList. !> @param [in] stream - stream identifier for the stream to use for map or unmap operations. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` interface hipMemMapArrayAsync #ifdef USE_CUDA_NAMES function hipMemMapArrayAsync_(mapInfoList,count,stream) bind(c, name="cuMemMapArrayAsync") #else function hipMemMapArrayAsync_(mapInfoList,count,stream) bind(c, name="hipMemMapArrayAsync") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemMapArrayAsync_ type(hipArrayMapInfo) :: mapInfoList integer(c_int),value :: count type(c_ptr),value :: stream end function end interface !> @brief Release a memory handle representing a memory allocation which was previously allocated !> through hipMemCreate. !> !> @param [in] handle - handle of the memory allocation. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemRelease #ifdef USE_CUDA_NAMES function hipMemRelease_(handle) bind(c, name="cuMemRelease") #else function hipMemRelease_(handle) bind(c, name="hipMemRelease") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemRelease_ type(c_ptr),value :: handle end function end interface !> @brief Returns the allocation handle of the backing memory allocation given the address. !> !> @param [out] handle - handle representing addr. !> @param [in] addr - address to look up. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemRetainAllocationHandle #ifdef USE_CUDA_NAMES function hipMemRetainAllocationHandle_(handle,addr) bind(c, name="cuMemRetainAllocationHandle") #else function hipMemRetainAllocationHandle_(handle,addr) bind(c, name="hipMemRetainAllocationHandle") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemRetainAllocationHandle_ type(c_ptr) :: handle type(c_ptr),value :: addr end function end interface !> @brief Set the access flags for each location specified in desc for the given virtual address !> range. !> !> @param [in] ptr - starting address of the virtual address range. !> @param [in] size - size of the range. !> @param [in] desc - array of hipMemAccessDesc. !> @param [in] count - number of hipMemAccessDesc in desc. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemSetAccess #ifdef USE_CUDA_NAMES function hipMemSetAccess_(ptr,mySize,desc,count) bind(c, name="cuMemSetAccess") #else function hipMemSetAccess_(ptr,mySize,desc,count) bind(c, name="hipMemSetAccess") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemSetAccess_ type(c_ptr),value :: ptr integer(c_size_t),value :: mySize type(hipMemAccessDesc) :: desc integer(c_size_t),value :: count end function end interface !> @brief Unmap memory allocation of a given address range. !> !> @param [in] ptr - starting address of the range to unmap. !> @param [in] size - size of the virtual address range. !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorNotSupported` !> !> @note This API is implemented on Linux and is under development on Microsoft Windows. interface hipMemUnmap #ifdef USE_CUDA_NAMES function hipMemUnmap_(ptr,mySize) bind(c, name="cuMemUnmap") #else function hipMemUnmap_(ptr,mySize) bind(c, name="hipMemUnmap") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemUnmap_ type(c_ptr),value :: ptr integer(c_size_t),value :: mySize end function end interface !> @brief Maps a graphics resource for access. !> !> @param [in] count - Number of resources to map. !> @param [in] resources - Pointer of resources to map. !> @param [in] stream - Stream for synchronization. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorUnknown`, !> `hipErrorInvalidResourceHandle` interface hipGraphicsMapResources #ifdef USE_CUDA_NAMES function hipGraphicsMapResources_(count,resources,stream) & bind(c, name="cudaGraphicsMapResources") #else function hipGraphicsMapResources_(count,resources,stream) & bind(c, name="hipGraphicsMapResources") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphicsMapResources_ integer(c_int),value :: count type(c_ptr) :: resources type(c_ptr),value :: stream end function end interface !> @brief Get an array through which to access a subresource of a mapped graphics resource. !> !> @param [out] array - Pointer of array through which a subresource of resource may be accessed. !> @param [in] resource - Mapped resource to access. !> @param [in] arrayIndex - Array index for the subresource to access. !> @param [in] mipLevel - Mipmap level for the subresource to access. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @note In this API, the value of arrayIndex higher than zero is currently not supported. interface hipGraphicsSubResourceGetMappedArray #ifdef USE_CUDA_NAMES function hipGraphicsSubResourceGetMappedArray_(array,resource,arrayIndex,mipLevel) & bind(c, name="cudaGraphicsSubResourceGetMappedArray") #else function hipGraphicsSubResourceGetMappedArray_(array,resource,arrayIndex,mipLevel) & bind(c, name="hipGraphicsSubResourceGetMappedArray") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphicsSubResourceGetMappedArray_ type(c_ptr) :: array type(c_ptr),value :: resource integer(c_int),value :: arrayIndex integer(c_int),value :: mipLevel end function end interface !> @brief Gets device accessible address of a graphics resource. !> !> @param [out] devPtr - Pointer of device through which graphic resource may be accessed. !> @param [out] size - Size of the buffer accessible from devPtr. !> @param [in] resource - Mapped resource to access. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipGraphicsResourceGetMappedPointer #ifdef USE_CUDA_NAMES function hipGraphicsResourceGetMappedPointer_(devPtr,mySize,resource) & bind(c, name="cudaGraphicsResourceGetMappedPointer") #else function hipGraphicsResourceGetMappedPointer_(devPtr,mySize,resource) & bind(c, name="hipGraphicsResourceGetMappedPointer") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphicsResourceGetMappedPointer_ type(c_ptr) :: devPtr type(c_ptr),value :: mySize type(c_ptr),value :: resource end function end interface !> @brief Unmaps graphics resources. !> !> @param [in] count - Number of resources to unmap. !> @param [in] resources - Pointer of resources to unmap. !> @param [in] stream - Stream for synchronization. !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorUnknown`, `hipErrorContextIsDestroyed` interface hipGraphicsUnmapResources #ifdef USE_CUDA_NAMES function hipGraphicsUnmapResources_(count,resources,stream) & bind(c, name="cudaGraphicsUnmapResources") #else function hipGraphicsUnmapResources_(count,resources,stream) & bind(c, name="hipGraphicsUnmapResources") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphicsUnmapResources_ integer(c_int),value :: count type(c_ptr) :: resources type(c_ptr),value :: stream end function end interface !> @brief Unregisters a graphics resource. !> !> @param [in] resource - Graphics resources to unregister. !> !> @returns `hipSuccess` interface hipGraphicsUnregisterResource #ifdef USE_CUDA_NAMES function hipGraphicsUnregisterResource_(resource) bind(c, name="cudaGraphicsUnregisterResource") #else function hipGraphicsUnregisterResource_(resource) bind(c, name="hipGraphicsUnregisterResource") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphicsUnregisterResource_ type(c_ptr),value :: resource end function end interface !> @brief Create a surface object. !> !> @param [out] pSurfObject Pointer of surface object to be created. !> @param [in] pResDesc Pointer of suface object descriptor. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipCreateSurfaceObject #ifdef USE_CUDA_NAMES function hipCreateSurfaceObject_(pSurfObject,pResDesc) bind(c, name="cudaCreateSurfaceObject") #else function hipCreateSurfaceObject_(pSurfObject,pResDesc) bind(c, name="hipCreateSurfaceObject") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipCreateSurfaceObject_ type(c_ptr) :: pSurfObject type(hipResourceDesc) :: pResDesc end function end interface !> @brief Destroy a surface object. !> !> @param [in] surfaceObject Surface object to be destroyed. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipDestroySurfaceObject #ifdef USE_CUDA_NAMES function hipDestroySurfaceObject_(surfaceObject) bind(c, name="cudaDestroySurfaceObject") #else function hipDestroySurfaceObject_(surfaceObject) bind(c, name="hipDestroySurfaceObject") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipDestroySurfaceObject_ type(c_ptr),value :: surfaceObject end function end interface !> @brief Enable HIP runtime logging. !> !> This function enables the HIP runtime logging mechanism, allowing diagnostic !> and trace information to be captured during HIP API execution. !> !> @returns `hipSuccess` !> !> @see hipExtDisableLogging, hipExtSetLoggingParams #ifndef USE_CUDA_NAMES interface hipExtEnableLogging function hipExtEnableLogging_() bind(c, name="hipExtEnableLogging") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipExtEnableLogging_ end function end interface #endif !> @brief Disable HIP runtime logging. !> !> This function disables the HIP runtime logging mechanism, stopping the capture !> of diagnostic and trace information during HIP API execution. !> !> @returns `hipSuccess` !> !> @see hipExtEnableLogging, hipExtSetLoggingParams #ifndef USE_CUDA_NAMES interface hipExtDisableLogging function hipExtDisableLogging_() bind(c, name="hipExtDisableLogging") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipExtDisableLogging_ end function end interface #endif !> @brief Set HIP runtime logging parameters. !> !> This function configures the logging behavior of the HIP runtime, including !> the verbosity level, buffer size, and which components to log. !> !> @param [in] log_level The logging verbosity level. Higher values produce more detailed output. !> @param [in] log_size Reserved for future use. Currently not implemented. !> @param [in] log_mask A bitmask specifying which HIP runtime components to log. !> !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @see hipExtEnableLogging, hipExtDisableLogging #ifndef USE_CUDA_NAMES interface hipExtSetLoggingParams function hipExtSetLoggingParams_(log_level,log_size,log_mask) & bind(c, name="hipExtSetLoggingParams") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipExtSetLoggingParams_ integer(c_size_t),value :: log_level integer(c_size_t),value :: log_size integer(c_size_t),value :: log_mask end function end interface #endif interface hipMemcpy_spt #ifdef USE_CUDA_NAMES function hipMemcpy_spt_(dst,src,sizeBytes,myKind) bind(c, name="cudaMemcpy_ptds") #else function hipMemcpy_spt_(dst,src,sizeBytes,myKind) bind(c, name="hipMemcpy_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpy_spt_ type(c_ptr),value :: dst type(c_ptr),value :: src integer(c_size_t),value :: sizeBytes integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface interface hipMemcpyToSymbol_spt #ifdef USE_CUDA_NAMES function hipMemcpyToSymbol_spt_(symbol,src,sizeBytes,offset,myKind) & bind(c, name="cudaMemcpyToSymbol_ptds") #else function hipMemcpyToSymbol_spt_(symbol,src,sizeBytes,offset,myKind) & bind(c, name="hipMemcpyToSymbol_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyToSymbol_spt_ type(c_ptr),value :: symbol type(c_ptr),value :: src integer(c_size_t),value :: sizeBytes integer(c_size_t),value :: offset integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface interface hipMemcpyFromSymbol_spt #ifdef USE_CUDA_NAMES function hipMemcpyFromSymbol_spt_(dst,symbol,sizeBytes,offset,myKind) & bind(c, name="cudaMemcpyFromSymbol_ptds") #else function hipMemcpyFromSymbol_spt_(dst,symbol,sizeBytes,offset,myKind) & bind(c, name="hipMemcpyFromSymbol_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyFromSymbol_spt_ type(c_ptr),value :: dst type(c_ptr),value :: symbol integer(c_size_t),value :: sizeBytes integer(c_size_t),value :: offset integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface interface hipMemcpy2D_spt #ifdef USE_CUDA_NAMES function hipMemcpy2D_spt_(dst,dpitch,src,spitch,width,height,myKind) & bind(c, name="cudaMemcpy2D_ptds") #else function hipMemcpy2D_spt_(dst,dpitch,src,spitch,width,height,myKind) & bind(c, name="hipMemcpy2D_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpy2D_spt_ type(c_ptr),value :: dst integer(c_size_t),value :: dpitch type(c_ptr),value :: src integer(c_size_t),value :: spitch integer(c_size_t),value :: width integer(c_size_t),value :: height integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface interface hipMemcpy2DFromArray_spt #ifdef USE_CUDA_NAMES function hipMemcpy2DFromArray_spt_(dst,dpitch,src,wOffset,hOffset,width,height,myKind) & bind(c, name="cudaMemcpy2DFromArray_ptds") #else function hipMemcpy2DFromArray_spt_(dst,dpitch,src,wOffset,hOffset,width,height,myKind) & bind(c, name="hipMemcpy2DFromArray_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpy2DFromArray_spt_ type(c_ptr),value :: dst integer(c_size_t),value :: dpitch type(c_ptr),value :: src integer(c_size_t),value :: wOffset integer(c_size_t),value :: hOffset integer(c_size_t),value :: width integer(c_size_t),value :: height integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface interface hipMemcpy3D_spt #ifdef USE_CUDA_NAMES function hipMemcpy3D_spt_(p) bind(c, name="cudaMemcpy3D_ptds") #else function hipMemcpy3D_spt_(p) bind(c, name="hipMemcpy3D_spt") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemcpy3D_spt_ type(hipMemcpy3DParms) :: p end function end interface interface hipMemset_spt #ifdef USE_CUDA_NAMES function hipMemset_spt_(dst,myValue,sizeBytes) bind(c, name="cudaMemset_ptds") #else function hipMemset_spt_(dst,myValue,sizeBytes) bind(c, name="hipMemset_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemset_spt_ type(c_ptr),value :: dst integer(c_int),value :: myValue integer(c_size_t),value :: sizeBytes end function end interface interface hipMemsetAsync_spt #ifdef USE_CUDA_NAMES function hipMemsetAsync_spt_(dst,myValue,sizeBytes,stream) bind(c, name="cudaMemsetAsync_ptsz") #else function hipMemsetAsync_spt_(dst,myValue,sizeBytes,stream) bind(c, name="hipMemsetAsync_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemsetAsync_spt_ type(c_ptr),value :: dst integer(c_int),value :: myValue integer(c_size_t),value :: sizeBytes type(c_ptr),value :: stream end function end interface interface hipMemset2D_spt #ifdef USE_CUDA_NAMES function hipMemset2D_spt_(dst,pitch,myValue,width,height) bind(c, name="cudaMemset2D_ptds") #else function hipMemset2D_spt_(dst,pitch,myValue,width,height) bind(c, name="hipMemset2D_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemset2D_spt_ type(c_ptr),value :: dst integer(c_size_t),value :: pitch integer(c_int),value :: myValue integer(c_size_t),value :: width integer(c_size_t),value :: height end function end interface interface hipMemset2DAsync_spt #ifdef USE_CUDA_NAMES function hipMemset2DAsync_spt_(dst,pitch,myValue,width,height,stream) & bind(c, name="cudaMemset2DAsync_ptsz") #else function hipMemset2DAsync_spt_(dst,pitch,myValue,width,height,stream) & bind(c, name="hipMemset2DAsync_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemset2DAsync_spt_ type(c_ptr),value :: dst integer(c_size_t),value :: pitch integer(c_int),value :: myValue integer(c_size_t),value :: width integer(c_size_t),value :: height type(c_ptr),value :: stream end function end interface interface hipMemset3DAsync_spt #ifdef USE_CUDA_NAMES function hipMemset3DAsync_spt_(pitchedDevPtr,myValue,extent,stream) & bind(c, name="cudaMemset3DAsync_ptsz") #else function hipMemset3DAsync_spt_(pitchedDevPtr,myValue,extent,stream) & bind(c, name="hipMemset3DAsync_spt") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemset3DAsync_spt_ type(hipPitchedPtr),value :: pitchedDevPtr integer(c_int),value :: myValue type(hipExtent),value :: extent type(c_ptr),value :: stream end function end interface interface hipMemset3D_spt #ifdef USE_CUDA_NAMES function hipMemset3D_spt_(pitchedDevPtr,myValue,extent) bind(c, name="cudaMemset3D_ptds") #else function hipMemset3D_spt_(pitchedDevPtr,myValue,extent) bind(c, name="hipMemset3D_spt") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemset3D_spt_ type(hipPitchedPtr),value :: pitchedDevPtr integer(c_int),value :: myValue type(hipExtent),value :: extent end function end interface interface hipMemcpyAsync_spt #ifdef USE_CUDA_NAMES function hipMemcpyAsync_spt_(dst,src,sizeBytes,myKind,stream) & bind(c, name="cudaMemcpyAsync_ptsz") #else function hipMemcpyAsync_spt_(dst,src,sizeBytes,myKind,stream) bind(c, name="hipMemcpyAsync_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyAsync_spt_ type(c_ptr),value :: dst type(c_ptr),value :: src integer(c_size_t),value :: sizeBytes integer(kind(hipMemcpyHostToHost)),value :: myKind type(c_ptr),value :: stream end function end interface interface hipMemcpy3DAsync_spt #ifdef USE_CUDA_NAMES function hipMemcpy3DAsync_spt_(p,stream) bind(c, name="cudaMemcpy3DAsync_ptsz") #else function hipMemcpy3DAsync_spt_(p,stream) bind(c, name="hipMemcpy3DAsync_spt") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipMemcpy3DAsync_spt_ type(hipMemcpy3DParms) :: p type(c_ptr),value :: stream end function end interface interface hipMemcpy2DAsync_spt #ifdef USE_CUDA_NAMES function hipMemcpy2DAsync_spt_(dst,dpitch,src,spitch,width,height,myKind,stream) & bind(c, name="cudaMemcpy2DAsync_ptsz") #else function hipMemcpy2DAsync_spt_(dst,dpitch,src,spitch,width,height,myKind,stream) & bind(c, name="hipMemcpy2DAsync_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpy2DAsync_spt_ type(c_ptr),value :: dst integer(c_size_t),value :: dpitch type(c_ptr),value :: src integer(c_size_t),value :: spitch integer(c_size_t),value :: width integer(c_size_t),value :: height integer(kind(hipMemcpyHostToHost)),value :: myKind type(c_ptr),value :: stream end function end interface interface hipMemcpyFromSymbolAsync_spt #ifdef USE_CUDA_NAMES function hipMemcpyFromSymbolAsync_spt_(dst,symbol,sizeBytes,offset,myKind,stream) & bind(c, name="cudaMemcpyFromSymbolAsync_ptsz") #else function hipMemcpyFromSymbolAsync_spt_(dst,symbol,sizeBytes,offset,myKind,stream) & bind(c, name="hipMemcpyFromSymbolAsync_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyFromSymbolAsync_spt_ type(c_ptr),value :: dst type(c_ptr),value :: symbol integer(c_size_t),value :: sizeBytes integer(c_size_t),value :: offset integer(kind(hipMemcpyHostToHost)),value :: myKind type(c_ptr),value :: stream end function end interface interface hipMemcpyToSymbolAsync_spt #ifdef USE_CUDA_NAMES function hipMemcpyToSymbolAsync_spt_(symbol,src,sizeBytes,offset,myKind,stream) & bind(c, name="cudaMemcpyToSymbolAsync_ptsz") #else function hipMemcpyToSymbolAsync_spt_(symbol,src,sizeBytes,offset,myKind,stream) & bind(c, name="hipMemcpyToSymbolAsync_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyToSymbolAsync_spt_ type(c_ptr),value :: symbol type(c_ptr),value :: src integer(c_size_t),value :: sizeBytes integer(c_size_t),value :: offset integer(kind(hipMemcpyHostToHost)),value :: myKind type(c_ptr),value :: stream end function end interface interface hipMemcpyFromArray_spt #ifdef USE_CUDA_NAMES function hipMemcpyFromArray_spt_(dst,src,wOffsetSrc,hOffset,count,myKind) & bind(c, name="cudaMemcpyFromArray_ptds") #else function hipMemcpyFromArray_spt_(dst,src,wOffsetSrc,hOffset,count,myKind) & bind(c, name="hipMemcpyFromArray_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpyFromArray_spt_ type(c_ptr),value :: dst type(c_ptr),value :: src integer(c_size_t),value :: wOffsetSrc integer(c_size_t),value :: hOffset integer(c_size_t),value :: count integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface interface hipMemcpy2DToArray_spt #ifdef USE_CUDA_NAMES function hipMemcpy2DToArray_spt_(dst,wOffset,hOffset,src,spitch,width,height,myKind) & bind(c, name="cudaMemcpy2DToArray_ptds") #else function hipMemcpy2DToArray_spt_(dst,wOffset,hOffset,src,spitch,width,height,myKind) & bind(c, name="hipMemcpy2DToArray_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpy2DToArray_spt_ type(c_ptr),value :: dst integer(c_size_t),value :: wOffset integer(c_size_t),value :: hOffset type(c_ptr),value :: src integer(c_size_t),value :: spitch integer(c_size_t),value :: width integer(c_size_t),value :: height integer(kind(hipMemcpyHostToHost)),value :: myKind end function end interface interface hipMemcpy2DFromArrayAsync_spt #ifdef USE_CUDA_NAMES function hipMemcpy2DFromArrayAsync_spt_(dst,dpitch,src,wOffsetSrc,hOffsetSrc,width,height, & myKind,stream) & bind(c, name="cudaMemcpy2DFromArrayAsync_ptsz") #else function hipMemcpy2DFromArrayAsync_spt_(dst,dpitch,src,wOffsetSrc,hOffsetSrc,width,height, & myKind,stream) & bind(c, name="hipMemcpy2DFromArrayAsync_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpy2DFromArrayAsync_spt_ type(c_ptr),value :: dst integer(c_size_t),value :: dpitch type(c_ptr),value :: src integer(c_size_t),value :: wOffsetSrc integer(c_size_t),value :: hOffsetSrc integer(c_size_t),value :: width integer(c_size_t),value :: height integer(kind(hipMemcpyHostToHost)),value :: myKind type(c_ptr),value :: stream end function end interface interface hipMemcpy2DToArrayAsync_spt #ifdef USE_CUDA_NAMES function hipMemcpy2DToArrayAsync_spt_(dst,wOffset,hOffset,src,spitch,width,height,myKind, & stream) & bind(c, name="cudaMemcpy2DToArrayAsync_ptsz") #else function hipMemcpy2DToArrayAsync_spt_(dst,wOffset,hOffset,src,spitch,width,height,myKind, & stream) & bind(c, name="hipMemcpy2DToArrayAsync_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipMemcpy2DToArrayAsync_spt_ type(c_ptr),value :: dst integer(c_size_t),value :: wOffset integer(c_size_t),value :: hOffset type(c_ptr),value :: src integer(c_size_t),value :: spitch integer(c_size_t),value :: width integer(c_size_t),value :: height integer(kind(hipMemcpyHostToHost)),value :: myKind type(c_ptr),value :: stream end function end interface interface hipStreamQuery_spt #ifdef USE_CUDA_NAMES function hipStreamQuery_spt_(stream) bind(c, name="cudaStreamQuery_ptsz") #else function hipStreamQuery_spt_(stream) bind(c, name="hipStreamQuery_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamQuery_spt_ type(c_ptr),value :: stream end function end interface interface hipStreamSynchronize_spt #ifdef USE_CUDA_NAMES function hipStreamSynchronize_spt_(stream) bind(c, name="cudaStreamSynchronize_ptsz") #else function hipStreamSynchronize_spt_(stream) bind(c, name="hipStreamSynchronize_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamSynchronize_spt_ type(c_ptr),value :: stream end function end interface interface hipStreamGetPriority_spt #ifdef USE_CUDA_NAMES function hipStreamGetPriority_spt_(stream,priority) bind(c, name="cudaStreamGetPriority_ptsz") #else function hipStreamGetPriority_spt_(stream,priority) bind(c, name="hipStreamGetPriority_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamGetPriority_spt_ type(c_ptr),value :: stream type(c_ptr),value :: priority end function end interface interface hipStreamWaitEvent_spt #ifdef USE_CUDA_NAMES function hipStreamWaitEvent_spt_(stream,event,flags) bind(c, name="cudaStreamWaitEvent_ptsz") #else function hipStreamWaitEvent_spt_(stream,event,flags) bind(c, name="hipStreamWaitEvent_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamWaitEvent_spt_ type(c_ptr),value :: stream type(c_ptr),value :: event integer(c_int),value :: flags end function end interface interface hipStreamGetFlags_spt #ifdef USE_CUDA_NAMES function hipStreamGetFlags_spt_(stream,flags) bind(c, name="cudaStreamGetFlags_ptsz") #else function hipStreamGetFlags_spt_(stream,flags) bind(c, name="hipStreamGetFlags_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamGetFlags_spt_ type(c_ptr),value :: stream type(c_ptr),value :: flags end function end interface interface hipStreamAddCallback_spt #ifdef USE_CUDA_NAMES function hipStreamAddCallback_spt_(stream,callback,userData,flags) & bind(c, name="cudaStreamAddCallback_ptsz") #else function hipStreamAddCallback_spt_(stream,callback,userData,flags) & bind(c, name="hipStreamAddCallback_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamAddCallback_spt_ type(c_ptr),value :: stream type(c_funptr),value :: callback type(c_ptr),value :: userData integer(c_int),value :: flags end function end interface interface hipEventRecord_spt #ifdef USE_CUDA_NAMES function hipEventRecord_spt_(event,stream) bind(c, name="cudaEventRecord_ptsz") #else function hipEventRecord_spt_(event,stream) bind(c, name="hipEventRecord_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipEventRecord_spt_ type(c_ptr),value :: event type(c_ptr),value :: stream end function end interface interface hipLaunchCooperativeKernel_spt #ifdef USE_CUDA_NAMES function hipLaunchCooperativeKernel_spt_(f,gridDim,blockDim,kernelParams,sharedMemBytes, & hStream) & bind(c, name="cudaLaunchCooperativeKernel_ptsz") #else function hipLaunchCooperativeKernel_spt_(f,gridDim,blockDim,kernelParams,sharedMemBytes, & hStream) & bind(c, name="hipLaunchCooperativeKernel_spt") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipLaunchCooperativeKernel_spt_ type(c_ptr),value :: f type(dim3),value :: gridDim type(dim3),value :: blockDim type(c_ptr) :: kernelParams integer(c_int32_t),value :: sharedMemBytes type(c_ptr),value :: hStream end function end interface interface hipLaunchKernel_spt #ifdef USE_CUDA_NAMES function hipLaunchKernel_spt_(function_address,numBlocks,dimBlocks,args,sharedMemBytes,stream) & bind(c, name="cudaLaunchKernel_ptsz") #else function hipLaunchKernel_spt_(function_address,numBlocks,dimBlocks,args,sharedMemBytes,stream) & bind(c, name="hipLaunchKernel_spt") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipLaunchKernel_spt_ type(c_ptr),value :: function_address type(dim3),value :: numBlocks type(dim3),value :: dimBlocks type(c_ptr) :: args integer(c_size_t),value :: sharedMemBytes type(c_ptr),value :: stream end function end interface interface hipGraphLaunch_spt #ifdef USE_CUDA_NAMES function hipGraphLaunch_spt_(graphExec,stream) bind(c, name="cudaGraphLaunch_ptsz") #else function hipGraphLaunch_spt_(graphExec,stream) bind(c, name="hipGraphLaunch_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGraphLaunch_spt_ type(c_ptr),value :: graphExec type(c_ptr),value :: stream end function end interface interface hipStreamBeginCapture_spt #ifdef USE_CUDA_NAMES function hipStreamBeginCapture_spt_(stream,mode) bind(c, name="cudaStreamBeginCapture_ptsz") #else function hipStreamBeginCapture_spt_(stream,mode) bind(c, name="hipStreamBeginCapture_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamBeginCapture_spt_ type(c_ptr),value :: stream integer(kind(hipStreamCaptureModeGlobal)),value :: mode end function end interface interface hipStreamEndCapture_spt #ifdef USE_CUDA_NAMES function hipStreamEndCapture_spt_(stream,pGraph) bind(c, name="cudaStreamEndCapture_ptsz") #else function hipStreamEndCapture_spt_(stream,pGraph) bind(c, name="hipStreamEndCapture_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamEndCapture_spt_ type(c_ptr),value :: stream type(c_ptr) :: pGraph end function end interface interface hipStreamIsCapturing_spt #ifdef USE_CUDA_NAMES function hipStreamIsCapturing_spt_(stream,pCaptureStatus) & bind(c, name="cudaStreamIsCapturing_ptsz") #else function hipStreamIsCapturing_spt_(stream,pCaptureStatus) & bind(c, name="hipStreamIsCapturing_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamIsCapturing_spt_ type(c_ptr),value :: stream type(c_ptr),value :: pCaptureStatus end function end interface interface hipStreamGetCaptureInfo_spt #ifdef USE_CUDA_NAMES function hipStreamGetCaptureInfo_spt_(stream,pCaptureStatus,pId) & bind(c, name="cudaStreamGetCaptureInfo_ptsz") #else function hipStreamGetCaptureInfo_spt_(stream,pCaptureStatus,pId) & bind(c, name="hipStreamGetCaptureInfo_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamGetCaptureInfo_spt_ type(c_ptr),value :: stream type(c_ptr),value :: pCaptureStatus type(c_ptr),value :: pId end function end interface interface hipStreamGetCaptureInfo_v2_spt #ifdef USE_CUDA_NAMES function hipStreamGetCaptureInfo_v2_spt_(stream,captureStatus_out,id_out,graph_out, & dependencies_out,numDependencies_out) & bind(c, name="cuStreamGetCaptureInfo_v2_ptsz") #else function hipStreamGetCaptureInfo_v2_spt_(stream,captureStatus_out,id_out,graph_out, & dependencies_out,numDependencies_out) & bind(c, name="hipStreamGetCaptureInfo_v2_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipStreamGetCaptureInfo_v2_spt_ type(c_ptr),value :: stream type(c_ptr),value :: captureStatus_out type(c_ptr),value :: id_out type(c_ptr) :: graph_out type(c_ptr) :: dependencies_out type(c_ptr),value :: numDependencies_out end function end interface interface hipLaunchHostFunc_spt #ifdef USE_CUDA_NAMES function hipLaunchHostFunc_spt_(stream,fn,userData) bind(c, name="cudaLaunchHostFunc_ptsz") #else function hipLaunchHostFunc_spt_(stream,fn,userData) bind(c, name="hipLaunchHostFunc_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipLaunchHostFunc_spt_ type(c_ptr),value :: stream type(c_funptr),value :: fn type(c_ptr),value :: userData end function end interface interface hipGetDriverEntryPoint_spt #ifdef USE_CUDA_NAMES function hipGetDriverEntryPoint_spt_(symbol,funcPtr,flags,status) & bind(c, name="cudaGetDriverEntryPoint_ptsz") #else function hipGetDriverEntryPoint_spt_(symbol,funcPtr,flags,status) & bind(c, name="hipGetDriverEntryPoint_spt") #endif use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGetDriverEntryPoint_spt_ type(c_ptr),value :: symbol type(c_ptr) :: funcPtr integer(c_int64_t),value :: flags type(c_ptr),value :: status end function end interface #ifndef USE_CUDA_NAMES interface hipGetProcAddress_spt function hipGetProcAddress_spt_(symbol,pfn,hipVersion,flags,symbolStatus) & bind(c, name="hipGetProcAddress_spt") use iso_c_binding use hipfort_enums implicit none integer(kind(hipSuccess)) :: hipGetProcAddress_spt_ type(c_ptr),value :: symbol type(c_ptr) :: pfn integer(c_int),value :: hipVersion integer(c_int64_t),value :: flags type(c_ptr),value :: symbolStatus end function end interface #endif !> @brief Device which matches hipDeviceProp_t is returned !> !> @param [out] device Pointer of the device !> @param [in] prop Pointer of the properties !> !> @returns `hipSuccess`, `hipErrorInvalidValue` interface hipChooseDevice #ifdef USE_CUDA_NAMES function hipChooseDevice_(device,prop) bind(c, name="cudaChooseDevice") #else function hipChooseDevice_(device,prop) bind(c, name="hipChooseDeviceR0600") #endif use iso_c_binding use hipfort_enums use hipfort_types implicit none integer(kind(hipSuccess)) :: hipChooseDevice_ type(c_ptr),value :: device type(hipDeviceProp_t) :: prop end function end interface end module hipfort hipfort-rocm-10.0.0/lib/hipfort/hipfort_auxiliary.F90000066400000000000000000000052761524740623400224650ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_auxiliary !> @brief Returns device properties. !> !> @param [out] prop written with device properties !> @param [in] deviceId which device to query for information !> !> @returns `hipSuccess`, `hipErrorInvalidDevice` !> @bug HIP-Clang always returns 0 for maxThreadsPerMultiProcessor !> @bug HIP-Clang always returns 0 for regsPerBlock !> @bug HIP-Clang always returns 0 for l2CacheSize !> !> Populates hipGetDeviceProperties with information for the specified device. interface hipGetDeviceProperties #ifdef USE_CUDA_NAMES function hipGetDeviceProperties_(prop,deviceId) bind(c, name="cudaGetDeviceProperties") #else function hipGetDeviceProperties_(prop,deviceId) bind(c, name="hipGetDevicePropertiesR0600") #endif use iso_c_binding #ifdef USE_CUDA_NAMES use hipfort_cuda_errors #endif use hipfort_enums use hipfort_types implicit none #ifdef USE_CUDA_NAMES integer(kind(cudaSuccess)) :: hipGetDeviceProperties_ #else integer(kind(hipSuccess)) :: hipGetDeviceProperties_ #endif type(hipDeviceProp_t),intent(out) :: prop integer(c_int),value :: deviceId end function end interface end module hipfort_auxiliary hipfort-rocm-10.0.0/lib/hipfort/hipfort_check.F90000066400000000000000000000121411524740623400215200ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_check implicit none contains subroutine hipCheck(status) #ifdef USE_CUDA_NAMES use hipfort_cuda_errors, only: cudaSuccess implicit none integer(kind(cudaSuccess)) :: status if (status /= cudaSuccess) then #else use hipfort_enums, only: HIP_SUCCESS implicit none integer(kind(HIP_SUCCESS)) :: status if (status /= HIP_SUCCESS) then #endif write (*, *) "HIP ERROR: code = ", status stop 1 end if end subroutine hipCheck subroutine hipblasCheck(status) use hipfort_hipblas_enums, only: HIPBLAS_STATUS_SUCCESS implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: status if (status /= HIPBLAS_STATUS_SUCCESS) then write (*, *) "HIPBLAS ERROR: code = ", status stop 1 end if end subroutine hipblasCheck subroutine hipfftCheck(status) use hipfort_hipfft_enums, only: HIPFFT_SUCCESS implicit none integer(kind(HIPFFT_SUCCESS)) :: status if (status /= HIPFFT_SUCCESS) then write (*, *) "HIPFFT ERROR: code = ", status stop 1 end if end subroutine hipfftCheck subroutine hiprandCheck(status) use hipfort_hiprand_enums, only: HIPRAND_STATUS_SUCCESS implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: status if (status /= HIPRAND_STATUS_SUCCESS) then write (*, *) "HIPRAND ERROR: code = ", status stop 1 end if end subroutine hiprandCheck subroutine hipsolverCheck(status) use hipfort_hipsolver_enums, only: HIPSOLVER_STATUS_SUCCESS implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: status if (status /= HIPSOLVER_STATUS_SUCCESS) then write (*, *) "HIPSOLVER ERROR: code = ", status stop 1 end if end subroutine hipsolverCheck subroutine hipsparseCheck(status) use hipfort_hipsparse_enums, only: HIPSPARSE_STATUS_SUCCESS implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: status if (status /= HIPSPARSE_STATUS_SUCCESS) then write (*, *) "HIPSPARSE ERROR: code = ", status stop 1 end if end subroutine hipsparseCheck subroutine rocblasCheck(status) use hipfort_rocblas_enums, only: rocblas_status_success implicit none integer(kind(rocblas_status_success)) :: status if (status /= rocblas_status_success) then write (*, *) "ROCBLAS ERROR: code = ", status stop 1 end if end subroutine rocblasCheck subroutine rocfftCheck(status) use hipfort_rocfft_enums, only: rocfft_status_success implicit none integer(kind(rocfft_status_success)) :: status if (status /= rocfft_status_success) then write (*, *) "ROCFFT ERROR: code = ", status stop 1 end if end subroutine rocfftCheck subroutine rocrandCheck(status) use hipfort_rocrand_enums, only: ROCRAND_STATUS_SUCCESS implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: status if (status /= ROCRAND_STATUS_SUCCESS) then write (*, *) "ROCRAND ERROR: code = ", status stop 1 end if end subroutine rocrandCheck subroutine rocsolverCheck(status) use hipfort_rocblas_enums, only: ROCBLAS_STATUS_SUCCESS implicit none integer(kind(ROCBLAS_STATUS_SUCCESS)) :: status if (status /= ROCBLAS_STATUS_SUCCESS) then write (*, *) "ROCSOLVER ERROR: code = ", status stop 1 end if end subroutine rocsolverCheck subroutine rocsparseCheck(status) use hipfort_rocsparse_enums, only: rocsparse_status_success implicit none integer(kind(rocsparse_status_success)) :: status if (status /= rocsparse_status_success) then write (*, *) "ROCSPARSE ERROR: code = ", status stop 1 end if end subroutine rocsparseCheck end module hipfort_check hipfort-rocm-10.0.0/lib/hipfort/hipfort_cuda_errors.f90000066400000000000000000000207451524740623400230240ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_cuda_errors implicit none enum, bind(c) enumerator :: cudaSuccess = 0 enumerator :: cudaErrorInvalidValue = 1 enumerator :: cudaErrorMemoryAllocation = 2 enumerator :: cudaErrorInitializationError = 3 enumerator :: cudaErrorCudartUnloading = 4 enumerator :: cudaErrorProfilerDisabled = 5 enumerator :: cudaErrorProfilerNotInitialized = 6 enumerator :: cudaErrorProfilerAlreadyStarted = 7 enumerator :: cudaErrorProfilerAlreadyStopped = 8 enumerator :: cudaErrorInvalidConfiguration = 9 enumerator :: cudaErrorVersionTranslation = 10 enumerator :: cudaErrorInvalidPitchValue = 12 enumerator :: cudaErrorInvalidSymbol = 13 enumerator :: cudaErrorInvalidHostPointer = 16 enumerator :: cudaErrorInvalidDevicePointer = 17 enumerator :: cudaErrorInvalidTexture = 18 enumerator :: cudaErrorInvalidTextureBinding = 19 enumerator :: cudaErrorInvalidChannelDescriptor = 20 enumerator :: cudaErrorInvalidMemcpyDirection = 21 enumerator :: cudaErrorAddressOfConstant = 22 enumerator :: cudaErrorTextureFetchFailed = 23 enumerator :: cudaErrorTextureNotBound = 24 enumerator :: cudaErrorSynchronizationError = 25 enumerator :: cudaErrorInvalidFilterSetting = 26 enumerator :: cudaErrorInvalidNormSetting = 27 enumerator :: cudaErrorMixedDeviceExecution = 28 enumerator :: cudaErrorNotYetImplemented = 31 enumerator :: cudaErrorMemoryValueTooLarge = 32 enumerator :: cudaErrorStubLibrary = 34 enumerator :: cudaErrorInsufficientDriver = 35 enumerator :: cudaErrorCallRequiresNewerDriver = 36 enumerator :: cudaErrorInvalidSurface = 37 enumerator :: cudaErrorDuplicateVariableName = 43 enumerator :: cudaErrorDuplicateTextureName = 44 enumerator :: cudaErrorDuplicateSurfaceName = 45 enumerator :: cudaErrorDevicesUnavailable = 46 enumerator :: cudaErrorIncompatibleDriverContext = 49 enumerator :: cudaErrorMissingConfiguration = 52 enumerator :: cudaErrorPriorLaunchFailure = 53 enumerator :: cudaErrorLaunchMaxDepthExceeded = 65 enumerator :: cudaErrorLaunchFileScopedTex = 66 enumerator :: cudaErrorLaunchFileScopedSurf = 67 enumerator :: cudaErrorSyncDepthExceeded = 68 enumerator :: cudaErrorLaunchPendingCountExceeded = 69 enumerator :: cudaErrorInvalidDeviceFunction = 98 enumerator :: cudaErrorNoDevice = 100 enumerator :: cudaErrorInvalidDevice = 101 enumerator :: cudaErrorDeviceNotLicensed = 102 enumerator :: cudaErrorSoftwareValidityNotEstablished = 103 enumerator :: cudaErrorStartupFailure = 127 enumerator :: cudaErrorInvalidKernelImage = 200 enumerator :: cudaErrorDeviceUninitialized = 201 enumerator :: cudaErrorMapBufferObjectFailed = 205 enumerator :: cudaErrorUnmapBufferObjectFailed = 206 enumerator :: cudaErrorArrayIsMapped = 207 enumerator :: cudaErrorAlreadyMapped = 208 enumerator :: cudaErrorNoKernelImageForDevice = 209 enumerator :: cudaErrorAlreadyAcquired = 210 enumerator :: cudaErrorNotMapped = 211 enumerator :: cudaErrorNotMappedAsArray = 212 enumerator :: cudaErrorNotMappedAsPointer = 213 enumerator :: cudaErrorECCUncorrectable = 214 enumerator :: cudaErrorUnsupportedLimit = 215 enumerator :: cudaErrorDeviceAlreadyInUse = 216 enumerator :: cudaErrorPeerAccessUnsupported = 217 enumerator :: cudaErrorInvalidPtx = 218 enumerator :: cudaErrorInvalidGraphicsContext = 219 enumerator :: cudaErrorNvlinkUncorrectable = 220 enumerator :: cudaErrorJitCompilerNotFound = 221 enumerator :: cudaErrorUnsupportedPtxVersion = 222 enumerator :: cudaErrorJitCompilationDisabled = 223 enumerator :: cudaErrorUnsupportedExecAffinity = 224 enumerator :: cudaErrorUnsupportedDevSideSync = 225 enumerator :: cudaErrorContained = 226 enumerator :: cudaErrorInvalidSource = 300 enumerator :: cudaErrorFileNotFound = 301 enumerator :: cudaErrorSharedObjectSymbolNotFound = 302 enumerator :: cudaErrorSharedObjectInitFailed = 303 enumerator :: cudaErrorOperatingSystem = 304 enumerator :: cudaErrorInvalidResourceHandle = 400 enumerator :: cudaErrorIllegalState = 401 enumerator :: cudaErrorLossyQuery = 402 enumerator :: cudaErrorSymbolNotFound = 500 enumerator :: cudaErrorNotReady = 600 enumerator :: cudaErrorIllegalAddress = 700 enumerator :: cudaErrorLaunchOutOfResources = 701 enumerator :: cudaErrorLaunchTimeout = 702 enumerator :: cudaErrorLaunchIncompatibleTexturing = 703 enumerator :: cudaErrorPeerAccessAlreadyEnabled = 704 enumerator :: cudaErrorPeerAccessNotEnabled = 705 enumerator :: cudaErrorSetOnActiveProcess = 708 enumerator :: cudaErrorContextIsDestroyed = 709 enumerator :: cudaErrorAssert = 710 enumerator :: cudaErrorTooManyPeers = 711 enumerator :: cudaErrorHostMemoryAlreadyRegistered = 712 enumerator :: cudaErrorHostMemoryNotRegistered = 713 enumerator :: cudaErrorHardwareStackError = 714 enumerator :: cudaErrorIllegalInstruction = 715 enumerator :: cudaErrorMisalignedAddress = 716 enumerator :: cudaErrorInvalidAddressSpace = 717 enumerator :: cudaErrorInvalidPc = 718 enumerator :: cudaErrorLaunchFailure = 719 enumerator :: cudaErrorCooperativeLaunchTooLarge = 720 enumerator :: cudaErrorTensorMemoryLeak = 721 enumerator :: cudaErrorNotPermitted = 800 enumerator :: cudaErrorNotSupported = 801 enumerator :: cudaErrorSystemNotReady = 802 enumerator :: cudaErrorSystemDriverMismatch = 803 enumerator :: cudaErrorCompatNotSupportedOnDevice = 804 enumerator :: cudaErrorMpsConnectionFailed = 805 enumerator :: cudaErrorMpsRpcFailure = 806 enumerator :: cudaErrorMpsServerNotReady = 807 enumerator :: cudaErrorMpsMaxClientsReached = 808 enumerator :: cudaErrorMpsMaxConnectionsReached = 809 enumerator :: cudaErrorMpsClientTerminated = 810 enumerator :: cudaErrorCdpNotSupported = 811 enumerator :: cudaErrorCdpVersionMismatch = 812 enumerator :: cudaErrorStreamCaptureUnsupported = 900 enumerator :: cudaErrorStreamCaptureInvalidated = 901 enumerator :: cudaErrorStreamCaptureMerge = 902 enumerator :: cudaErrorStreamCaptureUnmatched = 903 enumerator :: cudaErrorStreamCaptureUnjoined = 904 enumerator :: cudaErrorStreamCaptureIsolation = 905 enumerator :: cudaErrorStreamCaptureImplicit = 906 enumerator :: cudaErrorCapturedEvent = 907 enumerator :: cudaErrorStreamCaptureWrongThread = 908 enumerator :: cudaErrorTimeout = 909 enumerator :: cudaErrorGraphExecUpdateFailure = 910 enumerator :: cudaErrorExternalDevice = 911 enumerator :: cudaErrorInvalidClusterSize = 912 enumerator :: cudaErrorFunctionNotLoaded = 913 enumerator :: cudaErrorInvalidResourceType = 914 enumerator :: cudaErrorInvalidResourceConfiguration = 915 enumerator :: cudaErrorStreamDetached = 917 enumerator :: cudaErrorGraphRecaptureFailure = 918 enumerator :: cudaErrorUnknown = 999 enumerator :: cudaErrorApiFailureBase = 10000 end enum end module hipfort_cuda_errors hipfort-rocm-10.0.0/lib/hipfort/hipfort_enums.F90000066400000000000000000001362011524740623400215760ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_enums use, intrinsic :: iso_c_binding implicit none ! hipDataType enum, bind(c) enumerator :: HIP_R_32F = 0 enumerator :: HIP_R_64F = 1 enumerator :: HIP_R_16F = 2 enumerator :: HIP_R_8I = 3 enumerator :: HIP_C_32F = 4 enumerator :: HIP_C_64F = 5 enumerator :: HIP_C_16F = 6 enumerator :: HIP_C_8I = 7 enumerator :: HIP_R_8U = 8 enumerator :: HIP_C_8U = 9 enumerator :: HIP_R_32I = 10 enumerator :: HIP_C_32I = 11 enumerator :: HIP_R_32U = 12 enumerator :: HIP_C_32U = 13 enumerator :: HIP_R_16BF = 14 enumerator :: HIP_C_16BF = 15 enumerator :: HIP_R_4I = 16 enumerator :: HIP_C_4I = 17 enumerator :: HIP_R_4U = 18 enumerator :: HIP_C_4U = 19 enumerator :: HIP_R_16I = 20 enumerator :: HIP_C_16I = 21 enumerator :: HIP_R_16U = 22 enumerator :: HIP_C_16U = 23 enumerator :: HIP_R_64I = 24 enumerator :: HIP_C_64I = 25 enumerator :: HIP_R_64U = 26 enumerator :: HIP_C_64U = 27 enumerator :: HIP_R_8F_E4M3 = 28 enumerator :: HIP_R_8F_E5M2 = 29 enumerator :: HIP_R_8F_UE8M0 = 30 enumerator :: HIP_R_6F_E2M3 = 31 enumerator :: HIP_R_6F_E3M2 = 32 enumerator :: HIP_R_4F_E2M1 = 33 enumerator :: HIP_R_8F_E4M3_FNUZ = 1000 enumerator :: HIP_R_8F_E5M2_FNUZ = 1001 end enum ! hipLibraryPropertyType enum, bind(c) enumerator :: HIP_LIBRARY_MAJOR_VERSION = 0 enumerator :: HIP_LIBRARY_MINOR_VERSION = 1 enumerator :: HIP_LIBRARY_PATCH_LEVEL = 2 end enum ! hipJitOption enum, bind(c) enumerator :: hipJitOptionMaxRegisters = 0 enumerator :: hipJitOptionThreadsPerBlock = 1 enumerator :: hipJitOptionWallTime = 2 enumerator :: hipJitOptionInfoLogBuffer = 3 enumerator :: hipJitOptionInfoLogBufferSizeBytes = 4 enumerator :: hipJitOptionErrorLogBuffer = 5 enumerator :: hipJitOptionErrorLogBufferSizeBytes = 6 enumerator :: hipJitOptionOptimizationLevel = 7 enumerator :: hipJitOptionTargetFromContext = 8 enumerator :: hipJitOptionTarget = 9 enumerator :: hipJitOptionFallbackStrategy = 10 enumerator :: hipJitOptionGenerateDebugInfo = 11 enumerator :: hipJitOptionLogVerbose = 12 enumerator :: hipJitOptionGenerateLineInfo = 13 enumerator :: hipJitOptionCacheMode = 14 enumerator :: hipJitOptionSm3xOpt = 15 enumerator :: hipJitOptionFastCompile = 16 enumerator :: hipJitOptionGlobalSymbolNames = 17 enumerator :: hipJitOptionGlobalSymbolAddresses = 18 enumerator :: hipJitOptionGlobalSymbolCount = 19 enumerator :: hipJitOptionLto = 20 enumerator :: hipJitOptionFtz = 21 enumerator :: hipJitOptionPrecDiv = 22 enumerator :: hipJitOptionPrecSqrt = 23 enumerator :: hipJitOptionFma = 24 enumerator :: hipJitOptionPositionIndependentCode = 25 enumerator :: hipJitOptionMinCTAPerSM = 26 enumerator :: hipJitOptionMaxThreadsPerBlock = 27 enumerator :: hipJitOptionOverrideDirectiveValues = 28 enumerator :: hipJitOptionNumOptions = 29 enumerator :: hipJitOptionIRtoISAOptExt = 10000 enumerator :: hipJitOptionIRtoISAOptCountExt = 10001 end enum ! hipJitInputType enum, bind(c) enumerator :: hipJitInputCubin = 0 enumerator :: hipJitInputPtx = 1 enumerator :: hipJitInputFatBinary = 2 enumerator :: hipJitInputObject = 3 enumerator :: hipJitInputLibrary = 4 enumerator :: hipJitInputNvvm = 5 enumerator :: hipJitNumLegacyInputTypes = 6 enumerator :: hipJitInputLLVMBitcode = 100 enumerator :: hipJitInputLLVMBundledBitcode = 101 enumerator :: hipJitInputLLVMArchivesOfBundledBitcode = 102 enumerator :: hipJitInputSpirv = 103 enumerator :: hipJitNumInputTypes = 10 end enum ! hipJitCacheMode enum, bind(c) enumerator :: hipJitCacheOptionNone = 0 enumerator :: hipJitCacheOptionCG = 1 enumerator :: hipJitCacheOptionCA = 2 end enum ! hipJitFallback enum, bind(c) enumerator :: hipJitPreferPTX = 0 enumerator :: hipJitPreferBinary = 1 end enum ! hipLibraryOption_e enum, bind(c) enumerator :: hipLibraryHostUniversalFunctionAndDataTable = 0 enumerator :: hipLibraryBinaryIsPreserved = 1 end enum ! enum (unnamed at /opt/rocm/include/hip/hip_runtime_api.h:33:1) enum, bind(c) enumerator :: HIP_SUCCESS = 0 enumerator :: HIP_ERROR_INVALID_VALUE = 1 enumerator :: HIP_ERROR_NOT_INITIALIZED = 2 enumerator :: HIP_ERROR_LAUNCH_OUT_OF_RESOURCES = 3 end enum ! hipMemoryType enum, bind(c) enumerator :: hipMemoryTypeUnregistered = 0 enumerator :: hipMemoryTypeHost = 1 enumerator :: hipMemoryTypeDevice = 2 enumerator :: hipMemoryTypeManaged = 3 enumerator :: hipMemoryTypeArray = 10 enumerator :: hipMemoryTypeUnified = 11 end enum ! hipError_t enum, bind(c) enumerator :: hipSuccess = 0 enumerator :: hipErrorInvalidValue = 1 enumerator :: hipErrorOutOfMemory = 2 enumerator :: hipErrorMemoryAllocation = 2 enumerator :: hipErrorNotInitialized = 3 enumerator :: hipErrorInitializationError = 3 enumerator :: hipErrorDeinitialized = 4 enumerator :: hipErrorProfilerDisabled = 5 enumerator :: hipErrorProfilerNotInitialized = 6 enumerator :: hipErrorProfilerAlreadyStarted = 7 enumerator :: hipErrorProfilerAlreadyStopped = 8 enumerator :: hipErrorInvalidConfiguration = 9 enumerator :: hipErrorInvalidPitchValue = 12 enumerator :: hipErrorInvalidSymbol = 13 enumerator :: hipErrorInvalidDevicePointer = 17 enumerator :: hipErrorInvalidMemcpyDirection = 21 enumerator :: hipErrorInsufficientDriver = 35 enumerator :: hipErrorMissingConfiguration = 52 enumerator :: hipErrorPriorLaunchFailure = 53 enumerator :: hipErrorInvalidDeviceFunction = 98 enumerator :: hipErrorNoDevice = 100 enumerator :: hipErrorInvalidDevice = 101 enumerator :: hipErrorInvalidImage = 200 enumerator :: hipErrorInvalidContext = 201 enumerator :: hipErrorContextAlreadyCurrent = 202 enumerator :: hipErrorMapFailed = 205 enumerator :: hipErrorMapBufferObjectFailed = 205 enumerator :: hipErrorUnmapFailed = 206 enumerator :: hipErrorArrayIsMapped = 207 enumerator :: hipErrorAlreadyMapped = 208 enumerator :: hipErrorNoBinaryForGpu = 209 enumerator :: hipErrorAlreadyAcquired = 210 enumerator :: hipErrorNotMapped = 211 enumerator :: hipErrorNotMappedAsArray = 212 enumerator :: hipErrorNotMappedAsPointer = 213 enumerator :: hipErrorECCNotCorrectable = 214 enumerator :: hipErrorUnsupportedLimit = 215 enumerator :: hipErrorContextAlreadyInUse = 216 enumerator :: hipErrorPeerAccessUnsupported = 217 enumerator :: hipErrorInvalidKernelFile = 218 enumerator :: hipErrorInvalidGraphicsContext = 219 enumerator :: hipErrorInvalidSource = 300 enumerator :: hipErrorFileNotFound = 301 enumerator :: hipErrorSharedObjectSymbolNotFound = 302 enumerator :: hipErrorSharedObjectInitFailed = 303 enumerator :: hipErrorOperatingSystem = 304 enumerator :: hipErrorInvalidHandle = 400 enumerator :: hipErrorInvalidResourceHandle = 400 enumerator :: hipErrorIllegalState = 401 enumerator :: hipErrorNotFound = 500 enumerator :: hipErrorNotReady = 600 enumerator :: hipErrorIllegalAddress = 700 enumerator :: hipErrorLaunchOutOfResources = 701 enumerator :: hipErrorLaunchTimeOut = 702 enumerator :: hipErrorPeerAccessAlreadyEnabled = 704 enumerator :: hipErrorPeerAccessNotEnabled = 705 enumerator :: hipErrorSetOnActiveProcess = 708 enumerator :: hipErrorContextIsDestroyed = 709 enumerator :: hipErrorAssert = 710 enumerator :: hipErrorHostMemoryAlreadyRegistered = 712 enumerator :: hipErrorHostMemoryNotRegistered = 713 enumerator :: hipErrorLaunchFailure = 719 enumerator :: hipErrorCooperativeLaunchTooLarge = 720 enumerator :: hipErrorNotSupported = 801 enumerator :: hipErrorStreamCaptureUnsupported = 900 enumerator :: hipErrorStreamCaptureInvalidated = 901 enumerator :: hipErrorStreamCaptureMerge = 902 enumerator :: hipErrorStreamCaptureUnmatched = 903 enumerator :: hipErrorStreamCaptureUnjoined = 904 enumerator :: hipErrorStreamCaptureIsolation = 905 enumerator :: hipErrorStreamCaptureImplicit = 906 enumerator :: hipErrorCapturedEvent = 907 enumerator :: hipErrorStreamCaptureWrongThread = 908 enumerator :: hipErrorGraphExecUpdateFailure = 910 enumerator :: hipErrorInvalidChannelDescriptor = 911 enumerator :: hipErrorInvalidTexture = 912 enumerator :: hipErrorInvalidResourceType = 914 enumerator :: hipErrorInvalidResourceConfiguration = 915 enumerator :: hipErrorStreamDetached = 916 enumerator :: hipErrorUnknown = 999 enumerator :: hipErrorRuntimeMemory = 1052 enumerator :: hipErrorRuntimeOther = 1053 enumerator :: hipErrorInvalidClusterSize = 1054 enumerator :: hipErrorTbd = 1055 end enum ! hipDeviceAttribute_t enum, bind(c) enumerator :: hipDeviceAttributeCudaCompatibleBegin = 0 enumerator :: hipDeviceAttributeEccEnabled = 0 enumerator :: hipDeviceAttributeAccessPolicyMaxWindowSize = 1 enumerator :: hipDeviceAttributeAsyncEngineCount = 2 enumerator :: hipDeviceAttributeCanMapHostMemory = 3 enumerator :: hipDeviceAttributeCanUseHostPointerForRegisteredMem = 4 enumerator :: hipDeviceAttributeClockRate = 5 enumerator :: hipDeviceAttributeComputeMode = 6 enumerator :: hipDeviceAttributeComputePreemptionSupported = 7 enumerator :: hipDeviceAttributeConcurrentKernels = 8 enumerator :: hipDeviceAttributeConcurrentManagedAccess = 9 enumerator :: hipDeviceAttributeCooperativeLaunch = 10 enumerator :: hipDeviceAttributeCooperativeMultiDeviceLaunch = 11 enumerator :: hipDeviceAttributeDeviceOverlap = 12 enumerator :: hipDeviceAttributeDirectManagedMemAccessFromHost = 13 enumerator :: hipDeviceAttributeGlobalL1CacheSupported = 14 enumerator :: hipDeviceAttributeHostNativeAtomicSupported = 15 enumerator :: hipDeviceAttributeIntegrated = 16 enumerator :: hipDeviceAttributeIsMultiGpuBoard = 17 enumerator :: hipDeviceAttributeKernelExecTimeout = 18 enumerator :: hipDeviceAttributeL2CacheSize = 19 enumerator :: hipDeviceAttributeLocalL1CacheSupported = 20 enumerator :: hipDeviceAttributeLuid = 21 enumerator :: hipDeviceAttributeLuidDeviceNodeMask = 22 enumerator :: hipDeviceAttributeComputeCapabilityMajor = 23 enumerator :: hipDeviceAttributeManagedMemory = 24 enumerator :: hipDeviceAttributeMaxBlocksPerMultiProcessor = 25 enumerator :: hipDeviceAttributeMaxBlockDimX = 26 enumerator :: hipDeviceAttributeMaxBlockDimY = 27 enumerator :: hipDeviceAttributeMaxBlockDimZ = 28 enumerator :: hipDeviceAttributeMaxGridDimX = 29 enumerator :: hipDeviceAttributeMaxGridDimY = 30 enumerator :: hipDeviceAttributeMaxGridDimZ = 31 enumerator :: hipDeviceAttributeMaxSurface1D = 32 enumerator :: hipDeviceAttributeMaxSurface1DLayered = 33 enumerator :: hipDeviceAttributeMaxSurface2D = 34 enumerator :: hipDeviceAttributeMaxSurface2DLayered = 35 enumerator :: hipDeviceAttributeMaxSurface3D = 36 enumerator :: hipDeviceAttributeMaxSurfaceCubemap = 37 enumerator :: hipDeviceAttributeMaxSurfaceCubemapLayered = 38 enumerator :: hipDeviceAttributeMaxTexture1DWidth = 39 enumerator :: hipDeviceAttributeMaxTexture1DLayered = 40 enumerator :: hipDeviceAttributeMaxTexture1DLinear = 41 enumerator :: hipDeviceAttributeMaxTexture1DMipmap = 42 enumerator :: hipDeviceAttributeMaxTexture2DWidth = 43 enumerator :: hipDeviceAttributeMaxTexture2DHeight = 44 enumerator :: hipDeviceAttributeMaxTexture2DGather = 45 enumerator :: hipDeviceAttributeMaxTexture2DLayered = 46 enumerator :: hipDeviceAttributeMaxTexture2DLinear = 47 enumerator :: hipDeviceAttributeMaxTexture2DMipmap = 48 enumerator :: hipDeviceAttributeMaxTexture3DWidth = 49 enumerator :: hipDeviceAttributeMaxTexture3DHeight = 50 enumerator :: hipDeviceAttributeMaxTexture3DDepth = 51 enumerator :: hipDeviceAttributeMaxTexture3DAlt = 52 enumerator :: hipDeviceAttributeMaxTextureCubemap = 53 enumerator :: hipDeviceAttributeMaxTextureCubemapLayered = 54 enumerator :: hipDeviceAttributeMaxThreadsDim = 55 enumerator :: hipDeviceAttributeMaxThreadsPerBlock = 56 enumerator :: hipDeviceAttributeMaxThreadsPerMultiProcessor = 57 enumerator :: hipDeviceAttributeMaxPitch = 58 enumerator :: hipDeviceAttributeMemoryBusWidth = 59 enumerator :: hipDeviceAttributeMemoryClockRate = 60 enumerator :: hipDeviceAttributeComputeCapabilityMinor = 61 enumerator :: hipDeviceAttributeMultiGpuBoardGroupID = 62 enumerator :: hipDeviceAttributeMultiprocessorCount = 63 enumerator :: hipDeviceAttributeUnused1 = 64 enumerator :: hipDeviceAttributePageableMemoryAccess = 65 enumerator :: hipDeviceAttributePageableMemoryAccessUsesHostPageTables = 66 enumerator :: hipDeviceAttributePciBusId = 67 enumerator :: hipDeviceAttributePciDeviceId = 68 enumerator :: hipDeviceAttributePciDomainId = 69 enumerator :: hipDeviceAttributePersistingL2CacheMaxSize = 70 enumerator :: hipDeviceAttributeMaxRegistersPerBlock = 71 enumerator :: hipDeviceAttributeMaxRegistersPerMultiprocessor = 72 enumerator :: hipDeviceAttributeReservedSharedMemPerBlock = 73 enumerator :: hipDeviceAttributeMaxSharedMemoryPerBlock = 74 enumerator :: hipDeviceAttributeSharedMemPerBlockOptin = 75 enumerator :: hipDeviceAttributeSharedMemPerMultiprocessor = 76 enumerator :: hipDeviceAttributeSingleToDoublePrecisionPerfRatio = 77 enumerator :: hipDeviceAttributeStreamPrioritiesSupported = 78 enumerator :: hipDeviceAttributeSurfaceAlignment = 79 enumerator :: hipDeviceAttributeTccDriver = 80 enumerator :: hipDeviceAttributeTextureAlignment = 81 enumerator :: hipDeviceAttributeTexturePitchAlignment = 82 enumerator :: hipDeviceAttributeTotalConstantMemory = 83 enumerator :: hipDeviceAttributeTotalGlobalMem = 84 enumerator :: hipDeviceAttributeUnifiedAddressing = 85 enumerator :: hipDeviceAttributeUnused2 = 86 enumerator :: hipDeviceAttributeWarpSize = 87 enumerator :: hipDeviceAttributeMemoryPoolsSupported = 88 enumerator :: hipDeviceAttributeVirtualMemoryManagementSupported = 89 enumerator :: hipDeviceAttributeHostRegisterSupported = 90 enumerator :: hipDeviceAttributeMemoryPoolSupportedHandleTypes = 91 enumerator :: hipDeviceAttributeHostNumaId = 92 enumerator :: hipDeviceAttributeDmaBufSupported = 93 enumerator :: hipDeviceAttributeGPUDirectRDMAWithHipVMMSupported = 94 enumerator :: hipDeviceAttributeHandleTypeFabricSupported = 95 enumerator :: hipDeviceAttributeCudaCompatibleEnd = 9999 enumerator :: hipDeviceAttributeAmdSpecificBegin = 10000 enumerator :: hipDeviceAttributeClockInstructionRate = 10000 enumerator :: hipDeviceAttributeUnused3 = 10001 enumerator :: hipDeviceAttributeMaxSharedMemoryPerMultiprocessor = 10002 enumerator :: hipDeviceAttributeUnused4 = 10003 enumerator :: hipDeviceAttributeUnused5 = 10004 enumerator :: hipDeviceAttributeHdpMemFlushCntl = 10005 enumerator :: hipDeviceAttributeHdpRegFlushCntl = 10006 enumerator :: hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc = 10007 enumerator :: hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim = 10008 enumerator :: hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim = 10009 enumerator :: hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem = 10010 enumerator :: hipDeviceAttributeIsLargeBar = 10011 enumerator :: hipDeviceAttributeAsicRevision = 10012 enumerator :: hipDeviceAttributeCanUseStreamWaitValue = 10013 enumerator :: hipDeviceAttributeImageSupport = 10014 enumerator :: hipDeviceAttributePhysicalMultiProcessorCount = 10015 enumerator :: hipDeviceAttributeFineGrainSupport = 10016 enumerator :: hipDeviceAttributeWallClockRate = 10017 enumerator :: hipDeviceAttributeNumberOfXccs = 10018 enumerator :: hipDeviceAttributeMaxAvailableVgprsPerThread = 10019 enumerator :: hipDeviceAttributePciChipId = 10020 enumerator :: hipDeviceAttributeExpertSchedMode = 10021 enumerator :: hipDeviceAttributeMaxDynDataPrefetchRegions = 10022 enumerator :: hipDeviceAttributeAmdSpecificEnd = 19999 enumerator :: hipDeviceAttributeVendorSpecificBegin = 20000 end enum ! hipDriverProcAddressQueryResult enum, bind(c) enumerator :: HIP_GET_PROC_ADDRESS_SUCCESS = 0 enumerator :: HIP_GET_PROC_ADDRESS_SYMBOL_NOT_FOUND = 1 enumerator :: HIP_GET_PROC_ADDRESS_VERSION_NOT_SUFFICIENT = 2 end enum ! hipComputeMode enum, bind(c) enumerator :: hipComputeModeDefault = 0 enumerator :: hipComputeModeExclusive = 1 enumerator :: hipComputeModeProhibited = 2 enumerator :: hipComputeModeExclusiveProcess = 3 end enum ! hipFlushGPUDirectRDMAWritesOptions enum, bind(c) enumerator :: hipFlushGPUDirectRDMAWritesOptionHost = 1 enumerator :: hipFlushGPUDirectRDMAWritesOptionMemOps = 2 end enum ! hipGPUDirectRDMAWritesOrdering enum, bind(c) enumerator :: hipGPUDirectRDMAWritesOrderingNone = 0 enumerator :: hipGPUDirectRDMAWritesOrderingOwner = 100 enumerator :: hipGPUDirectRDMAWritesOrderingAllDevices = 200 end enum ! hipChannelFormatKind enum, bind(c) enumerator :: hipChannelFormatKindSigned = 0 enumerator :: hipChannelFormatKindUnsigned = 1 enumerator :: hipChannelFormatKindFloat = 2 enumerator :: hipChannelFormatKindNone = 3 end enum ! hipArray_Format enum, bind(c) enumerator :: HIP_AD_FORMAT_UNSIGNED_INT8 = 1 enumerator :: HIP_AD_FORMAT_UNSIGNED_INT16 = 2 enumerator :: HIP_AD_FORMAT_UNSIGNED_INT32 = 3 enumerator :: HIP_AD_FORMAT_SIGNED_INT8 = 8 enumerator :: HIP_AD_FORMAT_SIGNED_INT16 = 9 enumerator :: HIP_AD_FORMAT_SIGNED_INT32 = 10 enumerator :: HIP_AD_FORMAT_HALF = 16 enumerator :: HIP_AD_FORMAT_FLOAT = 32 end enum ! hipResourceType enum, bind(c) enumerator :: hipResourceTypeArray = 0 enumerator :: hipResourceTypeMipmappedArray = 1 enumerator :: hipResourceTypeLinear = 2 enumerator :: hipResourceTypePitch2D = 3 end enum ! HIPresourcetype_enum enum, bind(c) enumerator :: HIP_RESOURCE_TYPE_ARRAY = 0 enumerator :: HIP_RESOURCE_TYPE_MIPMAPPED_ARRAY = 1 enumerator :: HIP_RESOURCE_TYPE_LINEAR = 2 enumerator :: HIP_RESOURCE_TYPE_PITCH2D = 3 end enum ! HIPaddress_mode_enum enum, bind(c) enumerator :: HIP_TR_ADDRESS_MODE_WRAP = 0 enumerator :: HIP_TR_ADDRESS_MODE_CLAMP = 1 enumerator :: HIP_TR_ADDRESS_MODE_MIRROR = 2 enumerator :: HIP_TR_ADDRESS_MODE_BORDER = 3 end enum ! HIPfilter_mode_enum enum, bind(c) enumerator :: HIP_TR_FILTER_MODE_POINT = 0 enumerator :: HIP_TR_FILTER_MODE_LINEAR = 1 end enum ! hipResourceViewFormat enum, bind(c) enumerator :: hipResViewFormatNone = 0 enumerator :: hipResViewFormatUnsignedChar1 = 1 enumerator :: hipResViewFormatUnsignedChar2 = 2 enumerator :: hipResViewFormatUnsignedChar4 = 3 enumerator :: hipResViewFormatSignedChar1 = 4 enumerator :: hipResViewFormatSignedChar2 = 5 enumerator :: hipResViewFormatSignedChar4 = 6 enumerator :: hipResViewFormatUnsignedShort1 = 7 enumerator :: hipResViewFormatUnsignedShort2 = 8 enumerator :: hipResViewFormatUnsignedShort4 = 9 enumerator :: hipResViewFormatSignedShort1 = 10 enumerator :: hipResViewFormatSignedShort2 = 11 enumerator :: hipResViewFormatSignedShort4 = 12 enumerator :: hipResViewFormatUnsignedInt1 = 13 enumerator :: hipResViewFormatUnsignedInt2 = 14 enumerator :: hipResViewFormatUnsignedInt4 = 15 enumerator :: hipResViewFormatSignedInt1 = 16 enumerator :: hipResViewFormatSignedInt2 = 17 enumerator :: hipResViewFormatSignedInt4 = 18 enumerator :: hipResViewFormatHalf1 = 19 enumerator :: hipResViewFormatHalf2 = 20 enumerator :: hipResViewFormatHalf4 = 21 enumerator :: hipResViewFormatFloat1 = 22 enumerator :: hipResViewFormatFloat2 = 23 enumerator :: hipResViewFormatFloat4 = 24 enumerator :: hipResViewFormatUnsignedBlockCompressed1 = 25 enumerator :: hipResViewFormatUnsignedBlockCompressed2 = 26 enumerator :: hipResViewFormatUnsignedBlockCompressed3 = 27 enumerator :: hipResViewFormatUnsignedBlockCompressed4 = 28 enumerator :: hipResViewFormatSignedBlockCompressed4 = 29 enumerator :: hipResViewFormatUnsignedBlockCompressed5 = 30 enumerator :: hipResViewFormatSignedBlockCompressed5 = 31 enumerator :: hipResViewFormatUnsignedBlockCompressed6H = 32 enumerator :: hipResViewFormatSignedBlockCompressed6H = 33 enumerator :: hipResViewFormatUnsignedBlockCompressed7 = 34 end enum ! HIPresourceViewFormat_enum enum, bind(c) enumerator :: HIP_RES_VIEW_FORMAT_NONE = 0 enumerator :: HIP_RES_VIEW_FORMAT_UINT_1X8 = 1 enumerator :: HIP_RES_VIEW_FORMAT_UINT_2X8 = 2 enumerator :: HIP_RES_VIEW_FORMAT_UINT_4X8 = 3 enumerator :: HIP_RES_VIEW_FORMAT_SINT_1X8 = 4 enumerator :: HIP_RES_VIEW_FORMAT_SINT_2X8 = 5 enumerator :: HIP_RES_VIEW_FORMAT_SINT_4X8 = 6 enumerator :: HIP_RES_VIEW_FORMAT_UINT_1X16 = 7 enumerator :: HIP_RES_VIEW_FORMAT_UINT_2X16 = 8 enumerator :: HIP_RES_VIEW_FORMAT_UINT_4X16 = 9 enumerator :: HIP_RES_VIEW_FORMAT_SINT_1X16 = 10 enumerator :: HIP_RES_VIEW_FORMAT_SINT_2X16 = 11 enumerator :: HIP_RES_VIEW_FORMAT_SINT_4X16 = 12 enumerator :: HIP_RES_VIEW_FORMAT_UINT_1X32 = 13 enumerator :: HIP_RES_VIEW_FORMAT_UINT_2X32 = 14 enumerator :: HIP_RES_VIEW_FORMAT_UINT_4X32 = 15 enumerator :: HIP_RES_VIEW_FORMAT_SINT_1X32 = 16 enumerator :: HIP_RES_VIEW_FORMAT_SINT_2X32 = 17 enumerator :: HIP_RES_VIEW_FORMAT_SINT_4X32 = 18 enumerator :: HIP_RES_VIEW_FORMAT_FLOAT_1X16 = 19 enumerator :: HIP_RES_VIEW_FORMAT_FLOAT_2X16 = 20 enumerator :: HIP_RES_VIEW_FORMAT_FLOAT_4X16 = 21 enumerator :: HIP_RES_VIEW_FORMAT_FLOAT_1X32 = 22 enumerator :: HIP_RES_VIEW_FORMAT_FLOAT_2X32 = 23 enumerator :: HIP_RES_VIEW_FORMAT_FLOAT_4X32 = 24 enumerator :: HIP_RES_VIEW_FORMAT_UNSIGNED_BC1 = 25 enumerator :: HIP_RES_VIEW_FORMAT_UNSIGNED_BC2 = 26 enumerator :: HIP_RES_VIEW_FORMAT_UNSIGNED_BC3 = 27 enumerator :: HIP_RES_VIEW_FORMAT_UNSIGNED_BC4 = 28 enumerator :: HIP_RES_VIEW_FORMAT_SIGNED_BC4 = 29 enumerator :: HIP_RES_VIEW_FORMAT_UNSIGNED_BC5 = 30 enumerator :: HIP_RES_VIEW_FORMAT_SIGNED_BC5 = 31 enumerator :: HIP_RES_VIEW_FORMAT_UNSIGNED_BC6H = 32 enumerator :: HIP_RES_VIEW_FORMAT_SIGNED_BC6H = 33 enumerator :: HIP_RES_VIEW_FORMAT_UNSIGNED_BC7 = 34 end enum ! hipMemcpyKind enum, bind(c) enumerator :: hipMemcpyHostToHost = 0 enumerator :: hipMemcpyHostToDevice = 1 enumerator :: hipMemcpyDeviceToHost = 2 enumerator :: hipMemcpyDeviceToDevice = 3 enumerator :: hipMemcpyDefault = 4 enumerator :: hipMemcpyDeviceToDeviceNoCU = 1024 end enum ! hipMemLocationType enum, bind(c) enumerator :: hipMemLocationTypeInvalid = 0 enumerator :: hipMemLocationTypeNone = 0 enumerator :: hipMemLocationTypeDevice = 1 enumerator :: hipMemLocationTypeHost = 2 enumerator :: hipMemLocationTypeHostNuma = 3 enumerator :: hipMemLocationTypeHostNumaCurrent = 4 end enum ! hipMemcpyFlags enum, bind(c) enumerator :: hipMemcpyFlagDefault = 0 enumerator :: hipMemcpyFlagPreferOverlapWithCompute = 1 enumerator :: hipMemcpyFlagExtPreferCE = 256 enumerator :: hipMemcpyFlagExtOpSwap = 512 enumerator :: hipMemcpyFlagExtOpIndirectSrc = 1024 enumerator :: hipMemcpyFlagExtOpIndirectDst = 2048 end enum ! hipMemcpySrcAccessOrder enum, bind(c) enumerator :: hipMemcpySrcAccessOrderInvalid = 0 enumerator :: hipMemcpySrcAccessOrderStream = 1 enumerator :: hipMemcpySrcAccessOrderDuringApiCall = 2 enumerator :: hipMemcpySrcAccessOrderAny = 3 enumerator :: hipMemcpySrcAccessOrderMax = 2147483647 end enum ! hipMemcpy3DOperandType enum, bind(c) enumerator :: hipMemcpyOperandTypePointer = 1 enumerator :: hipMemcpyOperandTypeArray = 2 enumerator :: hipMemcpyOperandTypeMax = 2147483647 end enum ! hipFunction_attribute enum, bind(c) enumerator :: HIP_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK = 0 enumerator :: HIP_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES = 1 enumerator :: HIP_FUNC_ATTRIBUTE_CONST_SIZE_BYTES = 2 enumerator :: HIP_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES = 3 enumerator :: HIP_FUNC_ATTRIBUTE_NUM_REGS = 4 enumerator :: HIP_FUNC_ATTRIBUTE_PTX_VERSION = 5 enumerator :: HIP_FUNC_ATTRIBUTE_BINARY_VERSION = 6 enumerator :: HIP_FUNC_ATTRIBUTE_CACHE_MODE_CA = 7 enumerator :: HIP_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES = 8 enumerator :: HIP_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT = 9 enumerator :: HIP_FUNC_ATTRIBUTE_CLUSTER_DIM_MUST_BE_SET = 10 enumerator :: HIP_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_WIDTH = 11 enumerator :: HIP_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_HEIGHT = 12 enumerator :: HIP_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_DEPTH = 13 enumerator :: HIP_FUNC_ATTRIBUTE_NON_PORTABLE_CLUSTER_SIZE_ALLOWED = 14 enumerator :: HIP_FUNC_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE = 15 enumerator :: HIP_FUNC_ATTRIBUTE_MAX = 16 end enum ! hipPointer_attribute enum, bind(c) enumerator :: HIP_POINTER_ATTRIBUTE_CONTEXT = 1 enumerator :: HIP_POINTER_ATTRIBUTE_MEMORY_TYPE = 2 enumerator :: HIP_POINTER_ATTRIBUTE_DEVICE_POINTER = 3 enumerator :: HIP_POINTER_ATTRIBUTE_HOST_POINTER = 4 enumerator :: HIP_POINTER_ATTRIBUTE_P2P_TOKENS = 5 enumerator :: HIP_POINTER_ATTRIBUTE_SYNC_MEMOPS = 6 enumerator :: HIP_POINTER_ATTRIBUTE_BUFFER_ID = 7 enumerator :: HIP_POINTER_ATTRIBUTE_IS_MANAGED = 8 enumerator :: HIP_POINTER_ATTRIBUTE_DEVICE_ORDINAL = 9 enumerator :: HIP_POINTER_ATTRIBUTE_IS_LEGACY_HIP_IPC_CAPABLE = 10 enumerator :: HIP_POINTER_ATTRIBUTE_RANGE_START_ADDR = 11 enumerator :: HIP_POINTER_ATTRIBUTE_RANGE_SIZE = 12 enumerator :: HIP_POINTER_ATTRIBUTE_MAPPED = 13 enumerator :: HIP_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES = 14 enumerator :: HIP_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE = 15 enumerator :: HIP_POINTER_ATTRIBUTE_ACCESS_FLAGS = 16 enumerator :: HIP_POINTER_ATTRIBUTE_MEMPOOL_HANDLE = 17 end enum ! hipTextureAddressMode enum, bind(c) enumerator :: hipAddressModeWrap = 0 enumerator :: hipAddressModeClamp = 1 enumerator :: hipAddressModeMirror = 2 enumerator :: hipAddressModeBorder = 3 end enum ! hipTextureFilterMode enum, bind(c) enumerator :: hipFilterModePoint = 0 enumerator :: hipFilterModeLinear = 1 end enum ! hipTextureReadMode enum, bind(c) enumerator :: hipReadModeElementType = 0 enumerator :: hipReadModeNormalizedFloat = 1 end enum ! hipSurfaceBoundaryMode enum, bind(c) enumerator :: hipBoundaryModeZero = 0 enumerator :: hipBoundaryModeTrap = 1 enumerator :: hipBoundaryModeClamp = 2 end enum ! hipDevResourceType enum, bind(c) enumerator :: hipDevResourceTypeInvalid = 0 enumerator :: hipDevResourceTypeSm = 1 enumerator :: hipDevResourceTypeWorkqueueConfig = 1000 enumerator :: hipDevResourceTypeWorkqueue = 10000 end enum ! hipDevSmResourceGroup_flags enum, bind(c) enumerator :: hipDevSmResourceGroupDefault = 0 enumerator :: hipDevSmResourceGroupBackfill = 1 end enum ! hipDevSmResourceSplitByCount_flags enum, bind(c) enumerator :: hipDevSmResourceSplitIgnoreSmCoscheduling = 1 enumerator :: hipDevSmResourceSplitMaxPotentialClusterSize = 2 end enum ! hipDevWorkqueueConfigScope enum, bind(c) enumerator :: hipDevWorkqueueConfigScopeDeviceCtx = 0 enumerator :: hipDevWorkqueueConfigScopeGreenCtxBalanced = 1 end enum ! hipDeviceP2PAttr enum, bind(c) enumerator :: hipDevP2PAttrPerformanceRank = 0 enumerator :: hipDevP2PAttrAccessSupported = 1 enumerator :: hipDevP2PAttrNativeAtomicSupported = 2 enumerator :: hipDevP2PAttrHipArrayAccessSupported = 3 end enum ! hipDriverEntryPointQueryResult enum, bind(c) enumerator :: hipDriverEntryPointSuccess = 0 enumerator :: hipDriverEntryPointSymbolNotFound = 1 enumerator :: hipDriverEntryPointVersionNotSufficent = 2 end enum ! hipLimit_t enum, bind(c) enumerator :: hipLimitStackSize = 0 enumerator :: hipLimitPrintfFifoSize = 1 enumerator :: hipLimitMallocHeapSize = 2 enumerator :: hipExtLimitScratchMin = 4096 enumerator :: hipExtLimitScratchMax = 4097 enumerator :: hipExtLimitScratchCurrent = 4098 enumerator :: hipLimitRange = 4099 end enum ! hipStreamBatchMemOpType enum, bind(c) enumerator :: hipStreamMemOpWaitValue32 = 1 enumerator :: hipStreamMemOpWriteValue32 = 2 enumerator :: hipStreamMemOpWaitValue64 = 4 enumerator :: hipStreamMemOpWriteValue64 = 5 enumerator :: hipStreamMemOpBarrier = 6 enumerator :: hipStreamMemOpFlushRemoteWrites = 3 end enum ! hipMemoryAdvise enum, bind(c) enumerator :: hipMemAdviseSetReadMostly = 1 enumerator :: hipMemAdviseUnsetReadMostly = 2 enumerator :: hipMemAdviseSetPreferredLocation = 3 enumerator :: hipMemAdviseUnsetPreferredLocation = 4 enumerator :: hipMemAdviseSetAccessedBy = 5 enumerator :: hipMemAdviseUnsetAccessedBy = 6 enumerator :: hipMemAdviseSetCoarseGrain = 100 enumerator :: hipMemAdviseUnsetCoarseGrain = 101 end enum ! hipMemRangeCoherencyMode enum, bind(c) enumerator :: hipMemRangeCoherencyModeFineGrain = 0 enumerator :: hipMemRangeCoherencyModeCoarseGrain = 1 enumerator :: hipMemRangeCoherencyModeIndeterminate = 2 end enum ! hipMemRangeAttribute enum, bind(c) enumerator :: hipMemRangeAttributeReadMostly = 1 enumerator :: hipMemRangeAttributePreferredLocation = 2 enumerator :: hipMemRangeAttributeAccessedBy = 3 enumerator :: hipMemRangeAttributeLastPrefetchLocation = 4 enumerator :: hipMemRangeAttributeCoherencyMode = 100 end enum ! hipMemPoolAttr enum, bind(c) enumerator :: hipMemPoolReuseFollowEventDependencies = 1 enumerator :: hipMemPoolReuseAllowOpportunistic = 2 enumerator :: hipMemPoolReuseAllowInternalDependencies = 3 enumerator :: hipMemPoolAttrReleaseThreshold = 4 enumerator :: hipMemPoolAttrReservedMemCurrent = 5 enumerator :: hipMemPoolAttrReservedMemHigh = 6 enumerator :: hipMemPoolAttrUsedMemCurrent = 7 enumerator :: hipMemPoolAttrUsedMemHigh = 8 end enum ! hipMemAccessFlags enum, bind(c) enumerator :: hipMemAccessFlagsProtNone = 0 enumerator :: hipMemAccessFlagsProtRead = 1 enumerator :: hipMemAccessFlagsProtReadWrite = 3 end enum ! hipMemAllocationType enum, bind(c) enumerator :: hipMemAllocationTypeInvalid = 0 enumerator :: hipMemAllocationTypePinned = 1 enumerator :: hipMemAllocationTypeManaged = 2 enumerator :: hipMemAllocationTypeUncached = 1073741824 enumerator :: hipMemAllocationTypeMax = 2147483647 end enum ! hipMemAllocationHandleType enum, bind(c) enumerator :: hipMemHandleTypeNone = 0 enumerator :: hipMemHandleTypePosixFileDescriptor = 1 enumerator :: hipMemHandleTypeWin32 = 2 enumerator :: hipMemHandleTypeWin32Kmt = 4 enumerator :: hipMemHandleTypeFabric = 8 end enum ! hipFuncAttribute enum, bind(c) enumerator :: hipFuncAttributeMaxDynamicSharedMemorySize = 8 enumerator :: hipFuncAttributePreferredSharedMemoryCarveout = 9 enumerator :: hipFuncAttributeClusterDimMustBeSet = 10 enumerator :: hipFuncAttributeRequiredClusterWidth = 11 enumerator :: hipFuncAttributeRequiredClusterHeight = 12 enumerator :: hipFuncAttributeRequiredClusterDepth = 13 enumerator :: hipFuncAttributeNonPortableClusterSizeAllowed = 14 enumerator :: hipFuncAttributeClusterSchedulingPolicyPreference = 15 enumerator :: hipFuncAttributeMax = 16 end enum ! hipFuncCache_t enum, bind(c) enumerator :: hipFuncCachePreferNone = 0 enumerator :: hipFuncCachePreferShared = 1 enumerator :: hipFuncCachePreferL1 = 2 enumerator :: hipFuncCachePreferEqual = 3 end enum ! hipSharedMemConfig enum, bind(c) enumerator :: hipSharedMemBankSizeDefault = 0 enumerator :: hipSharedMemBankSizeFourByte = 1 enumerator :: hipSharedMemBankSizeEightByte = 2 end enum ! hipExternalMemoryHandleType_enum enum, bind(c) enumerator :: hipExternalMemoryHandleTypeOpaqueFd = 1 enumerator :: hipExternalMemoryHandleTypeOpaqueWin32 = 2 enumerator :: hipExternalMemoryHandleTypeOpaqueWin32Kmt = 3 enumerator :: hipExternalMemoryHandleTypeD3D12Heap = 4 enumerator :: hipExternalMemoryHandleTypeD3D12Resource = 5 enumerator :: hipExternalMemoryHandleTypeD3D11Resource = 6 enumerator :: hipExternalMemoryHandleTypeD3D11ResourceKmt = 7 enumerator :: hipExternalMemoryHandleTypeNvSciBuf = 8 end enum ! hipExternalSemaphoreHandleType_enum enum, bind(c) enumerator :: hipExternalSemaphoreHandleTypeOpaqueFd = 1 enumerator :: hipExternalSemaphoreHandleTypeOpaqueWin32 = 2 enumerator :: hipExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3 enumerator :: hipExternalSemaphoreHandleTypeD3D12Fence = 4 enumerator :: hipExternalSemaphoreHandleTypeD3D11Fence = 5 enumerator :: hipExternalSemaphoreHandleTypeNvSciSync = 6 enumerator :: hipExternalSemaphoreHandleTypeKeyedMutex = 7 enumerator :: hipExternalSemaphoreHandleTypeKeyedMutexKmt = 8 enumerator :: hipExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9 enumerator :: hipExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10 end enum ! hipGraphicsRegisterFlags enum, bind(c) enumerator :: hipGraphicsRegisterFlagsNone = 0 enumerator :: hipGraphicsRegisterFlagsReadOnly = 1 enumerator :: hipGraphicsRegisterFlagsWriteDiscard = 2 enumerator :: hipGraphicsRegisterFlagsSurfaceLoadStore = 4 enumerator :: hipGraphicsRegisterFlagsTextureGather = 8 end enum ! hipGraphNodeType enum, bind(c) enumerator :: hipGraphNodeTypeKernel = 0 enumerator :: hipGraphNodeTypeMemcpy = 1 enumerator :: hipGraphNodeTypeMemset = 2 enumerator :: hipGraphNodeTypeHost = 3 enumerator :: hipGraphNodeTypeGraph = 4 enumerator :: hipGraphNodeTypeEmpty = 5 enumerator :: hipGraphNodeTypeWaitEvent = 6 enumerator :: hipGraphNodeTypeEventRecord = 7 enumerator :: hipGraphNodeTypeExtSemaphoreSignal = 8 enumerator :: hipGraphNodeTypeExtSemaphoreWait = 9 enumerator :: hipGraphNodeTypeMemAlloc = 10 enumerator :: hipGraphNodeTypeMemFree = 11 enumerator :: hipGraphNodeTypeMemcpyFromSymbol = 12 enumerator :: hipGraphNodeTypeMemcpyToSymbol = 13 enumerator :: hipGraphNodeTypeBatchMemOp = 14 enumerator :: hipGraphNodeTypeCount = 15 end enum ! hipAccessProperty enum, bind(c) enumerator :: hipAccessPropertyNormal = 0 enumerator :: hipAccessPropertyStreaming = 1 enumerator :: hipAccessPropertyPersisting = 2 end enum ! hipLaunchMemSyncDomain enum, bind(c) enumerator :: hipLaunchMemSyncDomainDefault = 0 enumerator :: hipLaunchMemSyncDomainRemote = 1 end enum ! hipSynchronizationPolicy enum, bind(c) enumerator :: hipSyncPolicyAuto = 1 enumerator :: hipSyncPolicySpin = 2 enumerator :: hipSyncPolicyYield = 3 enumerator :: hipSyncPolicyBlockingSync = 4 end enum ! hipClusterSchedulingPolicy enum, bind(c) enumerator :: hipClusterSchedulingPolicyDefault = 0 enumerator :: hipClusterSchedulingPolicySpread = 1 enumerator :: hipClusterSchedulingPolicyLoadBalancing = 2 end enum ! hipExtDynDataPrefetchTemporal enum, bind(c) enumerator :: hipExtDynDataPrefetchTemporalRegular = 0 enumerator :: hipExtDynDataPrefetchTemporalHigh = 1 end enum ! hipLaunchAttributeID enum, bind(c) enumerator :: hipLaunchAttributeIgnore = 0 enumerator :: hipLaunchAttributeAccessPolicyWindow = 1 enumerator :: hipLaunchAttributeCooperative = 2 enumerator :: hipLaunchAttributeSynchronizationPolicy = 3 enumerator :: hipLaunchAttributeClusterDimension = 4 enumerator :: hipLaunchAttributeClusterSchedulingPolicyPreference = 5 enumerator :: hipLaunchAttributePriority = 8 enumerator :: hipLaunchAttributeMemSyncDomainMap = 9 enumerator :: hipLaunchAttributeMemSyncDomain = 10 enumerator :: hipLaunchAttributeExtDynDataPrefetch = 1024 enumerator :: hipLaunchAttributeMax = 1025 end enum ! hipGraphExecUpdateResult enum, bind(c) enumerator :: hipGraphExecUpdateSuccess = 0 enumerator :: hipGraphExecUpdateError = 1 enumerator :: hipGraphExecUpdateErrorTopologyChanged = 2 enumerator :: hipGraphExecUpdateErrorNodeTypeChanged = 3 enumerator :: hipGraphExecUpdateErrorFunctionChanged = 4 enumerator :: hipGraphExecUpdateErrorParametersChanged = 5 enumerator :: hipGraphExecUpdateErrorNotSupported = 6 enumerator :: hipGraphExecUpdateErrorUnsupportedFunctionChange = 7 end enum ! hipStreamCaptureMode enum, bind(c) enumerator :: hipStreamCaptureModeGlobal = 0 enumerator :: hipStreamCaptureModeThreadLocal = 1 enumerator :: hipStreamCaptureModeRelaxed = 2 end enum ! hipStreamCaptureStatus enum, bind(c) enumerator :: hipStreamCaptureStatusNone = 0 enumerator :: hipStreamCaptureStatusActive = 1 enumerator :: hipStreamCaptureStatusInvalidated = 2 end enum ! hipStreamUpdateCaptureDependenciesFlags enum, bind(c) enumerator :: hipStreamAddCaptureDependencies = 0 enumerator :: hipStreamSetCaptureDependencies = 1 end enum ! hipGraphMemAttributeType enum, bind(c) enumerator :: hipGraphMemAttrUsedMemCurrent = 0 enumerator :: hipGraphMemAttrUsedMemHigh = 1 enumerator :: hipGraphMemAttrReservedMemCurrent = 2 enumerator :: hipGraphMemAttrReservedMemHigh = 3 end enum ! hipUserObjectFlags enum, bind(c) enumerator :: hipUserObjectNoDestructorSync = 1 end enum ! hipUserObjectRetainFlags enum, bind(c) enumerator :: hipGraphUserObjectMove = 1 end enum ! hipGraphInstantiateFlags enum, bind(c) enumerator :: hipGraphInstantiateFlagAutoFreeOnLaunch = 1 enumerator :: hipGraphInstantiateFlagUpload = 2 enumerator :: hipGraphInstantiateFlagDeviceLaunch = 4 enumerator :: hipGraphInstantiateFlagUseNodePriority = 8 end enum ! hipGraphDebugDotFlags enum, bind(c) enumerator :: hipGraphDebugDotFlagsVerbose = 1 enumerator :: hipGraphDebugDotFlagsKernelNodeParams = 4 enumerator :: hipGraphDebugDotFlagsMemcpyNodeParams = 8 enumerator :: hipGraphDebugDotFlagsMemsetNodeParams = 16 enumerator :: hipGraphDebugDotFlagsHostNodeParams = 32 enumerator :: hipGraphDebugDotFlagsEventNodeParams = 64 enumerator :: hipGraphDebugDotFlagsExtSemasSignalNodeParams = 128 enumerator :: hipGraphDebugDotFlagsExtSemasWaitNodeParams = 256 enumerator :: hipGraphDebugDotFlagsKernelNodeAttributes = 512 enumerator :: hipGraphDebugDotFlagsHandles = 1024 end enum ! hipGraphInstantiateResult enum, bind(c) enumerator :: hipGraphInstantiateSuccess = 0 enumerator :: hipGraphInstantiateError = 1 enumerator :: hipGraphInstantiateInvalidStructure = 2 enumerator :: hipGraphInstantiateNodeOperationNotSupported = 3 enumerator :: hipGraphInstantiateMultipleDevicesNotSupported = 4 end enum ! hipMemAllocationGranularity_flags enum, bind(c) enumerator :: hipMemAllocationGranularityMinimum = 0 enumerator :: hipMemAllocationGranularityRecommended = 1 end enum ! hipMemHandleType enum, bind(c) enumerator :: hipMemHandleTypeGeneric = 0 end enum ! hipMemOperationType enum, bind(c) enumerator :: hipMemOperationTypeMap = 1 enumerator :: hipMemOperationTypeUnmap = 2 end enum ! hipArraySparseSubresourceType enum, bind(c) enumerator :: hipArraySparseSubresourceTypeSparseLevel = 0 enumerator :: hipArraySparseSubresourceTypeMiptail = 1 end enum ! hipGraphDependencyType enum, bind(c) enumerator :: hipGraphDependencyTypeDefault = 0 enumerator :: hipGraphDependencyTypeProgrammatic = 1 end enum ! hipMemRangeHandleType enum, bind(c) enumerator :: hipMemRangeHandleTypeDmaBufFd = 1 enumerator :: hipMemRangeHandleTypeMax = 2147483647 end enum ! hipMemRangeFlags enum, bind(c) enumerator :: hipMemRangeFlagDmaBufMappingTypePcie = 1 enumerator :: hipMemRangeFlagsMax = 2147483647 end enum integer(c_int), parameter :: HIP_VERSION_MAJOR = 7 integer(c_int), parameter :: HIP_VERSION_MINOR = 15 integer(c_int), parameter :: HIP_VERSION_PATCH = 26302 integer(c_int), parameter :: HIP_VERSION_BUILD_ID = 0 integer(c_int), parameter :: HIP_GET_PROC_ADDRESS_DEFAULT = 0 integer(c_int), parameter :: HIP_GET_PROC_ADDRESS_LEGACY_STREAM = 1 integer(c_int), parameter :: HIP_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM = 2 integer(c_int), parameter :: GENERIC_GRID_LAUNCH = 1 integer(c_int), parameter :: HIP_TRSA_OVERRIDE_FORMAT = 1 integer(c_int), parameter :: HIP_TRSF_READ_AS_INTEGER = 1 integer(c_int), parameter :: HIP_TRSF_NORMALIZED_COORDINATES = 2 integer(c_int), parameter :: HIP_TRSF_SRGB = 16 integer(c_int), parameter :: hipTextureType1D = 1 integer(c_int), parameter :: hipTextureType2D = 2 integer(c_int), parameter :: hipTextureType3D = 3 integer(c_int), parameter :: hipTextureTypeCubemap = 12 integer(c_int), parameter :: hipTextureType1DLayered = 241 integer(c_int), parameter :: hipTextureType2DLayered = 242 integer(c_int), parameter :: hipTextureTypeCubemapLayered = 252 integer(c_int), parameter :: HIP_IMAGE_OBJECT_SIZE_DWORD = 12 integer(c_int), parameter :: HIP_SAMPLER_OBJECT_SIZE_DWORD = 8 integer(c_int), parameter :: HIP_RESOURCE_ABI_BYTES = 40 integer(c_int), parameter :: hipIpcMemLazyEnablePeerAccess = 1 integer(c_int), parameter :: HIP_IPC_HANDLE_SIZE = 64 integer(c_int), parameter :: hipStreamDefault = 0 integer(c_int), parameter :: hipStreamNonBlocking = 1 integer(c_int), parameter :: hipEventDefault = 0 integer(c_int), parameter :: hipEventBlockingSync = 1 integer(c_int), parameter :: hipEventDisableTiming = 2 integer(c_int), parameter :: hipEventInterprocess = 4 integer(c_int), parameter :: hipEventRecordDefault = 0 integer(c_int), parameter :: hipEventRecordExternal = 1 integer(c_int), parameter :: hipEventWaitDefault = 0 integer(c_int), parameter :: hipEventWaitExternal = 1 integer(c_int), parameter :: hipEventDisableSystemFence = 536870912 integer(c_int), parameter :: hipEventReleaseToDevice = 1073741824 integer(c_int), parameter :: hipEventReleaseToSystem = -2147483647 - 1 ! 0x80000000 integer(c_int), parameter :: hipEnableDefault = 0 integer(c_int), parameter :: hipEnableLegacyStream = 1 integer(c_int), parameter :: hipEnablePerThreadDefaultStream = 2 integer(c_int), parameter :: hipHostAllocDefault = 0 integer(c_int), parameter :: hipHostMallocDefault = 0 integer(c_int), parameter :: hipHostAllocPortable = 1 integer(c_int), parameter :: hipHostMallocPortable = 1 integer(c_int), parameter :: hipHostAllocMapped = 2 integer(c_int), parameter :: hipHostMallocMapped = 2 integer(c_int), parameter :: hipHostAllocWriteCombined = 4 integer(c_int), parameter :: hipHostMallocWriteCombined = 4 integer(c_int), parameter :: hipHostMallocUncached = 268435456 integer(c_int), parameter :: hipHostMallocNumaUser = 536870912 integer(c_int), parameter :: hipHostMallocCoherent = 1073741824 integer(c_int), parameter :: hipHostMallocNonCoherent = -2147483647 - 1 ! 0x80000000 integer(c_int), parameter :: hipMemAttachGlobal = 1 integer(c_int), parameter :: hipMemAttachHost = 2 integer(c_int), parameter :: hipMemAttachSingle = 4 integer(c_int), parameter :: hipDeviceMallocDefault = 0 integer(c_int), parameter :: hipDeviceMallocFinegrained = 1 integer(c_int), parameter :: hipMallocSignalMemory = 2 integer(c_int), parameter :: hipDeviceMallocUncached = 3 integer(c_int), parameter :: hipDeviceMallocContiguous = 4 integer(c_int), parameter :: hipHostRegisterDefault = 0 integer(c_int), parameter :: hipHostRegisterPortable = 1 integer(c_int), parameter :: hipHostRegisterMapped = 2 integer(c_int), parameter :: hipHostRegisterIoMemory = 4 integer(c_int), parameter :: hipHostRegisterReadOnly = 8 integer(c_int), parameter :: hipExtHostRegisterCoarseGrained = 8 integer(c_int), parameter :: hipExtHostRegisterUncached = -2147483647 - 1 ! 0x80000000 integer(c_int), parameter :: hipDeviceScheduleAuto = 0 integer(c_int), parameter :: hipDeviceScheduleSpin = 1 integer(c_int), parameter :: hipDeviceScheduleYield = 2 integer(c_int), parameter :: hipDeviceScheduleBlockingSync = 4 integer(c_int), parameter :: hipDeviceScheduleMask = 7 integer(c_int), parameter :: hipDeviceMapHost = 8 integer(c_int), parameter :: hipDeviceLmemResizeToMax = 16 integer(c_int), parameter :: hipArrayDefault = 0 integer(c_int), parameter :: hipArrayLayered = 1 integer(c_int), parameter :: hipArraySurfaceLoadStore = 2 integer(c_int), parameter :: hipArrayCubemap = 4 integer(c_int), parameter :: hipArrayTextureGather = 8 integer(c_int), parameter :: hipOccupancyDefault = 0 integer(c_int), parameter :: hipOccupancyDisableCachingOverride = 1 integer(c_int), parameter :: hipCooperativeLaunchMultiDeviceNoPreSync = 1 integer(c_int), parameter :: hipCooperativeLaunchMultiDeviceNoPostSync = 2 integer(c_int), parameter :: hipCpuDeviceId = -1 integer(c_int), parameter :: hipInvalidDeviceId = -2 integer(c_int), parameter :: hipExtAnyOrderLaunch = 1 integer(c_int), parameter :: hipStreamWaitValueGte = 0 integer(c_int), parameter :: hipStreamWaitValueEq = 1 integer(c_int), parameter :: hipStreamWaitValueAnd = 2 integer(c_int), parameter :: hipStreamWaitValueNor = 3 integer(c_int), parameter :: hipStreamWriteValueDefault = 0 integer(c_int), parameter :: hipExtStreamWriteValueIncrement = 4096 integer(c_int), parameter :: hipExtStreamWriteValueDecrement = 4097 integer(c_int), parameter :: hipExternalMemoryDedicated = 1 integer(c_int), parameter :: HIP_EXT_DYN_DATA_PREFETCH_MAX_REGIONS = 2 integer(c_int), parameter :: hipGraphKernelNodePortDefault = 0 integer(c_int), parameter :: hipGraphKernelNodePortLaunchCompletion = 2 integer(c_int), parameter :: hipGraphKernelNodePortProgrammatic = 1 end module hipfort_enums hipfort-rocm-10.0.0/lib/hipfort/hipfort_hipblas.F90000066400000000000000000124515641524740623400221100ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_hipblas use hipfort_hipblas_enums implicit none !> \brief Create the hipBLAS handle. interface hipblasCreate #ifdef USE_CUDA_NAMES function hipblasCreate_(handle) bind(c, name="cublasCreate_v2") #else function hipblasCreate_(handle) bind(c, name="hipblasCreate") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCreate_ type(c_ptr) :: handle end function end interface !> \brief Destroys the library context created using hipblasCreate(). interface hipblasDestroy #ifdef USE_CUDA_NAMES function hipblasDestroy_(handle) bind(c, name="cublasDestroy_v2") #else function hipblasDestroy_(handle) bind(c, name="hipblasDestroy") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDestroy_ type(c_ptr),value :: handle end function end interface !> \brief Gets the hipBLAS library version number. !> \details !> Returns version as integer: major * 10000 + minor * 100 + patch. !> Example: version 3.5.1 returns 30501. !> !> Handle parameter can be NULL. !> !> @param[in] handle - Handle to library context (can be NULL) !> @param[out] version - Pointer to integer for version number !> !> @return HIPBLAS_STATUS_SUCCESS or HIPBLAS_STATUS_INVALID_VALUE if version is NULL interface hipblasGetVersion #ifdef USE_CUDA_NAMES function hipblasGetVersion_(handle,version) bind(c, name="cublasGetVersion") #else function hipblasGetVersion_(handle,version) bind(c, name="hipblasGetVersion") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetVersion_ type(c_ptr),value :: handle integer(c_int) :: version end function end interface !> \brief Gets a specific property of the hipBLAS library. !> \details !> Returns requested property value (major, minor, or patch). !> Does not require a handle. !> !> @param[in] myType - Property type to query !> @param[out] myValue - Pointer to integer for property value !> !> @return HIPBLAS_STATUS_SUCCESS or HIPBLAS_STATUS_INVALID_VALUE interface hipblasGetProperty #ifdef USE_CUDA_NAMES function hipblasGetProperty_(myType,myValue) bind(c, name="cublasGetProperty") #else function hipblasGetProperty_(myType,myValue) bind(c, name="hipblasGetProperty") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetProperty_ integer(kind(HIPBLAS_MAJOR_VERSION)),value :: myType type(c_ptr),value :: myValue end function end interface !> \brief Sets the stream for the handle interface hipblasSetStream #ifdef USE_CUDA_NAMES function hipblasSetStream_(handle,streamId) bind(c, name="cublasSetStream_v2") #else function hipblasSetStream_(handle,streamId) bind(c, name="hipblasSetStream") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSetStream_ type(c_ptr),value :: handle type(c_ptr),value :: streamId end function end interface !> \brief Gets stream[0] for the handle interface hipblasGetStream #ifdef USE_CUDA_NAMES function hipblasGetStream_(handle,streamId) bind(c, name="cublasGetStream_v2") #else function hipblasGetStream_(handle,streamId) bind(c, name="hipblasGetStream") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetStream_ type(c_ptr),value :: handle type(c_ptr) :: streamId end function end interface !> \brief Sets hipBLAS pointer mode interface hipblasSetPointerMode #ifdef USE_CUDA_NAMES function hipblasSetPointerMode_(handle,mode) bind(c, name="cublasSetPointerMode_v2") #else function hipblasSetPointerMode_(handle,mode) bind(c, name="hipblasSetPointerMode") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSetPointerMode_ type(c_ptr),value :: handle integer(kind(HIPBLAS_POINTER_MODE_HOST)),value :: mode end function end interface !> \brief Gets hipBLAS pointer mode interface hipblasGetPointerMode #ifdef USE_CUDA_NAMES function hipblasGetPointerMode_(handle,mode) bind(c, name="cublasGetPointerMode_v2") #else function hipblasGetPointerMode_(handle,mode) bind(c, name="hipblasGetPointerMode") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetPointerMode_ type(c_ptr),value :: handle type(c_ptr),value :: mode end function end interface !> \brief Set hipblas math mode interface hipblasSetMathMode #ifdef USE_CUDA_NAMES function hipblasSetMathMode_(handle,mode) bind(c, name="cublasSetMathMode") #else function hipblasSetMathMode_(handle,mode) bind(c, name="hipblasSetMathMode") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSetMathMode_ type(c_ptr),value :: handle integer(kind(HIPBLAS_DEFAULT_MATH)),value :: mode end function end interface !> \brief Get hipblas math mode interface hipblasGetMathMode #ifdef USE_CUDA_NAMES function hipblasGetMathMode_(handle,mode) bind(c, name="cublasGetMathMode") #else function hipblasGetMathMode_(handle,mode) bind(c, name="hipblasGetMathMode") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetMathMode_ type(c_ptr),value :: handle type(c_ptr),value :: mode end function end interface !> \brief Set hipblas workspace to user-owned device buffer interface hipblasSetWorkspace #ifdef USE_CUDA_NAMES function hipblasSetWorkspace_(handle,workspace,workspaceSizeInBytes) & bind(c, name="cublasSetWorkspace_v2") #else function hipblasSetWorkspace_(handle,workspace,workspaceSizeInBytes) & bind(c, name="hipblasSetWorkspace") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSetWorkspace_ type(c_ptr),value :: handle type(c_ptr),value :: workspace integer(c_size_t),value :: workspaceSizeInBytes end function end interface !> \brief Sets hipblasSetAtomicsMode interface hipblasSetAtomicsMode #ifdef USE_CUDA_NAMES function hipblasSetAtomicsMode_(handle,atomics_mode) bind(c, name="cublasSetAtomicsMode") #else function hipblasSetAtomicsMode_(handle,atomics_mode) bind(c, name="hipblasSetAtomicsMode") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSetAtomicsMode_ type(c_ptr),value :: handle integer(kind(HIPBLAS_ATOMICS_NOT_ALLOWED)),value :: atomics_mode end function end interface !> \brief Gets hipblasSetAtomicsMode interface hipblasGetAtomicsMode #ifdef USE_CUDA_NAMES function hipblasGetAtomicsMode_(handle,atomics_mode) bind(c, name="cublasGetAtomicsMode") #else function hipblasGetAtomicsMode_(handle,atomics_mode) bind(c, name="hipblasGetAtomicsMode") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetAtomicsMode_ type(c_ptr),value :: handle type(c_ptr),value :: atomics_mode end function end interface !> \brief Set alpha stride for a limited set of batched and strided_batched functions to specify !> the stride for alpha between successive batch elements. !> Only applies to hipblasPointerModeDevice and thus device side allocations. !> It enables interpretation of the alpha pointer for both batched and strided_batched !> functions as a pointer to a vector of values. !> Default value is 0 which treats it as a pointer to a single scalar. Support is denoted with !> specific function documentation. !> Warning this is a modal like state in the handle. Restore to value 0 if no longer !> applicable to later function calls. !> - Supported in rocBLAS backend only. #ifndef USE_CUDA_NAMES interface hipblasSetBatchAlphaStride function hipblasSetBatchAlphaStride_(handle,alpha_stride) & bind(c, name="hipblasSetBatchAlphaStride") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSetBatchAlphaStride_ type(c_ptr),value :: handle integer(c_int64_t),value :: alpha_stride end function end interface #endif !> \brief Get batch alpha stride from the handle. #ifndef USE_CUDA_NAMES interface hipblasGetBatchAlphaStride function hipblasGetBatchAlphaStride_(handle,alpha_stride) & bind(c, name="hipblasGetBatchAlphaStride") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetBatchAlphaStride_ type(c_ptr),value :: handle type(c_ptr),value :: alpha_stride end function end interface #endif !> \brief Set beta stride for a limited set of batched and strided_batched functions to specify !> the stride for beta between successive batch elements. !> Only applies to hipblasPointerModeDevice and thus device side allocations. !> It enables interpretation of the beta pointer for both batched and strided_batched !> functions as a pointer to a vector of values. !> Default value is 0 which treats it as a pointer to a single scalar. Support is denoted with !> specific function documentation. !> Warning this is a modal like state in the handle. Restore to value 0 if no longer !> applicable to later function calls. !> - Supported in rocBLAS backend only. #ifndef USE_CUDA_NAMES interface hipblasSetBatchBetaStride function hipblasSetBatchBetaStride_(handle,beta_stride) & bind(c, name="hipblasSetBatchBetaStride") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSetBatchBetaStride_ type(c_ptr),value :: handle integer(c_int64_t),value :: beta_stride end function end interface #endif !> \brief Get batch beta stride from the handle. #ifndef USE_CUDA_NAMES interface hipblasGetBatchBetaStride function hipblasGetBatchBetaStride_(handle,beta_stride) & bind(c, name="hipblasGetBatchBetaStride") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGetBatchBetaStride_ type(c_ptr),value :: handle type(c_ptr),value :: beta_stride end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The amax functions find the first index of the element of maximum magnitude of a vector !> ``x``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in x. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of y. !> @param[inout] myResult !> device pointer or host pointer to store the amax index. !> Return value is 0.0 if n, incx<=0. interface hipblasIsamax #ifdef USE_CUDA_NAMES function hipblasIsamax_(handle,n,x,incx,myResult) bind(c, name="cublasIsamax_v2") #else function hipblasIsamax_(handle,n,x,incx,myResult) bind(c, name="hipblasIsamax") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasIsamax_assumed_rank #else module procedure & hipblasIsamax_rank_0,& hipblasIsamax_rank_1 #endif #endif end interface interface hipblasIdamax #ifdef USE_CUDA_NAMES function hipblasIdamax_(handle,n,x,incx,myResult) bind(c, name="cublasIdamax_v2") #else function hipblasIdamax_(handle,n,x,incx,myResult) bind(c, name="hipblasIdamax") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasIdamax_assumed_rank #else module procedure & hipblasIdamax_rank_0,& hipblasIdamax_rank_1 #endif #endif end interface interface hipblasIcamax #ifdef USE_CUDA_NAMES function hipblasIcamax_(handle,n,x,incx,myResult) bind(c, name="cublasIcamax_v2") #else function hipblasIcamax_(handle,n,x,incx,myResult) bind(c, name="hipblasIcamax") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasIcamax_assumed_rank #else module procedure & hipblasIcamax_rank_0,& hipblasIcamax_rank_1 #endif #endif end interface interface hipblasIzamax #ifdef USE_CUDA_NAMES function hipblasIzamax_(handle,n,x,incx,myResult) bind(c, name="cublasIzamax_v2") #else function hipblasIzamax_(handle,n,x,incx,myResult) bind(c, name="hipblasIzamax") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasIzamax_assumed_rank #else module procedure & hipblasIzamax_rank_0,& hipblasIzamax_rank_1 #endif #endif end interface interface hipblasIsamax_64 #ifdef USE_CUDA_NAMES function hipblasIsamax_64_(handle,n,x,incx,myResult) bind(c, name="cublasIsamax_v2_64") #else function hipblasIsamax_64_(handle,n,x,incx,myResult) bind(c, name="hipblasIsamax_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamax_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface hipblasIdamax_64 #ifdef USE_CUDA_NAMES function hipblasIdamax_64_(handle,n,x,incx,myResult) bind(c, name="cublasIdamax_v2_64") #else function hipblasIdamax_64_(handle,n,x,incx,myResult) bind(c, name="hipblasIdamax_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamax_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface hipblasIcamax_64 #ifdef USE_CUDA_NAMES function hipblasIcamax_64_(handle,n,x,incx,myResult) bind(c, name="cublasIcamax_v2_64") #else function hipblasIcamax_64_(handle,n,x,incx,myResult) bind(c, name="hipblasIcamax_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamax_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface hipblasIzamax_64 #ifdef USE_CUDA_NAMES function hipblasIzamax_64_(handle,n,x,incx,myResult) bind(c, name="cublasIzamax_v2_64") #else function hipblasIzamax_64_(handle,n,x,incx,myResult) bind(c, name="hipblasIzamax_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamax_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface !> \brief BLAS Level 1 API !> !> \details !> The amaxBatched functions find the first index of the element of maximum magnitude of each !> vector ``x_i`` in a batch, for ``i`` = 1, ..., ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> number of elements in each vector x_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] batchCount - [int] !> number of instances in the batch. Must be > 0. !> @param[out] myResult !> device or host array of pointers of batchCount size for results. !> Return value is 0 if n, incx<=0. #ifndef USE_CUDA_NAMES interface hipblasIsamaxBatched function hipblasIsamaxBatched_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasIsamaxBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIdamaxBatched function hipblasIdamaxBatched_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasIdamaxBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIcamaxBatched function hipblasIcamaxBatched_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasIcamaxBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIzamaxBatched function hipblasIzamaxBatched_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasIzamaxBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIsamaxBatched_64 function hipblasIsamaxBatched_64_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasIsamaxBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamaxBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIdamaxBatched_64 function hipblasIdamaxBatched_64_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasIdamaxBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamaxBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIcamaxBatched_64 function hipblasIcamaxBatched_64_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasIcamaxBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamaxBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIzamaxBatched_64 function hipblasIzamaxBatched_64_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasIzamaxBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamaxBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The amaxStridedBatched functions find the first index of the element of maximum magnitude !> of each vector ``x_i`` in a batch, for ``i`` = 1, ..., ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> number of elements in each vector x_i. !> @param[in] x - device pointer to the first vector x_1. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] stridex - [hipblasStride] !> specifies the pointer increment between one x_i and the next x_(i + 1). !> @param[in] batchCount - [int] !> number of instances in the batch. !> @param[out] myResult !> device or host pointer for storing contiguous batchCount results. !> Return value is 0 if n <= 0, incx<=0. #ifndef USE_CUDA_NAMES interface hipblasIsamaxStridedBatched function hipblasIsamaxStridedBatched_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasIsamaxStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasIsamaxStridedBatched_assumed_rank #else module procedure & hipblasIsamaxStridedBatched_rank_0,& hipblasIsamaxStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIdamaxStridedBatched function hipblasIdamaxStridedBatched_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasIdamaxStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasIdamaxStridedBatched_assumed_rank #else module procedure & hipblasIdamaxStridedBatched_rank_0,& hipblasIdamaxStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIcamaxStridedBatched function hipblasIcamaxStridedBatched_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasIcamaxStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasIcamaxStridedBatched_assumed_rank #else module procedure & hipblasIcamaxStridedBatched_rank_0,& hipblasIcamaxStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIzamaxStridedBatched function hipblasIzamaxStridedBatched_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasIzamaxStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasIzamaxStridedBatched_assumed_rank #else module procedure & hipblasIzamaxStridedBatched_rank_0,& hipblasIzamaxStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIsamaxStridedBatched_64 function hipblasIsamaxStridedBatched_64_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasIsamaxStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamaxStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIdamaxStridedBatched_64 function hipblasIdamaxStridedBatched_64_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasIdamaxStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamaxStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIcamaxStridedBatched_64 function hipblasIcamaxStridedBatched_64_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasIcamaxStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamaxStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIzamaxStridedBatched_64 function hipblasIzamaxStridedBatched_64_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasIzamaxStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamaxStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The amin functions find the first index of the element of minimum magnitude of a vector !> ``x``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in x. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of y. !> @param[inout] myResult !> device pointer or host pointer to store the amin index. !> Return value is 0.0 if n, incx<=0. interface hipblasIsamin #ifdef USE_CUDA_NAMES function hipblasIsamin_(handle,n,x,incx,myResult) bind(c, name="cublasIsamin_v2") #else function hipblasIsamin_(handle,n,x,incx,myResult) bind(c, name="hipblasIsamin") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasIsamin_assumed_rank #else module procedure & hipblasIsamin_rank_0,& hipblasIsamin_rank_1 #endif #endif end interface interface hipblasIdamin #ifdef USE_CUDA_NAMES function hipblasIdamin_(handle,n,x,incx,myResult) bind(c, name="cublasIdamin_v2") #else function hipblasIdamin_(handle,n,x,incx,myResult) bind(c, name="hipblasIdamin") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasIdamin_assumed_rank #else module procedure & hipblasIdamin_rank_0,& hipblasIdamin_rank_1 #endif #endif end interface interface hipblasIcamin #ifdef USE_CUDA_NAMES function hipblasIcamin_(handle,n,x,incx,myResult) bind(c, name="cublasIcamin_v2") #else function hipblasIcamin_(handle,n,x,incx,myResult) bind(c, name="hipblasIcamin") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasIcamin_assumed_rank #else module procedure & hipblasIcamin_rank_0,& hipblasIcamin_rank_1 #endif #endif end interface interface hipblasIzamin #ifdef USE_CUDA_NAMES function hipblasIzamin_(handle,n,x,incx,myResult) bind(c, name="cublasIzamin_v2") #else function hipblasIzamin_(handle,n,x,incx,myResult) bind(c, name="hipblasIzamin") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasIzamin_assumed_rank #else module procedure & hipblasIzamin_rank_0,& hipblasIzamin_rank_1 #endif #endif end interface interface hipblasIsamin_64 #ifdef USE_CUDA_NAMES function hipblasIsamin_64_(handle,n,x,incx,myResult) bind(c, name="cublasIsamin_v2_64") #else function hipblasIsamin_64_(handle,n,x,incx,myResult) bind(c, name="hipblasIsamin_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamin_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface hipblasIdamin_64 #ifdef USE_CUDA_NAMES function hipblasIdamin_64_(handle,n,x,incx,myResult) bind(c, name="cublasIdamin_v2_64") #else function hipblasIdamin_64_(handle,n,x,incx,myResult) bind(c, name="hipblasIdamin_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamin_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface hipblasIcamin_64 #ifdef USE_CUDA_NAMES function hipblasIcamin_64_(handle,n,x,incx,myResult) bind(c, name="cublasIcamin_v2_64") #else function hipblasIcamin_64_(handle,n,x,incx,myResult) bind(c, name="hipblasIcamin_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamin_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface hipblasIzamin_64 #ifdef USE_CUDA_NAMES function hipblasIzamin_64_(handle,n,x,incx,myResult) bind(c, name="cublasIzamin_v2_64") #else function hipblasIzamin_64_(handle,n,x,incx,myResult) bind(c, name="hipblasIzamin_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamin_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface !> \brief BLAS Level 1 API !> !> \details !> The aminBatched functions find the first index of the element of minimum magnitude of each !> vector ``x_i`` in a batch, for ``i`` = 1, ..., ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> number of elements in each vector x_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] batchCount - [int] !> number of instances in the batch. Must be > 0. !> @param[out] myResult !> device or host pointers to array of batchCount size for results. !> Return value is 0 if n, incx<=0. #ifndef USE_CUDA_NAMES interface hipblasIsaminBatched function hipblasIsaminBatched_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasIsaminBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIdaminBatched function hipblasIdaminBatched_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasIdaminBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIcaminBatched function hipblasIcaminBatched_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasIcaminBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIzaminBatched function hipblasIzaminBatched_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasIzaminBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIsaminBatched_64 function hipblasIsaminBatched_64_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasIsaminBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsaminBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIdaminBatched_64 function hipblasIdaminBatched_64_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasIdaminBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdaminBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIcaminBatched_64 function hipblasIcaminBatched_64_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasIcaminBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcaminBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIzaminBatched_64 function hipblasIzaminBatched_64_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasIzaminBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzaminBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The aminStridedBatched functions find the first index of the element of minimum magnitude !> of each vector ``x_i`` in a batch, for ``i`` = 1, ..., ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> number of elements in each vector x_i. !> @param[in] x - device pointer to the first vector x_1. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] stridex - [hipblasStride] !> specifies the pointer increment between one x_i and the next x_(i + 1). !> @param[in] batchCount - [int] !> number of instances in the batch. !> @param[out] myResult !> device or host pointer to array for storing contiguous batchCount results. !> Return value is 0 if n <= 0, incx<=0. #ifndef USE_CUDA_NAMES interface hipblasIsaminStridedBatched function hipblasIsaminStridedBatched_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasIsaminStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasIsaminStridedBatched_assumed_rank #else module procedure & hipblasIsaminStridedBatched_rank_0,& hipblasIsaminStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIdaminStridedBatched function hipblasIdaminStridedBatched_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasIdaminStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasIdaminStridedBatched_assumed_rank #else module procedure & hipblasIdaminStridedBatched_rank_0,& hipblasIdaminStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIcaminStridedBatched function hipblasIcaminStridedBatched_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasIcaminStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasIcaminStridedBatched_assumed_rank #else module procedure & hipblasIcaminStridedBatched_rank_0,& hipblasIcaminStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIzaminStridedBatched function hipblasIzaminStridedBatched_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasIzaminStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasIzaminStridedBatched_assumed_rank #else module procedure & hipblasIzaminStridedBatched_rank_0,& hipblasIzaminStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIsaminStridedBatched_64 function hipblasIsaminStridedBatched_64_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasIsaminStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsaminStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIdaminStridedBatched_64 function hipblasIdaminStridedBatched_64_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasIdaminStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdaminStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIcaminStridedBatched_64 function hipblasIcaminStridedBatched_64_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasIcaminStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcaminStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasIzaminStridedBatched_64 function hipblasIzaminStridedBatched_64_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasIzaminStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzaminStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The asum functions compute the sum of the magnitudes of elements of a real vector ``x``, !> or the sum of the magnitudes of the real and imaginary parts of elements if ``x`` is a !> complex vector. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in x and y. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. incx must be > 0. !> @param[inout] myResult !> device pointer or host pointer to store the asum product. !> Return value is 0.0 if n <= 0. interface hipblasSasum #ifdef USE_CUDA_NAMES function hipblasSasum_(handle,n,x,incx,myResult) bind(c, name="cublasSasum_v2") #else function hipblasSasum_(handle,n,x,incx,myResult) bind(c, name="hipblasSasum") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSasum_assumed_rank #else module procedure & hipblasSasum_rank_0,& hipblasSasum_rank_1 #endif #endif end interface interface hipblasDasum #ifdef USE_CUDA_NAMES function hipblasDasum_(handle,n,x,incx,myResult) bind(c, name="cublasDasum_v2") #else function hipblasDasum_(handle,n,x,incx,myResult) bind(c, name="hipblasDasum") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDasum_assumed_rank #else module procedure & hipblasDasum_rank_0,& hipblasDasum_rank_1 #endif #endif end interface interface hipblasScasum #ifdef USE_CUDA_NAMES function hipblasScasum_(handle,n,x,incx,myResult) bind(c, name="cublasScasum_v2") #else function hipblasScasum_(handle,n,x,incx,myResult) bind(c, name="hipblasScasum") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasScasum_assumed_rank #else module procedure & hipblasScasum_rank_0,& hipblasScasum_rank_1 #endif #endif end interface interface hipblasDzasum #ifdef USE_CUDA_NAMES function hipblasDzasum_(handle,n,x,incx,myResult) bind(c, name="cublasDzasum_v2") #else function hipblasDzasum_(handle,n,x,incx,myResult) bind(c, name="hipblasDzasum") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDzasum_assumed_rank #else module procedure & hipblasDzasum_rank_0,& hipblasDzasum_rank_1 #endif #endif end interface interface hipblasSasum_64 #ifdef USE_CUDA_NAMES function hipblasSasum_64_(handle,n,x,incx,myResult) bind(c, name="cublasSasum_v2_64") #else function hipblasSasum_64_(handle,n,x,incx,myResult) bind(c, name="hipblasSasum_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSasum_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface hipblasDasum_64 #ifdef USE_CUDA_NAMES function hipblasDasum_64_(handle,n,x,incx,myResult) bind(c, name="cublasDasum_v2_64") #else function hipblasDasum_64_(handle,n,x,incx,myResult) bind(c, name="hipblasDasum_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDasum_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface hipblasScasum_64 #ifdef USE_CUDA_NAMES function hipblasScasum_64_(handle,n,x,incx,myResult) bind(c, name="cublasScasum_v2_64") #else function hipblasScasum_64_(handle,n,x,incx,myResult) bind(c, name="hipblasScasum_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScasum_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface hipblasDzasum_64 #ifdef USE_CUDA_NAMES function hipblasDzasum_64_(handle,n,x,incx,myResult) bind(c, name="cublasDzasum_v2_64") #else function hipblasDzasum_64_(handle,n,x,incx,myResult) bind(c, name="hipblasDzasum_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDzasum_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface !> \brief BLAS Level 1 API !> !> \details !> The asumBatched functions computes the sum of the magnitudes of the elements in a batch of !> real vectors ``x_i``, !> or the sum of the magnitudes of the real and imaginary parts of elements if ``x_i`` is !> a complex !> vector, for ``i`` = 1, ..., ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> number of elements in each vector x_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] batchCount - [int] !> number of instances in the batch. !> @param[out] myResult !> device array or host array of batchCount size for results. !> Return value is 0.0 if n, incx<=0. #ifndef USE_CUDA_NAMES interface hipblasSasumBatched function hipblasSasumBatched_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasSasumBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDasumBatched function hipblasDasumBatched_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasDasumBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasScasumBatched function hipblasScasumBatched_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasScasumBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDzasumBatched function hipblasDzasumBatched_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasDzasumBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSasumBatched_64 function hipblasSasumBatched_64_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasSasumBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSasumBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDasumBatched_64 function hipblasDasumBatched_64_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasDasumBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDasumBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasScasumBatched_64 function hipblasScasumBatched_64_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasScasumBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScasumBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDzasumBatched_64 function hipblasDzasumBatched_64_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasDzasumBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDzasumBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The asumStridedBatched functions compute the sum of the magnitudes of elements of real !> vectors ``x_i``, !> or the sum of the magnitudes of the real and imaginary parts of elements if ``x_i`` is !> a complex !> vector, for ``i`` = 1, ..., ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> number of elements in each vector x_i. !> @param[in] x - device pointer to the first vector x_1. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stride_x. However, the user should !> take care to ensure that stride_x is of an appropriate size. For a typical !> case, this means stride_x >= n * incx. !> @param[in] batchCount - [int] !> number of instances in the batch. !> @param[out] myResult !> device pointer or host pointer to array for storing contiguous batchCount !> results. !> Return value is 0.0 if n, incx<=0. #ifndef USE_CUDA_NAMES interface hipblasSasumStridedBatched function hipblasSasumStridedBatched_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasSasumStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSasumStridedBatched_assumed_rank #else module procedure & hipblasSasumStridedBatched_rank_0,& hipblasSasumStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDasumStridedBatched function hipblasDasumStridedBatched_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasDasumStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDasumStridedBatched_assumed_rank #else module procedure & hipblasDasumStridedBatched_rank_0,& hipblasDasumStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasScasumStridedBatched function hipblasScasumStridedBatched_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasScasumStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasScasumStridedBatched_assumed_rank #else module procedure & hipblasScasumStridedBatched_rank_0,& hipblasScasumStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDzasumStridedBatched function hipblasDzasumStridedBatched_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasDzasumStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDzasumStridedBatched_assumed_rank #else module procedure & hipblasDzasumStridedBatched_rank_0,& hipblasDzasumStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSasumStridedBatched_64 function hipblasSasumStridedBatched_64_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasSasumStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSasumStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDasumStridedBatched_64 function hipblasDasumStridedBatched_64_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasDasumStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDasumStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasScasumStridedBatched_64 function hipblasScasumStridedBatched_64_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasScasumStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScasumStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDzasumStridedBatched_64 function hipblasDzasumStridedBatched_64_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasDzasumStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDzasumStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The axpy functions compute a constant ``alpha`` multiplied by vector ``x`` plus vector !> ``y``. !> !> y := alpha * x + y !> !> - Supported precisions in rocBLAS : ``h``, ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in x and y. !> @param[in] alpha - device pointer or host pointer to specify the scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[out] y - device pointer storing vector y. !> @param[inout] incy - [int] !> specifies the increment for the elements of y. #ifndef USE_CUDA_NAMES interface hipblasHaxpy function hipblasHaxpy_(handle,n,alpha,x,incx,y,incy) bind(c, name="hipblasHaxpy") use iso_c_binding use hipfort_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 type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function end interface #endif interface hipblasSaxpy #ifdef USE_CUDA_NAMES function hipblasSaxpy_(handle,n,alpha,x,incx,y,incy) bind(c, name="cublasSaxpy_v2") #else function hipblasSaxpy_(handle,n,alpha,x,incx,y,incy) bind(c, name="hipblasSaxpy") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSaxpy_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSaxpy_assumed_rank #else module procedure & hipblasSaxpy_rank_0,& hipblasSaxpy_rank_1 #endif #endif end interface interface hipblasDaxpy #ifdef USE_CUDA_NAMES function hipblasDaxpy_(handle,n,alpha,x,incx,y,incy) bind(c, name="cublasDaxpy_v2") #else function hipblasDaxpy_(handle,n,alpha,x,incx,y,incy) bind(c, name="hipblasDaxpy") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDaxpy_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDaxpy_assumed_rank #else module procedure & hipblasDaxpy_rank_0,& hipblasDaxpy_rank_1 #endif #endif end interface interface hipblasCaxpy #ifdef USE_CUDA_NAMES function hipblasCaxpy_(handle,n,alpha,x,incx,y,incy) bind(c, name="cublasCaxpy_v2") #else function hipblasCaxpy_(handle,n,alpha,x,incx,y,incy) bind(c, name="hipblasCaxpy") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCaxpy_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCaxpy_assumed_rank #else module procedure & hipblasCaxpy_rank_0,& hipblasCaxpy_rank_1 #endif #endif end interface interface hipblasZaxpy #ifdef USE_CUDA_NAMES function hipblasZaxpy_(handle,n,alpha,x,incx,y,incy) bind(c, name="cublasZaxpy_v2") #else function hipblasZaxpy_(handle,n,alpha,x,incx,y,incy) bind(c, name="hipblasZaxpy") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZaxpy_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZaxpy_assumed_rank #else module procedure & hipblasZaxpy_rank_0,& hipblasZaxpy_rank_1 #endif #endif end interface #ifndef USE_CUDA_NAMES interface hipblasHaxpy_64 function hipblasHaxpy_64_(handle,n,alpha,x,incx,y,incy) bind(c, name="hipblasHaxpy_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHaxpy_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface #endif interface hipblasSaxpy_64 #ifdef USE_CUDA_NAMES function hipblasSaxpy_64_(handle,n,alpha,x,incx,y,incy) bind(c, name="cublasSaxpy_v2_64") #else function hipblasSaxpy_64_(handle,n,alpha,x,incx,y,incy) bind(c, name="hipblasSaxpy_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSaxpy_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasDaxpy_64 #ifdef USE_CUDA_NAMES function hipblasDaxpy_64_(handle,n,alpha,x,incx,y,incy) bind(c, name="cublasDaxpy_v2_64") #else function hipblasDaxpy_64_(handle,n,alpha,x,incx,y,incy) bind(c, name="hipblasDaxpy_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDaxpy_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasCaxpy_64 #ifdef USE_CUDA_NAMES function hipblasCaxpy_64_(handle,n,alpha,x,incx,y,incy) bind(c, name="cublasCaxpy_v2_64") #else function hipblasCaxpy_64_(handle,n,alpha,x,incx,y,incy) bind(c, name="hipblasCaxpy_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCaxpy_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasZaxpy_64 #ifdef USE_CUDA_NAMES function hipblasZaxpy_64_(handle,n,alpha,x,incx,y,incy) bind(c, name="cublasZaxpy_v2_64") #else function hipblasZaxpy_64_(handle,n,alpha,x,incx,y,incy) bind(c, name="hipblasZaxpy_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZaxpy_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 1 API !> !> \details !> The axpyBatched functions compute ``y := alpha * x + y`` over a set of batched vectors. !> !> - Supported precisions in rocBLAS : ``h``, ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in x and y. !> @param[in] alpha - specifies the scalar alpha. !> @param[in] x - pointer storing vector x on the GPU. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[out] y - pointer storing vector y on the GPU. !> @param[inout] incy - [int] !> specifies the increment for the elements of y. !> !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasHaxpyBatched function hipblasHaxpyBatched_(handle,n,alpha,x,incx,y,incy,batchCount) & bind(c, name="hipblasHaxpyBatched") use iso_c_binding use hipfort_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 type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSaxpyBatched function hipblasSaxpyBatched_(handle,n,alpha,x,incx,y,incy,batchCount) & bind(c, name="hipblasSaxpyBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSaxpyBatched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDaxpyBatched function hipblasDaxpyBatched_(handle,n,alpha,x,incx,y,incy,batchCount) & bind(c, name="hipblasDaxpyBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDaxpyBatched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCaxpyBatched function hipblasCaxpyBatched_(handle,n,alpha,x,incx,y,incy,batchCount) & bind(c, name="hipblasCaxpyBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCaxpyBatched_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZaxpyBatched function hipblasZaxpyBatched_(handle,n,alpha,x,incx,y,incy,batchCount) & bind(c, name="hipblasZaxpyBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZaxpyBatched_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasHaxpyBatched_64 function hipblasHaxpyBatched_64_(handle,n,alpha,x,incx,y,incy,batchCount) & bind(c, name="hipblasHaxpyBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHaxpyBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSaxpyBatched_64 function hipblasSaxpyBatched_64_(handle,n,alpha,x,incx,y,incy,batchCount) & bind(c, name="hipblasSaxpyBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSaxpyBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDaxpyBatched_64 function hipblasDaxpyBatched_64_(handle,n,alpha,x,incx,y,incy,batchCount) & bind(c, name="hipblasDaxpyBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDaxpyBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCaxpyBatched_64 function hipblasCaxpyBatched_64_(handle,n,alpha,x,incx,y,incy,batchCount) & bind(c, name="hipblasCaxpyBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCaxpyBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZaxpyBatched_64 function hipblasZaxpyBatched_64_(handle,n,alpha,x,incx,y,incy,batchCount) & bind(c, name="hipblasZaxpyBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZaxpyBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The axpyStridedBatched functions compute ``y := alpha * x + y`` over a set of strided !> batched vectors. !> !> - Supported precisions in rocBLAS : ``h``, ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> @param[in] alpha - specifies the scalar alpha. !> @param[in] x - pointer storing vector x on the GPU. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[in] stridex - [hipblasStride] !> specifies the increment between vectors of x. !> @param[out] y - pointer storing vector y on the GPU. !> @param[inout] incy - [int] !> specifies the increment for the elements of y. !> @param[in] stridey - [hipblasStride] !> specifies the increment between vectors of y. !> !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasHaxpyStridedBatched function hipblasHaxpyStridedBatched_(handle,n,alpha,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasHaxpyStridedBatched") use iso_c_binding use hipfort_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 type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSaxpyStridedBatched function hipblasSaxpyStridedBatched_(handle,n,alpha,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasSaxpyStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSaxpyStridedBatched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSaxpyStridedBatched_assumed_rank #else module procedure & hipblasSaxpyStridedBatched_rank_0,& hipblasSaxpyStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDaxpyStridedBatched function hipblasDaxpyStridedBatched_(handle,n,alpha,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasDaxpyStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDaxpyStridedBatched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDaxpyStridedBatched_assumed_rank #else module procedure & hipblasDaxpyStridedBatched_rank_0,& hipblasDaxpyStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCaxpyStridedBatched function hipblasCaxpyStridedBatched_(handle,n,alpha,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasCaxpyStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCaxpyStridedBatched_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCaxpyStridedBatched_assumed_rank #else module procedure & hipblasCaxpyStridedBatched_rank_0,& hipblasCaxpyStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZaxpyStridedBatched function hipblasZaxpyStridedBatched_(handle,n,alpha,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasZaxpyStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZaxpyStridedBatched_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZaxpyStridedBatched_assumed_rank #else module procedure & hipblasZaxpyStridedBatched_rank_0,& hipblasZaxpyStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasHaxpyStridedBatched_64 function hipblasHaxpyStridedBatched_64_(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batchCount) & bind(c, name="hipblasHaxpyStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHaxpyStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSaxpyStridedBatched_64 function hipblasSaxpyStridedBatched_64_(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batchCount) & bind(c, name="hipblasSaxpyStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSaxpyStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDaxpyStridedBatched_64 function hipblasDaxpyStridedBatched_64_(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batchCount) & bind(c, name="hipblasDaxpyStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDaxpyStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCaxpyStridedBatched_64 function hipblasCaxpyStridedBatched_64_(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batchCount) & bind(c, name="hipblasCaxpyStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCaxpyStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZaxpyStridedBatched_64 function hipblasZaxpyStridedBatched_64_(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batchCount) & bind(c, name="hipblasZaxpyStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZaxpyStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The copy functions copy each element x[i] into y[i], for ``i`` = 1 , ... , ``n``. !> !> y := x, !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in x to be copied to y. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[out] y - device pointer storing vector y. !> @param[in] incy - [int] !> specifies the increment for the elements of y. interface hipblasScopy #ifdef USE_CUDA_NAMES function hipblasScopy_(handle,n,x,incx,y,incy) bind(c, name="cublasScopy_v2") #else function hipblasScopy_(handle,n,x,incx,y,incy) bind(c, name="hipblasScopy") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasScopy_assumed_rank #else module procedure & hipblasScopy_rank_0,& hipblasScopy_rank_1 #endif #endif end interface interface hipblasDcopy #ifdef USE_CUDA_NAMES function hipblasDcopy_(handle,n,x,incx,y,incy) bind(c, name="cublasDcopy_v2") #else function hipblasDcopy_(handle,n,x,incx,y,incy) bind(c, name="hipblasDcopy") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDcopy_assumed_rank #else module procedure & hipblasDcopy_rank_0,& hipblasDcopy_rank_1 #endif #endif end interface interface hipblasCcopy #ifdef USE_CUDA_NAMES function hipblasCcopy_(handle,n,x,incx,y,incy) bind(c, name="cublasCcopy_v2") #else function hipblasCcopy_(handle,n,x,incx,y,incy) bind(c, name="hipblasCcopy") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCcopy_assumed_rank #else module procedure & hipblasCcopy_rank_0,& hipblasCcopy_rank_1 #endif #endif end interface interface hipblasZcopy #ifdef USE_CUDA_NAMES function hipblasZcopy_(handle,n,x,incx,y,incy) bind(c, name="cublasZcopy_v2") #else function hipblasZcopy_(handle,n,x,incx,y,incy) bind(c, name="hipblasZcopy") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZcopy_assumed_rank #else module procedure & hipblasZcopy_rank_0,& hipblasZcopy_rank_1 #endif #endif end interface interface hipblasScopy_64 #ifdef USE_CUDA_NAMES function hipblasScopy_64_(handle,n,x,incx,y,incy) bind(c, name="cublasScopy_v2_64") #else function hipblasScopy_64_(handle,n,x,incx,y,incy) bind(c, name="hipblasScopy_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScopy_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasDcopy_64 #ifdef USE_CUDA_NAMES function hipblasDcopy_64_(handle,n,x,incx,y,incy) bind(c, name="cublasDcopy_v2_64") #else function hipblasDcopy_64_(handle,n,x,incx,y,incy) bind(c, name="hipblasDcopy_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDcopy_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasCcopy_64 #ifdef USE_CUDA_NAMES function hipblasCcopy_64_(handle,n,x,incx,y,incy) bind(c, name="cublasCcopy_v2_64") #else function hipblasCcopy_64_(handle,n,x,incx,y,incy) bind(c, name="hipblasCcopy_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCcopy_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasZcopy_64 #ifdef USE_CUDA_NAMES function hipblasZcopy_64_(handle,n,x,incx,y,incy) bind(c, name="cublasZcopy_v2_64") #else function hipblasZcopy_64_(handle,n,x,incx,y,incy) bind(c, name="hipblasZcopy_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZcopy_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 1 API !> !> \details !> The copyBatched functions copy each element x_i[j] into y_i[j], for ``j`` = 1 , ... , !> ``n``; ``i`` = 1 , ... , ``batchCount``. !> !> y_i := x_i, !> !> where (``x_i``, ``y_i``) is the ``i``-th instance of the batch. !> ``x_i`` and ``y_i`` are vectors. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in each x_i to be copied to y_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each vector x_i. !> @param[out] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of each vector y_i. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasScopyBatched function hipblasScopyBatched_(handle,n,x,incx,y,incy,batchCount) & bind(c, name="hipblasScopyBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDcopyBatched function hipblasDcopyBatched_(handle,n,x,incx,y,incy,batchCount) & bind(c, name="hipblasDcopyBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCcopyBatched function hipblasCcopyBatched_(handle,n,x,incx,y,incy,batchCount) & bind(c, name="hipblasCcopyBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZcopyBatched function hipblasZcopyBatched_(handle,n,x,incx,y,incy,batchCount) & bind(c, name="hipblasZcopyBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasScopyBatched_64 function hipblasScopyBatched_64_(handle,n,x,incx,y,incy,batchCount) & bind(c, name="hipblasScopyBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScopyBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDcopyBatched_64 function hipblasDcopyBatched_64_(handle,n,x,incx,y,incy,batchCount) & bind(c, name="hipblasDcopyBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDcopyBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCcopyBatched_64 function hipblasCcopyBatched_64_(handle,n,x,incx,y,incy,batchCount) & bind(c, name="hipblasCcopyBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCcopyBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZcopyBatched_64 function hipblasZcopyBatched_64_(handle,n,x,incx,y,incy,batchCount) & bind(c, name="hipblasZcopyBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZcopyBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The copyStridedBatched functions copy each element x_i[j] into y_i[j], for ``j`` = 1 , ... !> , ``n``; ``i`` = 1 , ... , ``batchCount``. !> !> y_i := x_i, !> !> where (``x_i``, ``y_i``) is the ``i``-th instance of the batch. !> ``x_i`` and ``y_i`` are vectors. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in each x_i to be copied to y_i. !> @param[in] x - device pointer to the first vector (x_1) in the batch. !> @param[in] incx - [int] !> specifies the increments for the elements of vectors x_i. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stridex. However, the user should !> ensure that stridex is of an appropriate size. For a typical !> case, this means stridex >= n * incx. !> @param[out] y - device pointer to the first vector (y_1) in the batch. !> @param[in] incy - [int] !> specifies the increment for the elements of vectors y_i. !> @param[in] stridey - [hipblasStride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> There are no restrictions placed on stridey. However, the user should !> ensure that stridey is of an appropriate size. For a typical !> case this means stridey >= n * incy. stridey should be non zero. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasScopyStridedBatched function hipblasScopyStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasScopyStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasScopyStridedBatched_assumed_rank #else module procedure & hipblasScopyStridedBatched_rank_0,& hipblasScopyStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDcopyStridedBatched function hipblasDcopyStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasDcopyStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDcopyStridedBatched_assumed_rank #else module procedure & hipblasDcopyStridedBatched_rank_0,& hipblasDcopyStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCcopyStridedBatched function hipblasCcopyStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasCcopyStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCcopyStridedBatched_assumed_rank #else module procedure & hipblasCcopyStridedBatched_rank_0,& hipblasCcopyStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZcopyStridedBatched function hipblasZcopyStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasZcopyStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZcopyStridedBatched_assumed_rank #else module procedure & hipblasZcopyStridedBatched_rank_0,& hipblasZcopyStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasScopyStridedBatched_64 function hipblasScopyStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasScopyStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScopyStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDcopyStridedBatched_64 function hipblasDcopyStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasDcopyStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDcopyStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCcopyStridedBatched_64 function hipblasCcopyStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasCcopyStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCcopyStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZcopyStridedBatched_64 function hipblasZcopyStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasZcopyStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZcopyStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The dot(u) functions performs the dot product of vectors ``x`` and ``y``. !> !> result = x * y; !> !> The dotc functions performs the dot product of the conjugate of complex vector ``x`` and !> complex vector ``y``. !> !> result = conjugate (x) * y; !> !> - Supported precisions in rocBLAS : ``h``, ``bf``, ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in x and y. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of y. !> @param[in] y - device pointer storing vector y. !> @param[in] incy - [int] !> specifies the increment for the elements of y. !> @param[inout] myResult !> device pointer or host pointer to store the dot product. !> Return value is 0.0 if n <= 0. #ifndef USE_CUDA_NAMES interface hipblasHdot function hipblasHdot_(handle,n,x,incx,y,incy,myResult) bind(c, name="hipblasHdot") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasBfdot function hipblasBfdot_(handle,n,x,incx,y,incy,myResult) bind(c, name="hipblasBfdot") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: myResult end function end interface #endif interface hipblasSdot #ifdef USE_CUDA_NAMES function hipblasSdot_(handle,n,x,incx,y,incy,myResult) bind(c, name="cublasSdot_v2") #else function hipblasSdot_(handle,n,x,incx,y,incy,myResult) bind(c, name="hipblasSdot") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSdot_assumed_rank #else module procedure & hipblasSdot_rank_0,& hipblasSdot_rank_1 #endif #endif end interface interface hipblasDdot #ifdef USE_CUDA_NAMES function hipblasDdot_(handle,n,x,incx,y,incy,myResult) bind(c, name="cublasDdot_v2") #else function hipblasDdot_(handle,n,x,incx,y,incy,myResult) bind(c, name="hipblasDdot") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDdot_assumed_rank #else module procedure & hipblasDdot_rank_0,& hipblasDdot_rank_1 #endif #endif end interface interface hipblasCdotc #ifdef USE_CUDA_NAMES function hipblasCdotc_(handle,n,x,incx,y,incy,myResult) bind(c, name="cublasCdotc_v2") #else function hipblasCdotc_(handle,n,x,incx,y,incy,myResult) bind(c, name="hipblasCdotc") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCdotc_assumed_rank #else module procedure & hipblasCdotc_rank_0,& hipblasCdotc_rank_1 #endif #endif end interface interface hipblasCdotu #ifdef USE_CUDA_NAMES function hipblasCdotu_(handle,n,x,incx,y,incy,myResult) bind(c, name="cublasCdotu_v2") #else function hipblasCdotu_(handle,n,x,incx,y,incy,myResult) bind(c, name="hipblasCdotu") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCdotu_assumed_rank #else module procedure & hipblasCdotu_rank_0,& hipblasCdotu_rank_1 #endif #endif end interface interface hipblasZdotc #ifdef USE_CUDA_NAMES function hipblasZdotc_(handle,n,x,incx,y,incy,myResult) bind(c, name="cublasZdotc_v2") #else function hipblasZdotc_(handle,n,x,incx,y,incy,myResult) bind(c, name="hipblasZdotc") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZdotc_assumed_rank #else module procedure & hipblasZdotc_rank_0,& hipblasZdotc_rank_1 #endif #endif end interface interface hipblasZdotu #ifdef USE_CUDA_NAMES function hipblasZdotu_(handle,n,x,incx,y,incy,myResult) bind(c, name="cublasZdotu_v2") #else function hipblasZdotu_(handle,n,x,incx,y,incy,myResult) bind(c, name="hipblasZdotu") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZdotu_assumed_rank #else module procedure & hipblasZdotu_rank_0,& hipblasZdotu_rank_1 #endif #endif end interface #ifndef USE_CUDA_NAMES interface hipblasHdot_64 function hipblasHdot_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="hipblasHdot_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHdot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasBfdot_64 function hipblasBfdot_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="hipblasBfdot_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasBfdot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: myResult end function end interface #endif interface hipblasSdot_64 #ifdef USE_CUDA_NAMES function hipblasSdot_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="cublasSdot_v2_64") #else function hipblasSdot_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="hipblasSdot_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: myResult end function end interface interface hipblasDdot_64 #ifdef USE_CUDA_NAMES function hipblasDdot_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="cublasDdot_v2_64") #else function hipblasDdot_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="hipblasDdot_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: myResult end function end interface interface hipblasCdotc_64 #ifdef USE_CUDA_NAMES function hipblasCdotc_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="cublasCdotc_v2_64") #else function hipblasCdotc_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="hipblasCdotc_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotc_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: myResult end function end interface interface hipblasCdotu_64 #ifdef USE_CUDA_NAMES function hipblasCdotu_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="cublasCdotu_v2_64") #else function hipblasCdotu_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="hipblasCdotu_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotu_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: myResult end function end interface interface hipblasZdotc_64 #ifdef USE_CUDA_NAMES function hipblasZdotc_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="cublasZdotc_v2_64") #else function hipblasZdotc_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="hipblasZdotc_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotc_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: myResult end function end interface interface hipblasZdotu_64 #ifdef USE_CUDA_NAMES function hipblasZdotu_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="cublasZdotu_v2_64") #else function hipblasZdotu_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="hipblasZdotu_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotu_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: myResult end function end interface !> \brief BLAS Level 1 API !> !> \details !> The dot(u)Batched functions perform a batch of dot products of vectors ``x`` and ``y``. !> !> result_i = x_i * y_i; !> !> The dotcBatched functions performs a batch of dot products of the conjugate of complex !> vector ``x`` and complex vector ``y``. !> !> result_i = conjugate (x_i) * y_i; !> !> where (``x_i``, ``y_i``) is the ``i``-th instance of the batch and !> ``x_i`` and ``y_i`` are vectors, for ``i`` = 1, ..., ``batchCount``. !> !> - Supported precisions in rocBLAS : ``h``, ``bf``, ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in each x_i and y_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of each y_i. !> @param[in] batchCount - [int] !> number of instances in the batch. !> @param[inout] myResult !> device array or host array of batchCount size to store the dot products of each !> batch. !> Returns 0.0 for each element if n <= 0. #ifndef USE_CUDA_NAMES interface hipblasHdotBatched function hipblasHdotBatched_(handle,n,x,incx,y,incy,batchCount,myResult) & bind(c, name="hipblasHdotBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasBfdotBatched function hipblasBfdotBatched_(handle,n,x,incx,y,incy,batchCount,myResult) & bind(c, name="hipblasBfdotBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSdotBatched function hipblasSdotBatched_(handle,n,x,incx,y,incy,batchCount,myResult) & bind(c, name="hipblasSdotBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDdotBatched function hipblasDdotBatched_(handle,n,x,incx,y,incy,batchCount,myResult) & bind(c, name="hipblasDdotBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCdotcBatched function hipblasCdotcBatched_(handle,n,x,incx,y,incy,batchCount,myResult) & bind(c, name="hipblasCdotcBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCdotuBatched function hipblasCdotuBatched_(handle,n,x,incx,y,incy,batchCount,myResult) & bind(c, name="hipblasCdotuBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdotcBatched function hipblasZdotcBatched_(handle,n,x,incx,y,incy,batchCount,myResult) & bind(c, name="hipblasZdotcBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdotuBatched function hipblasZdotuBatched_(handle,n,x,incx,y,incy,batchCount,myResult) & bind(c, name="hipblasZdotuBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasHdotBatched_64 function hipblasHdotBatched_64_(handle,n,x,incx,y,incy,batchCount,myResult) & bind(c, name="hipblasHdotBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHdotBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasBfdotBatched_64 function hipblasBfdotBatched_64_(handle,n,x,incx,y,incy,batchCount,myResult) & bind(c, name="hipblasBfdotBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasBfdotBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSdotBatched_64 function hipblasSdotBatched_64_(handle,n,x,incx,y,incy,batchCount,myResult) & bind(c, name="hipblasSdotBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdotBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDdotBatched_64 function hipblasDdotBatched_64_(handle,n,x,incx,y,incy,batchCount,myResult) & bind(c, name="hipblasDdotBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdotBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCdotcBatched_64 function hipblasCdotcBatched_64_(handle,n,x,incx,y,incy,batchCount,myResult) & bind(c, name="hipblasCdotcBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotcBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCdotuBatched_64 function hipblasCdotuBatched_64_(handle,n,x,incx,y,incy,batchCount,myResult) & bind(c, name="hipblasCdotuBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotuBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdotcBatched_64 function hipblasZdotcBatched_64_(handle,n,x,incx,y,incy,batchCount,myResult) & bind(c, name="hipblasZdotcBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotcBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdotuBatched_64 function hipblasZdotuBatched_64_(handle,n,x,incx,y,incy,batchCount,myResult) & bind(c, name="hipblasZdotuBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotuBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The dot(u)StridedBatched functions perform a batch of dot products of vectors ``x`` and !> ``y``. !> !> result_i = x_i * y_i; !> !> The dotcStridedBatched functions perform a batch of dot products of the conjugate of !> complex vector ``x`` and complex vector ``y``. !> !> result_i = conjugate (x_i) * y_i; !> !> where (``x_i``, ``y_i``) is the ``i``-th instance of the batch and !> ``x_i`` and ``y_i`` are vectors, for ``i`` = 1, ..., ``batchCount``. !> !> - Supported precisions in rocBLAS : ``h``, ``bf``, ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in each x_i and y_i. !> @param[in] x - device pointer to the first vector (x_1) in the batch. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[in] y - device pointer to the first vector (y_1) in the batch. !> @param[in] incy - [int] !> specifies the increment for the elements of each y_i. !> @param[in] stridey - [hipblasStride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> @param[in] batchCount - [int] !> number of instances in the batch. !> @param[inout] myResult !> device array or host array of batchCount size to store the dot products of each !> batch. !> Returns 0.0 for each element if n <= 0. #ifndef USE_CUDA_NAMES interface hipblasHdotStridedBatched function hipblasHdotStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) & bind(c, name="hipblasHdotStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasBfdotStridedBatched function hipblasBfdotStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) & bind(c, name="hipblasBfdotStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSdotStridedBatched function hipblasSdotStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) & bind(c, name="hipblasSdotStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSdotStridedBatched_assumed_rank #else module procedure & hipblasSdotStridedBatched_rank_0,& hipblasSdotStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDdotStridedBatched function hipblasDdotStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) & bind(c, name="hipblasDdotStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDdotStridedBatched_assumed_rank #else module procedure & hipblasDdotStridedBatched_rank_0,& hipblasDdotStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCdotcStridedBatched function hipblasCdotcStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) & bind(c, name="hipblasCdotcStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCdotcStridedBatched_assumed_rank #else module procedure & hipblasCdotcStridedBatched_rank_0,& hipblasCdotcStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCdotuStridedBatched function hipblasCdotuStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) & bind(c, name="hipblasCdotuStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCdotuStridedBatched_assumed_rank #else module procedure & hipblasCdotuStridedBatched_rank_0,& hipblasCdotuStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdotcStridedBatched function hipblasZdotcStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) & bind(c, name="hipblasZdotcStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZdotcStridedBatched_assumed_rank #else module procedure & hipblasZdotcStridedBatched_rank_0,& hipblasZdotcStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdotuStridedBatched function hipblasZdotuStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) & bind(c, name="hipblasZdotuStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZdotuStridedBatched_assumed_rank #else module procedure & hipblasZdotuStridedBatched_rank_0,& hipblasZdotuStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasHdotStridedBatched_64 function hipblasHdotStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) & bind(c, name="hipblasHdotStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHdotStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasBfdotStridedBatched_64 function hipblasBfdotStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) & bind(c, name="hipblasBfdotStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasBfdotStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSdotStridedBatched_64 function hipblasSdotStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) & bind(c, name="hipblasSdotStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdotStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDdotStridedBatched_64 function hipblasDdotStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) & bind(c, name="hipblasDdotStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdotStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCdotcStridedBatched_64 function hipblasCdotcStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) & bind(c, name="hipblasCdotcStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotcStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCdotuStridedBatched_64 function hipblasCdotuStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) & bind(c, name="hipblasCdotuStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotuStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdotcStridedBatched_64 function hipblasZdotcStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) & bind(c, name="hipblasZdotcStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotcStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdotuStridedBatched_64 function hipblasZdotuStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) & bind(c, name="hipblasZdotuStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotuStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The nrm2 functions compute the Euclidean norm of a real or complex vector. !> !> result := sqrt( x'*x ) for real vectors !> result := sqrt( x**H*x ) for complex vectors !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, ``z``, ``sc``, and ``dz``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``sc``, and ``dz``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in x. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of y. !> @param[inout] myResult !> device pointer or host pointer to store the nrm2 product. !> Return value is 0.0 if n, incx<=0. interface hipblasSnrm2 #ifdef USE_CUDA_NAMES function hipblasSnrm2_(handle,n,x,incx,myResult) bind(c, name="cublasSnrm2_v2") #else function hipblasSnrm2_(handle,n,x,incx,myResult) bind(c, name="hipblasSnrm2") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSnrm2_assumed_rank #else module procedure & hipblasSnrm2_rank_0,& hipblasSnrm2_rank_1 #endif #endif end interface interface hipblasDnrm2 #ifdef USE_CUDA_NAMES function hipblasDnrm2_(handle,n,x,incx,myResult) bind(c, name="cublasDnrm2_v2") #else function hipblasDnrm2_(handle,n,x,incx,myResult) bind(c, name="hipblasDnrm2") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDnrm2_assumed_rank #else module procedure & hipblasDnrm2_rank_0,& hipblasDnrm2_rank_1 #endif #endif end interface interface hipblasScnrm2 #ifdef USE_CUDA_NAMES function hipblasScnrm2_(handle,n,x,incx,myResult) bind(c, name="cublasScnrm2_v2") #else function hipblasScnrm2_(handle,n,x,incx,myResult) bind(c, name="hipblasScnrm2") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasScnrm2_assumed_rank #else module procedure & hipblasScnrm2_rank_0,& hipblasScnrm2_rank_1 #endif #endif end interface interface hipblasDznrm2 #ifdef USE_CUDA_NAMES function hipblasDznrm2_(handle,n,x,incx,myResult) bind(c, name="cublasDznrm2_v2") #else function hipblasDznrm2_(handle,n,x,incx,myResult) bind(c, name="hipblasDznrm2") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDznrm2_assumed_rank #else module procedure & hipblasDznrm2_rank_0,& hipblasDznrm2_rank_1 #endif #endif end interface interface hipblasSnrm2_64 #ifdef USE_CUDA_NAMES function hipblasSnrm2_64_(handle,n,x,incx,myResult) bind(c, name="cublasSnrm2_v2_64") #else function hipblasSnrm2_64_(handle,n,x,incx,myResult) bind(c, name="hipblasSnrm2_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSnrm2_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface hipblasDnrm2_64 #ifdef USE_CUDA_NAMES function hipblasDnrm2_64_(handle,n,x,incx,myResult) bind(c, name="cublasDnrm2_v2_64") #else function hipblasDnrm2_64_(handle,n,x,incx,myResult) bind(c, name="hipblasDnrm2_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDnrm2_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface hipblasScnrm2_64 #ifdef USE_CUDA_NAMES function hipblasScnrm2_64_(handle,n,x,incx,myResult) bind(c, name="cublasScnrm2_v2_64") #else function hipblasScnrm2_64_(handle,n,x,incx,myResult) bind(c, name="hipblasScnrm2_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScnrm2_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface hipblasDznrm2_64 #ifdef USE_CUDA_NAMES function hipblasDznrm2_64_(handle,n,x,incx,myResult) bind(c, name="cublasDznrm2_v2_64") #else function hipblasDznrm2_64_(handle,n,x,incx,myResult) bind(c, name="hipblasDznrm2_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDznrm2_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface !> \brief BLAS Level 1 API !> !> \details !> The nrm2Batched functions compute the Euclidean norm over a batch of real or complex !> vectors. !> !> result := sqrt( x_i'*x_i ) for real vectors x, for i = 1, ..., batchCount !> result := sqrt( x_i**H*x_i ) for complex vectors x, for i = 1, ..., batchCount !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, ``z``, ``sc``, and ``dz``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> number of elements in each x_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] batchCount - [int] !> number of instances in the batch. !> @param[out] myResult !> device pointer or host pointer to array of batchCount size for nrm2 results. !> Return value is 0.0 for each element if n <= 0, incx<=0. #ifndef USE_CUDA_NAMES interface hipblasSnrm2Batched function hipblasSnrm2Batched_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasSnrm2Batched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDnrm2Batched function hipblasDnrm2Batched_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasDnrm2Batched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasScnrm2Batched function hipblasScnrm2Batched_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasScnrm2Batched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDznrm2Batched function hipblasDznrm2Batched_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasDznrm2Batched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSnrm2Batched_64 function hipblasSnrm2Batched_64_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasSnrm2Batched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSnrm2Batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDnrm2Batched_64 function hipblasDnrm2Batched_64_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasDnrm2Batched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDnrm2Batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasScnrm2Batched_64 function hipblasScnrm2Batched_64_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasScnrm2Batched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScnrm2Batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDznrm2Batched_64 function hipblasDznrm2Batched_64_(handle,n,x,incx,batchCount,myResult) & bind(c, name="hipblasDznrm2Batched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDznrm2Batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The nrm2StridedBatched functions compute the Euclidean norm over a batch of real or complex !> vectors. !> !> := sqrt( x_i'*x_i ) for real vectors x, for i = 1, ..., batchCount !> := sqrt( x_i**H*x_i ) for complex vectors, for i = 1, ..., batchCount !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, ``z``, ``sc``, and ``dz``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> number of elements in each x_i. !> @param[in] x - device pointer to the first vector x_1. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stridex. However, the user should !> ensure that stridex is of an appropriate size. For a typical !> case, this means stridex >= n * incx. !> @param[in] batchCount - [int] !> number of instances in the batch. !> @param[out] myResult !> device pointer or host pointer to array for storing contiguous batchCount !> results. !> Return value is 0.0 for each element if n <= 0, incx<=0. #ifndef USE_CUDA_NAMES interface hipblasSnrm2StridedBatched function hipblasSnrm2StridedBatched_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasSnrm2StridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSnrm2StridedBatched_assumed_rank #else module procedure & hipblasSnrm2StridedBatched_rank_0,& hipblasSnrm2StridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDnrm2StridedBatched function hipblasDnrm2StridedBatched_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasDnrm2StridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDnrm2StridedBatched_assumed_rank #else module procedure & hipblasDnrm2StridedBatched_rank_0,& hipblasDnrm2StridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasScnrm2StridedBatched function hipblasScnrm2StridedBatched_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasScnrm2StridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasScnrm2StridedBatched_assumed_rank #else module procedure & hipblasScnrm2StridedBatched_rank_0,& hipblasScnrm2StridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDznrm2StridedBatched function hipblasDznrm2StridedBatched_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasDznrm2StridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDznrm2StridedBatched_assumed_rank #else module procedure & hipblasDznrm2StridedBatched_rank_0,& hipblasDznrm2StridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSnrm2StridedBatched_64 function hipblasSnrm2StridedBatched_64_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasSnrm2StridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSnrm2StridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDnrm2StridedBatched_64 function hipblasDnrm2StridedBatched_64_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasDnrm2StridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDnrm2StridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasScnrm2StridedBatched_64 function hipblasScnrm2StridedBatched_64_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasScnrm2StridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScnrm2StridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDznrm2StridedBatched_64 function hipblasDznrm2StridedBatched_64_(handle,n,x,incx,stridex,batchCount,myResult) & bind(c, name="hipblasDznrm2StridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDznrm2StridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The rot functions apply the Givens rotation matrix defined by ``c=cos(alpha)`` and !> ``s=sin(alpha)`` to vectors ``x`` and ``y``. !> Scalars ``c`` and ``s`` can be stored in either host or device memory. The location is !> specified by calling ``hipblasSetPointerMode``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, ``z``, ``sc``, and ``dz``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, ``z``, ``cs``, and ``zd``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> number of elements in the x and y vectors. !> @param[inout] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment between elements of x. !> @param[inout] y - device pointer storing vector y. !> @param[in] incy - [int] !> specifies the increment between elements of y. !> @param[in] c - device pointer or host pointer storing the scalar cosine component of the !> rotation matrix. !> @param[in] s - device pointer or host pointer storing the scalar sine component of the !> rotation matrix. interface hipblasSrot #ifdef USE_CUDA_NAMES function hipblasSrot_(handle,n,x,incx,y,incy,c,s) bind(c, name="cublasSrot_v2") #else function hipblasSrot_(handle,n,x,incx,y,incy,c,s) bind(c, name="hipblasSrot") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSrot_assumed_rank #else module procedure & hipblasSrot_rank_0,& hipblasSrot_rank_1 #endif #endif end interface interface hipblasDrot #ifdef USE_CUDA_NAMES function hipblasDrot_(handle,n,x,incx,y,incy,c,s) bind(c, name="cublasDrot_v2") #else function hipblasDrot_(handle,n,x,incx,y,incy,c,s) bind(c, name="hipblasDrot") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDrot_assumed_rank #else module procedure & hipblasDrot_rank_0,& hipblasDrot_rank_1 #endif #endif end interface interface hipblasCrot #ifdef USE_CUDA_NAMES function hipblasCrot_(handle,n,x,incx,y,incy,c,s) bind(c, name="cublasCrot_v2") #else function hipblasCrot_(handle,n,x,incx,y,incy,c,s) bind(c, name="hipblasCrot") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCrot_assumed_rank #else module procedure & hipblasCrot_rank_0,& hipblasCrot_rank_1 #endif #endif end interface interface hipblasCsrot #ifdef USE_CUDA_NAMES function hipblasCsrot_(handle,n,x,incx,y,incy,c,s) bind(c, name="cublasCsrot_v2") #else function hipblasCsrot_(handle,n,x,incx,y,incy,c,s) bind(c, name="hipblasCsrot") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCsrot_assumed_rank #else module procedure & hipblasCsrot_rank_0,& hipblasCsrot_rank_1 #endif #endif end interface interface hipblasZrot #ifdef USE_CUDA_NAMES function hipblasZrot_(handle,n,x,incx,y,incy,c,s) bind(c, name="cublasZrot_v2") #else function hipblasZrot_(handle,n,x,incx,y,incy,c,s) bind(c, name="hipblasZrot") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZrot_assumed_rank #else module procedure & hipblasZrot_rank_0,& hipblasZrot_rank_1 #endif #endif end interface interface hipblasZdrot #ifdef USE_CUDA_NAMES function hipblasZdrot_(handle,n,x,incx,y,incy,c,s) bind(c, name="cublasZdrot_v2") #else function hipblasZdrot_(handle,n,x,incx,y,incy,c,s) bind(c, name="hipblasZdrot") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZdrot_assumed_rank #else module procedure & hipblasZdrot_rank_0,& hipblasZdrot_rank_1 #endif #endif end interface interface hipblasSrot_64 #ifdef USE_CUDA_NAMES function hipblasSrot_64_(handle,n,x,incx,y,incy,c,s) bind(c, name="cublasSrot_v2_64") #else function hipblasSrot_64_(handle,n,x,incx,y,incy,c,s) bind(c, name="hipblasSrot_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s end function end interface interface hipblasDrot_64 #ifdef USE_CUDA_NAMES function hipblasDrot_64_(handle,n,x,incx,y,incy,c,s) bind(c, name="cublasDrot_v2_64") #else function hipblasDrot_64_(handle,n,x,incx,y,incy,c,s) bind(c, name="hipblasDrot_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s end function end interface interface hipblasCrot_64 #ifdef USE_CUDA_NAMES function hipblasCrot_64_(handle,n,x,incx,y,incy,c,s) bind(c, name="cublasCrot_v2_64") #else function hipblasCrot_64_(handle,n,x,incx,y,incy,c,s) bind(c, name="hipblasCrot_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s end function end interface interface hipblasCsrot_64 #ifdef USE_CUDA_NAMES function hipblasCsrot_64_(handle,n,x,incx,y,incy,c,s) bind(c, name="cublasCsrot_v2_64") #else function hipblasCsrot_64_(handle,n,x,incx,y,incy,c,s) bind(c, name="hipblasCsrot_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsrot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s end function end interface interface hipblasZrot_64 #ifdef USE_CUDA_NAMES function hipblasZrot_64_(handle,n,x,incx,y,incy,c,s) bind(c, name="cublasZrot_v2_64") #else function hipblasZrot_64_(handle,n,x,incx,y,incy,c,s) bind(c, name="hipblasZrot_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s end function end interface interface hipblasZdrot_64 #ifdef USE_CUDA_NAMES function hipblasZdrot_64_(handle,n,x,incx,y,incy,c,s) bind(c, name="cublasZdrot_v2_64") #else function hipblasZdrot_64_(handle,n,x,incx,y,incy,c,s) bind(c, name="hipblasZdrot_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdrot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s end function end interface !> \brief BLAS Level 1 API !> !> \details !> The rotBatched functions apply the Givens rotation matrix defined by ``c=cos(alpha)`` and !> ``s=sin(alpha)`` to batched vectors ``x_i`` and ``y_i``, for ``i`` = 1, ..., !> ``batchCount``. !> Scalars ``c`` and ``s`` can be stored in either host or device memory. The location is !> specified by calling ``hipblasSetPointerMode``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``sc``, and ``dz``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> number of elements in each x_i and y_i vectors. !> @param[inout] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment between elements of each x_i. !> @param[inout] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [int] !> specifies the increment between elements of each y_i. !> @param[in] c - device pointer or host pointer to the scalar cosine component of the !> rotation matrix. !> @param[in] s - device pointer or host pointer to the scalar sine component of the rotation !> matrix. !> @param[in] batchCount - [int] !> the number of x and y arrays, that is, the number of batches. #ifndef USE_CUDA_NAMES interface hipblasSrotBatched function hipblasSrotBatched_(handle,n,x,incx,y,incy,c,s,batchCount) & bind(c, name="hipblasSrotBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDrotBatched function hipblasDrotBatched_(handle,n,x,incx,y,incy,c,s,batchCount) & bind(c, name="hipblasDrotBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCrotBatched function hipblasCrotBatched_(handle,n,x,incx,y,incy,c,s,batchCount) & bind(c, name="hipblasCrotBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsrotBatched function hipblasCsrotBatched_(handle,n,x,incx,y,incy,c,s,batchCount) & bind(c, name="hipblasCsrotBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZrotBatched function hipblasZrotBatched_(handle,n,x,incx,y,incy,c,s,batchCount) & bind(c, name="hipblasZrotBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdrotBatched function hipblasZdrotBatched_(handle,n,x,incx,y,incy,c,s,batchCount) & bind(c, name="hipblasZdrotBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSrotBatched_64 function hipblasSrotBatched_64_(handle,n,x,incx,y,incy,c,s,batchCount) & bind(c, name="hipblasSrotBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDrotBatched_64 function hipblasDrotBatched_64_(handle,n,x,incx,y,incy,c,s,batchCount) & bind(c, name="hipblasDrotBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCrotBatched_64 function hipblasCrotBatched_64_(handle,n,x,incx,y,incy,c,s,batchCount) & bind(c, name="hipblasCrotBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrotBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsrotBatched_64 function hipblasCsrotBatched_64_(handle,n,x,incx,y,incy,c,s,batchCount) & bind(c, name="hipblasCsrotBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsrotBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZrotBatched_64 function hipblasZrotBatched_64_(handle,n,x,incx,y,incy,c,s,batchCount) & bind(c, name="hipblasZrotBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrotBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdrotBatched_64 function hipblasZdrotBatched_64_(handle,n,x,incx,y,incy,c,s,batchCount) & bind(c, name="hipblasZdrotBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdrotBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The rotStridedBatched functions apply the Givens rotation matrix defined by !> ``c=cos(alpha)`` and ``s=sin(alpha)`` to strided batched vectors ``x_i`` and ``y_i``, for !> ``i`` = 1, ..., ``batchCount``. !> Scalars ``c`` and ``s`` can be stored in either host or device memory. The location is !> specified by calling ``hipblasSetPointerMode``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``sc``, and ``dz``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> number of elements in each x_i and y_i vectors. !> @param[inout] x - device pointer to the first vector x_1. !> @param[in] incx - [int] !> specifies the increment between elements of each x_i. !> @param[in] stridex - [hipblasStride] !> specifies the increment from the beginning of x_i to the beginning of x_(i+1). !> @param[inout] y - device pointer to the first vector y_1. !> @param[in] incy - [int] !> specifies the increment between elements of each y_i. !> @param[in] stridey - [hipblasStride] !> specifies the increment from the beginning of y_i to the beginning of y_(i+1). !> @param[in] c - device pointer or host pointer to the scalar cosine component of the !> rotation matrix. !> @param[in] s - device pointer or host pointer to the scalar sine component of the rotation !> matrix. !> @param[in] batchCount - [int] !> the number of x and y arrays, that is, the number of batches. #ifndef USE_CUDA_NAMES interface hipblasSrotStridedBatched function hipblasSrotStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) & bind(c, name="hipblasSrotStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSrotStridedBatched_assumed_rank #else module procedure & hipblasSrotStridedBatched_rank_0,& hipblasSrotStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDrotStridedBatched function hipblasDrotStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) & bind(c, name="hipblasDrotStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDrotStridedBatched_assumed_rank #else module procedure & hipblasDrotStridedBatched_rank_0,& hipblasDrotStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCrotStridedBatched function hipblasCrotStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) & bind(c, name="hipblasCrotStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCrotStridedBatched_assumed_rank #else module procedure & hipblasCrotStridedBatched_rank_0,& hipblasCrotStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsrotStridedBatched function hipblasCsrotStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) & bind(c, name="hipblasCsrotStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCsrotStridedBatched_assumed_rank #else module procedure & hipblasCsrotStridedBatched_rank_0,& hipblasCsrotStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZrotStridedBatched function hipblasZrotStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) & bind(c, name="hipblasZrotStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZrotStridedBatched_assumed_rank #else module procedure & hipblasZrotStridedBatched_rank_0,& hipblasZrotStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdrotStridedBatched function hipblasZdrotStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) & bind(c, name="hipblasZdrotStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZdrotStridedBatched_assumed_rank #else module procedure & hipblasZdrotStridedBatched_rank_0,& hipblasZdrotStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSrotStridedBatched_64 function hipblasSrotStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) & bind(c, name="hipblasSrotStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDrotStridedBatched_64 function hipblasDrotStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) & bind(c, name="hipblasDrotStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCrotStridedBatched_64 function hipblasCrotStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) & bind(c, name="hipblasCrotStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrotStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsrotStridedBatched_64 function hipblasCsrotStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) & bind(c, name="hipblasCsrotStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsrotStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZrotStridedBatched_64 function hipblasZrotStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) & bind(c, name="hipblasZrotStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrotStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdrotStridedBatched_64 function hipblasZdrotStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) & bind(c, name="hipblasZdrotStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdrotStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The rotg functions create the Givens rotation matrix for the vector ``(a b)``. !> Scalars ``c`` and ``s`` and arrays ``a`` and ``b`` can be stored in either host or !> device memory. The location is specified by calling ``hipblasSetPointerMode``. !> If the pointer mode is set to ``HIPBLAS_POINTER_MODE_HOST``, this function blocks the !> CPU until the GPU has finished and the results are available in host memory. !> If the pointer mode is set to ``HIPBLAS_POINTER_MODE_DEVICE``, this function returns !> immediately and synchronization is required to read the results. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[inout] a - device pointer or host pointer to the input vector element, overwritten !> with r. !> @param[inout] b - device pointer or host pointer to the input vector element, overwritten !> with z. !> @param[inout] c - device pointer or host pointer to the cosine element of the Givens !> rotation. !> @param[inout] s - device pointer or host pointer to the sine element of the Givens !> rotation. interface hipblasSrotg #ifdef USE_CUDA_NAMES function hipblasSrotg_(handle,a,b,c,s) bind(c, name="cublasSrotg_v2") #else function hipblasSrotg_(handle,a,b,c,s) bind(c, name="hipblasSrotg") #endif use iso_c_binding use hipfort_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 type(c_ptr),value :: c type(c_ptr),value :: s end function end interface interface hipblasDrotg #ifdef USE_CUDA_NAMES function hipblasDrotg_(handle,a,b,c,s) bind(c, name="cublasDrotg_v2") #else function hipblasDrotg_(handle,a,b,c,s) bind(c, name="hipblasDrotg") #endif use iso_c_binding use hipfort_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 type(c_ptr),value :: c type(c_ptr),value :: s end function end interface interface hipblasCrotg #ifdef USE_CUDA_NAMES function hipblasCrotg_(handle,a,b,c,s) bind(c, name="cublasCrotg_v2") #else function hipblasCrotg_(handle,a,b,c,s) bind(c, name="hipblasCrotg") #endif use iso_c_binding use hipfort_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 type(c_ptr),value :: c type(c_ptr),value :: s end function end interface interface hipblasZrotg #ifdef USE_CUDA_NAMES function hipblasZrotg_(handle,a,b,c,s) bind(c, name="cublasZrotg_v2") #else function hipblasZrotg_(handle,a,b,c,s) bind(c, name="hipblasZrotg") #endif use iso_c_binding use hipfort_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 type(c_ptr),value :: c type(c_ptr),value :: s end function end interface #ifndef USE_CUDA_NAMES interface hipblasSrotg_64 function hipblasSrotg_64_(handle,a,b,c,s) bind(c, name="hipblasSrotg_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotg_64_ 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 end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDrotg_64 function hipblasDrotg_64_(handle,a,b,c,s) bind(c, name="hipblasDrotg_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotg_64_ 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 end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCrotg_64 function hipblasCrotg_64_(handle,a,b,c,s) bind(c, name="hipblasCrotg_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrotg_64_ 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 end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZrotg_64 function hipblasZrotg_64_(handle,a,b,c,s) bind(c, name="hipblasZrotg_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrotg_64_ 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 end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The rotgBatched functions create the Givens rotation matrix for the batched vectors !> ``(a_i b_i)``, for ``i`` = 1, ..., ``batchCount``. !> ``a``, ``b``, ``c``, and ``s`` can be stored in either host or device memory. The !> location is specified by calling ``hipblasSetPointerMode``. !> If the pointer mode is set to ``HIPBLAS_POINTER_MODE_HOST``, this function blocks the !> CPU until the GPU has finished and the results are available in host memory. !> If the pointer mode is set to ``HIPBLAS_POINTER_MODE_DEVICE``, this function returns !> immediately and synchronization is required to read the results. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[inout] a - device array of device pointers storing each single input vector element !> a_i, overwritten with r_i. !> @param[inout] b - device array of device pointers storing each single input vector element !> b_i, overwritten with z_i. !> @param[inout] c - device array of device pointers storing each cosine element of the Givens !> rotation for the batch. !> @param[inout] s - device array of device pointers storing each sine element of the Givens !> rotation for the batch. !> @param[in] batchCount - [int] !> number of batches (length of arrays a, b, c, and s). #ifndef USE_CUDA_NAMES interface hipblasSrotgBatched function hipblasSrotgBatched_(handle,a,b,c,s,batchCount) bind(c, name="hipblasSrotgBatched") use iso_c_binding use hipfort_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 type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDrotgBatched function hipblasDrotgBatched_(handle,a,b,c,s,batchCount) bind(c, name="hipblasDrotgBatched") use iso_c_binding use hipfort_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 type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCrotgBatched function hipblasCrotgBatched_(handle,a,b,c,s,batchCount) bind(c, name="hipblasCrotgBatched") use iso_c_binding use hipfort_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 type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZrotgBatched function hipblasZrotgBatched_(handle,a,b,c,s,batchCount) bind(c, name="hipblasZrotgBatched") use iso_c_binding use hipfort_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 type(c_ptr),value :: c type(c_ptr),value :: s integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSrotgBatched_64 function hipblasSrotgBatched_64_(handle,a,b,c,s,batchCount) & bind(c, name="hipblasSrotgBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotgBatched_64_ 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_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDrotgBatched_64 function hipblasDrotgBatched_64_(handle,a,b,c,s,batchCount) & bind(c, name="hipblasDrotgBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotgBatched_64_ 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_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCrotgBatched_64 function hipblasCrotgBatched_64_(handle,a,b,c,s,batchCount) & bind(c, name="hipblasCrotgBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrotgBatched_64_ 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_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZrotgBatched_64 function hipblasZrotgBatched_64_(handle,a,b,c,s,batchCount) & bind(c, name="hipblasZrotgBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrotgBatched_64_ 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_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The rotgStridedBatched functions create the Givens rotation matrix for the strided batched !> vectors ``(a_i b_i)``, for ``i`` = 1, ..., ``batchCount``. !> ``a``, ``b``, ``c``, and ``s`` can be stored in either host or device memory. The !> location is specified by calling ``hipblasSetPointerMode``. !> If the pointer mode is set to ``HIPBLAS_POINTER_MODE_HOST``, this function blocks the !> CPU until the GPU has finished and the results are available in host memory. !> If the pointer mode is set to ``HIPBLAS_POINTER_MODE_HOST``, this function returns !> immediately and synchronization is required to read the results. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[inout] a - device strided_batched pointer or host strided_batched pointer to the !> first single input vector element a_1, overwritten with r. !> @param[in] stridea - [hipblasStride] !> distance between elements of a in batch (distance between a_i and a_(i + 1)). !> @param[inout] b - device strided_batched pointer or host strided_batched pointer to the !> first single input vector element b_1, overwritten with z. !> @param[in] strideb - [hipblasStride] !> distance between elements of b in batch (distance between b_i and b_(i + 1)). !> @param[inout] c - device strided_batched pointer or host strided_batched pointer to the !> first cosine element of the Givens rotations c_1. !> @param[in] stridec - [hipblasStride] !> distance between elements of c in batch (distance between c_i and c_(i + 1)). !> @param[inout] s - device strided_batched pointer or host strided_batched pointer to the !> sine element of the Givens rotations s_1. !> @param[in] strides - [hipblasStride] !> distance between elements of s in batch (distance between s_i and s_(i + 1)). !> @param[in] batchCount - [int] !> number of batches (length of arrays a, b, c, and s). #ifndef USE_CUDA_NAMES interface hipblasSrotgStridedBatched function hipblasSrotgStridedBatched_(handle,a,stridea,b,strideb,c,stridec,s,strides, & batchCount) & bind(c, name="hipblasSrotgStridedBatched") use iso_c_binding use hipfort_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 :: stridea type(c_ptr),value :: b integer(c_int64_t),value :: strideb type(c_ptr),value :: c integer(c_int64_t),value :: stridec type(c_ptr),value :: s integer(c_int64_t),value :: strides integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDrotgStridedBatched function hipblasDrotgStridedBatched_(handle,a,stridea,b,strideb,c,stridec,s,strides, & batchCount) & bind(c, name="hipblasDrotgStridedBatched") use iso_c_binding use hipfort_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 :: stridea type(c_ptr),value :: b integer(c_int64_t),value :: strideb type(c_ptr),value :: c integer(c_int64_t),value :: stridec type(c_ptr),value :: s integer(c_int64_t),value :: strides integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCrotgStridedBatched function hipblasCrotgStridedBatched_(handle,a,stridea,b,strideb,c,stridec,s,strides, & batchCount) & bind(c, name="hipblasCrotgStridedBatched") use iso_c_binding use hipfort_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 :: stridea type(c_ptr),value :: b integer(c_int64_t),value :: strideb type(c_ptr),value :: c integer(c_int64_t),value :: stridec type(c_ptr),value :: s integer(c_int64_t),value :: strides integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZrotgStridedBatched function hipblasZrotgStridedBatched_(handle,a,stridea,b,strideb,c,stridec,s,strides, & batchCount) & bind(c, name="hipblasZrotgStridedBatched") use iso_c_binding use hipfort_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 :: stridea type(c_ptr),value :: b integer(c_int64_t),value :: strideb type(c_ptr),value :: c integer(c_int64_t),value :: stridec type(c_ptr),value :: s integer(c_int64_t),value :: strides integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSrotgStridedBatched_64 function hipblasSrotgStridedBatched_64_(handle,a,stridea,b,strideb,c,stridec,s,strides, & batchCount) & bind(c, name="hipblasSrotgStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotgStridedBatched_64_ type(c_ptr),value :: handle type(c_ptr),value :: a integer(c_int64_t),value :: stridea type(c_ptr),value :: b integer(c_int64_t),value :: strideb type(c_ptr),value :: c integer(c_int64_t),value :: stridec type(c_ptr),value :: s integer(c_int64_t),value :: strides integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDrotgStridedBatched_64 function hipblasDrotgStridedBatched_64_(handle,a,stridea,b,strideb,c,stridec,s,strides, & batchCount) & bind(c, name="hipblasDrotgStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotgStridedBatched_64_ type(c_ptr),value :: handle type(c_ptr),value :: a integer(c_int64_t),value :: stridea type(c_ptr),value :: b integer(c_int64_t),value :: strideb type(c_ptr),value :: c integer(c_int64_t),value :: stridec type(c_ptr),value :: s integer(c_int64_t),value :: strides integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCrotgStridedBatched_64 function hipblasCrotgStridedBatched_64_(handle,a,stridea,b,strideb,c,stridec,s,strides, & batchCount) & bind(c, name="hipblasCrotgStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrotgStridedBatched_64_ type(c_ptr),value :: handle type(c_ptr),value :: a integer(c_int64_t),value :: stridea type(c_ptr),value :: b integer(c_int64_t),value :: strideb type(c_ptr),value :: c integer(c_int64_t),value :: stridec type(c_ptr),value :: s integer(c_int64_t),value :: strides integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZrotgStridedBatched_64 function hipblasZrotgStridedBatched_64_(handle,a,stridea,b,strideb,c,stridec,s,strides, & batchCount) & bind(c, name="hipblasZrotgStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrotgStridedBatched_64_ type(c_ptr),value :: handle type(c_ptr),value :: a integer(c_int64_t),value :: stridea type(c_ptr),value :: b integer(c_int64_t),value :: strideb type(c_ptr),value :: c integer(c_int64_t),value :: stridec type(c_ptr),value :: s integer(c_int64_t),value :: strides integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The rotm functions apply the modified Givens rotation matrix defined by ``param`` to !> vectors ``x`` and ``y``. !> !> - Supported precisions in rocBLAS : ``s`` and ``d``. !> - Supported precisions in cuBLAS : ``s`` and ``d``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> number of elements in the x and y vectors. !> @param[inout] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment between elements of x. !> @param[inout] y - device pointer storing vector y. !> @param[in] incy - [int] !> specifies the increment between elements of y. !> @param[in] param - device vector or host vector of five elements defining the rotation. !> param can be stored in either the host or device memory. The location is specified !> by calling hipblasSetPointerMode. !> - param[0] = flag !> - param[1] = H11 !> - param[2] = H21 !> - param[3] = H12 !> - param[4] = H22 !> The flag parameter defines the form of H: !> - flag = -1 => H = ( H11 H12 H21 H22 ) !> - flag = 0 => H = ( 1.0 H12 H21 1.0 ) !> - flag = 1 => H = ( H11 1.0 -1.0 H22 ) !> - flag = -2 => H = ( 1.0 0.0 0.0 1.0 ) interface hipblasSrotm #ifdef USE_CUDA_NAMES function hipblasSrotm_(handle,n,x,incx,y,incy,param) bind(c, name="cublasSrotm_v2") #else function hipblasSrotm_(handle,n,x,incx,y,incy,param) bind(c, name="hipblasSrotm") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: param end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSrotm_assumed_rank #else module procedure & hipblasSrotm_rank_0,& hipblasSrotm_rank_1 #endif #endif end interface interface hipblasDrotm #ifdef USE_CUDA_NAMES function hipblasDrotm_(handle,n,x,incx,y,incy,param) bind(c, name="cublasDrotm_v2") #else function hipblasDrotm_(handle,n,x,incx,y,incy,param) bind(c, name="hipblasDrotm") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: param end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDrotm_assumed_rank #else module procedure & hipblasDrotm_rank_0,& hipblasDrotm_rank_1 #endif #endif end interface interface hipblasSrotm_64 #ifdef USE_CUDA_NAMES function hipblasSrotm_64_(handle,n,x,incx,y,incy,param) bind(c, name="cublasSrotm_v2_64") #else function hipblasSrotm_64_(handle,n,x,incx,y,incy,param) bind(c, name="hipblasSrotm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotm_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: param end function end interface interface hipblasDrotm_64 #ifdef USE_CUDA_NAMES function hipblasDrotm_64_(handle,n,x,incx,y,incy,param) bind(c, name="cublasDrotm_v2_64") #else function hipblasDrotm_64_(handle,n,x,incx,y,incy,param) bind(c, name="hipblasDrotm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotm_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: param end function end interface !> \brief BLAS Level 1 API !> !> \details !> The rotmBatched functions apply the modified Givens rotation matrix defined by ``param_i`` !> to batched vectors ``x_i`` and ``y_i``, for ``i`` = 1, ..., ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s`` and ``d``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> number of elements in the x and y vectors. !> @param[inout] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment between elements of each x_i. !> @param[inout] y - device array of device pointers storing each vector y_1. !> @param[in] incy - [int] !> specifies the increment between elements of each y_i. !> @param[in] param - device array of device vectors of five elements defining the rotation. !> param can ONLY be stored on the device for the batched version of this function. !> - param[0] = flag !> - param[1] = H11 !> - param[2] = H21 !> - param[3] = H12 !> - param[4] = H22 !> The flag parameter defines the form of H: !> - flag = -1 => H = ( H11 H12 H21 H22 ) !> - flag = 0 => H = ( 1.0 H12 H21 1.0 ) !> - flag = 1 => H = ( H11 1.0 -1.0 H22 ) !> - flag = -2 => H = ( 1.0 0.0 0.0 1.0 ) !> @param[in] batchCount - [int] !> the number of x and y arrays, that is, the number of batches. #ifndef USE_CUDA_NAMES interface hipblasSrotmBatched function hipblasSrotmBatched_(handle,n,x,incx,y,incy,param,batchCount) & bind(c, name="hipblasSrotmBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: param integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDrotmBatched function hipblasDrotmBatched_(handle,n,x,incx,y,incy,param,batchCount) & bind(c, name="hipblasDrotmBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: param integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSrotmBatched_64 function hipblasSrotmBatched_64_(handle,n,x,incx,y,incy,param,batchCount) & bind(c, name="hipblasSrotmBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotmBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: param integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDrotmBatched_64 function hipblasDrotmBatched_64_(handle,n,x,incx,y,incy,param,batchCount) & bind(c, name="hipblasDrotmBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotmBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: param integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The rotmStridedBatched functions apply the modified Givens rotation matrix defined by !> ``param_i`` to strided batched vectors ``x_i`` and ``y_i``, for ``i`` = 1, ..., !> ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s`` and ``d``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> number of elements in the x and y vectors. !> @param[inout] x - device pointer pointing to first strided batched vector x_1. !> @param[in] incx - [int] !> specifies the increment between elements of each x_i. !> @param[in] stridex - [hipblasStride] !> specifies the increment between the beginning of x_i and x_(i + 1). !> @param[inout] y - device pointer pointing to the first strided batched vector y_1. !> @param[in] incy - [int] !> specifies the increment between elements of each y_i. !> @param[in] stridey - [hipblasStride] !> specifies the increment between the beginning of y_i and y_(i + 1). !> @param[in] param - device pointer pointing to first array of five elements defining the !> rotation (param_1). !> param can ONLY be stored on the device for the strided_batched version of this !> function. !> - param[0] = flag !> - param[1] = H11 !> - param[2] = H21 !> - param[3] = H12 !> - param[4] = H22 !> The flag parameter defines the form of H: !> - flag = -1 => H = ( H11 H12 H21 H22 ) !> - flag = 0 => H = ( 1.0 H12 H21 1.0 ) !> - flag = 1 => H = ( H11 1.0 -1.0 H22 ) !> - flag = -2 => H = ( 1.0 0.0 0.0 1.0 ) !> @param[in] strideParam - [hipblasStride] !> specifies the increment between the beginning of param_i and param_(i + 1). !> @param[in] batchCount - [int] !> the number of x and y arrays, that is, the number of batches. #ifndef USE_CUDA_NAMES interface hipblasSrotmStridedBatched function hipblasSrotmStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,param,strideParam, & batchCount) & bind(c, name="hipblasSrotmStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: param integer(c_int64_t),value :: strideParam integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSrotmStridedBatched_assumed_rank #else module procedure & hipblasSrotmStridedBatched_rank_0,& hipblasSrotmStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDrotmStridedBatched function hipblasDrotmStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,param,strideParam, & batchCount) & bind(c, name="hipblasDrotmStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: param integer(c_int64_t),value :: strideParam integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDrotmStridedBatched_assumed_rank #else module procedure & hipblasDrotmStridedBatched_rank_0,& hipblasDrotmStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSrotmStridedBatched_64 function hipblasSrotmStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,param, & strideParam,batchCount) & bind(c, name="hipblasSrotmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotmStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: param integer(c_int64_t),value :: strideParam integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDrotmStridedBatched_64 function hipblasDrotmStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,param, & strideParam,batchCount) & bind(c, name="hipblasDrotmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotmStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: param integer(c_int64_t),value :: strideParam integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The rotmg functions create the modified Givens rotation matrix for the vector !> ``(d1 * x1, d2 * y1)``. !> Parameters can be stored in either host or device memory. The location is specified !> by calling ``hipblasSetPointerMode``. !> If the pointer mode is set to ``HIPBLAS_POINTER_MODE_HOST``, this function blocks the !> CPU until the GPU has finished and the results are available in host memory. !> If the pointer mode is set to ``HIPBLAS_POINTER_MODE_DEVICE``, this function returns !> immediately and synchronization is required to read the results. !> !> - Supported precisions in rocBLAS : ``s`` and ``d``. !> - Supported precisions in cuBLAS : ``s`` and ``d``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[inout] d1 - device pointer or host pointer to input scalar that is overwritten. !> @param[inout] d2 - device pointer or host pointer to input scalar that is overwritten. !> @param[inout] x1 - device pointer or host pointer to input scalar that is overwritten. !> @param[in] y1 - device pointer or host pointer to input scalar. !> @param[out] param - device vector or host vector of five elements defining the rotation. !> param can be stored in either host or device memory. The location is specified by !> calling hipblasSetPointerMode. !> - param[0] = flag !> - param[1] = H11 !> - param[2] = H21 !> - param[3] = H12 !> - param[4] = H22 !> The flag parameter defines the form of H: !> - flag = -1 => H = ( H11 H12 H21 H22 ) !> - flag = 0 => H = ( 1.0 H12 H21 1.0 ) !> - flag = 1 => H = ( H11 1.0 -1.0 H22 ) !> - flag = -2 => H = ( 1.0 0.0 0.0 1.0 ) interface hipblasSrotmg #ifdef USE_CUDA_NAMES function hipblasSrotmg_(handle,d1,d2,x1,y1,param) bind(c, name="cublasSrotmg_v2") #else function hipblasSrotmg_(handle,d1,d2,x1,y1,param) bind(c, name="hipblasSrotmg") #endif use iso_c_binding use hipfort_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 type(c_ptr),value :: x1 type(c_ptr),value :: y1 type(c_ptr),value :: param end function end interface interface hipblasDrotmg #ifdef USE_CUDA_NAMES function hipblasDrotmg_(handle,d1,d2,x1,y1,param) bind(c, name="cublasDrotmg_v2") #else function hipblasDrotmg_(handle,d1,d2,x1,y1,param) bind(c, name="hipblasDrotmg") #endif use iso_c_binding use hipfort_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 type(c_ptr),value :: x1 type(c_ptr),value :: y1 type(c_ptr),value :: param end function end interface #ifndef USE_CUDA_NAMES interface hipblasSrotmg_64 function hipblasSrotmg_64_(handle,d1,d2,x1,y1,param) bind(c, name="hipblasSrotmg_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotmg_64_ 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 end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDrotmg_64 function hipblasDrotmg_64_(handle,d1,d2,x1,y1,param) bind(c, name="hipblasDrotmg_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotmg_64_ 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 end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The rotmgBatched functions create the modified Givens rotation matrix for the batched !> vectors ``(d1_i * x1_i, d2_i * y1_i)``, for ``i`` = 1, ..., ``batchCount``. !> Parameters can be stored in either host or device memory. The location is specified !> by calling ``hipblasSetPointerMode``. !> If the pointer mode is set to ``HIPBLAS_POINTER_MODE_HOST``, this function blocks the !> CPU until the GPU has finished and the results are available in host memory. !> If the pointer mode is set to ``HIPBLAS_POINTER_MODE_DEVICE``, this function returns !> immediately and synchronization is required to read the results. !> !> - Supported precisions in rocBLAS : ``s`` and ``d``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[inout] d1 - device batched array or host batched array of input scalars that is !> overwritten. !> @param[inout] d2 - device batched array or host batched array of input scalars that is !> overwritten. !> @param[inout] x1 - device batched array or host batched array of input scalars that is !> overwritten. !> @param[in] y1 - device batched array or host batched array of input scalars. !> @param[out] param - device batched array or host batched array of vectors of five elements !> defining the rotation. !> param can be stored in either host or device memory. The location is specified by !> calling hipblasSetPointerMode. !> - param[0] = flag !> - param[1] = H11 !> - param[2] = H21 !> - param[3] = H12 !> - param[4] = H22 !> The flag parameter defines the form of H: !> - flag = -1 => H = ( H11 H12 H21 H22 ) !> - flag = 0 => H = ( 1.0 H12 H21 1.0 ) !> - flag = 1 => H = ( H11 1.0 -1.0 H22 ) !> - flag = -2 => H = ( 1.0 0.0 0.0 1.0 ) !> @param[in] batchCount - [int] !> the number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSrotmgBatched function hipblasSrotmgBatched_(handle,d1,d2,x1,y1,param,batchCount) & bind(c, name="hipblasSrotmgBatched") use iso_c_binding use hipfort_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 type(c_ptr),value :: x1 type(c_ptr),value :: y1 type(c_ptr),value :: param integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDrotmgBatched function hipblasDrotmgBatched_(handle,d1,d2,x1,y1,param,batchCount) & bind(c, name="hipblasDrotmgBatched") use iso_c_binding use hipfort_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 type(c_ptr),value :: x1 type(c_ptr),value :: y1 type(c_ptr),value :: param integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSrotmgBatched_64 function hipblasSrotmgBatched_64_(handle,d1,d2,x1,y1,param,batchCount) & bind(c, name="hipblasSrotmgBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotmgBatched_64_ 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_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDrotmgBatched_64 function hipblasDrotmgBatched_64_(handle,d1,d2,x1,y1,param,batchCount) & bind(c, name="hipblasDrotmgBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotmgBatched_64_ 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_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The rotmgStridedBatched functions create the modified Givens rotation matrix for the !> strided batched vectors ``(d1_i * x1_i, d2_i * y1_i)``, for ``i`` = 1, ..., ``batchCount``. !> Parameters can be stored in either host or device memory. The location is specified !> by calling ``hipblasSetPointerMode``. !> If the pointer mode is set to ``HIPBLAS_POINTER_MODE_HOST``, this function blocks the !> CPU until the GPU has finished and the results are available in host memory. !> If the pointer mode is set to ``HIPBLAS_POINTER_MODE_DEVICE``, this function returns !> immediately and synchronization is required to read the results. !> !> - Supported precisions in rocBLAS : ``s`` and ``d``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[inout] d1 - device strided_batched array or host strided_batched array of input !> scalars that is overwritten. !> @param[in] strided1 - [hipblasStride] !> specifies the increment between the beginning of d1_i and d1_(i+1). !> @param[inout] d2 - device strided_batched array or host strided_batched array of input !> scalars that is overwritten. !> @param[in] strided2 - [hipblasStride] !> specifies the increment between the beginning of d2_i and d2_(i+1). !> @param[inout] x1 - device strided_batched array or host strided_batched array of input !> scalars that is overwritten. !> @param[in] stridex1 - [hipblasStride] !> specifies the increment between the beginning of x1_i and x1_(i+1). !> @param[in] y1 - device strided_batched array or host strided_batched array of input !> scalars. !> @param[in] stridey1 - [hipblasStride] !> specifies the increment between the beginning of y1_i and y1_(i+1). !> @param[out] param - device stridedBatched array or host stridedBatched array of vectors of !> five elements defining the rotation. !> param can be stored in either host or device memory. The location is specified by !> calling hipblasSetPointerMode. !> - param[0] = flag !> - param[1] = H11 !> - param[2] = H21 !> - param[3] = H12 !> - param[4] = H22 !> The flag parameter defines the form of H: !> - flag = -1 => H = ( H11 H12 H21 H22 ) !> - flag = 0 => H = ( 1.0 H12 H21 1.0 ) !> - flag = 1 => H = ( H11 1.0 -1.0 H22 ) !> - flag = -2 => H = ( 1.0 0.0 0.0 1.0 ) !> @param[in] strideParam - [hipblasStride] !> specifies the increment between the beginning of param_i and param_(i + 1). !> @param[in] batchCount - [int] !> the number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSrotmgStridedBatched function hipblasSrotmgStridedBatched_(handle,d1,strided1,d2,strided2,x1,stridex1,y1,stridey1, & param,strideParam,batchCount) & bind(c, name="hipblasSrotmgStridedBatched") use iso_c_binding use hipfort_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 :: strided1 type(c_ptr),value :: d2 integer(c_int64_t),value :: strided2 type(c_ptr),value :: x1 integer(c_int64_t),value :: stridex1 type(c_ptr),value :: y1 integer(c_int64_t),value :: stridey1 type(c_ptr),value :: param integer(c_int64_t),value :: strideParam integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDrotmgStridedBatched function hipblasDrotmgStridedBatched_(handle,d1,strided1,d2,strided2,x1,stridex1,y1,stridey1, & param,strideParam,batchCount) & bind(c, name="hipblasDrotmgStridedBatched") use iso_c_binding use hipfort_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 :: strided1 type(c_ptr),value :: d2 integer(c_int64_t),value :: strided2 type(c_ptr),value :: x1 integer(c_int64_t),value :: stridex1 type(c_ptr),value :: y1 integer(c_int64_t),value :: stridey1 type(c_ptr),value :: param integer(c_int64_t),value :: strideParam integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSrotmgStridedBatched_64 function hipblasSrotmgStridedBatched_64_(handle,d1,strided1,d2,strided2,x1,stridex1,y1, & stridey1,param,strideParam,batchCount) & bind(c, name="hipblasSrotmgStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotmgStridedBatched_64_ type(c_ptr),value :: handle type(c_ptr),value :: d1 integer(c_int64_t),value :: strided1 type(c_ptr),value :: d2 integer(c_int64_t),value :: strided2 type(c_ptr),value :: x1 integer(c_int64_t),value :: stridex1 type(c_ptr),value :: y1 integer(c_int64_t),value :: stridey1 type(c_ptr),value :: param integer(c_int64_t),value :: strideParam integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDrotmgStridedBatched_64 function hipblasDrotmgStridedBatched_64_(handle,d1,strided1,d2,strided2,x1,stridex1,y1, & stridey1,param,strideParam,batchCount) & bind(c, name="hipblasDrotmgStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotmgStridedBatched_64_ type(c_ptr),value :: handle type(c_ptr),value :: d1 integer(c_int64_t),value :: strided1 type(c_ptr),value :: d2 integer(c_int64_t),value :: strided2 type(c_ptr),value :: x1 integer(c_int64_t),value :: stridex1 type(c_ptr),value :: y1 integer(c_int64_t),value :: stridey1 type(c_ptr),value :: param integer(c_int64_t),value :: strideParam integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The scal functions scales each element of vector ``x`` with scalar ``alpha``. !> !> x := alpha * x !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, ``z``, ``cs``, and ``zd``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, ``z``, ``cs``, and ``zd``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in x. !> @param[in] alpha - device pointer or host pointer for the scalar alpha. !> @param[inout] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. interface hipblasSscal #ifdef USE_CUDA_NAMES function hipblasSscal_(handle,n,alpha,x,incx) bind(c, name="cublasSscal_v2") #else function hipblasSscal_(handle,n,alpha,x,incx) bind(c, name="hipblasSscal") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSscal_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSscal_assumed_rank #else module procedure & hipblasSscal_rank_0,& hipblasSscal_rank_1 #endif #endif end interface interface hipblasDscal #ifdef USE_CUDA_NAMES function hipblasDscal_(handle,n,alpha,x,incx) bind(c, name="cublasDscal_v2") #else function hipblasDscal_(handle,n,alpha,x,incx) bind(c, name="hipblasDscal") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDscal_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDscal_assumed_rank #else module procedure & hipblasDscal_rank_0,& hipblasDscal_rank_1 #endif #endif end interface interface hipblasCscal #ifdef USE_CUDA_NAMES function hipblasCscal_(handle,n,alpha,x,incx) bind(c, name="cublasCscal_v2") #else function hipblasCscal_(handle,n,alpha,x,incx) bind(c, name="hipblasCscal") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCscal_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCscal_assumed_rank #else module procedure & hipblasCscal_rank_0,& hipblasCscal_rank_1 #endif #endif end interface interface hipblasCsscal #ifdef USE_CUDA_NAMES function hipblasCsscal_(handle,n,alpha,x,incx) bind(c, name="cublasCsscal_v2") #else function hipblasCsscal_(handle,n,alpha,x,incx) bind(c, name="hipblasCsscal") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsscal_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCsscal_assumed_rank #else module procedure & hipblasCsscal_rank_0,& hipblasCsscal_rank_1 #endif #endif end interface interface hipblasZscal #ifdef USE_CUDA_NAMES function hipblasZscal_(handle,n,alpha,x,incx) bind(c, name="cublasZscal_v2") #else function hipblasZscal_(handle,n,alpha,x,incx) bind(c, name="hipblasZscal") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZscal_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZscal_assumed_rank #else module procedure & hipblasZscal_rank_0,& hipblasZscal_rank_1 #endif #endif end interface interface hipblasZdscal #ifdef USE_CUDA_NAMES function hipblasZdscal_(handle,n,alpha,x,incx) bind(c, name="cublasZdscal_v2") #else function hipblasZdscal_(handle,n,alpha,x,incx) bind(c, name="hipblasZdscal") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdscal_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZdscal_assumed_rank #else module procedure & hipblasZdscal_rank_0,& hipblasZdscal_rank_1 #endif #endif end interface interface hipblasSscal_64 #ifdef USE_CUDA_NAMES function hipblasSscal_64_(handle,n,alpha,x,incx) bind(c, name="cublasSscal_v2_64") #else function hipblasSscal_64_(handle,n,alpha,x,incx) bind(c, name="hipblasSscal_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSscal_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasDscal_64 #ifdef USE_CUDA_NAMES function hipblasDscal_64_(handle,n,alpha,x,incx) bind(c, name="cublasDscal_v2_64") #else function hipblasDscal_64_(handle,n,alpha,x,incx) bind(c, name="hipblasDscal_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDscal_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasCscal_64 #ifdef USE_CUDA_NAMES function hipblasCscal_64_(handle,n,alpha,x,incx) bind(c, name="cublasCscal_v2_64") #else function hipblasCscal_64_(handle,n,alpha,x,incx) bind(c, name="hipblasCscal_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCscal_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasCsscal_64 #ifdef USE_CUDA_NAMES function hipblasCsscal_64_(handle,n,alpha,x,incx) bind(c, name="cublasCsscal_v2_64") #else function hipblasCsscal_64_(handle,n,alpha,x,incx) bind(c, name="hipblasCsscal_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsscal_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasZscal_64 #ifdef USE_CUDA_NAMES function hipblasZscal_64_(handle,n,alpha,x,incx) bind(c, name="cublasZscal_v2_64") #else function hipblasZscal_64_(handle,n,alpha,x,incx) bind(c, name="hipblasZscal_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZscal_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasZdscal_64 #ifdef USE_CUDA_NAMES function hipblasZdscal_64_(handle,n,alpha,x,incx) bind(c, name="cublasZdscal_v2_64") #else function hipblasZdscal_64_(handle,n,alpha,x,incx) bind(c, name="hipblasZdscal_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdscal_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface !> \brief BLAS Level 1 API !> \details !> The scalBatched functions scale each element of vector ``x_i`` with scalar ``alpha``, for !> ``i`` = 1, ... , ``batchCount``. !> !> x_i := alpha * x_i !> !> where (``x_i``) is the ``i``-th instance of the batch. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, ``z``, ``cs``, and ``zd``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in each x_i. !> @param[in] alpha - host pointer or device pointer for the scalar alpha. !> @param[inout] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] batchCount - [int] !> specifies the number of batches in x. #ifndef USE_CUDA_NAMES interface hipblasSscalBatched function hipblasSscalBatched_(handle,n,alpha,x,incx,batchCount) & bind(c, name="hipblasSscalBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSscalBatched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDscalBatched function hipblasDscalBatched_(handle,n,alpha,x,incx,batchCount) & bind(c, name="hipblasDscalBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDscalBatched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCscalBatched function hipblasCscalBatched_(handle,n,alpha,x,incx,batchCount) & bind(c, name="hipblasCscalBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCscalBatched_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZscalBatched function hipblasZscalBatched_(handle,n,alpha,x,incx,batchCount) & bind(c, name="hipblasZscalBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZscalBatched_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsscalBatched function hipblasCsscalBatched_(handle,n,alpha,x,incx,batchCount) & bind(c, name="hipblasCsscalBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsscalBatched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdscalBatched function hipblasZdscalBatched_(handle,n,alpha,x,incx,batchCount) & bind(c, name="hipblasZdscalBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdscalBatched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSscalBatched_64 function hipblasSscalBatched_64_(handle,n,alpha,x,incx,batchCount) & bind(c, name="hipblasSscalBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSscalBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDscalBatched_64 function hipblasDscalBatched_64_(handle,n,alpha,x,incx,batchCount) & bind(c, name="hipblasDscalBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDscalBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCscalBatched_64 function hipblasCscalBatched_64_(handle,n,alpha,x,incx,batchCount) & bind(c, name="hipblasCscalBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCscalBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZscalBatched_64 function hipblasZscalBatched_64_(handle,n,alpha,x,incx,batchCount) & bind(c, name="hipblasZscalBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZscalBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsscalBatched_64 function hipblasCsscalBatched_64_(handle,n,alpha,x,incx,batchCount) & bind(c, name="hipblasCsscalBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsscalBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdscalBatched_64 function hipblasZdscalBatched_64_(handle,n,alpha,x,incx,batchCount) & bind(c, name="hipblasZdscalBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdscalBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 1 API !> \details !> The scalStridedBatched functions scale each element of vector ``x_i`` with scalar !> ``alpha``, for ``i`` = 1, ... , ``batchCount``. !> !> x_i := alpha * x_i , !> !> where ``(x_i)`` is the ``i``-th instance of the batch. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, ``z``, ``cs``, and ``zd``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in each x_i. !> @param[in] alpha - host pointer or device pointer for the scalar alpha. !> @param[inout] x - device pointer to the first vector (x_1) in the batch. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stride_x. However, the user should !> ensure that stride_x is of an appropriate size. For a typical !> case, this means stride_x >= n * incx. !> @param[in] batchCount - [int] !> specifies the number of batches in x. #ifndef USE_CUDA_NAMES interface hipblasSscalStridedBatched function hipblasSscalStridedBatched_(handle,n,alpha,x,incx,stridex,batchCount) & bind(c, name="hipblasSscalStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSscalStridedBatched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSscalStridedBatched_assumed_rank #else module procedure & hipblasSscalStridedBatched_rank_0,& hipblasSscalStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDscalStridedBatched function hipblasDscalStridedBatched_(handle,n,alpha,x,incx,stridex,batchCount) & bind(c, name="hipblasDscalStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDscalStridedBatched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDscalStridedBatched_assumed_rank #else module procedure & hipblasDscalStridedBatched_rank_0,& hipblasDscalStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCscalStridedBatched function hipblasCscalStridedBatched_(handle,n,alpha,x,incx,stridex,batchCount) & bind(c, name="hipblasCscalStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCscalStridedBatched_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCscalStridedBatched_assumed_rank #else module procedure & hipblasCscalStridedBatched_rank_0,& hipblasCscalStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZscalStridedBatched function hipblasZscalStridedBatched_(handle,n,alpha,x,incx,stridex,batchCount) & bind(c, name="hipblasZscalStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZscalStridedBatched_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZscalStridedBatched_assumed_rank #else module procedure & hipblasZscalStridedBatched_rank_0,& hipblasZscalStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsscalStridedBatched function hipblasCsscalStridedBatched_(handle,n,alpha,x,incx,stridex,batchCount) & bind(c, name="hipblasCsscalStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsscalStridedBatched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCsscalStridedBatched_assumed_rank #else module procedure & hipblasCsscalStridedBatched_rank_0,& hipblasCsscalStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdscalStridedBatched function hipblasZdscalStridedBatched_(handle,n,alpha,x,incx,stridex,batchCount) & bind(c, name="hipblasZdscalStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdscalStridedBatched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZdscalStridedBatched_assumed_rank #else module procedure & hipblasZdscalStridedBatched_rank_0,& hipblasZdscalStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSscalStridedBatched_64 function hipblasSscalStridedBatched_64_(handle,n,alpha,x,incx,stridex,batchCount) & bind(c, name="hipblasSscalStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSscalStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDscalStridedBatched_64 function hipblasDscalStridedBatched_64_(handle,n,alpha,x,incx,stridex,batchCount) & bind(c, name="hipblasDscalStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDscalStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCscalStridedBatched_64 function hipblasCscalStridedBatched_64_(handle,n,alpha,x,incx,stridex,batchCount) & bind(c, name="hipblasCscalStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCscalStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZscalStridedBatched_64 function hipblasZscalStridedBatched_64_(handle,n,alpha,x,incx,stridex,batchCount) & bind(c, name="hipblasZscalStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZscalStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsscalStridedBatched_64 function hipblasCsscalStridedBatched_64_(handle,n,alpha,x,incx,stridex,batchCount) & bind(c, name="hipblasCsscalStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsscalStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdscalStridedBatched_64 function hipblasZdscalStridedBatched_64_(handle,n,alpha,x,incx,stridex,batchCount) & bind(c, name="hipblasZdscalStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdscalStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The swap functions interchange vectors ``x`` and ``y``. !> !> y := x; x := y !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in x and y. !> @param[inout] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[inout] y - device pointer storing vector y. !> @param[in] incy - [int] !> specifies the increment for the elements of y. interface hipblasSswap #ifdef USE_CUDA_NAMES function hipblasSswap_(handle,n,x,incx,y,incy) bind(c, name="cublasSswap_v2") #else function hipblasSswap_(handle,n,x,incx,y,incy) bind(c, name="hipblasSswap") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSswap_assumed_rank #else module procedure & hipblasSswap_rank_0,& hipblasSswap_rank_1 #endif #endif end interface interface hipblasDswap #ifdef USE_CUDA_NAMES function hipblasDswap_(handle,n,x,incx,y,incy) bind(c, name="cublasDswap_v2") #else function hipblasDswap_(handle,n,x,incx,y,incy) bind(c, name="hipblasDswap") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDswap_assumed_rank #else module procedure & hipblasDswap_rank_0,& hipblasDswap_rank_1 #endif #endif end interface interface hipblasCswap #ifdef USE_CUDA_NAMES function hipblasCswap_(handle,n,x,incx,y,incy) bind(c, name="cublasCswap_v2") #else function hipblasCswap_(handle,n,x,incx,y,incy) bind(c, name="hipblasCswap") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCswap_assumed_rank #else module procedure & hipblasCswap_rank_0,& hipblasCswap_rank_1 #endif #endif end interface interface hipblasZswap #ifdef USE_CUDA_NAMES function hipblasZswap_(handle,n,x,incx,y,incy) bind(c, name="cublasZswap_v2") #else function hipblasZswap_(handle,n,x,incx,y,incy) bind(c, name="hipblasZswap") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZswap_assumed_rank #else module procedure & hipblasZswap_rank_0,& hipblasZswap_rank_1 #endif #endif end interface interface hipblasSswap_64 #ifdef USE_CUDA_NAMES function hipblasSswap_64_(handle,n,x,incx,y,incy) bind(c, name="cublasSswap_v2_64") #else function hipblasSswap_64_(handle,n,x,incx,y,incy) bind(c, name="hipblasSswap_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSswap_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasDswap_64 #ifdef USE_CUDA_NAMES function hipblasDswap_64_(handle,n,x,incx,y,incy) bind(c, name="cublasDswap_v2_64") #else function hipblasDswap_64_(handle,n,x,incx,y,incy) bind(c, name="hipblasDswap_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDswap_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasCswap_64 #ifdef USE_CUDA_NAMES function hipblasCswap_64_(handle,n,x,incx,y,incy) bind(c, name="cublasCswap_v2_64") #else function hipblasCswap_64_(handle,n,x,incx,y,incy) bind(c, name="hipblasCswap_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCswap_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasZswap_64 #ifdef USE_CUDA_NAMES function hipblasZswap_64_(handle,n,x,incx,y,incy) bind(c, name="cublasZswap_v2_64") #else function hipblasZswap_64_(handle,n,x,incx,y,incy) bind(c, name="hipblasZswap_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZswap_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 1 API !> !> \details !> The swapBatched functions interchange vectors ``x_i`` and ``y_i``, for ``i`` = 1 , ... , !> ``batchCount``. !> !> y_i := x_i; x_i := y_i !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in each x_i and y_i. !> @param[inout] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[inout] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of each y_i. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSswapBatched function hipblasSswapBatched_(handle,n,x,incx,y,incy,batchCount) & bind(c, name="hipblasSswapBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDswapBatched function hipblasDswapBatched_(handle,n,x,incx,y,incy,batchCount) & bind(c, name="hipblasDswapBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCswapBatched function hipblasCswapBatched_(handle,n,x,incx,y,incy,batchCount) & bind(c, name="hipblasCswapBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZswapBatched function hipblasZswapBatched_(handle,n,x,incx,y,incy,batchCount) & bind(c, name="hipblasZswapBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSswapBatched_64 function hipblasSswapBatched_64_(handle,n,x,incx,y,incy,batchCount) & bind(c, name="hipblasSswapBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSswapBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDswapBatched_64 function hipblasDswapBatched_64_(handle,n,x,incx,y,incy,batchCount) & bind(c, name="hipblasDswapBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDswapBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCswapBatched_64 function hipblasCswapBatched_64_(handle,n,x,incx,y,incy,batchCount) & bind(c, name="hipblasCswapBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCswapBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZswapBatched_64 function hipblasZswapBatched_64_(handle,n,x,incx,y,incy,batchCount) & bind(c, name="hipblasZswapBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZswapBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 1 API !> !> \details !> The swapStridedBatched functions interchange vectors ``x_i`` and ``y_i``, for ``i`` = 1 , !> ... , ``batchCount``. !> !> y_i := x_i; x_i := y_i !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in each x_i and y_i. !> @param[inout] x - device pointer to the first vector x_1. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stridex. However, the user should !> ensure that stridex is of an appropriate size. For a typical !> case, this means stridex >= n * incx. !> @param[inout] y - device pointer to the first vector y_1. !> @param[in] incy - [int] !> specifies the increment for the elements of y. !> @param[in] stridey - [hipblasStride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> There are no restrictions placed on stridey. However, the user should !> ensure that stridey is of an appropriate size. For a typical !> case, this means stridey >= n * incy. stridey should be non zero. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSswapStridedBatched function hipblasSswapStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasSswapStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSswapStridedBatched_assumed_rank #else module procedure & hipblasSswapStridedBatched_rank_0,& hipblasSswapStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDswapStridedBatched function hipblasDswapStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasDswapStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDswapStridedBatched_assumed_rank #else module procedure & hipblasDswapStridedBatched_rank_0,& hipblasDswapStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCswapStridedBatched function hipblasCswapStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasCswapStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCswapStridedBatched_assumed_rank #else module procedure & hipblasCswapStridedBatched_rank_0,& hipblasCswapStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZswapStridedBatched function hipblasZswapStridedBatched_(handle,n,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasZswapStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZswapStridedBatched_assumed_rank #else module procedure & hipblasZswapStridedBatched_rank_0,& hipblasZswapStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSswapStridedBatched_64 function hipblasSswapStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasSswapStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSswapStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDswapStridedBatched_64 function hipblasDswapStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasDswapStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDswapStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCswapStridedBatched_64 function hipblasCswapStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasCswapStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCswapStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZswapStridedBatched_64 function hipblasZswapStridedBatched_64_(handle,n,x,incx,stridex,y,incy,stridey,batchCount) & bind(c, name="hipblasZswapStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZswapStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The gbmv functions perform one of the matrix-vector operations: !> !> y := alpha*A*x + beta*y, or !> y := alpha*A**T*x + beta*y, or !> y := alpha*A**H*x + beta*y, !> !> where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are vectors, and ``A`` is an !> ``m`` by ``n`` banded matrix with ``kl`` sub-diagonals and ``ku`` super-diagonals. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] trans - [hipblasOperation_t] !> indicates whether matrix A is tranposed (conjugated) or not. !> @param[in] m - [int] !> number of rows of matrix A. !> @param[in] n - [int] !> number of columns of matrix A. !> @param[in] kl - [int] !> number of sub-diagonals of A. !> @param[in] ku - [int] !> number of super-diagonals of A. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] AP - device pointer storing banded matrix A. !> The leading (kl + ku + 1) by n part of the matrix contains the coefficients !> of the banded matrix. The leading diagonal resides in row (ku + 1) with !> the first super-diagonal above on the RHS of row ku. The first sub-diagonal !> resides below on the LHS of row ku + 2. This propagates up and down across !> sub/super-diagonals. !> Ex: (m = n = 7; ku = 2, kl = 2) !> 1 2 3 0 0 0 0 -> 0 0 3 3 3 3 3 !> 4 1 2 3 0 0 0 -> 0 2 2 2 2 2 2 !> 5 4 1 2 3 0 0 -> 1 1 1 1 1 1 1 !> 0 5 4 1 2 3 0 -> 4 4 4 4 4 4 0 !> 0 0 5 4 1 2 0 -> 5 5 5 5 5 0 0 !> 0 0 0 5 4 1 2 -> 0 0 0 0 0 0 0 !> 0 0 0 0 5 4 1 -> 0 0 0 0 0 0 0 !> Note that empty elements that don't correspond to data will not !> be referenced. !> @param[in] lda - [int] !> specifies the leading dimension of A. Must be >= (kl + ku + 1). !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[inout] y - device pointer storing vector y. !> @param[in] incy - [int] !> specifies the increment for the elements of y. interface hipblasSgbmv #ifdef USE_CUDA_NAMES function hipblasSgbmv_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasSgbmv_v2") #else function hipblasSgbmv_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasSgbmv") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSgbmv_assumed_rank #else module procedure & hipblasSgbmv_rank_0,& hipblasSgbmv_rank_1,& hipblasSgbmv_full_rank #endif #endif end interface interface hipblasDgbmv #ifdef USE_CUDA_NAMES function hipblasDgbmv_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasDgbmv_v2") #else function hipblasDgbmv_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasDgbmv") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDgbmv_assumed_rank #else module procedure & hipblasDgbmv_rank_0,& hipblasDgbmv_rank_1,& hipblasDgbmv_full_rank #endif #endif end interface interface hipblasCgbmv #ifdef USE_CUDA_NAMES function hipblasCgbmv_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasCgbmv_v2") #else function hipblasCgbmv_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasCgbmv") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCgbmv_assumed_rank #else module procedure & hipblasCgbmv_rank_0,& hipblasCgbmv_rank_1,& hipblasCgbmv_full_rank #endif #endif end interface interface hipblasZgbmv #ifdef USE_CUDA_NAMES function hipblasZgbmv_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasZgbmv_v2") #else function hipblasZgbmv_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasZgbmv") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZgbmv_assumed_rank #else module procedure & hipblasZgbmv_rank_0,& hipblasZgbmv_rank_1,& hipblasZgbmv_full_rank #endif #endif end interface interface hipblasSgbmv_64 #ifdef USE_CUDA_NAMES function hipblasSgbmv_64_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasSgbmv_v2_64") #else function hipblasSgbmv_64_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasSgbmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgbmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasDgbmv_64 #ifdef USE_CUDA_NAMES function hipblasDgbmv_64_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasDgbmv_v2_64") #else function hipblasDgbmv_64_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasDgbmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgbmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasCgbmv_64 #ifdef USE_CUDA_NAMES function hipblasCgbmv_64_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasCgbmv_v2_64") #else function hipblasCgbmv_64_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasCgbmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgbmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasZgbmv_64 #ifdef USE_CUDA_NAMES function hipblasZgbmv_64_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasZgbmv_v2_64") #else function hipblasZgbmv_64_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasZgbmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgbmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 2 API !> !> \details !> The gbmvBatched functions perform one of the matrix-vector operations: !> !> y_i := alpha*A_i*x_i + beta*y_i, or !> y_i := alpha*A_i**T*x_i + beta*y_i, or !> y_i := alpha*A_i**H*x_i + beta*y_i, !> !> where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``m`` by ``n`` banded matrix with ``kl`` sub-diagonals and ``ku`` super-diagonals, !> for ``i`` = 1, ..., ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] trans - [hipblasOperation_t] !> indicates whether matrix A is tranposed (conjugated) or not. !> @param[in] m - [int] !> number of rows of each matrix A_i. !> @param[in] n - [int] !> number of columns of each matrix A_i. !> @param[in] kl - [int] !> number of sub-diagonals of each A_i. !> @param[in] ku - [int] !> number of super-diagonals of each A_i. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] AP - device array of device pointers storing each banded matrix A_i. !> The leading (kl + ku + 1) by n part of the matrix contains the coefficients !> of the banded matrix. The leading diagonal resides in row (ku + 1) with !> the first super-diagonal above on the RHS of row ku. The first sub-diagonal !> resides below on the LHS of row ku + 2. This propagates up and down across !> sub/super-diagonals. !> Ex: (m = n = 7; ku = 2, kl = 2) !> 1 2 3 0 0 0 0 -> 0 0 3 3 3 3 3 !> 4 1 2 3 0 0 0 -> 0 2 2 2 2 2 2 !> 5 4 1 2 3 0 0 -> 1 1 1 1 1 1 1 !> 0 5 4 1 2 3 0 -> 4 4 4 4 4 4 0 !> 0 0 5 4 1 2 0 -> 5 5 5 5 5 0 0 !> 0 0 0 5 4 1 2 -> 0 0 0 0 0 0 0 !> 0 0 0 0 5 4 1 -> 0 0 0 0 0 0 0 !> Note that empty elements that don't correspond to data will not !> be referenced. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. Must be >= (kl + ku + 1). !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[inout] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of each y_i. !> @param[in] batchCount - [int] !> specifies the number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSgbmvBatched function hipblasSgbmvBatched_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy, & batchCount) & bind(c, name="hipblasSgbmvBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgbmvBatched function hipblasDgbmvBatched_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy, & batchCount) & bind(c, name="hipblasDgbmvBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgbmvBatched function hipblasCgbmvBatched_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy, & batchCount) & bind(c, name="hipblasCgbmvBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgbmvBatched function hipblasZgbmvBatched_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy, & batchCount) & bind(c, name="hipblasZgbmvBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSgbmvBatched_64 function hipblasSgbmvBatched_64_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy, & batchCount) & bind(c, name="hipblasSgbmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgbmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgbmvBatched_64 function hipblasDgbmvBatched_64_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy, & batchCount) & bind(c, name="hipblasDgbmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgbmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgbmvBatched_64 function hipblasCgbmvBatched_64_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy, & batchCount) & bind(c, name="hipblasCgbmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgbmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgbmvBatched_64 function hipblasZgbmvBatched_64_(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy, & batchCount) & bind(c, name="hipblasZgbmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgbmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The gbmvStridedBatched functions perform one of the matrix-vector operations: !> !> y_i := alpha*A_i*x_i + beta*y_i, or !> y_i := alpha*A_i**T*x_i + beta*y_i, or !> y_i := alpha*A_i**H*x_i + beta*y_i, !> !> where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``m`` by ``n`` banded matrix with ``kl`` sub-diagonals and ``ku`` super-diagonals, !> for ``i`` = 1, ..., ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] trans - [hipblasOperation_t] !> indicates whether matrix A is tranposed (conjugated) or not. !> @param[in] m - [int] !> number of rows of matrix A. !> @param[in] n - [int] !> number of columns of matrix A. !> @param[in] kl - [int] !> number of sub-diagonals of A. !> @param[in] ku - [int] !> number of super-diagonals of A. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] AP - device pointer to first banded matrix (A_1). !> The leading (kl + ku + 1) by n part of the matrix contains the coefficients !> of the banded matrix. The leading diagonal resides in row (ku + 1) with !> the first super-diagonal above on the RHS of row ku. The first sub-diagonal !> resides below on the LHS of row ku + 2. This propagates up and down across !> sub/super-diagonals. !> Ex: (m = n = 7; ku = 2, kl = 2) !> 1 2 3 0 0 0 0 -> 0 0 3 3 3 3 3 !> 4 1 2 3 0 0 0 -> 0 2 2 2 2 2 2 !> 5 4 1 2 3 0 0 -> 1 1 1 1 1 1 1 !> 0 5 4 1 2 3 0 -> 4 4 4 4 4 4 0 !> 0 0 5 4 1 2 0 -> 5 5 5 5 5 0 0 !> 0 0 0 5 4 1 2 -> 0 0 0 0 0 0 0 !> 0 0 0 0 5 4 1 -> 0 0 0 0 0 0 0 !> Note that empty elements that don't correspond to data will not !> be referenced. !> @param[in] lda - [int] !> specifies the leading dimension of A. Must be >= (kl + ku + 1). !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> @param[in] x - device pointer to first vector (x_1). !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[inout] y - device pointer to first vector (y_1). !> @param[in] incy - [int] !> specifies the increment for the elements of y. !> @param[in] stridey - [hipblasStride] !> stride from the start of one vector (y_i) to the next one (x_i+1). !> @param[in] batchCount - [int] !> specifies the number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSgbmvStridedBatched function hipblasSgbmvStridedBatched_(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) & bind(c, name="hipblasSgbmvStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSgbmvStridedBatched_assumed_rank #else module procedure & hipblasSgbmvStridedBatched_rank_0,& hipblasSgbmvStridedBatched_rank_1,& hipblasSgbmvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgbmvStridedBatched function hipblasDgbmvStridedBatched_(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) & bind(c, name="hipblasDgbmvStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDgbmvStridedBatched_assumed_rank #else module procedure & hipblasDgbmvStridedBatched_rank_0,& hipblasDgbmvStridedBatched_rank_1,& hipblasDgbmvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgbmvStridedBatched function hipblasCgbmvStridedBatched_(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) & bind(c, name="hipblasCgbmvStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCgbmvStridedBatched_assumed_rank #else module procedure & hipblasCgbmvStridedBatched_rank_0,& hipblasCgbmvStridedBatched_rank_1,& hipblasCgbmvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgbmvStridedBatched function hipblasZgbmvStridedBatched_(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) & bind(c, name="hipblasZgbmvStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZgbmvStridedBatched_assumed_rank #else module procedure & hipblasZgbmvStridedBatched_rank_0,& hipblasZgbmvStridedBatched_rank_1,& hipblasZgbmvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSgbmvStridedBatched_64 function hipblasSgbmvStridedBatched_64_(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) & bind(c, name="hipblasSgbmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgbmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgbmvStridedBatched_64 function hipblasDgbmvStridedBatched_64_(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) & bind(c, name="hipblasDgbmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgbmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgbmvStridedBatched_64 function hipblasCgbmvStridedBatched_64_(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) & bind(c, name="hipblasCgbmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgbmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgbmvStridedBatched_64 function hipblasZgbmvStridedBatched_64_(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) & bind(c, name="hipblasZgbmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgbmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The gemv functions perform one of the matrix-vector operations: !> !> y := alpha*A*x + beta*y, or !> y := alpha*A**T*x + beta*y, or !> y := alpha*A**H*x + beta*y, !> !> where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are vectors, and ``A`` is an !> ``m`` by ``n`` matrix. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] trans - [hipblasOperation_t] !> indicates whether matrix A is tranposed (conjugated) or not. !> @param[in] m - [int] !> number of rows of matrix A. !> @param[in] n - [int] !> number of columns of matrix A. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] AP - device pointer storing matrix A. !> @param[in] lda - [int] !> specifies the leading dimension of A. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[inout] y - device pointer storing vector y. !> @param[in] incy - [int] !> specifies the increment for the elements of y. interface hipblasSgemv #ifdef USE_CUDA_NAMES function hipblasSgemv_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasSgemv_v2") #else function hipblasSgemv_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasSgemv") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSgemv_assumed_rank #else module procedure & hipblasSgemv_rank_0,& hipblasSgemv_rank_1,& hipblasSgemv_full_rank #endif #endif end interface interface hipblasDgemv #ifdef USE_CUDA_NAMES function hipblasDgemv_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasDgemv_v2") #else function hipblasDgemv_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasDgemv") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDgemv_assumed_rank #else module procedure & hipblasDgemv_rank_0,& hipblasDgemv_rank_1,& hipblasDgemv_full_rank #endif #endif end interface interface hipblasCgemv #ifdef USE_CUDA_NAMES function hipblasCgemv_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasCgemv_v2") #else function hipblasCgemv_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasCgemv") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCgemv_assumed_rank #else module procedure & hipblasCgemv_rank_0,& hipblasCgemv_rank_1,& hipblasCgemv_full_rank #endif #endif end interface interface hipblasZgemv #ifdef USE_CUDA_NAMES function hipblasZgemv_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasZgemv_v2") #else function hipblasZgemv_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasZgemv") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZgemv_assumed_rank #else module procedure & hipblasZgemv_rank_0,& hipblasZgemv_rank_1,& hipblasZgemv_full_rank #endif #endif end interface interface hipblasSgemv_64 #ifdef USE_CUDA_NAMES function hipblasSgemv_64_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasSgemv_v2_64") #else function hipblasSgemv_64_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasSgemv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasDgemv_64 #ifdef USE_CUDA_NAMES function hipblasDgemv_64_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasDgemv_v2_64") #else function hipblasDgemv_64_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasDgemv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasCgemv_64 #ifdef USE_CUDA_NAMES function hipblasCgemv_64_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasCgemv_v2_64") #else function hipblasCgemv_64_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasCgemv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasZgemv_64 #ifdef USE_CUDA_NAMES function hipblasZgemv_64_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasZgemv_v2_64") #else function hipblasZgemv_64_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasZgemv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 2 API !> !> \details !> The gemvBatched functions perform a batch of matrix-vector operations: !> !> y_i := alpha*A_i*x_i + beta*y_i, or !> y_i := alpha*A_i**T*x_i + beta*y_i, or !> y_i := alpha*A_i**H*x_i + beta*y_i, !> !> where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``m`` by ``n`` matrix, for ``i`` = 1, ..., ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] trans - [hipblasOperation_t] !> indicates whether matrices A_i are tranposed (conjugated) or not. !> @param[in] m - [int] !> number of rows of each matrix A_i. !> @param[in] n - [int] !> number of columns of each matrix A_i. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] AP - device array of device pointers storing each matrix A_i. !> @param[in] lda - [int] !> specifies the leading dimension of each matrix A_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each vector x_i. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[inout] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of each vector y_i. !> @param[in] batchCount - [int] !> number of instances in the batch. interface hipblasSgemvBatched #ifdef USE_CUDA_NAMES function hipblasSgemvBatched_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="cublasSgemvBatched") #else function hipblasSgemvBatched_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasSgemvBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface interface hipblasDgemvBatched #ifdef USE_CUDA_NAMES function hipblasDgemvBatched_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="cublasDgemvBatched") #else function hipblasDgemvBatched_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasDgemvBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface interface hipblasCgemvBatched #ifdef USE_CUDA_NAMES function hipblasCgemvBatched_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="cublasCgemvBatched") #else function hipblasCgemvBatched_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasCgemvBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface interface hipblasZgemvBatched #ifdef USE_CUDA_NAMES function hipblasZgemvBatched_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="cublasZgemvBatched") #else function hipblasZgemvBatched_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasZgemvBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface interface hipblasSgemvBatched_64 #ifdef USE_CUDA_NAMES function hipblasSgemvBatched_64_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="cublasSgemvBatched_64") #else function hipblasSgemvBatched_64_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasSgemvBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface interface hipblasDgemvBatched_64 #ifdef USE_CUDA_NAMES function hipblasDgemvBatched_64_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="cublasDgemvBatched_64") #else function hipblasDgemvBatched_64_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasDgemvBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface interface hipblasCgemvBatched_64 #ifdef USE_CUDA_NAMES function hipblasCgemvBatched_64_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="cublasCgemvBatched_64") #else function hipblasCgemvBatched_64_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasCgemvBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface interface hipblasZgemvBatched_64 #ifdef USE_CUDA_NAMES function hipblasZgemvBatched_64_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="cublasZgemvBatched_64") #else function hipblasZgemvBatched_64_(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasZgemvBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface !> \brief BLAS Level 2 API !> !> \details !> The gemvStridedBatched functions perform a batch of matrix-vector operations: !> !> y_i := alpha*A_i*x_i + beta*y_i, or !> y_i := alpha*A_i**T*x_i + beta*y_i, or !> y_i := alpha*A_i**H*x_i + beta*y_i, !> !> where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``m`` by ``n`` matrix, for ``i`` = 1, ..., ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] transA - [hipblasOperation_t] !> indicates whether matrices A_i are tranposed (conjugated) or not. !> @param[in] m - [int] !> number of rows of matrices A_i. !> @param[in] n - [int] !> number of columns of matrices A_i. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] AP - device pointer to the first matrix (A_1) in the batch. !> @param[in] lda - [int] !> specifies the leading dimension of matrices A_i. !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> @param[in] x - device pointer to the first vector (x_1) in the batch. !> @param[in] incx - [int] !> specifies the increment for the elements of vectors x_i. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stridex. However, the user should !> ensure that stridex is of an appropriate size. When trans equals HIPBLAS_OP_N, !> this typically means stridex >= n * incx. Otherwise, stridex >= m * incx. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[inout] y - device pointer to the first vector (y_1) in the batch. !> @param[in] incy - [int] !> specifies the increment for the elements of vectors y_i. !> @param[in] stridey - [hipblasStride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> There are no restrictions placed on stridey. However, the user should !> ensure that stridey is of an appropriate size. When trans equals HIPBLAS_OP_N, !> this typically means stridey >= m * incy. Otherwise, stridey >= n * incy. !> stridey should be non zero. !> @param[in] batchCount - [int] !> number of instances in the batch. interface hipblasSgemvStridedBatched #ifdef USE_CUDA_NAMES function hipblasSgemvStridedBatched_(handle,transA,m,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="cublasSgemvStridedBatched") #else function hipblasSgemvStridedBatched_(handle,transA,m,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="hipblasSgemvStridedBatched") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSgemvStridedBatched_assumed_rank #else module procedure & hipblasSgemvStridedBatched_rank_0,& hipblasSgemvStridedBatched_rank_1,& hipblasSgemvStridedBatched_full_rank #endif #endif end interface interface hipblasDgemvStridedBatched #ifdef USE_CUDA_NAMES function hipblasDgemvStridedBatched_(handle,transA,m,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="cublasDgemvStridedBatched") #else function hipblasDgemvStridedBatched_(handle,transA,m,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="hipblasDgemvStridedBatched") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDgemvStridedBatched_assumed_rank #else module procedure & hipblasDgemvStridedBatched_rank_0,& hipblasDgemvStridedBatched_rank_1,& hipblasDgemvStridedBatched_full_rank #endif #endif end interface interface hipblasCgemvStridedBatched #ifdef USE_CUDA_NAMES function hipblasCgemvStridedBatched_(handle,transA,m,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="cublasCgemvStridedBatched") #else function hipblasCgemvStridedBatched_(handle,transA,m,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="hipblasCgemvStridedBatched") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCgemvStridedBatched_assumed_rank #else module procedure & hipblasCgemvStridedBatched_rank_0,& hipblasCgemvStridedBatched_rank_1,& hipblasCgemvStridedBatched_full_rank #endif #endif end interface interface hipblasZgemvStridedBatched #ifdef USE_CUDA_NAMES function hipblasZgemvStridedBatched_(handle,transA,m,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="cublasZgemvStridedBatched") #else function hipblasZgemvStridedBatched_(handle,transA,m,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="hipblasZgemvStridedBatched") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZgemvStridedBatched_assumed_rank #else module procedure & hipblasZgemvStridedBatched_rank_0,& hipblasZgemvStridedBatched_rank_1,& hipblasZgemvStridedBatched_full_rank #endif #endif end interface interface hipblasSgemvStridedBatched_64 #ifdef USE_CUDA_NAMES function hipblasSgemvStridedBatched_64_(handle,transA,m,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="cublasSgemvStridedBatched_64") #else function hipblasSgemvStridedBatched_64_(handle,transA,m,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="hipblasSgemvStridedBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface interface hipblasDgemvStridedBatched_64 #ifdef USE_CUDA_NAMES function hipblasDgemvStridedBatched_64_(handle,transA,m,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="cublasDgemvStridedBatched_64") #else function hipblasDgemvStridedBatched_64_(handle,transA,m,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="hipblasDgemvStridedBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface interface hipblasCgemvStridedBatched_64 #ifdef USE_CUDA_NAMES function hipblasCgemvStridedBatched_64_(handle,transA,m,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="cublasCgemvStridedBatched_64") #else function hipblasCgemvStridedBatched_64_(handle,transA,m,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="hipblasCgemvStridedBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface interface hipblasZgemvStridedBatched_64 #ifdef USE_CUDA_NAMES function hipblasZgemvStridedBatched_64_(handle,transA,m,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="cublasZgemvStridedBatched_64") #else function hipblasZgemvStridedBatched_64_(handle,transA,m,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="hipblasZgemvStridedBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface !> \brief BLAS Level 2 API !> !> \details !> The ger, geru, and gerc functions perform the matrix-vector operations: !> !> A := A + alpha*x*y**T , OR !> A := A + alpha*x*y**H for gerc !> !> where ``alpha`` is a scalar, ``x`` and ``y`` are vectors, and ``A`` is an !> ``m`` by ``n`` matrix. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] m - [int] !> the number of rows of the matrix A. !> @param[in] n - [int] !> the number of columns of the matrix A. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[in] y - device pointer storing vector y. !> @param[in] incy - [int] !> specifies the increment for the elements of y. !> @param[inout] AP - device pointer storing matrix A. !> @param[in] lda - [int] !> specifies the leading dimension of A. interface hipblasSger #ifdef USE_CUDA_NAMES function hipblasSger_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="cublasSger_v2") #else function hipblasSger_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="hipblasSger") #endif use iso_c_binding use hipfort_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 real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSger_assumed_rank #else module procedure & hipblasSger_rank_0,& hipblasSger_rank_1,& hipblasSger_full_rank #endif #endif end interface interface hipblasDger #ifdef USE_CUDA_NAMES function hipblasDger_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="cublasDger_v2") #else function hipblasDger_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="hipblasDger") #endif use iso_c_binding use hipfort_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 real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDger_assumed_rank #else module procedure & hipblasDger_rank_0,& hipblasDger_rank_1,& hipblasDger_full_rank #endif #endif end interface interface hipblasCgeru #ifdef USE_CUDA_NAMES function hipblasCgeru_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="cublasCgeru_v2") #else function hipblasCgeru_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="hipblasCgeru") #endif use iso_c_binding use hipfort_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 complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCgeru_assumed_rank #else module procedure & hipblasCgeru_rank_0,& hipblasCgeru_rank_1,& hipblasCgeru_full_rank #endif #endif end interface interface hipblasCgerc #ifdef USE_CUDA_NAMES function hipblasCgerc_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="cublasCgerc_v2") #else function hipblasCgerc_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="hipblasCgerc") #endif use iso_c_binding use hipfort_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 complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCgerc_assumed_rank #else module procedure & hipblasCgerc_rank_0,& hipblasCgerc_rank_1,& hipblasCgerc_full_rank #endif #endif end interface interface hipblasZgeru #ifdef USE_CUDA_NAMES function hipblasZgeru_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="cublasZgeru_v2") #else function hipblasZgeru_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="hipblasZgeru") #endif use iso_c_binding use hipfort_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 complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZgeru_assumed_rank #else module procedure & hipblasZgeru_rank_0,& hipblasZgeru_rank_1,& hipblasZgeru_full_rank #endif #endif end interface interface hipblasZgerc #ifdef USE_CUDA_NAMES function hipblasZgerc_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="cublasZgerc_v2") #else function hipblasZgerc_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="hipblasZgerc") #endif use iso_c_binding use hipfort_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 complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZgerc_assumed_rank #else module procedure & hipblasZgerc_rank_0,& hipblasZgerc_rank_1,& hipblasZgerc_full_rank #endif #endif end interface interface hipblasSger_64 #ifdef USE_CUDA_NAMES function hipblasSger_64_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="cublasSger_v2_64") #else function hipblasSger_64_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="hipblasSger_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSger_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda end function end interface interface hipblasDger_64 #ifdef USE_CUDA_NAMES function hipblasDger_64_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="cublasDger_v2_64") #else function hipblasDger_64_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="hipblasDger_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDger_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda end function end interface interface hipblasCgeru_64 #ifdef USE_CUDA_NAMES function hipblasCgeru_64_(handle,m,n,alpha,x,incx,y,incy,AP,lda) & bind(c, name="cublasCgeru_v2_64") #else function hipblasCgeru_64_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="hipblasCgeru_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeru_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda end function end interface interface hipblasCgerc_64 #ifdef USE_CUDA_NAMES function hipblasCgerc_64_(handle,m,n,alpha,x,incx,y,incy,AP,lda) & bind(c, name="cublasCgerc_v2_64") #else function hipblasCgerc_64_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="hipblasCgerc_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgerc_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda end function end interface interface hipblasZgeru_64 #ifdef USE_CUDA_NAMES function hipblasZgeru_64_(handle,m,n,alpha,x,incx,y,incy,AP,lda) & bind(c, name="cublasZgeru_v2_64") #else function hipblasZgeru_64_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="hipblasZgeru_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeru_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda end function end interface interface hipblasZgerc_64 #ifdef USE_CUDA_NAMES function hipblasZgerc_64_(handle,m,n,alpha,x,incx,y,incy,AP,lda) & bind(c, name="cublasZgerc_v2_64") #else function hipblasZgerc_64_(handle,m,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="hipblasZgerc_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgerc_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda end function end interface !> \brief BLAS Level 2 API !> !> \details !> The gerBatched, geruBatched, and gercBatched functions perform a batch of the matrix-vector !> operations: !> !> A := A + alpha*x*y**T , OR !> A := A + alpha*x*y**H for gerc !> !> where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch, !> ``alpha`` is a scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``m`` by ``n`` matrix, for ``i`` = 1, ..., ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] m - [int] !> the number of rows of each matrix A_i. !> @param[in] n - [int] !> the number of columns of each matrix A_i. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each vector x_i. !> @param[in] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of each vector y_i. !> @param[inout] AP - device array of device pointers storing each matrix A_i. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSgerBatched function hipblasSgerBatched_(handle,m,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasSgerBatched") use iso_c_binding use hipfort_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 real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgerBatched function hipblasDgerBatched_(handle,m,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasDgerBatched") use iso_c_binding use hipfort_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 real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgeruBatched function hipblasCgeruBatched_(handle,m,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasCgeruBatched") use iso_c_binding use hipfort_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 complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgercBatched function hipblasCgercBatched_(handle,m,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasCgercBatched") use iso_c_binding use hipfort_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 complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgeruBatched function hipblasZgeruBatched_(handle,m,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasZgeruBatched") use iso_c_binding use hipfort_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 complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgercBatched function hipblasZgercBatched_(handle,m,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasZgercBatched") use iso_c_binding use hipfort_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 complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSgerBatched_64 function hipblasSgerBatched_64_(handle,m,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasSgerBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgerBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgerBatched_64 function hipblasDgerBatched_64_(handle,m,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasDgerBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgerBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgeruBatched_64 function hipblasCgeruBatched_64_(handle,m,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasCgeruBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeruBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgercBatched_64 function hipblasCgercBatched_64_(handle,m,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasCgercBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgercBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgeruBatched_64 function hipblasZgeruBatched_64_(handle,m,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasZgeruBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeruBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgercBatched_64 function hipblasZgercBatched_64_(handle,m,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasZgercBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgercBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The gerStridedBatched, geruStridedBatched, and gercStridedBatched functions perform the !> matrix-vector operations: !> !> A_i := A_i + alpha*x_i*y_i**T, OR !> A_i := A_i + alpha*x_i*y_i**H for gerc !> !> where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch, !> ``alpha`` is a scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``m`` by ``n`` matrix, for ``i`` = 1, ..., ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] m - [int] !> the number of rows of each matrix A_i. !> @param[in] n - [int] !> the number of columns of each matrix A_i. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer to the first vector (x_1) in the batch. !> @param[in] incx - [int] !> specifies the increments for the elements of each vector x_i. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stridex. However, the user should !> ensure that stridex is of an appropriate size. For a typical !> case, this means stridex >= m * incx. !> @param[inout] y - device pointer to the first vector (y_1) in the batch. !> @param[in] incy - [int] !> specifies the increment for the elements of each vector y_i. !> @param[in] stridey - [hipblasStride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> There are no restrictions placed on stridey. However, the user should !> ensure that stridey is of an appropriate size. For a typical !> case, this means stridey >= n * incy. !> @param[inout] AP - device pointer to the first matrix (A_1) in the batch. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1) !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSgerStridedBatched function hipblasSgerStridedBatched_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP,lda, & strideA,batchCount) & bind(c, name="hipblasSgerStridedBatched") use iso_c_binding use hipfort_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 real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSgerStridedBatched_assumed_rank #else module procedure & hipblasSgerStridedBatched_rank_0,& hipblasSgerStridedBatched_rank_1,& hipblasSgerStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgerStridedBatched function hipblasDgerStridedBatched_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP,lda, & strideA,batchCount) & bind(c, name="hipblasDgerStridedBatched") use iso_c_binding use hipfort_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 real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDgerStridedBatched_assumed_rank #else module procedure & hipblasDgerStridedBatched_rank_0,& hipblasDgerStridedBatched_rank_1,& hipblasDgerStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgeruStridedBatched function hipblasCgeruStridedBatched_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP,lda, & strideA,batchCount) & bind(c, name="hipblasCgeruStridedBatched") use iso_c_binding use hipfort_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 complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCgeruStridedBatched_assumed_rank #else module procedure & hipblasCgeruStridedBatched_rank_0,& hipblasCgeruStridedBatched_rank_1,& hipblasCgeruStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgercStridedBatched function hipblasCgercStridedBatched_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP,lda, & strideA,batchCount) & bind(c, name="hipblasCgercStridedBatched") use iso_c_binding use hipfort_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 complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCgercStridedBatched_assumed_rank #else module procedure & hipblasCgercStridedBatched_rank_0,& hipblasCgercStridedBatched_rank_1,& hipblasCgercStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgeruStridedBatched function hipblasZgeruStridedBatched_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP,lda, & strideA,batchCount) & bind(c, name="hipblasZgeruStridedBatched") use iso_c_binding use hipfort_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 complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZgeruStridedBatched_assumed_rank #else module procedure & hipblasZgeruStridedBatched_rank_0,& hipblasZgeruStridedBatched_rank_1,& hipblasZgeruStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgercStridedBatched function hipblasZgercStridedBatched_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP,lda, & strideA,batchCount) & bind(c, name="hipblasZgercStridedBatched") use iso_c_binding use hipfort_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 complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZgercStridedBatched_assumed_rank #else module procedure & hipblasZgercStridedBatched_rank_0,& hipblasZgercStridedBatched_rank_1,& hipblasZgercStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSgerStridedBatched_64 function hipblasSgerStridedBatched_64_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP,lda, & strideA,batchCount) & bind(c, name="hipblasSgerStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgerStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgerStridedBatched_64 function hipblasDgerStridedBatched_64_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP,lda, & strideA,batchCount) & bind(c, name="hipblasDgerStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgerStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgeruStridedBatched_64 function hipblasCgeruStridedBatched_64_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP,lda, & strideA,batchCount) & bind(c, name="hipblasCgeruStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeruStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgercStridedBatched_64 function hipblasCgercStridedBatched_64_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP,lda, & strideA,batchCount) & bind(c, name="hipblasCgercStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgercStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgeruStridedBatched_64 function hipblasZgeruStridedBatched_64_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP,lda, & strideA,batchCount) & bind(c, name="hipblasZgeruStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeruStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgercStridedBatched_64 function hipblasZgercStridedBatched_64_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP,lda, & strideA,batchCount) & bind(c, name="hipblasZgercStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgercStridedBatched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The hbmv functions perform the matrix-vector operations: !> !> y := alpha*A*x + beta*y !> !> where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are ``n`` -element vectors, and !> ``A `` is an !> ``n`` by ``n`` Hermitian band matrix with ``k`` super-diagonals. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : ``c`` and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of A is being supplied. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of A is being supplied. !> @param[in] n - [int] !> the order of the matrix A. !> @param[in] k - [int] !> the number of super-diagonals of the matrix A. Must be >= 0. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] AP - device pointer storing matrix A. Of dimension (lda, n). !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The leading (k + 1) by n part of A must contain the upper !> triangular band part of the Hermitian matrix, with the leading !> diagonal in row (k + 1), the first super-diagonal on the RHS !> of row k, and so forth. !> The top left k by x triangle of A will not be referenced. !> Ex (upper, lda = n = 4, k = 1): !> A -> Represented matrix !> (0,0) (5,9) (6,8) (7,7) -> (1, 0) (5, 9) (0, 0) (0, 0) !> (1,0) (2,0) (3,0) (4,0) -> (5,-9) (2, 0) (6, 8) (0, 0) !> (0,0) (0,0) (0,0) (0,0) -> (0, 0) (6,-8) (3, 0) (7, 7) !> (0,0) (0,0) (0,0) (0,0) -> (0, 0) (0, 0) (7,-7) (4, 0) !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The leading (k + 1) by n part of A must contain the lower !> triangular band part of the Hermitian matrix, with the leading !> diagonal in row (1), the first sub-diagonal on the LHS of !> row 2, and so forth. !> The bottom right k by k triangle of A will not be referenced. !> Ex (lower, lda = 2, n = 4, k = 1): !> A -> Represented matrix !> (1,0) (2,0) (3,0) (4,0) -> (1, 0) (5,-9) (0, 0) (0, 0) !> (5,9) (6,8) (7,7) (0,0) -> (5, 9) (2, 0) (6,-8) (0, 0) !> -> (0, 0) (6, 8) (3, 0) (7,-7) !> -> (0, 0) (0, 0) (7, 7) (4, 0) !> - As a Hermitian matrix, the imaginary part of the main diagonal !> of A will not be referenced and is assumed to be == 0. !> @param[in] lda - [int] !> specifies the leading dimension of A. Must be >= k + 1. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[inout] y - device pointer storing vector y. !> @param[in] incy - [int] !> specifies the increment for the elements of y. interface hipblasChbmv #ifdef USE_CUDA_NAMES function hipblasChbmv_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasChbmv_v2") #else function hipblasChbmv_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasChbmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasChbmv_assumed_rank #else module procedure & hipblasChbmv_rank_0,& hipblasChbmv_rank_1,& hipblasChbmv_full_rank #endif #endif end interface interface hipblasZhbmv #ifdef USE_CUDA_NAMES function hipblasZhbmv_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasZhbmv_v2") #else function hipblasZhbmv_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasZhbmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZhbmv_assumed_rank #else module procedure & hipblasZhbmv_rank_0,& hipblasZhbmv_rank_1,& hipblasZhbmv_full_rank #endif #endif end interface interface hipblasChbmv_64 #ifdef USE_CUDA_NAMES function hipblasChbmv_64_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasChbmv_v2_64") #else function hipblasChbmv_64_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasChbmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasZhbmv_64 #ifdef USE_CUDA_NAMES function hipblasZhbmv_64_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasZhbmv_v2_64") #else function hipblasZhbmv_64_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasZhbmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hbmvBatched functions perform one of the matrix-vector operations: !> !> y_i := alpha*A_i*x_i + beta*y_i !> !> where ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are ``n`` -element vectors, !> and ``A_i`` is an !> ``n`` by ``n`` Hermitian band matrix with ``k`` super-diagonals, for each batch in !> ``i = [1, batchCount`` ]. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is being !> supplied. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is being !> supplied. !> @param[in] n - [int] !> the order of each matrix A_i. !> @param[in] k - [int] !> the number of super-diagonals of each matrix A_i. Must be >= 0. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] AP - device array of device pointers storing each matrix_i A of dimension (lda, !> n). !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The leading (k + 1) by n part of each A_i must contain the upper !> triangular band part of the Hermitian matrix, with the leading !> diagonal in row (k + 1), the first super-diagonal on the RHS !> of row k, and so forth. !> The top left k by x triangle of each A_i will not be referenced. !> Ex (upper, lda = n = 4, k = 1): !> A -> Represented matrix !> (0,0) (5,9) (6,8) (7,7) -> (1, 0) (5, 9) (0, 0) (0, 0) !> (1,0) (2,0) (3,0) (4,0) -> (5,-9) (2, 0) (6, 8) (0, 0) !> (0,0) (0,0) (0,0) (0,0) -> (0, 0) (6,-8) (3, 0) (7, 7) !> (0,0) (0,0) (0,0) (0,0) -> (0, 0) (0, 0) (7,-7) (4, 0) !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The leading (k + 1) by n part of each A_i must contain the lower !> triangular band part of the Hermitian matrix, with the leading !> diagonal in row (1), the first sub-diagonal on the LHS of !> row 2, and so forth. !> The bottom right k by k triangle of each A_i will not be referenced. !> Ex (lower, lda = 2, n = 4, k = 1): !> A -> Represented matrix !> (1,0) (2,0) (3,0) (4,0) -> (1, 0) (5,-9) (0, 0) (0, 0) !> (5,9) (6,8) (7,7) (0,0) -> (5, 9) (2, 0) (6,-8) (0, 0) !> -> (0, 0) (6, 8) (3, 0) (7,-7) !> -> (0, 0) (0, 0) (7, 7) (4, 0) !> - As a Hermitian matrix, the imaginary part of the main diagonal !> of each A_i will not be referenced and is assumed to be == 0. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. Must be >= max(1, n). !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[inout] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of y. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasChbmvBatched function hipblasChbmvBatched_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasChbmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhbmvBatched function hipblasZhbmvBatched_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasZhbmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasChbmvBatched_64 function hipblasChbmvBatched_64_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasChbmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhbmvBatched_64 function hipblasZhbmvBatched_64_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasZhbmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The hbmvStridedBatched functions perform one of the matrix-vector operations: !> !> y_i := alpha*A_i*x_i + beta*y_i !> !> where ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are ``n`` -element vectors, !> and ``A_i`` is an !> ``n`` by ``n`` Hermitian band matrix with ``k`` super-diagonals, for each batch in !> ``i = [1, batchCount`` ]. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is being !> supplied. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is being !> supplied. !> @param[in] n - [int] !> the order of each matrix A_i. !> @param[in] k - [int] !> the number of super-diagonals of each matrix A_i. Must be >= 0. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] AP - device array pointing to the first matrix A_1. Each A_i is of dimension !> (lda, n). !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The leading (k + 1) by n part of each A_i must contain the upper !> triangular band part of the Hermitian matrix, with the leading !> diagonal in row (k + 1), the first super-diagonal on the RHS !> of row k, and so forth. !> The top left k by x triangle of each A_i will not be referenced. !> Ex (upper, lda = n = 4, k = 1): !> A -> Represented matrix !> (0,0) (5,9) (6,8) (7,7) -> (1, 0) (5, 9) (0, 0) (0, 0) !> (1,0) (2,0) (3,0) (4,0) -> (5,-9) (2, 0) (6, 8) (0, 0) !> (0,0) (0,0) (0,0) (0,0) -> (0, 0) (6,-8) (3, 0) (7, 7) !> (0,0) (0,0) (0,0) (0,0) -> (0, 0) (0, 0) (7,-7) (4, 0) !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The leading (k + 1) by n part of each A_i must contain the lower !> triangular band part of the Hermitian matrix, with the leading !> diagonal in row (1), the first sub-diagonal on the LHS of !> row 2, and so forth. !> The bottom right k by k triangle of each A_i will not be referenced. !> Ex (lower, lda = 2, n = 4, k = 1): !> A Represented matrix !> (1,0) (2,0) (3,0) (4,0) -> (1, 0) (5,-9) (0, 0) (0, 0) !> (5,9) (6,8) (7,7) (0,0) -> (5, 9) (2, 0) (6,-8) (0, 0) !> -> (0, 0) (6, 8) (3, 0) (7,-7) !> -> (0, 0) (0, 0) (7, 7) (4, 0) !> - As a Hermitian matrix, the imaginary part of the main diagonal !> of each A_i will not be referenced and is assumed to be == 0. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. Must be >= max(1, n). !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> @param[in] x - device array pointing to the first vector y_1. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[inout] y - device array pointing to the first vector y_1. !> @param[in] incy - [int] !> specifies the increment for the elements of y. !> @param[in] stridey - [hipblasStride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasChbmvStridedBatched function hipblasChbmvStridedBatched_(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx,stridex,beta, & y,incy,stridey,batchCount) & bind(c, name="hipblasChbmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasChbmvStridedBatched_assumed_rank #else module procedure & hipblasChbmvStridedBatched_rank_0,& hipblasChbmvStridedBatched_rank_1,& hipblasChbmvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhbmvStridedBatched function hipblasZhbmvStridedBatched_(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx,stridex,beta, & y,incy,stridey,batchCount) & bind(c, name="hipblasZhbmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZhbmvStridedBatched_assumed_rank #else module procedure & hipblasZhbmvStridedBatched_rank_0,& hipblasZhbmvStridedBatched_rank_1,& hipblasZhbmvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasChbmvStridedBatched_64 function hipblasChbmvStridedBatched_64_(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="hipblasChbmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhbmvStridedBatched_64 function hipblasZhbmvStridedBatched_64_(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="hipblasZhbmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The hemv functions perform one of the matrix-vector operations: !> !> y := alpha*A*x + beta*y !> !> where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are ``n`` -element vectors, and !> ``A`` is an !> ``n`` by ``n`` Hermitian matrix. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : ``c`` and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: the upper triangular part of the Hermitian matrix A is !> supplied. !> - HIPBLAS_FILL_MODE_LOWER: the lower triangular part of the Hermitian matrix A is !> supplied. !> @param[in] n - [int] !> the order of the matrix A. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] AP - device pointer storing matrix A. Of dimension (lda, n). !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular part of A must contain !> the upper triangular part of a Hermitian matrix. The lower !> triangular part of A will not be referenced. !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular part of A must contain !> the lower triangular part of a Hermitian matrix. The upper !> triangular part of A will not be referenced. !> - As a Hermitian matrix, the imaginary part of the main diagonal !> of A will not be referenced and is assumed to be == 0. !> @param[in] lda - [int] !> specifies the leading dimension of A. Must be >= max(1, n). !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[inout] y - device pointer storing vector y. !> @param[in] incy - [int] !> specifies the increment for the elements of y. interface hipblasChemv #ifdef USE_CUDA_NAMES function hipblasChemv_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasChemv_v2") #else function hipblasChemv_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasChemv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasChemv_assumed_rank #else module procedure & hipblasChemv_rank_0,& hipblasChemv_rank_1,& hipblasChemv_full_rank #endif #endif end interface interface hipblasZhemv #ifdef USE_CUDA_NAMES function hipblasZhemv_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasZhemv_v2") #else function hipblasZhemv_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasZhemv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZhemv_assumed_rank #else module procedure & hipblasZhemv_rank_0,& hipblasZhemv_rank_1,& hipblasZhemv_full_rank #endif #endif end interface interface hipblasChemv_64 #ifdef USE_CUDA_NAMES function hipblasChemv_64_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasChemv_v2_64") #else function hipblasChemv_64_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasChemv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasZhemv_64 #ifdef USE_CUDA_NAMES function hipblasZhemv_64_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasZhemv_v2_64") #else function hipblasZhemv_64_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasZhemv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hemvBatched functions perform one of the matrix-vector operations: !> !> y_i := alpha*A_i*x_i + beta*y_i !> !> where ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are ``n`` -element vectors, !> and ``A_i`` is an !> ``n`` by ``n`` Hermitian matrix, for each batch in ``i = [1, batchCount``]. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: the upper triangular part of the Hermitian matrix A is !> supplied. !> - HIPBLAS_FILL_MODE_LOWER: the lower triangular part of the Hermitian matrix A is !> supplied. !> @param[in] n - [int] !> the order of each matrix A_i. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] AP - device array of device pointers storing each matrix A_i of dimension (lda, !> n). !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular part of each A_i must contain !> the upper triangular part of a Hermitian matrix. The lower !> triangular part of each A_i will not be referenced. !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular part of each A_i must contain !> the lower triangular part of a Hermitian matrix. The upper !> triangular part of each A_i will not be referenced. !> - As a Hermitian matrix, the imaginary part of the main diagonal !> of each A_i will not be referenced and is assumed to be == 0. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. Must be >= max(1, n). !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[inout] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of y. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasChemvBatched function hipblasChemvBatched_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasChemvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhemvBatched function hipblasZhemvBatched_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasZhemvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasChemvBatched_64 function hipblasChemvBatched_64_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasChemvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhemvBatched_64 function hipblasZhemvBatched_64_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasZhemvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The hemvStridedBatched functions perform one of the matrix-vector operations: !> !> y_i := alpha*A_i*x_i + beta*y_i !> !> where ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are ``n`` -element vectors, !> and ``A_i`` is an !> ``n`` by ``n`` Hermitian matrix, for each batch in ``i = [1, batchCount``]. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: the upper triangular part of the Hermitian matrix A is !> supplied. !> - HIPBLAS_FILL_MODE_LOWER: the lower triangular part of the Hermitian matrix A is !> supplied. !> @param[in] n - [int] !> the order of each matrix A_i. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] AP - device array of device pointers storing each matrix A_i of dimension (lda, !> n). !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular part of each A_i must contain !> the upper triangular part of a Hermitian matrix. The lower !> triangular part of each A_i will not be referenced. !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular part of each A_i must contain !> the lower triangular part of a Hermitian matrix. The upper !> triangular part of each A_i will not be referenced. !> - As a Hermitian matrix, the imaginary part of the main diagonal !> of each A_i will not be referenced and is assumed to be == 0. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. Must be >= max(1, n). !> @param[in] strideA - [hipblasStride] !> stride from the start of one (A_i) to the next (A_i+1). !> !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[inout] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of y. !> @param[in] stridey - [hipblasStride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasChemvStridedBatched function hipblasChemvStridedBatched_(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex,beta,y, & incy,stridey,batchCount) & bind(c, name="hipblasChemvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasChemvStridedBatched_assumed_rank #else module procedure & hipblasChemvStridedBatched_rank_0,& hipblasChemvStridedBatched_rank_1,& hipblasChemvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhemvStridedBatched function hipblasZhemvStridedBatched_(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex,beta,y, & incy,stridey,batchCount) & bind(c, name="hipblasZhemvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZhemvStridedBatched_assumed_rank #else module procedure & hipblasZhemvStridedBatched_rank_0,& hipblasZhemvStridedBatched_rank_1,& hipblasZhemvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasChemvStridedBatched_64 function hipblasChemvStridedBatched_64_(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="hipblasChemvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhemvStridedBatched_64 function hipblasZhemvStridedBatched_64_(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="hipblasZhemvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The her functions perform the matrix-vector operations: !> !> A := A + alpha*x*x**H !> !> where ``alpha`` is a real scalar, ``x`` is a vector, and ``A`` is an !> ``n`` by ``n`` Hermitian matrix. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : ``c`` and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of A is supplied in A. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of A is supplied in A. !> @param[in] n - [int] !> the number of rows and columns of matrix A. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[inout] AP - device pointer storing the specified triangular portion of !> the Hermitian matrix A. Of size (lda * n). !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of the Hermitian matrix A is supplied. The lower !> triangluar portion will not be touched. !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of the Hermitian matrix A is supplied. The upper !> triangular portion will not be touched. !> - Note that the imaginary parts of the diagonal elements are not accessed and are !> assumed !> to be 0. !> @param[in] lda - [int] !> specifies the leading dimension of A. Must be at least max(1, n). interface hipblasCher #ifdef USE_CUDA_NAMES function hipblasCher_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="cublasCher_v2") #else function hipblasCher_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="hipblasCher") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCher_assumed_rank #else module procedure & hipblasCher_rank_0,& hipblasCher_rank_1,& hipblasCher_full_rank #endif #endif end interface interface hipblasZher #ifdef USE_CUDA_NAMES function hipblasZher_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="cublasZher_v2") #else function hipblasZher_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="hipblasZher") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZher_assumed_rank #else module procedure & hipblasZher_rank_0,& hipblasZher_rank_1,& hipblasZher_full_rank #endif #endif end interface interface hipblasCher_64 #ifdef USE_CUDA_NAMES function hipblasCher_64_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="cublasCher_v2_64") #else function hipblasCher_64_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="hipblasCher_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: lda end function end interface interface hipblasZher_64 #ifdef USE_CUDA_NAMES function hipblasZher_64_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="cublasZher_v2_64") #else function hipblasZher_64_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="hipblasZher_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: lda end function end interface !> \brief BLAS Level 2 API !> !> \details !> herBatched performs the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*x_i**H !> !> where ``alpha`` is a real scalar, ``x_i`` is a vector, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, for ``i`` = 1, ..., ``batchCount``. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in !> A. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in !> A. !> @param[in] n - [int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[inout] AP - device array of device pointers storing the specified triangular portion !> of !> each Hermitian matrix A_i of at least size ((n * (n + 1)) / 2). Array is of at !> least size batchCount. !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of each Hermitian matrix A_i is supplied. The !> lower triangular portion !> of each A_i will not be touched. !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of each Hermitian matrix A_i is supplied. The !> upper triangular portion !> of each A_i will not be touched. !> - Note that the imaginary parts of the diagonal elements are not accessed and are !> assumed !> to be 0. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. Must be at least max(1, n). !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasCherBatched function hipblasCherBatched_(handle,uplo,n,alpha,x,incx,AP,lda,batchCount) & bind(c, name="hipblasCherBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZherBatched function hipblasZherBatched_(handle,uplo,n,alpha,x,incx,AP,lda,batchCount) & bind(c, name="hipblasZherBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCherBatched_64 function hipblasCherBatched_64_(handle,uplo,n,alpha,x,incx,AP,lda,batchCount) & bind(c, name="hipblasCherBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZherBatched_64 function hipblasZherBatched_64_(handle,uplo,n,alpha,x,incx,AP,lda,batchCount) & bind(c, name="hipblasZherBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The herStridedBatched functions perform the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*x_i**H !> !> where ``alpha`` is a real scalar, ``x_i`` is a vector, and ``A_i`` is an !> ``n`` by ``n`` Hermitian matrix, for ``i`` = 1, ..., ``batchCount``. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in !> A. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in !> A. !> @param[in] n - [int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer pointing to the first vector (x_1). !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[inout] AP - device array of device pointers storing the specified triangular portion !> of !> each Hermitian matrix A_i. Points to the first matrix (A_1). !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of each Hermitian matrix A_i is supplied. The !> lower triangular !> portion of each A_i will not be touched. !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of each Hermitian matrix A_i is supplied. The !> upper triangular !> portion of each A_i will not be touched. !> - Note that the imaginary parts of the diagonal elements are not accessed and are !> assumed !> to be 0. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. !> @param[in] strideA - [hipblasStride] !> stride from the start of one (A_i) to the next (A_i+1). !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasCherStridedBatched function hipblasCherStridedBatched_(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) & bind(c, name="hipblasCherStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCherStridedBatched_assumed_rank #else module procedure & hipblasCherStridedBatched_rank_0,& hipblasCherStridedBatched_rank_1,& hipblasCherStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZherStridedBatched function hipblasZherStridedBatched_(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) & bind(c, name="hipblasZherStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZherStridedBatched_assumed_rank #else module procedure & hipblasZherStridedBatched_rank_0,& hipblasZherStridedBatched_rank_1,& hipblasZherStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCherStridedBatched_64 function hipblasCherStridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) & bind(c, name="hipblasCherStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZherStridedBatched_64 function hipblasZherStridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) & bind(c, name="hipblasZherStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The her2 functions perform the matrix-vector operations: !> !> A := A + alpha*x*y**H + conj(alpha)*y*x**H !> !> where ``alpha`` is a complex scalar, ``x`` and ``y`` are vectors, and ``A`` is an !> n by n Hermitian matrix. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : ``c`` and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of A is supplied. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of A is supplied. !> @param[in] n - [int] !> the number of rows and columns of matrix A. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[in] y - device pointer storing vector y. !> @param[in] incy - [int] !> specifies the increment for the elements of y. !> @param[inout] AP - device pointer storing the specified triangular portion of !> the Hermitian matrix A. Of size (lda, n). !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of the Hermitian matrix A is supplied. The lower !> triangular !> portion of A will not be touched. !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of the Hermitian matrix A is supplied. The upper !> triangular !> portion of A will not be touched. !> - Note that the imaginary parts of the diagonal elements are not accessed and are !> assumed !> to be 0. !> @param[in] lda - [int] !> specifies the leading dimension of A. Must be at least max(lda, 1). interface hipblasCher2 #ifdef USE_CUDA_NAMES function hipblasCher2_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="cublasCher2_v2") #else function hipblasCher2_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="hipblasCher2") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCher2_assumed_rank #else module procedure & hipblasCher2_rank_0,& hipblasCher2_rank_1,& hipblasCher2_full_rank #endif #endif end interface interface hipblasZher2 #ifdef USE_CUDA_NAMES function hipblasZher2_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="cublasZher2_v2") #else function hipblasZher2_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="hipblasZher2") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZher2_assumed_rank #else module procedure & hipblasZher2_rank_0,& hipblasZher2_rank_1,& hipblasZher2_full_rank #endif #endif end interface interface hipblasCher2_64 #ifdef USE_CUDA_NAMES function hipblasCher2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) & bind(c, name="cublasCher2_v2_64") #else function hipblasCher2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) & bind(c, name="hipblasCher2_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda end function end interface interface hipblasZher2_64 #ifdef USE_CUDA_NAMES function hipblasZher2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) & bind(c, name="cublasZher2_v2_64") #else function hipblasZher2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) & bind(c, name="hipblasZher2_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda end function end interface !> \brief BLAS Level 2 API !> !> \details !> The her2Batched functions perform the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*y_i**H + conj(alpha)*y_i*x_i**H !> !> where ``alpha`` is a complex scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` Hermitian matrix for each batch in ``i = [1, batchCount``]. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied. !> @param[in] n - [int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[in] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of each y_i. !> @param[inout] AP - device array of device pointers storing the specified triangular portion !> of !> each Hermitian matrix A_i of size (lda, n). !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of each Hermitian matrix A_i is supplied. The !> lower triangular !> portion of each A_i will not be touched. !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of each Hermitian matrix A_i is supplied. The !> upper triangular !> portion of each A_i will not be touched. !> - Note that the imaginary parts of the diagonal elements are not accessed and are !> assumed !> to be 0. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. Must be at least max(lda, 1). !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasCher2Batched function hipblasCher2Batched_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasCher2Batched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2Batched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZher2Batched function hipblasZher2Batched_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasZher2Batched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2Batched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCher2Batched_64 function hipblasCher2Batched_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasCher2Batched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2Batched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZher2Batched_64 function hipblasZher2Batched_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasZher2Batched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2Batched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The her2StridedBatched functions perform the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*y_i**H + conj(alpha)*y_i*x_i**H !> !> where ``alpha`` is a complex scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` Hermitian matrix for each batch in ``i = [1, batchCount``]. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied. !> @param[in] n - [int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer pointing to the first vector x_1. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [hipblasStride] !> specifies the stride between the beginning of one vector (x_i) and the next !> (x_i+1). !> @param[in] y - device pointer pointing to the first vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of each y_i. !> @param[in] stridey - [hipblasStride] !> specifies the stride between the beginning of one vector (y_i) and the next !> (y_i+1). !> @param[inout] AP - device pointer pointing to the first matrix (A_1). Stores the specified !> triangular portion of !> each Hermitian matrix A_i. !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of each Hermitian matrix A_i is supplied. The !> lower triangular !> portion of each A_i will not be touched. !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of each Hermitian matrix A_i is supplied. The !> upper triangular !> portion of each A_i will not be touched. !> - Note that the imaginary part of the diagonal elements are not accessed and are !> assumed !> to be 0. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. Must be at least max(lda, 1). !> @param[in] strideA - [hipblasStride] !> specifies the stride between the beginning of one matrix (A_i) and the next !> (A_i+1). !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasCher2StridedBatched function hipblasCher2StridedBatched_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP,lda, & strideA,batchCount) & bind(c, name="hipblasCher2StridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2StridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCher2StridedBatched_assumed_rank #else module procedure & hipblasCher2StridedBatched_rank_0,& hipblasCher2StridedBatched_rank_1,& hipblasCher2StridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZher2StridedBatched function hipblasZher2StridedBatched_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP,lda, & strideA,batchCount) & bind(c, name="hipblasZher2StridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2StridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZher2StridedBatched_assumed_rank #else module procedure & hipblasZher2StridedBatched_rank_0,& hipblasZher2StridedBatched_rank_1,& hipblasZher2StridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCher2StridedBatched_64 function hipblasCher2StridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP, & lda,strideA,batchCount) & bind(c, name="hipblasCher2StridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2StridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZher2StridedBatched_64 function hipblasZher2StridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP, & lda,strideA,batchCount) & bind(c, name="hipblasZher2StridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2StridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The hpmv functions perform the matrix-vector operation: !> !> y := alpha*A*x + beta*y !> !> where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are ``n`` -element vectors and !> ``A`` is an !> ``n`` by ``n`` Hermitian matrix, supplied in packed form (see description below). !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : ``c`` and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: the upper triangular part of the Hermitian matrix A is !> supplied in AP. !> - HIPBLAS_FILL_MODE_LOWER: the lower triangular part of the Hermitian matrix A is !> supplied in AP. !> @param[in] n - [int] !> the order of the matrix A. Must be >= 0. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] AP - device pointer storing the packed version of the specified triangular !> portion of !> the Hermitian matrix A. Of at least size ((n * (n + 1)) / 2). !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of the Hermitian matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_UPPER; n = 3) !> (1, 0) (2, 1) (3, 2) !> (2,-1) (4, 0) (5,-1) -> [(1,0), (2,1), (4,0), (3,2), (5,-1), (6,0)] !> (3,-2) (5, 1) (6, 0) !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of the Hermitian matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_LOWER; n = 3) !> (1, 0) (2, 1) (3, 2) !> (2,-1) (4, 0) (5,-1) -> [(1,0), (2,-1), (3,-2), (4,0), (5,1), (6,0)] !> (3,-2) (5, 1) (6, 0) !> - Note that the imaginary parts of the diagonal elements are not accessed and are !> assumed !> to be 0. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[inout] y - device pointer storing vector y. !> @param[in] incy - [int] !> specifies the increment for the elements of y. interface hipblasChpmv #ifdef USE_CUDA_NAMES function hipblasChpmv_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) bind(c, name="cublasChpmv_v2") #else function hipblasChpmv_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) bind(c, name="hipblasChpmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasChpmv_assumed_rank #else module procedure & hipblasChpmv_rank_0,& hipblasChpmv_rank_1 #endif #endif end interface interface hipblasZhpmv #ifdef USE_CUDA_NAMES function hipblasZhpmv_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) bind(c, name="cublasZhpmv_v2") #else function hipblasZhpmv_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) bind(c, name="hipblasZhpmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZhpmv_assumed_rank #else module procedure & hipblasZhpmv_rank_0,& hipblasZhpmv_rank_1 #endif #endif end interface interface hipblasChpmv_64 #ifdef USE_CUDA_NAMES function hipblasChpmv_64_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) & bind(c, name="cublasChpmv_v2_64") #else function hipblasChpmv_64_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) & bind(c, name="hipblasChpmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasZhpmv_64 #ifdef USE_CUDA_NAMES function hipblasZhpmv_64_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) & bind(c, name="cublasZhpmv_v2_64") #else function hipblasZhpmv_64_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) & bind(c, name="hipblasZhpmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hpmvBatched functions performs the matrix-vector operation: !> !> y_i := alpha*A_i*x_i + beta*y_i !> !> where ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are ``n`` -element vectors, !> and ``A_i`` is an !> ``n`` by ``n`` Hermitian matrix, supplied in packed form (see description below), !> for each batch in ``i = [1, batchCount``]. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: the upper triangular part of each Hermitian matrix A_i !> is supplied in AP. !> - HIPBLAS_FILL_MODE_LOWER: the lower triangular part of each Hermitian matrix A_i !> is supplied in AP. !> @param[in] n - [int] !> the order of each matrix A_i. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] AP - device pointer of device pointers storing the packed version of the !> specified triangular !> portion of each Hermitian matrix A_i. Each A_i is of at least size ((n * (n + 1)) / !> 2). !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that each AP_i contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_UPPER; n = 3) !> (1, 0) (2, 1) (3, 2) !> (2,-1) (4, 0) (5,-1) -> [(1,0), (2,1), (4,0), (3,2), (5,-1), (6,0)] !> (3,-2) (5, 1) (6, 0) !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that each AP_i contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_LOWER; n = 3) !> (1, 0) (2, 1) (3, 2) !> (2,-1) (4, 0) (5,-1) -> [(1,0), (2,-1), (3,-2), (4,0), (5,1), (6,0)] !> (3,-2) (5, 1) (6, 0) !> - Note that the imaginary parts of the diagonal elements are not accessed and are !> assumed !> to be 0. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[inout] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of y. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasChpmvBatched function hipblasChpmvBatched_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasChpmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhpmvBatched function hipblasZhpmvBatched_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasZhpmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasChpmvBatched_64 function hipblasChpmvBatched_64_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasChpmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhpmvBatched_64 function hipblasZhpmvBatched_64_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasZhpmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The hpmvStridedBatched functions perform the matrix-vector operation: !> !> y_i := alpha*A_i*x_i + beta*y_i !> !> where ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are ``n`` -element vectors, !> and ``A_i`` is an !> ``n`` by ``n`` Hermitian matrix, supplied in packed form (see description below), !> for each batch in ``i = [1, batchCount``]. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: the upper triangular part of each Hermitian matrix A_i !> is supplied in AP. !> - HIPBLAS_FILL_MODE_LOWER: the lower triangular part of each Hermitian matrix A_i !> is supplied in AP. !> @param[in] n - [int] !> the order of each matrix A_i. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] AP - device pointer pointing to the beginning of the first matrix (AP_1). Stores !> the packed !> version of the specified triangular portion of each Hermitian matrix AP_i of size !> ((n * (n + 1)) / 2). !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that each AP_i contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_UPPER; n = 3) !> (1, 0) (2, 1) (3, 2) !> (2,-1) (4, 0) (5,-1) -> [(1,0), (2,1), (4,0), (3,2), (5,-1), (6,0)] !> (3,-2) (5, 1) (6, 0) !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that each AP_i contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_LOWER; n = 3) !> (1, 0) (2, 1) (3, 2) !> (2,-1) (4, 0) (5,-1) -> [(1,0), (2,-1), (3,-2), (4,0), (5,1), (6,0)] !> (3,-2) (5, 1) (6, 0) !> - Note that the imaginary parts of the diagonal elements are not accessed and are !> assumed !> to be 0. !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (AP_i) to the next one (AP_i+1). !> @param[in] x - device array pointing to the beginning of the first vector (x_1). !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[inout] y - device array pointing to the beginning of the first vector (y_1). !> @param[in] incy - [int] !> specifies the increment for the elements of y. !> @param[in] stridey - [hipblasStride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasChpmvStridedBatched function hipblasChpmvStridedBatched_(handle,uplo,n,alpha,AP,strideA,x,incx,stridex,beta,y, & incy,stridey,batchCount) & bind(c, name="hipblasChpmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasChpmvStridedBatched_assumed_rank #else module procedure & hipblasChpmvStridedBatched_rank_0,& hipblasChpmvStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhpmvStridedBatched function hipblasZhpmvStridedBatched_(handle,uplo,n,alpha,AP,strideA,x,incx,stridex,beta,y, & incy,stridey,batchCount) & bind(c, name="hipblasZhpmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZhpmvStridedBatched_assumed_rank #else module procedure & hipblasZhpmvStridedBatched_rank_0,& hipblasZhpmvStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasChpmvStridedBatched_64 function hipblasChpmvStridedBatched_64_(handle,uplo,n,alpha,AP,strideA,x,incx,stridex,beta,y, & incy,stridey,batchCount) & bind(c, name="hipblasChpmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhpmvStridedBatched_64 function hipblasZhpmvStridedBatched_64_(handle,uplo,n,alpha,AP,strideA,x,incx,stridex,beta,y, & incy,stridey,batchCount) & bind(c, name="hipblasZhpmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The hpr functions perform the matrix-vector operations: !> !> A := A + alpha*x*x**H !> !> where ``alpha`` is a real scalar, ``x`` is a vector, and ``A`` is an !> ``n`` by ``n`` Hermitian matrix, supplied in packed form. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : ``c`` and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of A is supplied in AP. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of A is supplied in AP. !> @param[in] n - [int] !> the number of rows and columns of matrix A. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[inout] AP - device pointer storing the packed version of the specified triangular !> portion of !> the Hermitian matrix A. Of at least size ((n * (n + 1)) / 2). !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of the Hermitian matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_UPPER; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) -> [(1,0), (2,1), (3,0), (4,9), (5,3), (6,0)] !> (4,-9) (5,-3) (6,0) !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of the Hermitian matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_LOWER; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) -> [(1,0), (2,-1), (4,-9), (3,0), (5,-3), (6,0)] !> (4,-9) (5,-3) (6,0) !> - Note that the imaginary parts of the diagonal elements are not accessed and are !> assumed !> to be 0. interface hipblasChpr #ifdef USE_CUDA_NAMES function hipblasChpr_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="cublasChpr_v2") #else function hipblasChpr_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="hipblasChpr") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasChpr_assumed_rank #else module procedure & hipblasChpr_rank_0,& hipblasChpr_rank_1 #endif #endif end interface interface hipblasZhpr #ifdef USE_CUDA_NAMES function hipblasZhpr_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="cublasZhpr_v2") #else function hipblasZhpr_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="hipblasZhpr") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZhpr_assumed_rank #else module procedure & hipblasZhpr_rank_0,& hipblasZhpr_rank_1 #endif #endif end interface interface hipblasChpr_64 #ifdef USE_CUDA_NAMES function hipblasChpr_64_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="cublasChpr_v2_64") #else function hipblasChpr_64_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="hipblasChpr_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP end function end interface interface hipblasZhpr_64 #ifdef USE_CUDA_NAMES function hipblasZhpr_64_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="cublasZhpr_v2_64") #else function hipblasZhpr_64_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="hipblasZhpr_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hprBatched functions perform the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*x_i**H !> !> where ``alpha`` is a real scalar, ``x_i`` is a vector, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., !> ``batchCount``. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in !> AP. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in !> AP. !> @param[in] n - [int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[inout] AP - device array of device pointers storing the packed version of the !> specified triangular portion of !> each Hermitian matrix A_i of at least size ((n * (n + 1)) / 2). Array is of at !> least size batchCount. !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_UPPER; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) -> [(1,0), (2,1), (3,0), (4,9), (5,3), (6,0)] !> (4,-9) (5,-3) (6,0) !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_LOWER; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) -> [(1,0), (2,-1), (4,-9), (3,0), (5,-3), (6,0)] !> (4,-9) (5,-3) (6,0) !> - Note that the imaginary part of the diagonal elements are not accessed and are !> assumed !> to be 0. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasChprBatched function hipblasChprBatched_(handle,uplo,n,alpha,x,incx,AP,batchCount) & bind(c, name="hipblasChprBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChprBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhprBatched function hipblasZhprBatched_(handle,uplo,n,alpha,x,incx,AP,batchCount) & bind(c, name="hipblasZhprBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhprBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasChprBatched_64 function hipblasChprBatched_64_(handle,uplo,n,alpha,x,incx,AP,batchCount) & bind(c, name="hipblasChprBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChprBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhprBatched_64 function hipblasZhprBatched_64_(handle,uplo,n,alpha,x,incx,AP,batchCount) & bind(c, name="hipblasZhprBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhprBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The hprStridedBatched functions perform the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*x_i**H !> !> where ``alpha`` is a real scalar, ``x_i`` is a vector, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., !> ``batchCount``. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in !> AP. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in !> AP. !> @param[in] n - [int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer pointing to the first vector (x_1). !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[inout] AP - device array of device pointers storing the packed version of the !> specified triangular portion of !> each Hermitian matrix A_i. Points to the first matrix (A_1). !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_UPPER; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) -> [(1,0), (2,1), (3,0), (4,9), (5,3), (6,0)] !> (4,-9) (5,-3) (6,0) !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_LOWER; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) -> [(1,0), (2,-1), (4,-9), (3,0), (5,-3), (6,0)] !> (4,-9) (5,-3) (6,0) !> - Note that the imaginary parts of the diagonal elements are not accessed and are !> assumed !> to be 0. !> @param[in] strideA - [hipblasStride] !> stride from the start of one (A_i) to the next (A_i+1). !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasChprStridedBatched function hipblasChprStridedBatched_(handle,uplo,n,alpha,x,incx,stridex,AP,strideA,batchCount) & bind(c, name="hipblasChprStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChprStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasChprStridedBatched_assumed_rank #else module procedure & hipblasChprStridedBatched_rank_0,& hipblasChprStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhprStridedBatched function hipblasZhprStridedBatched_(handle,uplo,n,alpha,x,incx,stridex,AP,strideA,batchCount) & bind(c, name="hipblasZhprStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhprStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZhprStridedBatched_assumed_rank #else module procedure & hipblasZhprStridedBatched_rank_0,& hipblasZhprStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasChprStridedBatched_64 function hipblasChprStridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) & bind(c, name="hipblasChprStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChprStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhprStridedBatched_64 function hipblasZhprStridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) & bind(c, name="hipblasZhprStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhprStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The hpr2 functions perform the matrix-vector operations: !> !> A := A + alpha*x*y**H + conj(alpha)*y*x**H !> !> where ``alpha`` is a complex scalar, ``x`` and ``y`` are vectors, and ``A`` is an !> ``n`` by ``n`` Hermitian matrix, supplied in packed form. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : ``c`` and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of A is supplied in AP. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of A is supplied in AP. !> @param[in] n - [int] !> the number of rows and columns of matrix A. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[in] y - device pointer storing vector y. !> @param[in] incy - [int] !> specifies the increment for the elements of y. !> @param[inout] AP - device pointer storing the packed version of the specified triangular !> portion of !> the Hermitian matrix A. Of at least size ((n * (n + 1)) / 2). !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of the Hermitian matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_UPPER; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) -> [(1,0), (2,1), (3,0), (4,9), (5,3), (6,0)] !> (4,-9) (5,-3) (6,0) !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of the Hermitian matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_LOWER; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) -> [(1,0), (2,-1), (4,-9), (3,0), (5,-3), (6,0)] !> (4,-9) (5,-3) (6,0) !> - Note that the imaginary parts of the diagonal elements are not accessed and are !> assumed !> to be 0. interface hipblasChpr2 #ifdef USE_CUDA_NAMES function hipblasChpr2_(handle,uplo,n,alpha,x,incx,y,incy,AP) bind(c, name="cublasChpr2_v2") #else function hipblasChpr2_(handle,uplo,n,alpha,x,incx,y,incy,AP) bind(c, name="hipblasChpr2") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr2_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasChpr2_assumed_rank #else module procedure & hipblasChpr2_rank_0,& hipblasChpr2_rank_1 #endif #endif end interface interface hipblasZhpr2 #ifdef USE_CUDA_NAMES function hipblasZhpr2_(handle,uplo,n,alpha,x,incx,y,incy,AP) bind(c, name="cublasZhpr2_v2") #else function hipblasZhpr2_(handle,uplo,n,alpha,x,incx,y,incy,AP) bind(c, name="hipblasZhpr2") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr2_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZhpr2_assumed_rank #else module procedure & hipblasZhpr2_rank_0,& hipblasZhpr2_rank_1 #endif #endif end interface interface hipblasChpr2_64 #ifdef USE_CUDA_NAMES function hipblasChpr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP) & bind(c, name="cublasChpr2_v2_64") #else function hipblasChpr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP) bind(c, name="hipblasChpr2_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr2_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP end function end interface interface hipblasZhpr2_64 #ifdef USE_CUDA_NAMES function hipblasZhpr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP) & bind(c, name="cublasZhpr2_v2_64") #else function hipblasZhpr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP) bind(c, name="hipblasZhpr2_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr2_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hpr2Batched functions perform the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*y_i**H + conj(alpha)*y_i*x_i**H !> !> where ``alpha`` is a complex scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., !> ``batchCount``. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in !> AP. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in !> AP. !> @param[in] n - [int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of each y_i. !> @param[inout] AP - device array of device pointers storing the packed version of the !> specified triangular portion of !> each Hermitian matrix A_i of at least size ((n * (n + 1)) / 2). Array is of at !> least size batchCount. !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_UPPER; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) -> [(1,0), (2,1), (3,0), (4,9), (5,3), (6,0)] !> (4,-9) (5,-3) (6,0) !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_LOWER; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) -> [(1,0), (2,-1), (4,-9), (3,0), (5,-3), (6,0)] !> (4,-9) (5,-3) (6,0) !> - Note that the imaginary parts of the diagonal elements are not accessed and are !> assumed !> to be 0. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasChpr2Batched function hipblasChpr2Batched_(handle,uplo,n,alpha,x,incx,y,incy,AP,batchCount) & bind(c, name="hipblasChpr2Batched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr2Batched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhpr2Batched function hipblasZhpr2Batched_(handle,uplo,n,alpha,x,incx,y,incy,AP,batchCount) & bind(c, name="hipblasZhpr2Batched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr2Batched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasChpr2Batched_64 function hipblasChpr2Batched_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,batchCount) & bind(c, name="hipblasChpr2Batched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr2Batched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhpr2Batched_64 function hipblasZhpr2Batched_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,batchCount) & bind(c, name="hipblasZhpr2Batched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr2Batched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The hpr2StridedBatched functions perform the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*y_i**H + conj(alpha)*y_i*x_i**H !> !> where ``alpha`` is a complex scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., !> ``batchCount``. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in !> AP. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in !> AP. !> @param[in] n - [int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer pointing to the first vector (x_1). !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[in] y - device pointer pointing to the first vector (y_1). !> @param[in] incy - [int] !> specifies the increment for the elements of each y_i. !> @param[in] stridey - [hipblasStride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> @param[inout] AP - device array of device pointers storing the packed version of the !> specified triangular portion of !> each Hermitian matrix A_i. Points to the first matrix (A_1). !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_UPPER; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) -> [(1,0), (2,1), (3,0), (4,9), (5,3), (6,0)] !> (4,-9) (5,-3) (6,0) !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_LOWER; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) -> [(1,0), (2,-1), (4,-9), (3,0), (5,-3), (6,0)] !> (4,-9) (5,-3) (6,0) !> - Note that the imaginary part of the diagonal elements are not accessed and are !> assumed !> to be 0. !> @param[in] strideA - [hipblasStride] !> stride from the start of one (A_i) to the next (A_i+1). !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasChpr2StridedBatched function hipblasChpr2StridedBatched_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP, & strideA,batchCount) & bind(c, name="hipblasChpr2StridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr2StridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasChpr2StridedBatched_assumed_rank #else module procedure & hipblasChpr2StridedBatched_rank_0,& hipblasChpr2StridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhpr2StridedBatched function hipblasZhpr2StridedBatched_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP, & strideA,batchCount) & bind(c, name="hipblasZhpr2StridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr2StridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZhpr2StridedBatched_assumed_rank #else module procedure & hipblasZhpr2StridedBatched_rank_0,& hipblasZhpr2StridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasChpr2StridedBatched_64 function hipblasChpr2StridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP, & strideA,batchCount) & bind(c, name="hipblasChpr2StridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr2StridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhpr2StridedBatched_64 function hipblasZhpr2StridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP, & strideA,batchCount) & bind(c, name="hipblasZhpr2StridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr2StridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The sbmv functions perform the matrix-vector operation: !> !> y := alpha*A*x + beta*y, !> !> where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are ``n``-element vectors, and !> ``A`` should contain an upper or lower triangular ``n`` by ``n`` symmetric banded matrix. !> !> - Supported precisions in rocBLAS : ``s`` and ``d``. !> - Supported precisions in cuBLAS : ``s`` and ``d``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced. !> - If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced. !> @param[in] n - [int] !> @param[in] k - [int] !> specifies the number of sub- and super-diagonals. !> @param[in] alpha !> specifies the scalar alpha. !> @param[in] AP - pointer storing matrix A on the GPU. !> @param[in] lda - [int] !> specifies the leading dimension of matrix A. !> @param[in] x - pointer storing vector x on the GPU. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[in] beta - specifies the scalar beta. !> @param[out] y - pointer storing vector y on the GPU. !> @param[in] incy - [int] !> specifies the increment for the elements of y. interface hipblasSsbmv #ifdef USE_CUDA_NAMES function hipblasSsbmv_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasSsbmv_v2") #else function hipblasSsbmv_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasSsbmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSsbmv_assumed_rank #else module procedure & hipblasSsbmv_rank_0,& hipblasSsbmv_rank_1,& hipblasSsbmv_full_rank #endif #endif end interface interface hipblasDsbmv #ifdef USE_CUDA_NAMES function hipblasDsbmv_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasDsbmv_v2") #else function hipblasDsbmv_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasDsbmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDsbmv_assumed_rank #else module procedure & hipblasDsbmv_rank_0,& hipblasDsbmv_rank_1,& hipblasDsbmv_full_rank #endif #endif end interface interface hipblasSsbmv_64 #ifdef USE_CUDA_NAMES function hipblasSsbmv_64_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasSsbmv_v2_64") #else function hipblasSsbmv_64_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasSsbmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasDsbmv_64 #ifdef USE_CUDA_NAMES function hipblasDsbmv_64_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasDsbmv_v2_64") #else function hipblasDsbmv_64_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasDsbmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 2 API !> !> \details !> The sbmvBatched functions perform the matrix-vector operation: !> !> y_i := alpha*A_i*x_i + beta*y_i, !> !> where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` symmetric banded matrix, for ``i`` = 1, ..., ``batchCount``. !> ``A`` should contain an upper or lower triangular ``n`` by ``n`` symmetric banded matrix. !> !> - Supported precisions in rocBLAS : ``s`` and ``d``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced. !> - If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced. !> @param[in] n - [int] !> number of rows and columns of each matrix A_i. !> @param[in] k - [int] !> specifies the number of sub- and super-diagonals. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] AP - device array of device pointers storing each matrix A_i. !> @param[in] lda - [int] !> specifies the leading dimension of each matrix A_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each vector x_i. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[out] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of each vector y_i. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSsbmvBatched function hipblasSsbmvBatched_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasSsbmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsbmvBatched function hipblasDsbmvBatched_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasDsbmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSsbmvBatched_64 function hipblasSsbmvBatched_64_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasSsbmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsbmvBatched_64 function hipblasDsbmvBatched_64_(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasDsbmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The sbmvStridedBatched functions perform the matrix-vector operation: !> !> y_i := alpha*A_i*x_i + beta*y_i, !> !> where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` symmetric banded matrix, for ``i`` = 1, ..., ``batchCount``. !> ``A`` should contain an upper or lower triangular ``n`` by ``n`` symmetric banded matrix. !> !> - Supported precisions in rocBLAS : ``s`` and ``d``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced. !> - If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced. !> @param[in] n - [int] !> number of rows and columns of each matrix A_i. !> @param[in] k - [int] !> specifies the number of sub- and super-diagonals. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] AP - device pointer to the first matrix A_1 on the GPU. !> @param[in] lda - [int] !> specifies the leading dimension of each matrix A_i. !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> @param[in] x - device pointer to the first vector x_1 on the GPU. !> @param[in] incx - [int] !> specifies the increment for the elements of each vector x_i. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stridex. However, the user should !> ensure that stridex is of an appropriate size. !> This typically means stridex >= n * incx. stridex should be non zero. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[out] y - device pointer to the first vector y_1 on the GPU. !> @param[in] incy - [int] !> specifies the increment for the elements of each vector y_i. !> @param[in] stridey - [hipblasStride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> There are no restrictions placed on stridey. However, the user should !> ensure that stridey is of an appropriate size. !> This typically means stridey >= n * incy. stridey should be non zero. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSsbmvStridedBatched function hipblasSsbmvStridedBatched_(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx,stridex,beta, & y,incy,stridey,batchCount) & bind(c, name="hipblasSsbmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSsbmvStridedBatched_assumed_rank #else module procedure & hipblasSsbmvStridedBatched_rank_0,& hipblasSsbmvStridedBatched_rank_1,& hipblasSsbmvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsbmvStridedBatched function hipblasDsbmvStridedBatched_(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx,stridex,beta, & y,incy,stridey,batchCount) & bind(c, name="hipblasDsbmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDsbmvStridedBatched_assumed_rank #else module procedure & hipblasDsbmvStridedBatched_rank_0,& hipblasDsbmvStridedBatched_rank_1,& hipblasDsbmvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSsbmvStridedBatched_64 function hipblasSsbmvStridedBatched_64_(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="hipblasSsbmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsbmvStridedBatched_64 function hipblasDsbmvStridedBatched_64_(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="hipblasDsbmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The spmv functions perform the matrix-vector operation: !> !> y := alpha*A*x + beta*y, !> !> where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are ``n``-element vectors, and !> ``A`` should contain an upper or lower triangular ``n`` by ``n`` packed symmetric matrix. !> !> - Supported precisions in rocBLAS : ``s`` and ``d``. !> - Supported precisions in cuBLAS : ``s`` and ``d``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced. !> - If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced. !> @param[in] n - [int] !> @param[in] alpha !> specifies the scalar alpha. !> @param[in] AP - pointer storing matrix A on the GPU. !> @param[in] x - pointer storing vector x on the GPU. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[in] beta - specifies the scalar beta. !> @param[out] y - pointer storing vector y on the GPU. !> @param[in] incy - [int] !> specifies the increment for the elements of y. interface hipblasSspmv #ifdef USE_CUDA_NAMES function hipblasSspmv_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) bind(c, name="cublasSspmv_v2") #else function hipblasSspmv_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) bind(c, name="hipblasSspmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSspmv_assumed_rank #else module procedure & hipblasSspmv_rank_0,& hipblasSspmv_rank_1 #endif #endif end interface interface hipblasDspmv #ifdef USE_CUDA_NAMES function hipblasDspmv_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) bind(c, name="cublasDspmv_v2") #else function hipblasDspmv_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) bind(c, name="hipblasDspmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDspmv_assumed_rank #else module procedure & hipblasDspmv_rank_0,& hipblasDspmv_rank_1 #endif #endif end interface interface hipblasSspmv_64 #ifdef USE_CUDA_NAMES function hipblasSspmv_64_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) & bind(c, name="cublasSspmv_v2_64") #else function hipblasSspmv_64_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) & bind(c, name="hipblasSspmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasDspmv_64 #ifdef USE_CUDA_NAMES function hipblasDspmv_64_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) & bind(c, name="cublasDspmv_v2_64") #else function hipblasDspmv_64_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) & bind(c, name="hipblasDspmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 2 API !> !> \details !> The spmvBatched functions perform the matrix-vector operation: !> !> y_i := alpha*AP_i*x_i + beta*y_i, !> !> where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, for ``i`` = 1, ..., ``batchCount``. !> ``A`` should contain an upper or lower triangular ``n`` by ``n`` packed symmetric matrix. !> !> - Supported precisions in rocBLAS : ``s`` and ``d``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced. !> - If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced. !> @param[in] n - [int] !> number of rows and columns of each matrix A_i. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] AP - device array of device pointers storing each matrix A_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each vector x_i. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[out] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of each vector y_i. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSspmvBatched function hipblasSspmvBatched_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasSspmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDspmvBatched function hipblasDspmvBatched_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasDspmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSspmvBatched_64 function hipblasSspmvBatched_64_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasSspmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDspmvBatched_64 function hipblasDspmvBatched_64_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasDspmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The spmvStridedBatched functions perform the matrix-vector operation: !> !> y_i := alpha*A_i*x_i + beta*y_i, !> !> where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, for ``i`` = 1, ..., ``batchCount``. !> ``A`` should contain an upper or lower triangular ``n`` by ``n`` packed symmetric matrix. !> !> - Supported precisions in rocBLAS : ``s`` and ``d``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced. !> - If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced. !> @param[in] n - [int] !> number of rows and columns of each matrix A_i. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] AP - Device pointer to the first matrix A_1 on the GPU. !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> @param[in] x - Device pointer to the first vector x_1 on the GPU. !> @param[in] incx - [int] !> specifies the increment for the elements of each vector x_i. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stridex. However, the user should !> take care to ensure that stridex is of an appropriate size. !> This typically means stridex >= n * incx. stridex should be non zero. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[out] y - Device pointer to the first vector y_1 on the GPU. !> @param[in] incy - [int] !> specifies the increment for the elements of each vector y_i. !> @param[in] stridey - [hipblasStride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> There are no restrictions placed on stridey. However, the user should !> take care to ensure that stridey is of an appropriate size. !> This typically means stridey >= n * incy. stridey should be non zero. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSspmvStridedBatched function hipblasSspmvStridedBatched_(handle,uplo,n,alpha,AP,strideA,x,incx,stridex,beta,y, & incy,stridey,batchCount) & bind(c, name="hipblasSspmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSspmvStridedBatched_assumed_rank #else module procedure & hipblasSspmvStridedBatched_rank_0,& hipblasSspmvStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDspmvStridedBatched function hipblasDspmvStridedBatched_(handle,uplo,n,alpha,AP,strideA,x,incx,stridex,beta,y, & incy,stridey,batchCount) & bind(c, name="hipblasDspmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDspmvStridedBatched_assumed_rank #else module procedure & hipblasDspmvStridedBatched_rank_0,& hipblasDspmvStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSspmvStridedBatched_64 function hipblasSspmvStridedBatched_64_(handle,uplo,n,alpha,AP,strideA,x,incx,stridex,beta,y, & incy,stridey,batchCount) & bind(c, name="hipblasSspmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDspmvStridedBatched_64 function hipblasDspmvStridedBatched_64_(handle,uplo,n,alpha,AP,strideA,x,incx,stridex,beta,y, & incy,stridey,batchCount) & bind(c, name="hipblasDspmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The spr functions perform the matrix-vector operations: !> !> A := A + alpha*x*x**T !> !> where ``alpha`` is a scalar, ``x`` is a vector, and ``A`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of A is supplied in AP. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of A is supplied in AP. !> @param[in] n - [int] !> the number of rows and columns of matrix A. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[inout] AP - device pointer storing the packed version of the specified triangular !> portion of !> the symmetric matrix A. Of at least size ((n * (n + 1)) / 2). !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of the symmetric matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_UPPER; n = 4) !> 1 2 4 7 !> 2 3 5 8 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 4 5 6 9 !> 7 8 9 0 !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of the symmetric matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_LOWER; n = 4) !> 1 2 3 4 !> 2 5 6 7 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 3 6 8 9 !> 4 7 9 0 interface hipblasSspr #ifdef USE_CUDA_NAMES function hipblasSspr_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="cublasSspr_v2") #else function hipblasSspr_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="hipblasSspr") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSspr_assumed_rank #else module procedure & hipblasSspr_rank_0,& hipblasSspr_rank_1 #endif #endif end interface interface hipblasDspr #ifdef USE_CUDA_NAMES function hipblasDspr_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="cublasDspr_v2") #else function hipblasDspr_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="hipblasDspr") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDspr_assumed_rank #else module procedure & hipblasDspr_rank_0,& hipblasDspr_rank_1 #endif #endif end interface #ifndef USE_CUDA_NAMES interface hipblasCspr function hipblasCspr_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="hipblasCspr") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCspr_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCspr_assumed_rank #else module procedure & hipblasCspr_rank_0,& hipblasCspr_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZspr function hipblasZspr_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="hipblasZspr") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZspr_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZspr_assumed_rank #else module procedure & hipblasZspr_rank_0,& hipblasZspr_rank_1 #endif #endif end interface #endif interface hipblasSspr_64 #ifdef USE_CUDA_NAMES function hipblasSspr_64_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="cublasSspr_v2_64") #else function hipblasSspr_64_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="hipblasSspr_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP end function end interface interface hipblasDspr_64 #ifdef USE_CUDA_NAMES function hipblasDspr_64_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="cublasDspr_v2_64") #else function hipblasDspr_64_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="hipblasDspr_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP end function end interface #ifndef USE_CUDA_NAMES interface hipblasCspr_64 function hipblasCspr_64_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="hipblasCspr_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCspr_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZspr_64 function hipblasZspr_64_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="hipblasZspr_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZspr_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The sprBatched functions perform the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*x_i**T !> !> where ``alpha`` is a scalar, ``x_i`` is a vector, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., !> ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in !> AP. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in !> AP. !> @param[in] n - [int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[inout] AP - device array of device pointers storing the packed version of the !> specified triangular portion of !> each symmetric matrix A_i of at least size ((n * (n + 1)) / 2). Array is of at !> least size batchCount. !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of each symmetric matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_UPPER; n = 4) !> 1 2 4 7 !> 2 3 5 8 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 4 5 6 9 !> 7 8 9 0 !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of each symmetric matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_LOWER; n = 4) !> 1 2 3 4 !> 2 5 6 7 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 3 6 8 9 !> 4 7 9 0 !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSsprBatched function hipblasSsprBatched_(handle,uplo,n,alpha,x,incx,AP,batchCount) & bind(c, name="hipblasSsprBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsprBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsprBatched function hipblasDsprBatched_(handle,uplo,n,alpha,x,incx,AP,batchCount) & bind(c, name="hipblasDsprBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsprBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsprBatched function hipblasCsprBatched_(handle,uplo,n,alpha,x,incx,AP,batchCount) & bind(c, name="hipblasCsprBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsprBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsprBatched function hipblasZsprBatched_(handle,uplo,n,alpha,x,incx,AP,batchCount) & bind(c, name="hipblasZsprBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsprBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSsprBatched_64 function hipblasSsprBatched_64_(handle,uplo,n,alpha,x,incx,AP,batchCount) & bind(c, name="hipblasSsprBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsprBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsprBatched_64 function hipblasDsprBatched_64_(handle,uplo,n,alpha,x,incx,AP,batchCount) & bind(c, name="hipblasDsprBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsprBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsprBatched_64 function hipblasCsprBatched_64_(handle,uplo,n,alpha,x,incx,AP,batchCount) & bind(c, name="hipblasCsprBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsprBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsprBatched_64 function hipblasZsprBatched_64_(handle,uplo,n,alpha,x,incx,AP,batchCount) & bind(c, name="hipblasZsprBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsprBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The sprStridedBatched functions perform the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*x_i**T !> !> where ``alpha`` is a scalar, ``x_i`` is a vector, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., !> ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in !> AP. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in !> AP. !> @param[in] n - [int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer pointing to the first vector (x_1). !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[inout] AP - device pointer storing the packed version of the specified triangular !> portion of !> each symmetric matrix A_i. Points to the first A_1. !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of each symmetric matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_UPPER; n = 4) !> 1 2 4 7 !> 2 3 5 8 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 4 5 6 9 !> 7 8 9 0 !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of each symmetric matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_LOWER; n = 4) !> 1 2 3 4 !> 2 5 6 7 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 3 6 8 9 !> 4 7 9 0 !> @param[in] strideA - [hipblasStride] !> stride from the start of one (A_i) to the next (A_i+1). !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSsprStridedBatched function hipblasSsprStridedBatched_(handle,uplo,n,alpha,x,incx,stridex,AP,strideA,batchCount) & bind(c, name="hipblasSsprStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsprStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSsprStridedBatched_assumed_rank #else module procedure & hipblasSsprStridedBatched_rank_0,& hipblasSsprStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsprStridedBatched function hipblasDsprStridedBatched_(handle,uplo,n,alpha,x,incx,stridex,AP,strideA,batchCount) & bind(c, name="hipblasDsprStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsprStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDsprStridedBatched_assumed_rank #else module procedure & hipblasDsprStridedBatched_rank_0,& hipblasDsprStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsprStridedBatched function hipblasCsprStridedBatched_(handle,uplo,n,alpha,x,incx,stridex,AP,strideA,batchCount) & bind(c, name="hipblasCsprStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsprStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCsprStridedBatched_assumed_rank #else module procedure & hipblasCsprStridedBatched_rank_0,& hipblasCsprStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsprStridedBatched function hipblasZsprStridedBatched_(handle,uplo,n,alpha,x,incx,stridex,AP,strideA,batchCount) & bind(c, name="hipblasZsprStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsprStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZsprStridedBatched_assumed_rank #else module procedure & hipblasZsprStridedBatched_rank_0,& hipblasZsprStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSsprStridedBatched_64 function hipblasSsprStridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) & bind(c, name="hipblasSsprStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsprStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsprStridedBatched_64 function hipblasDsprStridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) & bind(c, name="hipblasDsprStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsprStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsprStridedBatched_64 function hipblasCsprStridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) & bind(c, name="hipblasCsprStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsprStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsprStridedBatched_64 function hipblasZsprStridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) & bind(c, name="hipblasZsprStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsprStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The spr2 functions perform the matrix-vector operation: !> !> A := A + alpha*x*y**T + alpha*y*x**T !> !> where ``alpha`` is a scalar, ``x`` and ``y`` are vectors, and ``A`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form. !> !> - Supported precisions in rocBLAS : ``s`` and ``d``. !> - Supported precisions in cuBLAS : ``s`` and ``d``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of A is supplied in AP. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of A is supplied in AP. !> @param[in] n - [int] !> the number of rows and columns of matrix A. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[in] y - device pointer storing vector y. !> @param[in] incy - [int] !> specifies the increment for the elements of y. !> @param[inout] AP - device pointer storing the packed version of the specified triangular !> portion of !> the symmetric matrix A. Of at least size ((n * (n + 1)) / 2). !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of the symmetric matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_UPPER; n = 4) !> 1 2 4 7 !> 2 3 5 8 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 4 5 6 9 !> 7 8 9 0 !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of the symmetric matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(n) = A(2,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_LOWER; n = 4) !> 1 2 3 4 !> 2 5 6 7 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 3 6 8 9 !> 4 7 9 0 interface hipblasSspr2 #ifdef USE_CUDA_NAMES function hipblasSspr2_(handle,uplo,n,alpha,x,incx,y,incy,AP) bind(c, name="cublasSspr2_v2") #else function hipblasSspr2_(handle,uplo,n,alpha,x,incx,y,incy,AP) bind(c, name="hipblasSspr2") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr2_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSspr2_assumed_rank #else module procedure & hipblasSspr2_rank_0,& hipblasSspr2_rank_1 #endif #endif end interface interface hipblasDspr2 #ifdef USE_CUDA_NAMES function hipblasDspr2_(handle,uplo,n,alpha,x,incx,y,incy,AP) bind(c, name="cublasDspr2_v2") #else function hipblasDspr2_(handle,uplo,n,alpha,x,incx,y,incy,AP) bind(c, name="hipblasDspr2") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr2_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDspr2_assumed_rank #else module procedure & hipblasDspr2_rank_0,& hipblasDspr2_rank_1 #endif #endif end interface interface hipblasSspr2_64 #ifdef USE_CUDA_NAMES function hipblasSspr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP) & bind(c, name="cublasSspr2_v2_64") #else function hipblasSspr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP) bind(c, name="hipblasSspr2_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr2_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP end function end interface interface hipblasDspr2_64 #ifdef USE_CUDA_NAMES function hipblasDspr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP) & bind(c, name="cublasDspr2_v2_64") #else function hipblasDspr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP) bind(c, name="hipblasDspr2_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr2_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP end function end interface !> \brief BLAS Level 2 API !> !> \details !> The spr2Batched functions perform the matrix-vector operation: !> !> A_i := A_i + alpha*x_i*y_i**T + alpha*y_i*x_i**T !> !> where ``alpha`` is a scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., !> ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s`` and ``d``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in !> AP. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in !> AP. !> @param[in] n - [int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of each y_i. !> @param[inout] AP - device array of device pointers storing the packed version of the !> specified triangular portion of !> each symmetric matrix A_i of at least size ((n * (n + 1)) / 2). Array is of at !> least size batchCount. !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of each symmetric matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_UPPER; n = 4) !> 1 2 4 7 !> 2 3 5 8 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 4 5 6 9 !> 7 8 9 0 !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of each symmetric matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(n) = A(2,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_LOWER; n = 4) !> 1 2 3 4 !> 2 5 6 7 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 3 6 8 9 !> 4 7 9 0 !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSspr2Batched function hipblasSspr2Batched_(handle,uplo,n,alpha,x,incx,y,incy,AP,batchCount) & bind(c, name="hipblasSspr2Batched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr2Batched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDspr2Batched function hipblasDspr2Batched_(handle,uplo,n,alpha,x,incx,y,incy,AP,batchCount) & bind(c, name="hipblasDspr2Batched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr2Batched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSspr2Batched_64 function hipblasSspr2Batched_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,batchCount) & bind(c, name="hipblasSspr2Batched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr2Batched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDspr2Batched_64 function hipblasDspr2Batched_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,batchCount) & bind(c, name="hipblasDspr2Batched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr2Batched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The spr2StridedBatched functions perform the matrix-vector operation: !> !> A_i := A_i + alpha*x_i*y_i**T + alpha*y_i*x_i**T !> !> where ``alpha`` is a scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., !> ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s`` and ``d``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - HIPBLAS_FILL_MODE_UPPER: The upper triangular part of each A_i is supplied in !> AP. !> - HIPBLAS_FILL_MODE_LOWER: The lower triangular part of each A_i is supplied in !> AP. !> @param[in] n - [int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer pointing to the first vector (x_1). !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[in] y - device pointer pointing to the first vector (y_1). !> @param[in] incy - [int] !> specifies the increment for the elements of each y_i. !> @param[in] stridey - [hipblasStride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> @param[inout] AP - device pointer storing the packed version of the specified triangular !> portion of !> each symmetric matrix A_i. Points to the first A_1. !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The upper triangular portion of each symmetric matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_UPPER; n = 4) !> 1 2 4 7 !> 2 3 5 8 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 4 5 6 9 !> 7 8 9 0 !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The lower triangular portion of each symmetric matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(n) = A(2,1), and so forth. !> Ex: (HIPBLAS_FILL_MODE_LOWER; n = 4) !> 1 2 3 4 !> 2 5 6 7 -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 3 6 8 9 !> 4 7 9 0 !> @param[in] strideA - [hipblasStride] !> stride from the start of one (A_i) to the next (A_i+1). !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSspr2StridedBatched function hipblasSspr2StridedBatched_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP, & strideA,batchCount) & bind(c, name="hipblasSspr2StridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr2StridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSspr2StridedBatched_assumed_rank #else module procedure & hipblasSspr2StridedBatched_rank_0,& hipblasSspr2StridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDspr2StridedBatched function hipblasDspr2StridedBatched_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP, & strideA,batchCount) & bind(c, name="hipblasDspr2StridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr2StridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDspr2StridedBatched_assumed_rank #else module procedure & hipblasDspr2StridedBatched_rank_0,& hipblasDspr2StridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSspr2StridedBatched_64 function hipblasSspr2StridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP, & strideA,batchCount) & bind(c, name="hipblasSspr2StridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr2StridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDspr2StridedBatched_64 function hipblasDspr2StridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP, & strideA,batchCount) & bind(c, name="hipblasDspr2StridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr2StridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The symv functions perform the matrix-vector operation: !> !> y := alpha*A*x + beta*y, !> !> where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are ``n``-element vectors, and !> ``A`` should contain an upper or lower triangular ``n`` by ``n`` symmetric matrix. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced. !> - If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced. !> @param[in] n - [int] !> @param[in] alpha !> specifies the scalar alpha. !> @param[in] AP - pointer storing matrix A on the GPU. !> @param[in] lda - [int] !> specifies the leading dimension of A. !> @param[in] x - pointer storing vector x on the GPU. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[in] beta - specifies the scalar beta. !> @param[out] y - pointer storing vector y on the GPU. !> @param[in] incy - [int] !> specifies the increment for the elements of y. interface hipblasSsymv #ifdef USE_CUDA_NAMES function hipblasSsymv_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasSsymv_v2") #else function hipblasSsymv_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasSsymv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSsymv_assumed_rank #else module procedure & hipblasSsymv_rank_0,& hipblasSsymv_rank_1,& hipblasSsymv_full_rank #endif #endif end interface interface hipblasDsymv #ifdef USE_CUDA_NAMES function hipblasDsymv_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasDsymv_v2") #else function hipblasDsymv_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasDsymv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDsymv_assumed_rank #else module procedure & hipblasDsymv_rank_0,& hipblasDsymv_rank_1,& hipblasDsymv_full_rank #endif #endif end interface interface hipblasCsymv #ifdef USE_CUDA_NAMES function hipblasCsymv_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasCsymv_v2") #else function hipblasCsymv_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasCsymv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCsymv_assumed_rank #else module procedure & hipblasCsymv_rank_0,& hipblasCsymv_rank_1,& hipblasCsymv_full_rank #endif #endif end interface interface hipblasZsymv #ifdef USE_CUDA_NAMES function hipblasZsymv_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasZsymv_v2") #else function hipblasZsymv_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasZsymv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZsymv_assumed_rank #else module procedure & hipblasZsymv_rank_0,& hipblasZsymv_rank_1,& hipblasZsymv_full_rank #endif #endif end interface interface hipblasSsymv_64 #ifdef USE_CUDA_NAMES function hipblasSsymv_64_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasSsymv_v2_64") #else function hipblasSsymv_64_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasSsymv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasDsymv_64 #ifdef USE_CUDA_NAMES function hipblasDsymv_64_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasDsymv_v2_64") #else function hipblasDsymv_64_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasDsymv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasCsymv_64 #ifdef USE_CUDA_NAMES function hipblasCsymv_64_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasCsymv_v2_64") #else function hipblasCsymv_64_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasCsymv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface hipblasZsymv_64 #ifdef USE_CUDA_NAMES function hipblasZsymv_64_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="cublasZsymv_v2_64") #else function hipblasZsymv_64_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) & bind(c, name="hipblasZsymv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 2 API !> !> \details !> symvBatched performs the matrix-vector operation: !> !> y_i := alpha*A_i*x_i + beta*y_i, !> !> where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> n by n symmetric matrix, for ``i`` = 1, ..., ``batchCount``. !> ``A`` should contain an upper or lower triangular symmetric matrix. !> The opposing triangular part of ``A`` is not referenced. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced. !> - If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced. !> @param[in] n - [int] !> number of rows and columns of each matrix A_i. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] AP - device array of device pointers storing each matrix A_i. !> @param[in] lda - [int] !> specifies the leading dimension of each matrix A_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each vector x_i. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[out] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of each vector y_i. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSsymvBatched function hipblasSsymvBatched_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasSsymvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsymvBatched function hipblasDsymvBatched_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasDsymvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsymvBatched function hipblasCsymvBatched_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasCsymvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsymvBatched function hipblasZsymvBatched_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasZsymvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSsymvBatched_64 function hipblasSsymvBatched_64_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasSsymvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsymvBatched_64 function hipblasDsymvBatched_64_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasDsymvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsymvBatched_64 function hipblasCsymvBatched_64_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasCsymvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsymvBatched_64 function hipblasZsymvBatched_64_(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy,batchCount) & bind(c, name="hipblasZsymvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The symvStridedBatched functions perform the matrix-vector operation: !> !> y_i := alpha*A_i*x_i + beta*y_i, !> !> where ``(A_i, x_i, y_i)`` is the ``i``-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, for ``i`` = 1, ..., ``batchCount``. !> ``A`` should contain an upper or lower triangular symmetric matrix. !> The opposing triangular part of A is not referenced !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced. !> - If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced. !> @param[in] n - [int] !> number of rows and columns of each matrix A_i. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] AP - Device pointer to the first matrix A_1 on the GPU. !> @param[in] lda - [int] !> specifies the leading dimension of each matrix A_i. !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> @param[in] x - Device pointer to the first vector x_1 on the GPU. !> @param[in] incx - [int] !> specifies the increment for the elements of each vector x_i. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stridex. However, the user should !> take care to ensure that stridex is of an appropriate size. !> This typically means stridex >= n * incx. stridex should be non zero. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[out] y - Device pointer to the first vector y_1 on the GPU. !> @param[in] incy - [int] !> specifies the increment for the elements of each vector y_i. !> @param[in] stridey - [hipblasStride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> There are no restrictions placed on stridey. However, the user should !> take care to ensure that stridey is of an appropriate size. !> This typically means stridey >= n * incy. stridey should be non zero. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSsymvStridedBatched function hipblasSsymvStridedBatched_(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex,beta,y, & incy,stridey,batchCount) & bind(c, name="hipblasSsymvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSsymvStridedBatched_assumed_rank #else module procedure & hipblasSsymvStridedBatched_rank_0,& hipblasSsymvStridedBatched_rank_1,& hipblasSsymvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsymvStridedBatched function hipblasDsymvStridedBatched_(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex,beta,y, & incy,stridey,batchCount) & bind(c, name="hipblasDsymvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDsymvStridedBatched_assumed_rank #else module procedure & hipblasDsymvStridedBatched_rank_0,& hipblasDsymvStridedBatched_rank_1,& hipblasDsymvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsymvStridedBatched function hipblasCsymvStridedBatched_(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex,beta,y, & incy,stridey,batchCount) & bind(c, name="hipblasCsymvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCsymvStridedBatched_assumed_rank #else module procedure & hipblasCsymvStridedBatched_rank_0,& hipblasCsymvStridedBatched_rank_1,& hipblasCsymvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsymvStridedBatched function hipblasZsymvStridedBatched_(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex,beta,y, & incy,stridey,batchCount) & bind(c, name="hipblasZsymvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZsymvStridedBatched_assumed_rank #else module procedure & hipblasZsymvStridedBatched_rank_0,& hipblasZsymvStridedBatched_rank_1,& hipblasZsymvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSsymvStridedBatched_64 function hipblasSsymvStridedBatched_64_(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="hipblasSsymvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsymvStridedBatched_64 function hipblasDsymvStridedBatched_64_(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="hipblasDsymvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsymvStridedBatched_64 function hipblasCsymvStridedBatched_64_(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="hipblasCsymvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsymvStridedBatched_64 function hipblasZsymvStridedBatched_64_(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) & bind(c, name="hipblasZsymvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The syr functions perform the matrix-vector operations: !> !> A := A + alpha*x*x**T !> !> where ``alpha`` is a scalar, ``x`` is a vector, and ``A`` is an !> ``n`` by ``n`` symmetric matrix. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced. !> - If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced. !> !> @param[in] n - [int] !> the number of rows and columns of matrix A. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[inout] AP - device pointer storing matrix A. !> @param[in] lda - [int] !> specifies the leading dimension of A. interface hipblasSsyr #ifdef USE_CUDA_NAMES function hipblasSsyr_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="cublasSsyr_v2") #else function hipblasSsyr_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="hipblasSsyr") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSsyr_assumed_rank #else module procedure & hipblasSsyr_rank_0,& hipblasSsyr_rank_1,& hipblasSsyr_full_rank #endif #endif end interface interface hipblasDsyr #ifdef USE_CUDA_NAMES function hipblasDsyr_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="cublasDsyr_v2") #else function hipblasDsyr_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="hipblasDsyr") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDsyr_assumed_rank #else module procedure & hipblasDsyr_rank_0,& hipblasDsyr_rank_1,& hipblasDsyr_full_rank #endif #endif end interface interface hipblasCsyr #ifdef USE_CUDA_NAMES function hipblasCsyr_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="cublasCsyr_v2") #else function hipblasCsyr_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="hipblasCsyr") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCsyr_assumed_rank #else module procedure & hipblasCsyr_rank_0,& hipblasCsyr_rank_1,& hipblasCsyr_full_rank #endif #endif end interface interface hipblasZsyr #ifdef USE_CUDA_NAMES function hipblasZsyr_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="cublasZsyr_v2") #else function hipblasZsyr_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="hipblasZsyr") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZsyr_assumed_rank #else module procedure & hipblasZsyr_rank_0,& hipblasZsyr_rank_1,& hipblasZsyr_full_rank #endif #endif end interface interface hipblasSsyr_64 #ifdef USE_CUDA_NAMES function hipblasSsyr_64_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="cublasSsyr_v2_64") #else function hipblasSsyr_64_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="hipblasSsyr_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: lda end function end interface interface hipblasDsyr_64 #ifdef USE_CUDA_NAMES function hipblasDsyr_64_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="cublasDsyr_v2_64") #else function hipblasDsyr_64_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="hipblasDsyr_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: lda end function end interface interface hipblasCsyr_64 #ifdef USE_CUDA_NAMES function hipblasCsyr_64_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="cublasCsyr_v2_64") #else function hipblasCsyr_64_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="hipblasCsyr_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: lda end function end interface interface hipblasZsyr_64 #ifdef USE_CUDA_NAMES function hipblasZsyr_64_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="cublasZsyr_v2_64") #else function hipblasZsyr_64_(handle,uplo,n,alpha,x,incx,AP,lda) bind(c, name="hipblasZsyr_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: lda end function end interface !> \brief BLAS Level 2 API !> !> \details !> The syrBatched functions perform a batch of matrix-vector operations: !> !> A[i] := A[i] + alpha*x[i]*x[i]**T !> !> where ``alpha`` is a scalar, ``x`` is an array of vectors, and ``A`` is an array of !> ``n`` by ``n`` symmetric matrices, for ``i`` = 1 , ... , ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced. !> - If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced. !> @param[in] n - [int] !> the number of rows and columns of matrix A. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[inout] AP - device array of device pointers storing each matrix A_i. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSsyrBatched function hipblasSsyrBatched_(handle,uplo,n,alpha,x,incx,AP,lda,batchCount) & bind(c, name="hipblasSsyrBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyrBatched function hipblasDsyrBatched_(handle,uplo,n,alpha,x,incx,AP,lda,batchCount) & bind(c, name="hipblasDsyrBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyrBatched function hipblasCsyrBatched_(handle,uplo,n,alpha,x,incx,AP,lda,batchCount) & bind(c, name="hipblasCsyrBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyrBatched function hipblasZsyrBatched_(handle,uplo,n,alpha,x,incx,AP,lda,batchCount) & bind(c, name="hipblasZsyrBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSsyrBatched_64 function hipblasSsyrBatched_64_(handle,uplo,n,alpha,x,incx,AP,lda,batchCount) & bind(c, name="hipblasSsyrBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyrBatched_64 function hipblasDsyrBatched_64_(handle,uplo,n,alpha,x,incx,AP,lda,batchCount) & bind(c, name="hipblasDsyrBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyrBatched_64 function hipblasCsyrBatched_64_(handle,uplo,n,alpha,x,incx,AP,lda,batchCount) & bind(c, name="hipblasCsyrBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyrBatched_64 function hipblasZsyrBatched_64_(handle,uplo,n,alpha,x,incx,AP,lda,batchCount) & bind(c, name="hipblasZsyrBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The syrStridedBatched functions perform the matrix-vector operations: !> !> A[i] := A[i] + alpha*x[i]*x[i]**T !> !> where ``alpha`` is a scalar, ``x`` is a pointer to an array of vectors, and ``A`` is an !> array of !> ``n`` by ``n`` symmetric matrices, for ``i`` = 1 , ... , ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced. !> - If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced. !> @param[in] n - [int] !> the number of rows and columns of each matrix A. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer to the first vector x_1. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [hipblasStride] !> specifies the pointer increment between vectors (x_i) and (x_i+1). !> @param[inout] AP - device pointer to the first matrix A_1. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSsyrStridedBatched function hipblasSsyrStridedBatched_(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) & bind(c, name="hipblasSsyrStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSsyrStridedBatched_assumed_rank #else module procedure & hipblasSsyrStridedBatched_rank_0,& hipblasSsyrStridedBatched_rank_1,& hipblasSsyrStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyrStridedBatched function hipblasDsyrStridedBatched_(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) & bind(c, name="hipblasDsyrStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDsyrStridedBatched_assumed_rank #else module procedure & hipblasDsyrStridedBatched_rank_0,& hipblasDsyrStridedBatched_rank_1,& hipblasDsyrStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyrStridedBatched function hipblasCsyrStridedBatched_(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) & bind(c, name="hipblasCsyrStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCsyrStridedBatched_assumed_rank #else module procedure & hipblasCsyrStridedBatched_rank_0,& hipblasCsyrStridedBatched_rank_1,& hipblasCsyrStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyrStridedBatched function hipblasZsyrStridedBatched_(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) & bind(c, name="hipblasZsyrStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZsyrStridedBatched_assumed_rank #else module procedure & hipblasZsyrStridedBatched_rank_0,& hipblasZsyrStridedBatched_rank_1,& hipblasZsyrStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSsyrStridedBatched_64 function hipblasSsyrStridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) & bind(c, name="hipblasSsyrStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyrStridedBatched_64 function hipblasDsyrStridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) & bind(c, name="hipblasDsyrStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyrStridedBatched_64 function hipblasCsyrStridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) & bind(c, name="hipblasCsyrStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyrStridedBatched_64 function hipblasZsyrStridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) & bind(c, name="hipblasZsyrStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The syr2 functions perform the matrix-vector operations: !> !> A := A + alpha*x*y**T + alpha*y*x**T !> !> where ``alpha`` is a scalar, ``x`` and ``y`` are vectors, and ``A`` is an !> ``n`` by ``n`` symmetric matrix. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced. !> - If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced. !> !> @param[in] n - [int] !> the number of rows and columns of matrix A. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[in] y - device pointer storing vector y. !> @param[in] incy - [int] !> specifies the increment for the elements of y. !> @param[inout] AP - device pointer storing matrix A. !> @param[in] lda - [int] !> specifies the leading dimension of A. interface hipblasSsyr2 #ifdef USE_CUDA_NAMES function hipblasSsyr2_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="cublasSsyr2_v2") #else function hipblasSsyr2_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="hipblasSsyr2") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSsyr2_assumed_rank #else module procedure & hipblasSsyr2_rank_0,& hipblasSsyr2_rank_1,& hipblasSsyr2_full_rank #endif #endif end interface interface hipblasDsyr2 #ifdef USE_CUDA_NAMES function hipblasDsyr2_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="cublasDsyr2_v2") #else function hipblasDsyr2_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="hipblasDsyr2") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDsyr2_assumed_rank #else module procedure & hipblasDsyr2_rank_0,& hipblasDsyr2_rank_1,& hipblasDsyr2_full_rank #endif #endif end interface interface hipblasCsyr2 #ifdef USE_CUDA_NAMES function hipblasCsyr2_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="cublasCsyr2_v2") #else function hipblasCsyr2_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="hipblasCsyr2") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCsyr2_assumed_rank #else module procedure & hipblasCsyr2_rank_0,& hipblasCsyr2_rank_1,& hipblasCsyr2_full_rank #endif #endif end interface interface hipblasZsyr2 #ifdef USE_CUDA_NAMES function hipblasZsyr2_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="cublasZsyr2_v2") #else function hipblasZsyr2_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) bind(c, name="hipblasZsyr2") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZsyr2_assumed_rank #else module procedure & hipblasZsyr2_rank_0,& hipblasZsyr2_rank_1,& hipblasZsyr2_full_rank #endif #endif end interface interface hipblasSsyr2_64 #ifdef USE_CUDA_NAMES function hipblasSsyr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) & bind(c, name="cublasSsyr2_v2_64") #else function hipblasSsyr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) & bind(c, name="hipblasSsyr2_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda end function end interface interface hipblasDsyr2_64 #ifdef USE_CUDA_NAMES function hipblasDsyr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) & bind(c, name="cublasDsyr2_v2_64") #else function hipblasDsyr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) & bind(c, name="hipblasDsyr2_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda end function end interface interface hipblasCsyr2_64 #ifdef USE_CUDA_NAMES function hipblasCsyr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) & bind(c, name="cublasCsyr2_v2_64") #else function hipblasCsyr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) & bind(c, name="hipblasCsyr2_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda end function end interface interface hipblasZsyr2_64 #ifdef USE_CUDA_NAMES function hipblasZsyr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) & bind(c, name="cublasZsyr2_v2_64") #else function hipblasZsyr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) & bind(c, name="hipblasZsyr2_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda end function end interface !> \brief BLAS Level 2 API !> !> \details !> The syr2Batched functions perform a batch of matrix-vector operations: !> !> A[i] := A[i] + alpha*x[i]*y[i]**T + alpha*y[i]*x[i]**T !> !> where ``alpha`` is a scalar, x[i] and y[i] are vectors, and A[i] is an !> ``n`` by ``n`` symmetric matrix, for ``i`` = 1 , ... , ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced. !> - If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced. !> @param[in] n - [int] !> the number of rows and columns of matrix A. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of each y_i. !> @param[inout] AP - device array of device pointers storing each matrix A_i. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSsyr2Batched function hipblasSsyr2Batched_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasSsyr2Batched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2Batched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyr2Batched function hipblasDsyr2Batched_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasDsyr2Batched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2Batched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyr2Batched function hipblasCsyr2Batched_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasCsyr2Batched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2Batched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyr2Batched function hipblasZsyr2Batched_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasZsyr2Batched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2Batched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSsyr2Batched_64 function hipblasSsyr2Batched_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasSsyr2Batched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2Batched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyr2Batched_64 function hipblasDsyr2Batched_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasDsyr2Batched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2Batched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyr2Batched_64 function hipblasCsyr2Batched_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasCsyr2Batched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2Batched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyr2Batched_64 function hipblasZsyr2Batched_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,lda,batchCount) & bind(c, name="hipblasZsyr2Batched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2Batched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The syr2StridedBatched functions perform the matrix-vector operations: !> !> A[i] := A[i] + alpha*x[i]*y[i]**T + alpha*y[i]*x[i]**T !> !> where ``alpha`` is a scalar, x[i] and y[i] are vectors, and A[i] is an !> ``n`` by ``n`` symmetric matrices, for ``i`` = 1 , ... , ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced. !> - If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced. !> @param[in] n - [int] !> the number of rows and columns of each matrix A. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer to the first vector x_1. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [hipblasStride] !> specifies the pointer increment between vectors (x_i) and (x_i+1). !> @param[in] y - device pointer to the first vector y_1. !> @param[in] incy - [int] !> specifies the increment for the elements of each y_i. !> @param[in] stridey - [hipblasStride] !> specifies the pointer increment between vectors (y_i) and (y_i+1). !> @param[inout] AP - device pointer to the first matrix A_1. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSsyr2StridedBatched function hipblasSsyr2StridedBatched_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP,lda, & strideA,batchCount) & bind(c, name="hipblasSsyr2StridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2StridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSsyr2StridedBatched_assumed_rank #else module procedure & hipblasSsyr2StridedBatched_rank_0,& hipblasSsyr2StridedBatched_rank_1,& hipblasSsyr2StridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyr2StridedBatched function hipblasDsyr2StridedBatched_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP,lda, & strideA,batchCount) & bind(c, name="hipblasDsyr2StridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2StridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDsyr2StridedBatched_assumed_rank #else module procedure & hipblasDsyr2StridedBatched_rank_0,& hipblasDsyr2StridedBatched_rank_1,& hipblasDsyr2StridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyr2StridedBatched function hipblasCsyr2StridedBatched_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP,lda, & strideA,batchCount) & bind(c, name="hipblasCsyr2StridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2StridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCsyr2StridedBatched_assumed_rank #else module procedure & hipblasCsyr2StridedBatched_rank_0,& hipblasCsyr2StridedBatched_rank_1,& hipblasCsyr2StridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyr2StridedBatched function hipblasZsyr2StridedBatched_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP,lda, & strideA,batchCount) & bind(c, name="hipblasZsyr2StridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2StridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZsyr2StridedBatched_assumed_rank #else module procedure & hipblasZsyr2StridedBatched_rank_0,& hipblasZsyr2StridedBatched_rank_1,& hipblasZsyr2StridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSsyr2StridedBatched_64 function hipblasSsyr2StridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP, & lda,strideA,batchCount) & bind(c, name="hipblasSsyr2StridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2StridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyr2StridedBatched_64 function hipblasDsyr2StridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP, & lda,strideA,batchCount) & bind(c, name="hipblasDsyr2StridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2StridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyr2StridedBatched_64 function hipblasCsyr2StridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP, & lda,strideA,batchCount) & bind(c, name="hipblasCsyr2StridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2StridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyr2StridedBatched_64 function hipblasZsyr2StridedBatched_64_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,AP, & lda,strideA,batchCount) & bind(c, name="hipblasZsyr2StridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2StridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The tbmv functions perform one of the matrix-vector operations: !> !> x := A*x or !> x := A**T*x or !> x := A**H*x, !> !> where ``x`` is a vector and ``A`` is a banded ``n`` by ``n`` matrix (see description !> below). !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A is an upper banded triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A is a lower banded triangular matrix. !> @param[in] transA - [hipblasOperation_t] !> indicates whether matrix A is tranposed (conjugated) or not. !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: The main diagonal of A is assumed to consist of only !> 1's and is not referenced. !> - HIPBLAS_DIAG_NON_UNIT: No assumptions are made of A's main diagonal. !> @param[in] n - [int] !> the number of rows and columns of the matrix represented by A. !> @param[in] k - [int] !> - if uplo == HIPBLAS_FILL_MODE_UPPER, k specifies the number of super-diagonals !> of the matrix A. !> - if uplo == HIPBLAS_FILL_MODE_LOWER, k specifies the number of sub-diagonals !> of the matrix A. !> - k must satisfy k > 0 && k < lda. !> @param[in] AP - device pointer storing banded triangular matrix A. !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The matrix represented is an upper banded triangular matrix !> with the main diagonal and k super-diagonals. Everything !> else can be assumed to be 0. !> The matrix is compacted so that the main diagonal resides on the k'th !> row, the first super diagonal resides on the RHS of the k-1'th row, and so !> forth, !> with the k'th diagonal on the RHS of the 0'th row. !> Ex: (HIPBLAS_FILL_MODE_UPPER; n = 5; k = 2) !> 1 6 9 0 0 -> 0 0 9 8 7 !> 0 2 7 8 0 -> 0 6 7 8 9 !> 0 0 3 8 7 -> 1 2 3 4 5 !> 0 0 0 4 9 -> 0 0 0 0 0 !> 0 0 0 0 5 -> 0 0 0 0 0 !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The matrix represnted is a lower banded triangular matrix !> with the main diagonal and k sub-diagonals. Everything else can be !> assumed to be 0. !> The matrix is compacted so that the main diagonal resides on the 0'th row, !> working up to the k'th diagonal residing on the LHS of the k'th row. !> Ex: (HIPBLAS_FILL_MODE_LOWER; n = 5; k = 2) !> 1 0 0 0 0 -> 1 2 3 4 5 !> 6 2 0 0 0 -> 6 7 8 9 0 !> 9 7 3 0 0 -> 9 8 7 0 0 !> 0 8 8 4 0 -> 0 0 0 0 0 !> 0 0 7 9 5 -> 0 0 0 0 0 !> @param[in] lda - [int] !> specifies the leading dimension of A. lda must satisfy lda > k. !> @param[inout] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. interface hipblasStbmv #ifdef USE_CUDA_NAMES function hipblasStbmv_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) bind(c, name="cublasStbmv_v2") #else function hipblasStbmv_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) bind(c, name="hipblasStbmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasStbmv_assumed_rank #else module procedure & hipblasStbmv_rank_0,& hipblasStbmv_rank_1,& hipblasStbmv_full_rank #endif #endif end interface interface hipblasDtbmv #ifdef USE_CUDA_NAMES function hipblasDtbmv_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) bind(c, name="cublasDtbmv_v2") #else function hipblasDtbmv_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) bind(c, name="hipblasDtbmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDtbmv_assumed_rank #else module procedure & hipblasDtbmv_rank_0,& hipblasDtbmv_rank_1,& hipblasDtbmv_full_rank #endif #endif end interface interface hipblasCtbmv #ifdef USE_CUDA_NAMES function hipblasCtbmv_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) bind(c, name="cublasCtbmv_v2") #else function hipblasCtbmv_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) bind(c, name="hipblasCtbmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCtbmv_assumed_rank #else module procedure & hipblasCtbmv_rank_0,& hipblasCtbmv_rank_1,& hipblasCtbmv_full_rank #endif #endif end interface interface hipblasZtbmv #ifdef USE_CUDA_NAMES function hipblasZtbmv_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) bind(c, name="cublasZtbmv_v2") #else function hipblasZtbmv_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) bind(c, name="hipblasZtbmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZtbmv_assumed_rank #else module procedure & hipblasZtbmv_rank_0,& hipblasZtbmv_rank_1,& hipblasZtbmv_full_rank #endif #endif end interface interface hipblasStbmv_64 #ifdef USE_CUDA_NAMES function hipblasStbmv_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) & bind(c, name="cublasStbmv_v2_64") #else function hipblasStbmv_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) & bind(c, name="hipblasStbmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasDtbmv_64 #ifdef USE_CUDA_NAMES function hipblasDtbmv_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) & bind(c, name="cublasDtbmv_v2_64") #else function hipblasDtbmv_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) & bind(c, name="hipblasDtbmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasCtbmv_64 #ifdef USE_CUDA_NAMES function hipblasCtbmv_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) & bind(c, name="cublasCtbmv_v2_64") #else function hipblasCtbmv_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) & bind(c, name="hipblasCtbmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasZtbmv_64 #ifdef USE_CUDA_NAMES function hipblasZtbmv_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) & bind(c, name="cublasZtbmv_v2_64") #else function hipblasZtbmv_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) & bind(c, name="hipblasZtbmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface !> \brief BLAS Level 2 API !> !> \details !> The tbmvBatched functions perform one of the matrix-vector operations: !> !> x_i := A_i*x_i or !> x_i := A_i**T*x_i or !> x_i := A_i**H*x_i, !> !> where ``(A_i, x_i)`` is the ``i``-th instance of the batch, !> ``x_i`` is a vector, and ``A_i`` is an ``n`` by ``n`` matrix, for ``i`` = 1, ..., !> ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: each A_i is an upper banded triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: each A_i is a lower banded triangular matrix. !> @param[in] transA - [hipblasOperation_t] !> indicates whether each matrix A_i is tranposed (conjugated) or not. !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: The main diagonal of each A_i is assumed to consist of only !> 1's and is not referenced. !> - HIPBLAS_DIAG_NON_UNIT: No assumptions are made of each A_i's main diagonal. !> @param[in] n - [int] !> the number of rows and columns of the matrix represented by each A_i. !> @param[in] k - [int] !> - if uplo == HIPBLAS_FILL_MODE_UPPER, k specifies the number of super-diagonals !> of each matrix A_i. !> - if uplo == HIPBLAS_FILL_MODE_LOWER, k specifies the number of sub-diagonals !> of each matrix A_i. !> - k must satisfy k > 0 && k < lda. !> @param[in] AP - device array of device pointers storing each banded triangular matrix A_i. !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The matrix represented is an upper banded triangular matrix !> with the main diagonal and k super-diagonals. Everything !> else can be assumed to be 0. !> The matrix is compacted so that the main diagonal resides on the k'th !> row, the first super diagonal resides on the RHS of the k-1'th row, and so !> forth, !> with the k'th diagonal on the RHS of the 0'th row. !> Ex: (HIPBLAS_FILL_MODE_UPPER; n = 5; k = 2) !> 1 6 9 0 0 -> 0 0 9 8 7 !> 0 2 7 8 0 -> 0 6 7 8 9 !> 0 0 3 8 7 -> 1 2 3 4 5 !> 0 0 0 4 9 -> 0 0 0 0 0 !> 0 0 0 0 5 -> 0 0 0 0 0 !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The matrix represnted is a lower banded triangular matrix !> with the main diagonal and k sub-diagonals. Everything else can be !> assumed to be 0. !> The matrix is compacted so that the main diagonal resides on the 0'th row, !> working up to the k'th diagonal residing on the LHS of the k'th row. !> Ex: (HIPBLAS_FILL_MODE_LOWER; n = 5; k = 2) !> 1 0 0 0 0 -> 1 2 3 4 5 !> 6 2 0 0 0 -> 6 7 8 9 0 !> 9 7 3 0 0 -> 9 8 7 0 0 !> 0 8 8 4 0 -> 0 0 0 0 0 !> 0 0 7 9 5 -> 0 0 0 0 0 !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. lda must satisfy lda > k. !> @param[inout] x - device array of device pointer storing each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasStbmvBatched function hipblasStbmvBatched_(handle,uplo,transA,diag,n,k,AP,lda,x,incx,batchCount) & bind(c, name="hipblasStbmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtbmvBatched function hipblasDtbmvBatched_(handle,uplo,transA,diag,n,k,AP,lda,x,incx,batchCount) & bind(c, name="hipblasDtbmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtbmvBatched function hipblasCtbmvBatched_(handle,uplo,transA,diag,n,k,AP,lda,x,incx,batchCount) & bind(c, name="hipblasCtbmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtbmvBatched function hipblasZtbmvBatched_(handle,uplo,transA,diag,n,k,AP,lda,x,incx,batchCount) & bind(c, name="hipblasZtbmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasStbmvBatched_64 function hipblasStbmvBatched_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx,batchCount) & bind(c, name="hipblasStbmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtbmvBatched_64 function hipblasDtbmvBatched_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx,batchCount) & bind(c, name="hipblasDtbmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtbmvBatched_64 function hipblasCtbmvBatched_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx,batchCount) & bind(c, name="hipblasCtbmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtbmvBatched_64 function hipblasZtbmvBatched_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx,batchCount) & bind(c, name="hipblasZtbmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The tbmvStridedBatched functions perform one of the matrix-vector operations: !> !> x_i := A_i*x_i or !> x_i := A_i**T*x_i or !> x_i := A_i**H*x_i, !> !> where ``(A_i, x_i)`` is the ``i``-th instance of the batch, !> ``x_i`` is a vector, and ``A_i`` is an ``n`` by ``n`` matrix, for ``i`` = 1, ..., !> ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: each A_i is an upper banded triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: each A_i is a lower banded triangular matrix. !> @param[in] transA - [hipblasOperation_t] !> indicates whether each matrix A_i is tranposed (conjugated) or not. !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: The main diagonal of each A_i is assumed to consist of only !> 1's and is not referenced. !> - HIPBLAS_DIAG_NON_UNIT: No assumptions are made of each A_i's main diagonal. !> @param[in] n - [int] !> the number of rows and columns of the matrix represented by each A_i. !> @param[in] k - [int] !> - if uplo == HIPBLAS_FILL_MODE_UPPER, k specifies the number of super-diagonals !> of each matrix A_i. !> - if uplo == HIPBLAS_FILL_MODE_LOWER, k specifies the number of sub-diagonals !> of each matrix A_i. !> - k must satisfy k > 0 && k < lda. !> @param[in] AP - device array to the first matrix A_i of the batch. Stores each banded !> triangular matrix A_i. !> - if uplo == HIPBLAS_FILL_MODE_UPPER: !> The matrix represented is an upper banded triangular matrix !> with the main diagonal and k super-diagonals. Everything !> else can be assumed to be 0. !> The matrix is compacted so that the main diagonal resides on the k'th !> row, the first super diagonal resides on the RHS of the k-1'th row, and so !> forth, !> with the k'th diagonal on the RHS of the 0'th row. !> Ex: (HIPBLAS_FILL_MODE_UPPER; n = 5; k = 2) !> 1 6 9 0 0 -> 0 0 9 8 7 !> 0 2 7 8 0 -> 0 6 7 8 9 !> 0 0 3 8 7 -> 1 2 3 4 5 !> 0 0 0 4 9 -> 0 0 0 0 0 !> 0 0 0 0 5 -> 0 0 0 0 0 !> - if uplo == HIPBLAS_FILL_MODE_LOWER: !> The matrix represnted is a lower banded triangular matrix !> with the main diagonal and k sub-diagonals. Everything else can be !> assumed to be 0. !> The matrix is compacted so that the main diagonal resides on the 0'th row, !> working up to the k'th diagonal residing on the LHS of the k'th row. !> Ex: (HIPBLAS_FILL_MODE_LOWER; n = 5; k = 2) !> 1 0 0 0 0 -> 1 2 3 4 5 !> 6 2 0 0 0 -> 6 7 8 9 0 !> 9 7 3 0 0 -> 9 8 7 0 0 !> 0 8 8 4 0 -> 0 0 0 0 0 !> 0 0 7 9 5 -> 0 0 0 0 0 !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. lda must satisfy lda > k. !> @param[in] strideA - [hipblasStride] !> stride from the start of one A_i matrix to the next A_(i + 1). !> @param[inout] x - device array to the first vector x_i of the batch. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [hipblasStride] !> stride from the start of one x_i matrix to the next x_(i + 1). !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasStbmvStridedBatched function hipblasStbmvStridedBatched_(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasStbmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasStbmvStridedBatched_assumed_rank #else module procedure & hipblasStbmvStridedBatched_rank_0,& hipblasStbmvStridedBatched_rank_1,& hipblasStbmvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtbmvStridedBatched function hipblasDtbmvStridedBatched_(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasDtbmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDtbmvStridedBatched_assumed_rank #else module procedure & hipblasDtbmvStridedBatched_rank_0,& hipblasDtbmvStridedBatched_rank_1,& hipblasDtbmvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtbmvStridedBatched function hipblasCtbmvStridedBatched_(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasCtbmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCtbmvStridedBatched_assumed_rank #else module procedure & hipblasCtbmvStridedBatched_rank_0,& hipblasCtbmvStridedBatched_rank_1,& hipblasCtbmvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtbmvStridedBatched function hipblasZtbmvStridedBatched_(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasZtbmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZtbmvStridedBatched_assumed_rank #else module procedure & hipblasZtbmvStridedBatched_rank_0,& hipblasZtbmvStridedBatched_rank_1,& hipblasZtbmvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasStbmvStridedBatched_64 function hipblasStbmvStridedBatched_64_(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasStbmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtbmvStridedBatched_64 function hipblasDtbmvStridedBatched_64_(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasDtbmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtbmvStridedBatched_64 function hipblasCtbmvStridedBatched_64_(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasCtbmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtbmvStridedBatched_64 function hipblasZtbmvStridedBatched_64_(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasZtbmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The tbsv functions solve: !> !> A*x = b or A**T*x = b or A**H*x = b, !> !> where ``x`` and ``b`` are vectors and ``A`` is a banded triangular matrix. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_N: Solves A*x = b !> - HIPBLAS_OP_T: Solves A**T*x = b !> - HIPBLAS_OP_C: Solves A**H*x = b !> !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular (that is, the diagonal !> elements !> of A are not used in computations). !> - HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular. !> !> @param[in] n - [int] !> n specifies the number of rows of b. n >= 0. !> @param[in] k - [int] !> - if(uplo == HIPBLAS_FILL_MODE_UPPER), !> k specifies the number of super-diagonals of A. !> - if(uplo == HIPBLAS_FILL_MODE_LOWER), !> k specifies the number of sub-diagonals of A. !> - k >= 0. !> !> @param[in] AP - device pointer storing the matrix A in banded format. !> !> @param[in] lda - [int] !> specifies the leading dimension of A. !> lda >= (k + 1). !> !> @param[inout] x - device pointer storing input vector b. Overwritten by the output vector !> x. !> !> @param[in] incx - [int] !> specifies the increment for the elements of x. interface hipblasStbsv #ifdef USE_CUDA_NAMES function hipblasStbsv_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) bind(c, name="cublasStbsv_v2") #else function hipblasStbsv_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) bind(c, name="hipblasStbsv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasStbsv_assumed_rank #else module procedure & hipblasStbsv_rank_0,& hipblasStbsv_rank_1,& hipblasStbsv_full_rank #endif #endif end interface interface hipblasDtbsv #ifdef USE_CUDA_NAMES function hipblasDtbsv_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) bind(c, name="cublasDtbsv_v2") #else function hipblasDtbsv_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) bind(c, name="hipblasDtbsv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDtbsv_assumed_rank #else module procedure & hipblasDtbsv_rank_0,& hipblasDtbsv_rank_1,& hipblasDtbsv_full_rank #endif #endif end interface interface hipblasCtbsv #ifdef USE_CUDA_NAMES function hipblasCtbsv_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) bind(c, name="cublasCtbsv_v2") #else function hipblasCtbsv_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) bind(c, name="hipblasCtbsv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCtbsv_assumed_rank #else module procedure & hipblasCtbsv_rank_0,& hipblasCtbsv_rank_1,& hipblasCtbsv_full_rank #endif #endif end interface interface hipblasZtbsv #ifdef USE_CUDA_NAMES function hipblasZtbsv_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) bind(c, name="cublasZtbsv_v2") #else function hipblasZtbsv_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) bind(c, name="hipblasZtbsv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZtbsv_assumed_rank #else module procedure & hipblasZtbsv_rank_0,& hipblasZtbsv_rank_1,& hipblasZtbsv_full_rank #endif #endif end interface interface hipblasStbsv_64 #ifdef USE_CUDA_NAMES function hipblasStbsv_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) & bind(c, name="cublasStbsv_v2_64") #else function hipblasStbsv_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) & bind(c, name="hipblasStbsv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasDtbsv_64 #ifdef USE_CUDA_NAMES function hipblasDtbsv_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) & bind(c, name="cublasDtbsv_v2_64") #else function hipblasDtbsv_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) & bind(c, name="hipblasDtbsv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasCtbsv_64 #ifdef USE_CUDA_NAMES function hipblasCtbsv_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) & bind(c, name="cublasCtbsv_v2_64") #else function hipblasCtbsv_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) & bind(c, name="hipblasCtbsv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasZtbsv_64 #ifdef USE_CUDA_NAMES function hipblasZtbsv_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) & bind(c, name="cublasZtbsv_v2_64") #else function hipblasZtbsv_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx) & bind(c, name="hipblasZtbsv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface !> \brief BLAS Level 2 API !> !> \details !> The tbsvBatched functions solve: !> !> A_i*x_i = b_i or A_i**T*x_i = b_i or A_i**H*x_i = b_i, !> !> where ``x_i`` and ``b_i`` are vectors and ``A_i`` is a banded triangular matrix, !> for ``i = [1, batchCount``]. !> !> The input vectors ``b_i`` are overwritten by the output vectors ``x_i``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_N: Solves A_i*x_i = b_i !> - HIPBLAS_OP_T: Solves A_i**T*x_i = b_i !> - HIPBLAS_OP_C: Solves A_i**H*x_i = b_i !> !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: each A_i is assumed to be unit triangular (that is, the !> diagonal elements !> of each A_i are not used in computations). !> - HIPBLAS_DIAG_NON_UNIT: each A_i is not assumed to be unit triangular. !> !> @param[in] n - [int] !> n specifies the number of rows of each b_i. n >= 0. !> @param[in] k - [int] !> - if(uplo == HIPBLAS_FILL_MODE_UPPER), !> k specifies the number of super-diagonals of each A_i. !> - if(uplo == HIPBLAS_FILL_MODE_LOWER), !> k specifies the number of sub-diagonals of each A_i. !> - k >= 0. !> !> @param[in] AP - device vector of device pointers storing each matrix A_i in banded format. !> !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. !> lda >= (k + 1). !> !> @param[inout] x - device vector of device pointers storing each input vector b_i. !> Overwritten by each output !> vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasStbsvBatched function hipblasStbsvBatched_(handle,uplo,transA,diag,n,k,AP,lda,x,incx,batchCount) & bind(c, name="hipblasStbsvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtbsvBatched function hipblasDtbsvBatched_(handle,uplo,transA,diag,n,k,AP,lda,x,incx,batchCount) & bind(c, name="hipblasDtbsvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtbsvBatched function hipblasCtbsvBatched_(handle,uplo,transA,diag,n,k,AP,lda,x,incx,batchCount) & bind(c, name="hipblasCtbsvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtbsvBatched function hipblasZtbsvBatched_(handle,uplo,transA,diag,n,k,AP,lda,x,incx,batchCount) & bind(c, name="hipblasZtbsvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasStbsvBatched_64 function hipblasStbsvBatched_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx,batchCount) & bind(c, name="hipblasStbsvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtbsvBatched_64 function hipblasDtbsvBatched_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx,batchCount) & bind(c, name="hipblasDtbsvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtbsvBatched_64 function hipblasCtbsvBatched_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx,batchCount) & bind(c, name="hipblasCtbsvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtbsvBatched_64 function hipblasZtbsvBatched_64_(handle,uplo,transA,diag,n,k,AP,lda,x,incx,batchCount) & bind(c, name="hipblasZtbsvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The tbsvStridedBatched functions solve: !> !> A_i*x_i = b_i or A_i**T*x_i = b_i or A_i**H*x_i = b_i, !> !> where ``x_i`` and ``b_i`` are vectors and ``A_i`` is a banded triangular matrix, !> for ``i = [1, batchCount``]. !> !> The input vectors ``b_i`` are overwritten by the output vectors ``x_i``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_N: Solves A_i*x_i = b_i !> - HIPBLAS_OP_T: Solves A_i**T*x_i = b_i !> - HIPBLAS_OP_C: Solves A_i**H*x_i = b_i !> !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: each A_i is assumed to be unit triangular (that is, the !> diagonal elements !> of each A_i are not used in computations). !> - HIPBLAS_DIAG_NON_UNIT: each A_i is not assumed to be unit triangular. !> !> @param[in] n - [int] !> n specifies the number of rows of each b_i. n >= 0. !> @param[in] k - [int] !> - if(uplo == HIPBLAS_FILL_MODE_UPPER), !> k specifies the number of super-diagonals of each A_i. !> - if(uplo == HIPBLAS_FILL_MODE_LOWER), !> k specifies the number of sub-diagonals of each A_i. !> - k >= 0. !> !> @param[in] AP - device pointer pointing to the first banded matrix A_1. !> !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. !> lda >= (k + 1). !> @param[in] strideA - [hipblasStride] !> specifies the distance between the start of one matrix (A_i) and the next !> (A_i+1). !> !> @param[inout] x - device pointer pointing to the first input vector b_1. Overwritten by !> output vectors x. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [hipblasStride] !> specifies the distance between the start of one vector (x_i) and the next !> (x_i+1). !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasStbsvStridedBatched function hipblasStbsvStridedBatched_(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasStbsvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasStbsvStridedBatched_assumed_rank #else module procedure & hipblasStbsvStridedBatched_rank_0,& hipblasStbsvStridedBatched_rank_1,& hipblasStbsvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtbsvStridedBatched function hipblasDtbsvStridedBatched_(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasDtbsvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDtbsvStridedBatched_assumed_rank #else module procedure & hipblasDtbsvStridedBatched_rank_0,& hipblasDtbsvStridedBatched_rank_1,& hipblasDtbsvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtbsvStridedBatched function hipblasCtbsvStridedBatched_(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasCtbsvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCtbsvStridedBatched_assumed_rank #else module procedure & hipblasCtbsvStridedBatched_rank_0,& hipblasCtbsvStridedBatched_rank_1,& hipblasCtbsvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtbsvStridedBatched function hipblasZtbsvStridedBatched_(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasZtbsvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZtbsvStridedBatched_assumed_rank #else module procedure & hipblasZtbsvStridedBatched_rank_0,& hipblasZtbsvStridedBatched_rank_1,& hipblasZtbsvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasStbsvStridedBatched_64 function hipblasStbsvStridedBatched_64_(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasStbsvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtbsvStridedBatched_64 function hipblasDtbsvStridedBatched_64_(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasDtbsvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtbsvStridedBatched_64 function hipblasCtbsvStridedBatched_64_(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasCtbsvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtbsvStridedBatched_64 function hipblasZtbsvStridedBatched_64_(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasZtbsvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The tpmv functions perform one of the matrix-vector operations: !> !> x = A*x or x = A**T*x, !> !> where ``x`` is an ``n`` -element vector and ``A`` is an ``n`` by ``n`` unit, or non-unit, !> upper or lower triangular matrix, supplied in the pack form. !> !> The vector ``x`` is overwritten. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular. !> - HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular. !> !> @param[in] n - [int] !> n specifies the number of rows of A. n >= 0. !> !> @param[in] AP - device pointer storing matrix A, !> of dimension at least ( n * ( n + 1 ) / 2 ). !> - Before entry with uplo = HIPBLAS_FILL_MODE_UPPER, the array A !> must contain the upper triangular matrix packed sequentially, !> column by column, so that A[0] contains a_{0,0}, A[1] and A[2] contain !> a_{0,1} and a_{1, 1} respectively, and so on. !> - Before entry with uplo = HIPBLAS_FILL_MODE_LOWER, the array A !> must contain the lower triangular matrix packed sequentially, !> column by column, so that A[0] contains a_{0,0}, A[1] and A[2] contain !> a_{1,0} and a_{2,0} respectively, and so on. !> - Note that when DIAG = HIPBLAS_DIAG_UNIT, the diagonal elements of A are !> not referenced, but are assumed to be unity. !> !> @param[in] x - device pointer storing vector x. !> !> @param[in] incx - [int] !> specifies the increment for the elements of x. incx must not be zero. interface hipblasStpmv #ifdef USE_CUDA_NAMES function hipblasStpmv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="cublasStpmv_v2") #else function hipblasStpmv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="hipblasStpmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasStpmv_assumed_rank #else module procedure & hipblasStpmv_rank_0,& hipblasStpmv_rank_1 #endif #endif end interface interface hipblasDtpmv #ifdef USE_CUDA_NAMES function hipblasDtpmv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="cublasDtpmv_v2") #else function hipblasDtpmv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="hipblasDtpmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDtpmv_assumed_rank #else module procedure & hipblasDtpmv_rank_0,& hipblasDtpmv_rank_1 #endif #endif end interface interface hipblasCtpmv #ifdef USE_CUDA_NAMES function hipblasCtpmv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="cublasCtpmv_v2") #else function hipblasCtpmv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="hipblasCtpmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCtpmv_assumed_rank #else module procedure & hipblasCtpmv_rank_0,& hipblasCtpmv_rank_1 #endif #endif end interface interface hipblasZtpmv #ifdef USE_CUDA_NAMES function hipblasZtpmv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="cublasZtpmv_v2") #else function hipblasZtpmv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="hipblasZtpmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZtpmv_assumed_rank #else module procedure & hipblasZtpmv_rank_0,& hipblasZtpmv_rank_1 #endif #endif end interface interface hipblasStpmv_64 #ifdef USE_CUDA_NAMES function hipblasStpmv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="cublasStpmv_v2_64") #else function hipblasStpmv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="hipblasStpmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasDtpmv_64 #ifdef USE_CUDA_NAMES function hipblasDtpmv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="cublasDtpmv_v2_64") #else function hipblasDtpmv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="hipblasDtpmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasCtpmv_64 #ifdef USE_CUDA_NAMES function hipblasCtpmv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="cublasCtpmv_v2_64") #else function hipblasCtpmv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="hipblasCtpmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasZtpmv_64 #ifdef USE_CUDA_NAMES function hipblasZtpmv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="cublasZtpmv_v2_64") #else function hipblasZtpmv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="hipblasZtpmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface !> \brief BLAS Level 2 API !> !> \details !> The tpmvBatched functions perform one of the matrix-vector operations: !> !> x_i = A_i*x_i or x_i = A**T*x_i, 0 ≤ i < batchCount !> !> where ``x_i`` is an ``n`` -element vector and ``A_i`` is an ``n`` by ``n`` (unit, or !> non-unit, upper or lower triangular matrix). !> !> The vectors ``x_i`` are overwritten. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: A_i is assumed to be unit triangular. !> - HIPBLAS_DIAG_NON_UNIT: A_i is not assumed to be unit triangular. !> !> @param[in] n - [int] !> n specifies the number of rows of matrices A_i. n >= 0. !> !> @param[in] AP - device pointer storing pointer of matrices A_i !> of dimension ( lda, n ). !> !> @param[in] x - device pointer storing vectors x_i. !> !> @param[in] incx - [int] !> specifies the increment for the elements of vectors x_i. !> !> @param[in] batchCount - [int] !> The number of batched matrices/vectors. #ifndef USE_CUDA_NAMES interface hipblasStpmvBatched function hipblasStpmvBatched_(handle,uplo,transA,diag,n,AP,x,incx,batchCount) & bind(c, name="hipblasStpmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtpmvBatched function hipblasDtpmvBatched_(handle,uplo,transA,diag,n,AP,x,incx,batchCount) & bind(c, name="hipblasDtpmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtpmvBatched function hipblasCtpmvBatched_(handle,uplo,transA,diag,n,AP,x,incx,batchCount) & bind(c, name="hipblasCtpmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtpmvBatched function hipblasZtpmvBatched_(handle,uplo,transA,diag,n,AP,x,incx,batchCount) & bind(c, name="hipblasZtpmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasStpmvBatched_64 function hipblasStpmvBatched_64_(handle,uplo,transA,diag,n,AP,x,incx,batchCount) & bind(c, name="hipblasStpmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtpmvBatched_64 function hipblasDtpmvBatched_64_(handle,uplo,transA,diag,n,AP,x,incx,batchCount) & bind(c, name="hipblasDtpmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtpmvBatched_64 function hipblasCtpmvBatched_64_(handle,uplo,transA,diag,n,AP,x,incx,batchCount) & bind(c, name="hipblasCtpmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtpmvBatched_64 function hipblasZtpmvBatched_64_(handle,uplo,transA,diag,n,AP,x,incx,batchCount) & bind(c, name="hipblasZtpmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The tpmvStridedBatched functions perform one of the matrix-vector operations: !> !> x_i = A_i*x_i or x_i = A**T*x_i, 0 ≤ i < batchCount !> !> where ``x_i`` is an n element vector and ``A_i`` is an ``n`` by ``n`` (unit, or non-unit, !> upper or lower triangular matrix), !> with strides specifying how to retrieve ``$x_i$`` (resp. ``$A_i$`` ) from ``$x_{i-1}$`` !> (resp. ``$A_i$`` ). !> !> The vectors ``x_i`` are overwritten. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: A_i is assumed to be unit triangular. !> - HIPBLAS_DIAG_NON_UNIT: A_i is not assumed to be unit triangular. !> !> @param[in] n - [int] !> n specifies the number of rows of matrices A_i. n >= 0. !> !> @param[in] AP - device pointer of the matrix A_0 !> of dimension ( lda, n ). !> !> @param[in] strideA - [hipblasStride] !> stride from the start of one A_i matrix to the next A_{i + 1}. !> !> @param[in] x - device pointer storing the vector x_0. !> !> @param[in] incx - [int] !> specifies the increment for the elements of one vector x. !> !> @param[in] stridex - [hipblasStride] !> stride from the start of one x_i vector to the next x_{i + 1}. !> !> @param[in] batchCount - [int] !> The number of batched matrices/vectors. #ifndef USE_CUDA_NAMES interface hipblasStpmvStridedBatched function hipblasStpmvStridedBatched_(handle,uplo,transA,diag,n,AP,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasStpmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasStpmvStridedBatched_assumed_rank #else module procedure & hipblasStpmvStridedBatched_rank_0,& hipblasStpmvStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtpmvStridedBatched function hipblasDtpmvStridedBatched_(handle,uplo,transA,diag,n,AP,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasDtpmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDtpmvStridedBatched_assumed_rank #else module procedure & hipblasDtpmvStridedBatched_rank_0,& hipblasDtpmvStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtpmvStridedBatched function hipblasCtpmvStridedBatched_(handle,uplo,transA,diag,n,AP,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasCtpmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCtpmvStridedBatched_assumed_rank #else module procedure & hipblasCtpmvStridedBatched_rank_0,& hipblasCtpmvStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtpmvStridedBatched function hipblasZtpmvStridedBatched_(handle,uplo,transA,diag,n,AP,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasZtpmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZtpmvStridedBatched_assumed_rank #else module procedure & hipblasZtpmvStridedBatched_rank_0,& hipblasZtpmvStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasStpmvStridedBatched_64 function hipblasStpmvStridedBatched_64_(handle,uplo,transA,diag,n,AP,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasStpmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtpmvStridedBatched_64 function hipblasDtpmvStridedBatched_64_(handle,uplo,transA,diag,n,AP,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasDtpmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtpmvStridedBatched_64 function hipblasCtpmvStridedBatched_64_(handle,uplo,transA,diag,n,AP,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasCtpmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtpmvStridedBatched_64 function hipblasZtpmvStridedBatched_64_(handle,uplo,transA,diag,n,AP,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasZtpmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The tpsv functions solve: !> !> A*x = b or A**T*x = b, or A**H*x = b, !> !> where ``x`` and ``b`` are vectors and ``A`` is a triangular matrix stored in the packed !> format. !> !> The input vector ``b`` is overwritten by the output vector ``x``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_N: Solves A*x = b !> - HIPBLAS_OP_T: Solves A**T*x = b !> - HIPBLAS_OP_C: Solves A**H*x = b !> !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular (that is, the diagonal !> elements !> of A are not used in computations). !> - HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular. !> !> @param[in] n - [int] !> n specifies the number of rows of b. n >= 0. !> !> @param[in] AP - device pointer storing the packed version of matrix A !> of dimension >= (n * (n + 1) / 2). !> !> @param[inout] x - device pointer storing vector b on input, overwritten by x on output. !> !> @param[in] incx - [int] !> specifies the increment for the elements of x. interface hipblasStpsv #ifdef USE_CUDA_NAMES function hipblasStpsv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="cublasStpsv_v2") #else function hipblasStpsv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="hipblasStpsv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpsv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasStpsv_assumed_rank #else module procedure & hipblasStpsv_rank_0,& hipblasStpsv_rank_1 #endif #endif end interface interface hipblasDtpsv #ifdef USE_CUDA_NAMES function hipblasDtpsv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="cublasDtpsv_v2") #else function hipblasDtpsv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="hipblasDtpsv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpsv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDtpsv_assumed_rank #else module procedure & hipblasDtpsv_rank_0,& hipblasDtpsv_rank_1 #endif #endif end interface interface hipblasCtpsv #ifdef USE_CUDA_NAMES function hipblasCtpsv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="cublasCtpsv_v2") #else function hipblasCtpsv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="hipblasCtpsv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpsv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCtpsv_assumed_rank #else module procedure & hipblasCtpsv_rank_0,& hipblasCtpsv_rank_1 #endif #endif end interface interface hipblasZtpsv #ifdef USE_CUDA_NAMES function hipblasZtpsv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="cublasZtpsv_v2") #else function hipblasZtpsv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="hipblasZtpsv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpsv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZtpsv_assumed_rank #else module procedure & hipblasZtpsv_rank_0,& hipblasZtpsv_rank_1 #endif #endif end interface interface hipblasStpsv_64 #ifdef USE_CUDA_NAMES function hipblasStpsv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="cublasStpsv_v2_64") #else function hipblasStpsv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="hipblasStpsv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpsv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasDtpsv_64 #ifdef USE_CUDA_NAMES function hipblasDtpsv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="cublasDtpsv_v2_64") #else function hipblasDtpsv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="hipblasDtpsv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpsv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasCtpsv_64 #ifdef USE_CUDA_NAMES function hipblasCtpsv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="cublasCtpsv_v2_64") #else function hipblasCtpsv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="hipblasCtpsv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpsv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasZtpsv_64 #ifdef USE_CUDA_NAMES function hipblasZtpsv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="cublasZtpsv_v2_64") #else function hipblasZtpsv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="hipblasZtpsv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpsv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface !> \brief BLAS Level 2 API !> !> \details !> The tpsvBatched functions solve: !> !> A_i*x_i = b_i or A_i**T*x_i = b_i, or A_i**H*x_i = b_i, !> !> where ``x_i`` and ``b_i`` are vectors and ``A_i`` is a triangular matrix stored in the !> packed format, !> for ``i in [1, batchCount``]. !> !> The input vectors ``b_i`` are overwritten by the output vectors ``x_i``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: each A_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: each A_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_N: Solves A*x = b !> - HIPBLAS_OP_T: Solves A**T*x = b !> - HIPBLAS_OP_C: Solves A**H*x = b !> !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: each A_i is assumed to be unit triangular (that is, the !> diagonal elements !> of each A_i are not used in computations). !> - HIPBLAS_DIAG_NON_UNIT: each A_i is not assumed to be unit triangular. !> !> @param[in] n - [int] !> n specifies the number of rows of each b_i. n >= 0. !> !> @param[in] AP - device array of device pointers storing the packed versions of each matrix !> A_i !> of dimension >= (n * (n + 1) / 2). !> !> @param[inout] x - device array of device pointers storing each input vector b_i, !> overwritten by x_i on output. !> !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] batchCount - [int] !> specifies the number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasStpsvBatched function hipblasStpsvBatched_(handle,uplo,transA,diag,n,AP,x,incx,batchCount) & bind(c, name="hipblasStpsvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpsvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtpsvBatched function hipblasDtpsvBatched_(handle,uplo,transA,diag,n,AP,x,incx,batchCount) & bind(c, name="hipblasDtpsvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpsvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtpsvBatched function hipblasCtpsvBatched_(handle,uplo,transA,diag,n,AP,x,incx,batchCount) & bind(c, name="hipblasCtpsvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpsvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtpsvBatched function hipblasZtpsvBatched_(handle,uplo,transA,diag,n,AP,x,incx,batchCount) & bind(c, name="hipblasZtpsvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpsvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasStpsvBatched_64 function hipblasStpsvBatched_64_(handle,uplo,transA,diag,n,AP,x,incx,batchCount) & bind(c, name="hipblasStpsvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpsvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtpsvBatched_64 function hipblasDtpsvBatched_64_(handle,uplo,transA,diag,n,AP,x,incx,batchCount) & bind(c, name="hipblasDtpsvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpsvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtpsvBatched_64 function hipblasCtpsvBatched_64_(handle,uplo,transA,diag,n,AP,x,incx,batchCount) & bind(c, name="hipblasCtpsvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpsvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtpsvBatched_64 function hipblasZtpsvBatched_64_(handle,uplo,transA,diag,n,AP,x,incx,batchCount) & bind(c, name="hipblasZtpsvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpsvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The tpsvStridedBatched functions solve: !> !> A_i*x_i = b_i or A_i**T*x_i = b_i, or A_i**H*x_i = b_i, !> !> where ``x_i`` and ``b_i`` are vectors and ``A_i`` is a triangular matrix stored in the !> packed format, !> for ``i in [1, batchCount``]. !> !> The input vectors ``b_i`` are overwritten by the output vectors ``x_i``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: each A_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: each A_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_N: Solves A*x = b !> - HIPBLAS_OP_T: Solves A**T*x = b !> - HIPBLAS_OP_C: Solves A**H*x = b !> !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: each A_i is assumed to be unit triangular (that is, the !> diagonal elements !> of each A_i are not used in computations). !> - HIPBLAS_DIAG_NON_UNIT: each A_i is not assumed to be unit triangular. !> !> @param[in] n - [int] !> n specifies the number of rows of each b_i. n >= 0. !> !> @param[in] AP - device pointer pointing to the first packed matrix A_1 !> of dimension >= (n * (n + 1) / 2). !> !> @param[in] strideA - [hipblasStride] !> stride from the beginning of one packed matrix (AP_i) to the next (AP_i+1). !> !> @param[inout] x - device pointer pointing to the first input vector b_1. Overwritten by !> each x_i on output. !> !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [hipblasStride] !> stride from the beginning of one vector (x_i) to the next (x_i+1). !> @param[in] batchCount - [int] !> specifies the number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasStpsvStridedBatched function hipblasStpsvStridedBatched_(handle,uplo,transA,diag,n,AP,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasStpsvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpsvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasStpsvStridedBatched_assumed_rank #else module procedure & hipblasStpsvStridedBatched_rank_0,& hipblasStpsvStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtpsvStridedBatched function hipblasDtpsvStridedBatched_(handle,uplo,transA,diag,n,AP,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasDtpsvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpsvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDtpsvStridedBatched_assumed_rank #else module procedure & hipblasDtpsvStridedBatched_rank_0,& hipblasDtpsvStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtpsvStridedBatched function hipblasCtpsvStridedBatched_(handle,uplo,transA,diag,n,AP,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasCtpsvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpsvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCtpsvStridedBatched_assumed_rank #else module procedure & hipblasCtpsvStridedBatched_rank_0,& hipblasCtpsvStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtpsvStridedBatched function hipblasZtpsvStridedBatched_(handle,uplo,transA,diag,n,AP,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasZtpsvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpsvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZtpsvStridedBatched_assumed_rank #else module procedure & hipblasZtpsvStridedBatched_rank_0,& hipblasZtpsvStridedBatched_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasStpsvStridedBatched_64 function hipblasStpsvStridedBatched_64_(handle,uplo,transA,diag,n,AP,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasStpsvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpsvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtpsvStridedBatched_64 function hipblasDtpsvStridedBatched_64_(handle,uplo,transA,diag,n,AP,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasDtpsvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpsvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtpsvStridedBatched_64 function hipblasCtpsvStridedBatched_64_(handle,uplo,transA,diag,n,AP,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasCtpsvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpsvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtpsvStridedBatched_64 function hipblasZtpsvStridedBatched_64_(handle,uplo,transA,diag,n,AP,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasZtpsvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpsvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The trmv functions perform one of the matrix-vector operations: !> !> x = A*x or x = A**T*x, !> !> where ``x`` is an ``n`` -element vector and ``A`` is an ``n`` by ``n`` unit, or non-unit, !> upper or lower triangular matrix. !> !> The vector ``x`` is overwritten. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular. !> - HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular. !> !> @param[in] n - [int] !> n specifies the number of rows of A. n >= 0. !> !> @param[in] AP - device pointer storing matrix A, !> of dimension ( lda, n ). !> !> @param[in] lda - [int] !> specifies the leading dimension of A. !> lda = max( 1, n ). !> !> @param[in] x - device pointer storing vector x. !> !> @param[in] incx - [int] !> specifies the increment for the elements of x. interface hipblasStrmv #ifdef USE_CUDA_NAMES function hipblasStrmv_(handle,uplo,transA,diag,n,AP,lda,x,incx) bind(c, name="cublasStrmv_v2") #else function hipblasStrmv_(handle,uplo,transA,diag,n,AP,lda,x,incx) bind(c, name="hipblasStrmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasStrmv_assumed_rank #else module procedure & hipblasStrmv_rank_0,& hipblasStrmv_rank_1,& hipblasStrmv_full_rank #endif #endif end interface interface hipblasDtrmv #ifdef USE_CUDA_NAMES function hipblasDtrmv_(handle,uplo,transA,diag,n,AP,lda,x,incx) bind(c, name="cublasDtrmv_v2") #else function hipblasDtrmv_(handle,uplo,transA,diag,n,AP,lda,x,incx) bind(c, name="hipblasDtrmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDtrmv_assumed_rank #else module procedure & hipblasDtrmv_rank_0,& hipblasDtrmv_rank_1,& hipblasDtrmv_full_rank #endif #endif end interface interface hipblasCtrmv #ifdef USE_CUDA_NAMES function hipblasCtrmv_(handle,uplo,transA,diag,n,AP,lda,x,incx) bind(c, name="cublasCtrmv_v2") #else function hipblasCtrmv_(handle,uplo,transA,diag,n,AP,lda,x,incx) bind(c, name="hipblasCtrmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCtrmv_assumed_rank #else module procedure & hipblasCtrmv_rank_0,& hipblasCtrmv_rank_1,& hipblasCtrmv_full_rank #endif #endif end interface interface hipblasZtrmv #ifdef USE_CUDA_NAMES function hipblasZtrmv_(handle,uplo,transA,diag,n,AP,lda,x,incx) bind(c, name="cublasZtrmv_v2") #else function hipblasZtrmv_(handle,uplo,transA,diag,n,AP,lda,x,incx) bind(c, name="hipblasZtrmv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZtrmv_assumed_rank #else module procedure & hipblasZtrmv_rank_0,& hipblasZtrmv_rank_1,& hipblasZtrmv_full_rank #endif #endif end interface interface hipblasStrmv_64 #ifdef USE_CUDA_NAMES function hipblasStrmv_64_(handle,uplo,transA,diag,n,AP,lda,x,incx) & bind(c, name="cublasStrmv_v2_64") #else function hipblasStrmv_64_(handle,uplo,transA,diag,n,AP,lda,x,incx) & bind(c, name="hipblasStrmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasDtrmv_64 #ifdef USE_CUDA_NAMES function hipblasDtrmv_64_(handle,uplo,transA,diag,n,AP,lda,x,incx) & bind(c, name="cublasDtrmv_v2_64") #else function hipblasDtrmv_64_(handle,uplo,transA,diag,n,AP,lda,x,incx) & bind(c, name="hipblasDtrmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasCtrmv_64 #ifdef USE_CUDA_NAMES function hipblasCtrmv_64_(handle,uplo,transA,diag,n,AP,lda,x,incx) & bind(c, name="cublasCtrmv_v2_64") #else function hipblasCtrmv_64_(handle,uplo,transA,diag,n,AP,lda,x,incx) & bind(c, name="hipblasCtrmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasZtrmv_64 #ifdef USE_CUDA_NAMES function hipblasZtrmv_64_(handle,uplo,transA,diag,n,AP,lda,x,incx) & bind(c, name="cublasZtrmv_v2_64") #else function hipblasZtrmv_64_(handle,uplo,transA,diag,n,AP,lda,x,incx) & bind(c, name="hipblasZtrmv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface !> \brief BLAS Level 2 API !> !> \details !> The trmvBatched functions perform one of the matrix-vector operations: !> !> x_i = A_i*x_i or x_i = A**T*x_i, 0 ≤ i < batchCount !> !> where ``x_i`` is an ``n`` -element vector and ``A_i`` is an ``n`` by ``n`` (unit, or !> non-unit, upper or lower triangular) matrix. !> !> The vectors ``x_i`` are overwritten. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: A_i is assumed to be unit triangular. !> - HIPBLAS_DIAG_NON_UNIT: A_i is not assumed to be unit triangular. !> !> @param[in] n - [int] !> n specifies the number of rows of matrices A_i. n >= 0. !> !> @param[in] AP - device pointer storing pointer of matrices A_i, !> of dimension ( lda, n ). !> !> @param[in] lda - [int] !> specifies the leading dimension of A_i. !> lda >= max( 1, n ). !> !> @param[in] x - device pointer storing vectors x_i. !> !> @param[in] incx - [int] !> specifies the increment for the elements of vectors x_i. !> !> @param[in] batchCount - [int] !> The number of batched matrices/vectors. #ifndef USE_CUDA_NAMES interface hipblasStrmvBatched function hipblasStrmvBatched_(handle,uplo,transA,diag,n,AP,lda,x,incx,batchCount) & bind(c, name="hipblasStrmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtrmvBatched function hipblasDtrmvBatched_(handle,uplo,transA,diag,n,AP,lda,x,incx,batchCount) & bind(c, name="hipblasDtrmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtrmvBatched function hipblasCtrmvBatched_(handle,uplo,transA,diag,n,AP,lda,x,incx,batchCount) & bind(c, name="hipblasCtrmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtrmvBatched function hipblasZtrmvBatched_(handle,uplo,transA,diag,n,AP,lda,x,incx,batchCount) & bind(c, name="hipblasZtrmvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasStrmvBatched_64 function hipblasStrmvBatched_64_(handle,uplo,transA,diag,n,AP,lda,x,incx,batchCount) & bind(c, name="hipblasStrmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtrmvBatched_64 function hipblasDtrmvBatched_64_(handle,uplo,transA,diag,n,AP,lda,x,incx,batchCount) & bind(c, name="hipblasDtrmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtrmvBatched_64 function hipblasCtrmvBatched_64_(handle,uplo,transA,diag,n,AP,lda,x,incx,batchCount) & bind(c, name="hipblasCtrmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtrmvBatched_64 function hipblasZtrmvBatched_64_(handle,uplo,transA,diag,n,AP,lda,x,incx,batchCount) & bind(c, name="hipblasZtrmvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The trmvStridedBatched functions perform one of the matrix-vector operations: !> !> x_i = A_i*x_i or x_i = A**T*x_i, 0 ≤ i < batchCount !> !> where ``x_i`` is an ``n`` -element vector and ``A_i`` is an ``n`` by ``n`` (unit, or !> non-unit, upper or lower triangular) matrix, !> with strides specifying how to retrieve ``$x_i$`` (resp. ``$A_i$`` ) from ``$x_{i-1}$`` !> (resp. ``$A_i$`` ). !> !> The vectors ``x_i`` are overwritten. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: A_i is assumed to be unit triangular. !> - HIPBLAS_DIAG_NON_UNIT: A_i is not assumed to be unit triangular. !> !> @param[in] n - [int] !> n specifies the number of rows of matrices A_i. n >= 0. !> !> @param[in] AP - device pointer of the matrix A_0, !> of dimension ( lda, n ). !> !> @param[in] lda - [int] !> specifies the leading dimension of A_i. !> lda >= max( 1, n ). !> !> @param[in] strideA - [hipblasStride] !> stride from the start of one A_i matrix to the next A_{i + 1}. !> !> @param[in] x - device pointer storing the vector x_0. !> !> @param[in] incx - [int] !> specifies the increment for the elements of one vector x. !> !> @param[in] stridex - [hipblasStride] !> stride from the start of one x_i vector to the next x_{i + 1}. !> !> @param[in] batchCount - [int] !> The number of batched matrices/vectors. #ifndef USE_CUDA_NAMES interface hipblasStrmvStridedBatched function hipblasStrmvStridedBatched_(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasStrmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasStrmvStridedBatched_assumed_rank #else module procedure & hipblasStrmvStridedBatched_rank_0,& hipblasStrmvStridedBatched_rank_1,& hipblasStrmvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtrmvStridedBatched function hipblasDtrmvStridedBatched_(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasDtrmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDtrmvStridedBatched_assumed_rank #else module procedure & hipblasDtrmvStridedBatched_rank_0,& hipblasDtrmvStridedBatched_rank_1,& hipblasDtrmvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtrmvStridedBatched function hipblasCtrmvStridedBatched_(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasCtrmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCtrmvStridedBatched_assumed_rank #else module procedure & hipblasCtrmvStridedBatched_rank_0,& hipblasCtrmvStridedBatched_rank_1,& hipblasCtrmvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtrmvStridedBatched function hipblasZtrmvStridedBatched_(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasZtrmvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZtrmvStridedBatched_assumed_rank #else module procedure & hipblasZtrmvStridedBatched_rank_0,& hipblasZtrmvStridedBatched_rank_1,& hipblasZtrmvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasStrmvStridedBatched_64 function hipblasStrmvStridedBatched_64_(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasStrmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtrmvStridedBatched_64 function hipblasDtrmvStridedBatched_64_(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasDtrmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtrmvStridedBatched_64 function hipblasCtrmvStridedBatched_64_(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasCtrmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtrmvStridedBatched_64 function hipblasZtrmvStridedBatched_64_(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasZtrmvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The trsv functions solve: !> !> A*x = b or A**T*x = b, !> !> where ``x`` and ``b`` are vectors and ``A`` is a triangular matrix. !> !> The vector ``x`` is overwritten on ``b``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular. !> - HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular. !> !> @param[in] n - [int] !> n specifies the number of rows of b. n >= 0. !> !> @param[in] AP - device pointer storing matrix A, !> of dimension ( lda, n ). !> !> @param[in] lda - [int] !> specifies the leading dimension of A. !> lda = max( 1, n ). !> !> @param[in] x - device pointer storing vector x. !> !> @param[in] incx - [int] !> specifies the increment for the elements of x. interface hipblasStrsv #ifdef USE_CUDA_NAMES function hipblasStrsv_(handle,uplo,transA,diag,n,AP,lda,x,incx) bind(c, name="cublasStrsv_v2") #else function hipblasStrsv_(handle,uplo,transA,diag,n,AP,lda,x,incx) bind(c, name="hipblasStrsv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasStrsv_assumed_rank #else module procedure & hipblasStrsv_rank_0,& hipblasStrsv_rank_1,& hipblasStrsv_full_rank #endif #endif end interface interface hipblasDtrsv #ifdef USE_CUDA_NAMES function hipblasDtrsv_(handle,uplo,transA,diag,n,AP,lda,x,incx) bind(c, name="cublasDtrsv_v2") #else function hipblasDtrsv_(handle,uplo,transA,diag,n,AP,lda,x,incx) bind(c, name="hipblasDtrsv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDtrsv_assumed_rank #else module procedure & hipblasDtrsv_rank_0,& hipblasDtrsv_rank_1,& hipblasDtrsv_full_rank #endif #endif end interface interface hipblasCtrsv #ifdef USE_CUDA_NAMES function hipblasCtrsv_(handle,uplo,transA,diag,n,AP,lda,x,incx) bind(c, name="cublasCtrsv_v2") #else function hipblasCtrsv_(handle,uplo,transA,diag,n,AP,lda,x,incx) bind(c, name="hipblasCtrsv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCtrsv_assumed_rank #else module procedure & hipblasCtrsv_rank_0,& hipblasCtrsv_rank_1,& hipblasCtrsv_full_rank #endif #endif end interface interface hipblasZtrsv #ifdef USE_CUDA_NAMES function hipblasZtrsv_(handle,uplo,transA,diag,n,AP,lda,x,incx) bind(c, name="cublasZtrsv_v2") #else function hipblasZtrsv_(handle,uplo,transA,diag,n,AP,lda,x,incx) bind(c, name="hipblasZtrsv") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsv_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZtrsv_assumed_rank #else module procedure & hipblasZtrsv_rank_0,& hipblasZtrsv_rank_1,& hipblasZtrsv_full_rank #endif #endif end interface interface hipblasStrsv_64 #ifdef USE_CUDA_NAMES function hipblasStrsv_64_(handle,uplo,transA,diag,n,AP,lda,x,incx) & bind(c, name="cublasStrsv_v2_64") #else function hipblasStrsv_64_(handle,uplo,transA,diag,n,AP,lda,x,incx) & bind(c, name="hipblasStrsv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasDtrsv_64 #ifdef USE_CUDA_NAMES function hipblasDtrsv_64_(handle,uplo,transA,diag,n,AP,lda,x,incx) & bind(c, name="cublasDtrsv_v2_64") #else function hipblasDtrsv_64_(handle,uplo,transA,diag,n,AP,lda,x,incx) & bind(c, name="hipblasDtrsv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasCtrsv_64 #ifdef USE_CUDA_NAMES function hipblasCtrsv_64_(handle,uplo,transA,diag,n,AP,lda,x,incx) & bind(c, name="cublasCtrsv_v2_64") #else function hipblasCtrsv_64_(handle,uplo,transA,diag,n,AP,lda,x,incx) & bind(c, name="hipblasCtrsv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface hipblasZtrsv_64 #ifdef USE_CUDA_NAMES function hipblasZtrsv_64_(handle,uplo,transA,diag,n,AP,lda,x,incx) & bind(c, name="cublasZtrsv_v2_64") #else function hipblasZtrsv_64_(handle,uplo,transA,diag,n,AP,lda,x,incx) & bind(c, name="hipblasZtrsv_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsv_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface !> \brief BLAS Level 2 API !> !> \details !> The trsvBatched functions solve: !> !> A_i*x_i = b_i or A_i**T*x_i = b_i, !> !> where ``(A_i, x_i, b_i)`` is the ``i``-th instance of the batch, !> ``x_i`` and ``b_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` triangular matrix. !> !> The vector ``x`` is overwritten on ``b``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular. !> - HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular. !> !> @param[in] n - [int] !> n specifies the number of rows of b. n >= 0. !> !> @param[in] AP - device array of device pointers storing each matrix A_i. !> !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. !> lda = max(1, n). !> !> @param[in] x - device array of device pointers storing each vector x_i. !> !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> !> @param[in] batchCount - [int] !> number of instances in the batch #ifndef USE_CUDA_NAMES interface hipblasStrsvBatched function hipblasStrsvBatched_(handle,uplo,transA,diag,n,AP,lda,x,incx,batchCount) & bind(c, name="hipblasStrsvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtrsvBatched function hipblasDtrsvBatched_(handle,uplo,transA,diag,n,AP,lda,x,incx,batchCount) & bind(c, name="hipblasDtrsvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtrsvBatched function hipblasCtrsvBatched_(handle,uplo,transA,diag,n,AP,lda,x,incx,batchCount) & bind(c, name="hipblasCtrsvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtrsvBatched function hipblasZtrsvBatched_(handle,uplo,transA,diag,n,AP,lda,x,incx,batchCount) & bind(c, name="hipblasZtrsvBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsvBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasStrsvBatched_64 function hipblasStrsvBatched_64_(handle,uplo,transA,diag,n,AP,lda,x,incx,batchCount) & bind(c, name="hipblasStrsvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtrsvBatched_64 function hipblasDtrsvBatched_64_(handle,uplo,transA,diag,n,AP,lda,x,incx,batchCount) & bind(c, name="hipblasDtrsvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtrsvBatched_64 function hipblasCtrsvBatched_64_(handle,uplo,transA,diag,n,AP,lda,x,incx,batchCount) & bind(c, name="hipblasCtrsvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtrsvBatched_64 function hipblasZtrsvBatched_64_(handle,uplo,transA,diag,n,AP,lda,x,incx,batchCount) & bind(c, name="hipblasZtrsvBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsvBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 2 API !> !> \details !> The trsvStridedBatched functions solve: !> !> A_i*x_i = b_i or A_i**T*x_i = b_i, !> !> where ``(A_i, x_i, b_i)`` is the ``i``-th instance of the batch, !> ``x_i`` and ``b_i`` are vectors, and ``A_i`` is an ``n`` by ``n`` triangular matrix, for !> ``i`` = 1, ..., ``batchCount``. !> !> The vector ``x`` is overwritten on ``b``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular. !> - HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular. !> !> @param[in] n - [int] !> n specifies the number of rows of each b_i. n >= 0. !> !> @param[in] AP - device pointer to the first matrix (A_1) in the batch, of dimension ( lda, !> n ). !> !> @param[in] strideA - [hipblasStride] !> stride from the start of one A_i matrix to the next A_(i + 1). !> !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. !> lda = max( 1, n ). !> !> @param[in, out] x - device pointer to the first vector (x_1) in the batch. !> !> @param[in] stridex - [hipblasStride] !> stride from the start of one x_i vector to the next x_(i + 1). !> !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasStrsvStridedBatched function hipblasStrsvStridedBatched_(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasStrsvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasStrsvStridedBatched_assumed_rank #else module procedure & hipblasStrsvStridedBatched_rank_0,& hipblasStrsvStridedBatched_rank_1,& hipblasStrsvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtrsvStridedBatched function hipblasDtrsvStridedBatched_(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasDtrsvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDtrsvStridedBatched_assumed_rank #else module procedure & hipblasDtrsvStridedBatched_rank_0,& hipblasDtrsvStridedBatched_rank_1,& hipblasDtrsvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtrsvStridedBatched function hipblasCtrsvStridedBatched_(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasCtrsvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCtrsvStridedBatched_assumed_rank #else module procedure & hipblasCtrsvStridedBatched_rank_0,& hipblasCtrsvStridedBatched_rank_1,& hipblasCtrsvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtrsvStridedBatched function hipblasZtrsvStridedBatched_(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx,stridex, & batchCount) & bind(c, name="hipblasZtrsvStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsvStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZtrsvStridedBatched_assumed_rank #else module procedure & hipblasZtrsvStridedBatched_rank_0,& hipblasZtrsvStridedBatched_rank_1,& hipblasZtrsvStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasStrsvStridedBatched_64 function hipblasStrsvStridedBatched_64_(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasStrsvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtrsvStridedBatched_64 function hipblasDtrsvStridedBatched_64_(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasDtrsvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtrsvStridedBatched_64 function hipblasCtrsvStridedBatched_64_(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasCtrsvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtrsvStridedBatched_64 function hipblasZtrsvStridedBatched_64_(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) & bind(c, name="hipblasZtrsvStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsvStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> The gemm functions perform one of the matrix-matrix operations: !> !> C = alpha*op( A )*op( B ) + beta*C, !> !> where op( X ) is one of: !> !> op( X ) = X or !> op( X ) = X**T or !> op( X ) = X**H, !> !> ``alpha`` and ``beta`` are scalars, and ``A``, ``B``, and ``C`` are matrices, with !> ``op( A )`` an ``m`` by ``k`` matrix, ``op( B )`` a ``k`` by ``n`` matrix, and ``C`` an !> ``m`` by ``n`` matrix. !> !> - Supported precisions in rocBLAS : ``h``, ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``h``, ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] transA - [hipblasOperation_t] !> specifies the form of op( A ). !> @param[in] transB - [hipblasOperation_t] !> specifies the form of op( B ). !> @param[in] m - [int] !> number or rows of matrices op( A ) and C. !> @param[in] n - [int] !> number of columns of matrices op( B ) and C. !> @param[in] k - [int] !> number of columns of matrix op( A ) and number of rows of matrix op( B ). !> @param[in] alpha - device pointer or host pointer specifying the scalar alpha. !> @param[in] AP - device pointer storing matrix A. !> @param[in] lda - [int] !> specifies the leading dimension of A. !> @param[in] BP - device pointer storing matrix B. !> @param[in] ldb - [int] !> specifies the leading dimension of B. !> @param[in] beta - device pointer or host pointer specifying the scalar beta. !> @param[in, out] CP - device pointer storing matrix C on the GPU. !> @param[in] ldc - [int] !> specifies the leading dimension of C. interface hipblasHgemm #ifdef USE_CUDA_NAMES function hipblasHgemm_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasHgemm") #else function hipblasHgemm_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasHgemm") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb type(c_ptr),value :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function end interface interface hipblasSgemm #ifdef USE_CUDA_NAMES function hipblasSgemm_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasSgemm_v2") #else function hipblasSgemm_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasSgemm") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSgemm_assumed_rank #else module procedure & hipblasSgemm_rank_0,& hipblasSgemm_rank_1,& hipblasSgemm_full_rank #endif #endif end interface interface hipblasDgemm #ifdef USE_CUDA_NAMES function hipblasDgemm_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasDgemm_v2") #else function hipblasDgemm_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasDgemm") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDgemm_assumed_rank #else module procedure & hipblasDgemm_rank_0,& hipblasDgemm_rank_1,& hipblasDgemm_full_rank #endif #endif end interface interface hipblasCgemm #ifdef USE_CUDA_NAMES function hipblasCgemm_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasCgemm_v2") #else function hipblasCgemm_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasCgemm") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCgemm_assumed_rank #else module procedure & hipblasCgemm_rank_0,& hipblasCgemm_rank_1,& hipblasCgemm_full_rank #endif #endif end interface interface hipblasZgemm #ifdef USE_CUDA_NAMES function hipblasZgemm_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasZgemm_v2") #else function hipblasZgemm_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasZgemm") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZgemm_assumed_rank #else module procedure & hipblasZgemm_rank_0,& hipblasZgemm_rank_1,& hipblasZgemm_full_rank #endif #endif end interface interface hipblasHgemm_64 #ifdef USE_CUDA_NAMES function hipblasHgemm_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasHgemm_64") #else function hipblasHgemm_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasHgemm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHgemm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb type(c_ptr),value :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasSgemm_64 #ifdef USE_CUDA_NAMES function hipblasSgemm_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasSgemm_v2_64") #else function hipblasSgemm_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasSgemm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasDgemm_64 #ifdef USE_CUDA_NAMES function hipblasDgemm_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasDgemm_v2_64") #else function hipblasDgemm_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasDgemm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasCgemm_64 #ifdef USE_CUDA_NAMES function hipblasCgemm_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasCgemm_v2_64") #else function hipblasCgemm_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasCgemm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasZgemm_64 #ifdef USE_CUDA_NAMES function hipblasZgemm_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasZgemm_v2_64") #else function hipblasZgemm_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasZgemm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> The gemmBatched functions perform one of the batched matrix-matrix operations: !> !> C_i = alpha*op( A_i )*op( B_i ) + beta*C_i, for i = 1, ..., batchCount. !> !> where ``op( X )`` is one of: !> !> op( X ) = X or !> op( X ) = X**T or !> op( X ) = X**H, !> !> ``alpha`` and ``beta`` are scalars, and ``A``, ``B`` , and ``C`` are strided batched !> matrices, with !> ``op( A )`` an ``m`` by ``k`` by ``batchCount`` strided_batched matrix, !> ``op( B )`` a ``k`` by ``n`` by ``batchCount`` strided_batched matrix, and !> ``C`` an ``m`` by ``n`` by ``batchCount`` strided_batched matrix. !> !> - Supported precisions in rocBLAS : ``h``, ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``h``, ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] transA - [hipblasOperation_t] !> specifies the form of op( A ). !> @param[in] transB - [hipblasOperation_t] !> specifies the form of op( B ). !> @param[in] m - [int] !> matrix dimension m. !> @param[in] n - [int] !> matrix dimension n. !> @param[in] k - [int] !> matrix dimension k. !> @param[in] alpha - device pointer or host pointer specifying the scalar alpha. !> @param[in] AP - device array of device pointers storing each matrix A_i. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. !> @param[in] BP - device array of device pointers storing each matrix B_i. !> @param[in] ldb - [int] !> specifies the leading dimension of each B_i. !> @param[in] beta - device pointer or host pointer specifying the scalar beta. !> @param[in, out] CP - device array of device pointers storing each matrix C_i. !> @param[in] ldc - [int] !> specifies the leading dimension of each C_i. !> @param[in] batchCount !> [int] !> number of gemm operations in the batch. interface hipblasHgemmBatched #ifdef USE_CUDA_NAMES function hipblasHgemmBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="cublasHgemmBatched") #else function hipblasHgemmBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasHgemmBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb type(c_ptr),value :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface interface hipblasSgemmBatched #ifdef USE_CUDA_NAMES function hipblasSgemmBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="cublasSgemmBatched") #else function hipblasSgemmBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasSgemmBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface interface hipblasDgemmBatched #ifdef USE_CUDA_NAMES function hipblasDgemmBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="cublasDgemmBatched") #else function hipblasDgemmBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasDgemmBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface interface hipblasCgemmBatched #ifdef USE_CUDA_NAMES function hipblasCgemmBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="cublasCgemmBatched") #else function hipblasCgemmBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasCgemmBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface interface hipblasZgemmBatched #ifdef USE_CUDA_NAMES function hipblasZgemmBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="cublasZgemmBatched") #else function hipblasZgemmBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasZgemmBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface interface hipblasHgemmBatched_64 #ifdef USE_CUDA_NAMES function hipblasHgemmBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="cublasHgemmBatched_64") #else function hipblasHgemmBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasHgemmBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHgemmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb type(c_ptr),value :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface interface hipblasSgemmBatched_64 #ifdef USE_CUDA_NAMES function hipblasSgemmBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="cublasSgemmBatched_64") #else function hipblasSgemmBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasSgemmBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface interface hipblasDgemmBatched_64 #ifdef USE_CUDA_NAMES function hipblasDgemmBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="cublasDgemmBatched_64") #else function hipblasDgemmBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasDgemmBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface interface hipblasCgemmBatched_64 #ifdef USE_CUDA_NAMES function hipblasCgemmBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="cublasCgemmBatched_64") #else function hipblasCgemmBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasCgemmBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface interface hipblasZgemmBatched_64 #ifdef USE_CUDA_NAMES function hipblasZgemmBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="cublasZgemmBatched_64") #else function hipblasZgemmBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasZgemmBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface !> \brief BLAS Level 3 API !> !> \details !> The gemmStridedBatched functions perform one of the strided batched matrix-matrix !> operations: !> !> C_i = alpha*op( A_i )*op( B_i ) + beta*C_i, for i = 1, ..., batchCount !> !> where ``op( X )`` is one of: !> !> op( X ) = X or !> op( X ) = X**T or !> op( X ) = X**H, !> !> ``alpha`` and ``beta`` are scalars, and ``A``, ``B``, and ``C`` are strided batched !> matrices, with !> ``op( A )`` an ``m`` by ``k`` by ``batchCount`` strided_batched matrix, !> ``op( B )`` a ``k`` by ``n`` by ``batchCount`` strided_batched matrix, and !> ``C`` an ``m`` by ``n`` by ``batchCount`` strided_batched matrix. !> !> - Supported precisions in rocBLAS : ``h``, ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``h``, ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] transA - [hipblasOperation_t] !> specifies the form of op( A ). !> @param[in] transB - [hipblasOperation_t] !> specifies the form of op( B ). !> @param[in] m - [int] !> matrix dimension m. !> @param[in] n - [int] !> matrix dimension n. !> @param[in] k - [int] !> matrix dimension k. !> @param[in] alpha - device pointer or host pointer specifying the scalar alpha. !> @param[in] AP - device pointer pointing to the first matrix A_1. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. !> @param[in] strideA - [hipblasStride] !> stride from the start of one A_i matrix to the next A_(i + 1). !> @param[in] BP - device pointer pointing to the first matrix B_1. !> @param[in] ldb - [int] !> specifies the leading dimension of each B_i. !> @param[in] strideB - [hipblasStride] !> stride from the start of one B_i matrix to the next B_(i + 1). !> @param[in] beta - device pointer or host pointer specifying the scalar beta. !> @param[in, out] CP - device pointer pointing to the first matrix C_1. !> @param[in] ldc - [int] !> specifies the leading dimension of each C_i. !> @param[in] strideC - [hipblasStride] !> stride from the start of one C_i matrix to the next C_(i + 1). !> @param[in] batchCount !> [int] !> number of gemm operatons in the batch. interface hipblasHgemmStridedBatched #ifdef USE_CUDA_NAMES function hipblasHgemmStridedBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="cublasHgemmStridedBatched") #else function hipblasHgemmStridedBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasHgemmStridedBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function end interface interface hipblasSgemmStridedBatched #ifdef USE_CUDA_NAMES function hipblasSgemmStridedBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="cublasSgemmStridedBatched") #else function hipblasSgemmStridedBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasSgemmStridedBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSgemmStridedBatched_assumed_rank #else module procedure & hipblasSgemmStridedBatched_rank_0,& hipblasSgemmStridedBatched_rank_1,& hipblasSgemmStridedBatched_full_rank #endif #endif end interface interface hipblasDgemmStridedBatched #ifdef USE_CUDA_NAMES function hipblasDgemmStridedBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="cublasDgemmStridedBatched") #else function hipblasDgemmStridedBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasDgemmStridedBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDgemmStridedBatched_assumed_rank #else module procedure & hipblasDgemmStridedBatched_rank_0,& hipblasDgemmStridedBatched_rank_1,& hipblasDgemmStridedBatched_full_rank #endif #endif end interface interface hipblasCgemmStridedBatched #ifdef USE_CUDA_NAMES function hipblasCgemmStridedBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="cublasCgemmStridedBatched") #else function hipblasCgemmStridedBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasCgemmStridedBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCgemmStridedBatched_assumed_rank #else module procedure & hipblasCgemmStridedBatched_rank_0,& hipblasCgemmStridedBatched_rank_1,& hipblasCgemmStridedBatched_full_rank #endif #endif end interface interface hipblasZgemmStridedBatched #ifdef USE_CUDA_NAMES function hipblasZgemmStridedBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="cublasZgemmStridedBatched") #else function hipblasZgemmStridedBatched_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasZgemmStridedBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZgemmStridedBatched_assumed_rank #else module procedure & hipblasZgemmStridedBatched_rank_0,& hipblasZgemmStridedBatched_rank_1,& hipblasZgemmStridedBatched_full_rank #endif #endif end interface interface hipblasHgemmStridedBatched_64 #ifdef USE_CUDA_NAMES function hipblasHgemmStridedBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="cublasHgemmStridedBatched_64") #else function hipblasHgemmStridedBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasHgemmStridedBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHgemmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface interface hipblasSgemmStridedBatched_64 #ifdef USE_CUDA_NAMES function hipblasSgemmStridedBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="cublasSgemmStridedBatched_64") #else function hipblasSgemmStridedBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasSgemmStridedBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface interface hipblasDgemmStridedBatched_64 #ifdef USE_CUDA_NAMES function hipblasDgemmStridedBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="cublasDgemmStridedBatched_64") #else function hipblasDgemmStridedBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasDgemmStridedBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface interface hipblasCgemmStridedBatched_64 #ifdef USE_CUDA_NAMES function hipblasCgemmStridedBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="cublasCgemmStridedBatched_64") #else function hipblasCgemmStridedBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasCgemmStridedBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface interface hipblasZgemmStridedBatched_64 #ifdef USE_CUDA_NAMES function hipblasZgemmStridedBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="cublasZgemmStridedBatched_64") #else function hipblasZgemmStridedBatched_64_(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasZgemmStridedBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface !> \brief BLAS Level 3 API !> !> \details !> !> The herk functions perform one of the matrix-matrix operations for a Hermitian rank-k !> update: !> !> C := alpha*op( A )*op( A )^H + beta*C !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` is an ``n`` by ``k`` matrix, and !> ``C`` is an ``n`` x ``n`` Hermitian matrix stored as either upper or lower. !> !> op( A ) = A, and A is n by k if transA == HIPBLAS_OP_N !> op( A ) = A^H and A is k by n if transA == HIPBLAS_OP_C !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : ``c`` and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: C is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: C is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_C: op(A) = A^H !> - HIPBLAS_ON_N: op(A) = A !> !> @param[in] n - [int] !> n specifies the number of rows and columns of C. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and A does not need to be set before !> entry. !> !> @param[in] AP - pointer storing matrix A on the GPU. !> Matrix dimension is ( lda, k ) when transA = HIPBLAS_OP_N. Otherwise, (lda, n). !> Only the upper/lower triangular part is accessed. !> !> @param[in] lda - [int] !> lda specifies the first dimension of A. !> If transA = HIPBLAS_OP_N, lda >= max( 1, n ). !> Otherwise, lda >= max( 1, k ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - pointer storing matrix C on the GPU. !> The imaginary component of the diagonal elements are not used but are set to zero, !> except for quick return. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). interface hipblasCherk #ifdef USE_CUDA_NAMES function hipblasCherk_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="cublasCherk_v2") #else function hipblasCherk_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="hipblasCherk") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherk_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCherk_assumed_rank #else module procedure & hipblasCherk_rank_0,& hipblasCherk_rank_1,& hipblasCherk_full_rank #endif #endif end interface interface hipblasZherk #ifdef USE_CUDA_NAMES function hipblasZherk_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="cublasZherk_v2") #else function hipblasZherk_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="hipblasZherk") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherk_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZherk_assumed_rank #else module procedure & hipblasZherk_rank_0,& hipblasZherk_rank_1,& hipblasZherk_full_rank #endif #endif end interface interface hipblasCherk_64 #ifdef USE_CUDA_NAMES function hipblasCherk_64_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="cublasCherk_v2_64") #else function hipblasCherk_64_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="hipblasCherk_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherk_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasZherk_64 #ifdef USE_CUDA_NAMES function hipblasZherk_64_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="cublasZherk_v2_64") #else function hipblasZherk_64_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="hipblasZherk_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherk_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> !> The herkBatched functions perform a batch of the matrix-matrix operations for a Hermitian !> rank-k update: !> !> C_i := alpha*op( A_i )*op( A_i )^H + beta*C_i !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` is an ``n`` by ``k`` matrix, and !> ``C_i`` is an ``n`` x ``n`` Hermitian matrix stored as either upper or lower. !> !> op( A_i ) = A_i, and A_i is n by k if transA == HIPBLAS_OP_N !> op( A_i ) = A_i^H and A_i is k by n if transA == HIPBLAS_OP_C !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_C: op(A) = A^H !> - HIPBLAS_OP_N: op(A) = A !> !> @param[in] n - [int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and A does not need to be set before !> entry. !> !> @param[in] AP - device array of device pointers storing each matrix_i A of dimension (lda, !> k) !> when transA is HIPBLAS_OP_N. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [int] !> lda specifies the first dimension of A_i. !> If transA = HIPBLAS_OP_N, lda >= max( 1, n ). !> Otherwise, lda >= max( 1, k ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - device array of device pointers storing each matrix C_i on the GPU. !> The imaginary components of the diagonal elements are not used but are set to zero, !> except for quick return. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasCherkBatched function hipblasCherkBatched_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc,batchCount) & bind(c, name="hipblasCherkBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZherkBatched function hipblasZherkBatched_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc,batchCount) & bind(c, name="hipblasZherkBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCherkBatched_64 function hipblasCherkBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc,batchCount) & bind(c, name="hipblasCherkBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZherkBatched_64 function hipblasZherkBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc,batchCount) & bind(c, name="hipblasZherkBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> !> The herkStridedBatched functions perform a batch of the matrix-matrix operations for a !> Hermitian rank-k update: !> !> C_i := alpha*op( A_i )*op( A_i )^H + beta*C_i !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` is an ``n`` by ``k`` matrix, and !> ``C_i`` is an ``n`` by ``n`` Hermitian matrix stored as either upper or lower. !> !> op( A_i ) = A_i, and A_i is n by k if transA == HIPBLAS_OP_N !> op( A_i ) = A_i^H and A_i is k by n if transA == HIPBLAS_OP_C !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_C: op(A) = A^H !> - HIPBLAS_OP_N: op(A) = A !> !> @param[in] n - [int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and A does not need to be set before !> entry. !> !> @param[in] AP - Device pointer to the first matrix A_1 on the GPU of dimension (lda, k) !> when transA is HIPBLAS_OP_N. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [int] !> lda specifies the first dimension of A_i. !> If transA = HIPBLAS_OP_N, lda >= max( 1, n ). !> Otherwise, lda >= max( 1, k ). !> !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - Device pointer to the first matrix C_1 on the GPU. !> The imaginary components of the diagonal elements are not used but are set to zero, !> except for quick return. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> !> @param[inout] strideC - [hipblasStride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasCherkStridedBatched function hipblasCherkStridedBatched_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta,CP,ldc, & strideC,batchCount) & bind(c, name="hipblasCherkStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCherkStridedBatched_assumed_rank #else module procedure & hipblasCherkStridedBatched_rank_0,& hipblasCherkStridedBatched_rank_1,& hipblasCherkStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZherkStridedBatched function hipblasZherkStridedBatched_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta,CP,ldc, & strideC,batchCount) & bind(c, name="hipblasZherkStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZherkStridedBatched_assumed_rank #else module procedure & hipblasZherkStridedBatched_rank_0,& hipblasZherkStridedBatched_rank_1,& hipblasZherkStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCherkStridedBatched_64 function hipblasCherkStridedBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta,CP, & ldc,strideC,batchCount) & bind(c, name="hipblasCherkStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZherkStridedBatched_64 function hipblasZherkStridedBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta,CP, & ldc,strideC,batchCount) & bind(c, name="hipblasZherkStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> !> The herkx functions perform one of the matrix-matrix operations for a Hermitian rank-k !> update: !> !> C := alpha*op( A )*op( B )^H + beta*C !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` and ``op(B)`` are ``n`` by ``k`` !> matrices, and !> ``C`` is an ``n`` by ``n`` Hermitian matrix stored as either upper or lower. !> This routine should only be used when the caller can guarantee that the result of !> ``op( A )*op( B )^T`` will be Hermitian. !> !> op( A ) = A, op( B ) = B, and A and B are n by k if trans == HIPBLAS_OP_N !> op( A ) = A^H, op( B ) = B^H, and A and B are k by n if trans == HIPBLAS_OP_C !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : ``c`` and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: C is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: C is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_C: op( A ) = A^H, op( B ) = B^H !> - HIPBLAS_OP_N: op( A ) = A, op( B ) = B !> !> @param[in] n - [int] !> n specifies the number of rows and columns of C. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and does not need to be set before !> entry. !> !> @param[in] AP - pointer storing matrix A on the GPU. !> Matrix dimension is ( lda, k ) when trans = HIPBLAS_OP_N. Otherwise, (lda, n). !> Only the upper/lower triangular part is accessed. !> !> @param[in] lda - [int] !> lda specifies the first dimension of A. !> if trans = HIPBLAS_OP_N, lda >= max( 1, n ). !> Otherwise, lda >= max( 1, k ). !> @param[in] BP - pointer storing matrix B on the GPU. !> Matrix dimension is ( ldb, k ) when trans = HIPBLAS_OP_N. Otherwise, (ldb, n). !> Only the upper/lower triangular part is accessed. !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B. !> If trans = HIPBLAS_OP_N, ldb >= max( 1, n ). !> Otherwise, ldb >= max( 1, k ). !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - pointer storing matrix C on the GPU. !> The imaginary components of the diagonal elements are not used but are set to zero, !> except for quick return. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). interface hipblasCherkx #ifdef USE_CUDA_NAMES function hipblasCherkx_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasCherkx") #else function hipblasCherkx_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasCherkx") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkx_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCherkx_assumed_rank #else module procedure & hipblasCherkx_rank_0,& hipblasCherkx_rank_1,& hipblasCherkx_full_rank #endif #endif end interface interface hipblasZherkx #ifdef USE_CUDA_NAMES function hipblasZherkx_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasZherkx") #else function hipblasZherkx_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasZherkx") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkx_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZherkx_assumed_rank #else module procedure & hipblasZherkx_rank_0,& hipblasZherkx_rank_1,& hipblasZherkx_full_rank #endif #endif end interface interface hipblasCherkx_64 #ifdef USE_CUDA_NAMES function hipblasCherkx_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasCherkx_64") #else function hipblasCherkx_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasCherkx_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkx_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasZherkx_64 #ifdef USE_CUDA_NAMES function hipblasZherkx_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasZherkx_64") #else function hipblasZherkx_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasZherkx_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkx_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> !> The herkxBatched functions perform a batch of the matrix-matrix operations for a Hermitian !> rank-k update: !> !> C_i := alpha*op( A_i )*op( B_i )^H + beta*C_i !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` !> matrices, and !> ``C_i`` is an ``n`` by ``n`` Hermitian matrix stored as either upper or lower. !> This routine should only be used when the caller can guarantee that the result of !> ``op( A )*op( B )^T`` will be Hermitian. !> !> op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == HIPBLAS_OP_N !> op( A_i ) = A_i^H, op( B_i ) = B_i^H, and A_i and B_i are k by n if trans == !> HIPBLAS_OP_C !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_C: op(A) = A^H !> - HIPBLAS_OP_N: op(A) = A !> !> @param[in] n - [int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and does not need to be set before !> entry. !> !> @param[in] AP - device array of device pointers storing each matrix_i A of dimension (lda, !> k) !> when trans is HIPBLAS_OP_N. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [int] !> lda specifies the first dimension of A_i. !> If trans = HIPBLAS_OP_N, lda >= max( 1, n ). !> Otherwise, lda >= max( 1, k ). !> !> @param[in] BP - device array of device pointers storing each matrix_i B of dimension (ldb, !> k) !> when trans is HIPBLAS_OP_N. Otherwise, of dimension (ldb, n). !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B_i. !> If trans = HIPBLAS_OP_N, ldb >= max( 1, n ). !> Otherwise, ldb >= max( 1, k ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - device array of device pointers storing each matrix C_i on the GPU. !> The imaginary components of the diagonal elements are not used but are set to zero, !> except for quick return. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasCherkxBatched function hipblasCherkxBatched_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasCherkxBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkxBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZherkxBatched function hipblasZherkxBatched_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasZherkxBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkxBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCherkxBatched_64 function hipblasCherkxBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasCherkxBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkxBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZherkxBatched_64 function hipblasZherkxBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasZherkxBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkxBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> !> The herkxStridedBatched functions perform a batch of the matrix-matrix operations for a !> Hermitian rank-k update: !> !> C_i := alpha*op( A_i )*op( B_i )^H + beta*C_i !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` !> matrices, and !> ``C_i`` is an ``n`` by ``n`` Hermitian matrix stored as either upper or lower. !> This routine should only be used when the caller can guarantee that the result of !> ``op( A )*op( B )^T`` will be Hermitian. !> !> op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == HIPBLAS_OP_N !> op( A_i ) = A_i^H, op( B_i ) = B_i^H, and A_i and B_i are k by n if trans == !> HIPBLAS_OP_C !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_C: op( A_i ) = A_i^H, op( B_i ) = B_i^H !> - HIPBLAS_OP_N: op( A_i ) = A_i, op( B_i ) = B_i !> !> @param[in] n - [int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and does not need to be set before !> entry. !> !> @param[in] AP - Device pointer to the first matrix A_1 on the GPU of dimension (lda, k) !> when trans is HIPBLAS_OP_N. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [int] !> lda specifies the first dimension of A_i. !> If trans = HIPBLAS_OP_N, lda >= max( 1, n ). !> Otherwise, lda >= max( 1, k ). !> !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[in] BP - Device pointer to the first matrix B_1 on the GPU of dimension (ldb, k) !> when trans is HIPBLAS_OP_N. Otherwise, of dimension (ldb, n). !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B_i. !> If trans = HIPBLAS_OP_N, ldb >= max( 1, n ). !> Otherwise, ldb >= max( 1, k ). !> !> @param[in] strideB - [hipblasStride] !> stride from the start of one matrix (B_i) to the next one (B_i+1). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - Device pointer to the first matrix C_1 on the GPU. !> The imaginary components of the diagonal elements are not used but are set to zero, !> except for quick return. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> !> @param[inout] strideC - [hipblasStride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasCherkxStridedBatched function hipblasCherkxStridedBatched_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasCherkxStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkxStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCherkxStridedBatched_assumed_rank #else module procedure & hipblasCherkxStridedBatched_rank_0,& hipblasCherkxStridedBatched_rank_1,& hipblasCherkxStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZherkxStridedBatched function hipblasZherkxStridedBatched_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasZherkxStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkxStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZherkxStridedBatched_assumed_rank #else module procedure & hipblasZherkxStridedBatched_rank_0,& hipblasZherkxStridedBatched_rank_1,& hipblasZherkxStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCherkxStridedBatched_64 function hipblasCherkxStridedBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasCherkxStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkxStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZherkxStridedBatched_64 function hipblasZherkxStridedBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasZherkxStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkxStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> !> The her2k functions perform one of the matrix-matrix operations for a Hermitian rank-2k !> update: !> !> C := alpha*op( A )*op( B )^H + conj(alpha)*op( B )*op( A )^H + beta*C !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` and ``op(B)`` are ``n`` by ``k`` !> matrices, and !> ``C`` is an ``n`` by ``n`` Hermitian matrix stored as either upper or lower. !> !> op( A ) = A, op( B ) = B, and A and B are n by k if trans == HIPBLAS_OP_N !> op( A ) = A^H, op( B ) = B^H, and A and B are k by n if trans == HIPBLAS_OP_C !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : ``c`` and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: C is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: C is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_C: op( A ) = A^H, op( B ) = B^H !> - HIPBLAS_OP_N: op( A ) = A, op( B ) = B !> !> @param[in] n - [int] !> n specifies the number of rows and columns of C. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and does not need to be set before !> entry. !> !> @param[in] AP - pointer storing matrix A on the GPU. !> Matrix dimension is ( lda, k ) when trans = HIPBLAS_OP_N. Otherwise, (lda, n). !> Only the upper/lower triangular part is accessed. !> !> @param[in] lda - [int] !> lda specifies the first dimension of A. !> If trans = HIPBLAS_OP_N, lda >= max( 1, n ). !> Otherwise, lda >= max( 1, k ). !> @param[in] BP - pointer storing matrix B on the GPU. !> Matrix dimension is ( ldb, k ) when trans = HIPBLAS_OP_N. Otherwise, (ldb, n). !> Only the upper/lower triangular part is accessed. !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B. !> If trans = HIPBLAS_OP_N, ldb >= max( 1, n ). !> Otherwise, ldb >= max( 1, k ). !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - pointer storing matrix C on the GPU. !> The imaginary components of the diagonal elements are not used but are set to zero, !> except for quick return. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). interface hipblasCher2k #ifdef USE_CUDA_NAMES function hipblasCher2k_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasCher2k_v2") #else function hipblasCher2k_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasCher2k") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2k_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCher2k_assumed_rank #else module procedure & hipblasCher2k_rank_0,& hipblasCher2k_rank_1,& hipblasCher2k_full_rank #endif #endif end interface interface hipblasZher2k #ifdef USE_CUDA_NAMES function hipblasZher2k_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasZher2k_v2") #else function hipblasZher2k_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasZher2k") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2k_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZher2k_assumed_rank #else module procedure & hipblasZher2k_rank_0,& hipblasZher2k_rank_1,& hipblasZher2k_full_rank #endif #endif end interface interface hipblasCher2k_64 #ifdef USE_CUDA_NAMES function hipblasCher2k_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasCher2k_v2_64") #else function hipblasCher2k_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasCher2k_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2k_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasZher2k_64 #ifdef USE_CUDA_NAMES function hipblasZher2k_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasZher2k_v2_64") #else function hipblasZher2k_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasZher2k_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2k_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> !> The her2kBatched functions perform a batch of the matrix-matrix operations for a Hermitian !> rank-2k update: !> !> C_i := alpha*op( A_i )*op( B_i )^H + conj(alpha)*op( B_i )*op( A_i )^H + beta*C_i !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` !> matrices, and !> ``C_i`` is an ``n`` by ``n`` Hermitian matrix stored as either upper or lower. !> !> op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == HIPBLAS_OP_N !> op( A_i ) = A_i^H, op( B_i ) = B_i^H, and A_i and B_i are k by n if trans == !> HIPBLAS_OP_C !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_C: op(A) = A^H !> - HIPBLAS_OP_N: op(A) = A !> !> @param[in] n - [int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and does not need to be set before !> entry. !> !> @param[in] AP - device array of device pointers storing each matrix_i A of dimension (lda, !> k) !> when trans is HIPBLAS_OP_N. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [int] !> lda specifies the first dimension of A_i. !> If trans = HIPBLAS_OP_N, lda >= max( 1, n ). !> Otherwise, lda >= max( 1, k ). !> @param[in] BP - device array of device pointers storing each matrix_i B of dimension (ldb, !> k) !> when trans is HIPBLAS_OP_N. Otherwise, of dimension (ldb, n). !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B_i. !> If trans = HIPBLAS_OP_N, ldb >= max( 1, n ). !> Otherwise, ldb >= max( 1, k ). !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - device array of device pointers storing each matrix C_i on the GPU. !> The imaginary components of the diagonal elements are not used but are set to zero, !> except for quick return. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasCher2kBatched function hipblasCher2kBatched_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasCher2kBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2kBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZher2kBatched function hipblasZher2kBatched_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasZher2kBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2kBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCher2kBatched_64 function hipblasCher2kBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasCher2kBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2kBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZher2kBatched_64 function hipblasZher2kBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasZher2kBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2kBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> !> The her2kStridedBatched functions perform a batch of the matrix-matrix operations for a !> Hermitian rank-2k update: !> !> C_i := alpha*op( A_i )*op( B_i )^H + conj(alpha)*op( B_i )*op( A_i )^H + beta*C_i !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` !> matrices, and !> ``C_i`` is an ``n`` by ``n`` Hermitian matrix stored as either upper or lower. !> !> op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == HIPBLAS_OP_N !> op( A_i ) = A_i^H, op( B_i ) = B_i^H, and A_i and B_i are k by n if trans == !> HIPBLAS_OP_C !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_C: op( A_i ) = A_i^H, op( B_i ) = B_i^H !> - HIPBLAS_OP_N: op( A_i ) = A_i, op( B_i ) = B_i !> !> @param[in] n - [int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and does not need to be set before !> entry. !> !> @param[in] AP - Device pointer to the first matrix A_1 on the GPU of dimension (lda, k) !> when trans is HIPBLAS_OP_N. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [int] !> lda specifies the first dimension of A_i. !> if trans = HIPBLAS_OP_N, lda >= max( 1, n ). !> Otherwise, lda >= max( 1, k ). !> !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[in] BP - Device pointer to the first matrix B_1 on the GPU of dimension (ldb, k) !> when trans is HIPBLAS_OP_N. Otherwise, of dimension (ldb, n). !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B_i. !> If trans = HIPBLAS_OP_N, ldb >= max( 1, n ). !> Otherwise, ldb >= max( 1, k ). !> !> @param[in] strideB - [hipblasStride] !> stride from the start of one matrix (B_i) to the next one (B_i+1). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - Device pointer to the first matrix C_1 on the GPU. !> The imaginary components of the diagonal elements are not used but are set to zero, !> except for quick return. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> !> @param[inout] strideC - [hipblasStride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasCher2kStridedBatched function hipblasCher2kStridedBatched_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasCher2kStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2kStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCher2kStridedBatched_assumed_rank #else module procedure & hipblasCher2kStridedBatched_rank_0,& hipblasCher2kStridedBatched_rank_1,& hipblasCher2kStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZher2kStridedBatched function hipblasZher2kStridedBatched_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasZher2kStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2kStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZher2kStridedBatched_assumed_rank #else module procedure & hipblasZher2kStridedBatched_rank_0,& hipblasZher2kStridedBatched_rank_1,& hipblasZher2kStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCher2kStridedBatched_64 function hipblasCher2kStridedBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasCher2kStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2kStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZher2kStridedBatched_64 function hipblasZher2kStridedBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasZher2kStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2kStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> !> The symm functions perform one of the matrix-matrix operations: !> !> C := alpha*A*B + beta*C if side == HIPBLAS_SIDE_LEFT, !> C := alpha*B*A + beta*C if side == HIPBLAS_SIDE_RIGHT, !> !> where ``alpha`` and ``beta`` are scalars, ``B`` and ``C`` are ``m`` by ``n`` matrices, and !> ``A`` is a symmetric matrix stored as either upper or lower. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] side - [hipblasSideMode_t] !> - HIPBLAS_SIDE_LEFT: C := alpha*A*B + beta*C !> - HIPBLAS_SIDE_RIGHT: C := alpha*B*A + beta*C !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix. !> !> @param[in] m - [int] !> m specifies the number of rows of B and C. m >= 0. !> !> @param[in] n - [int] !> n specifies the number of columns of B and C. n >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A and B are not referenced. !> !> @param[in] AP - pointer storing matrix A on the GPU. !> A is m by m if side == HIPBLAS_SIDE_LEFT. !> A is n by n if side == HIPBLAS_SIDE_RIGHT. !> Only the upper/lower triangular part is accessed. !> !> @param[in] lda - [int] !> lda specifies the first dimension of A. !> If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ). !> Otherwise, lda >= max( 1, n ). !> !> @param[in] BP - pointer storing matrix B on the GPU. !> Matrix dimension is m by n. !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B. ldb >= max( 1, m ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - pointer storing matrix C on the GPU. !> Matrix dimension is m by n. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, m ). interface hipblasSsymm #ifdef USE_CUDA_NAMES function hipblasSsymm_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasSsymm_v2") #else function hipblasSsymm_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasSsymm") #endif use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSsymm_assumed_rank #else module procedure & hipblasSsymm_rank_0,& hipblasSsymm_rank_1,& hipblasSsymm_full_rank #endif #endif end interface interface hipblasDsymm #ifdef USE_CUDA_NAMES function hipblasDsymm_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasDsymm_v2") #else function hipblasDsymm_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasDsymm") #endif use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDsymm_assumed_rank #else module procedure & hipblasDsymm_rank_0,& hipblasDsymm_rank_1,& hipblasDsymm_full_rank #endif #endif end interface interface hipblasCsymm #ifdef USE_CUDA_NAMES function hipblasCsymm_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasCsymm_v2") #else function hipblasCsymm_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasCsymm") #endif use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCsymm_assumed_rank #else module procedure & hipblasCsymm_rank_0,& hipblasCsymm_rank_1,& hipblasCsymm_full_rank #endif #endif end interface interface hipblasZsymm #ifdef USE_CUDA_NAMES function hipblasZsymm_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasZsymm_v2") #else function hipblasZsymm_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasZsymm") #endif use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZsymm_assumed_rank #else module procedure & hipblasZsymm_rank_0,& hipblasZsymm_rank_1,& hipblasZsymm_full_rank #endif #endif end interface interface hipblasSsymm_64 #ifdef USE_CUDA_NAMES function hipblasSsymm_64_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasSsymm_v2_64") #else function hipblasSsymm_64_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasSsymm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasDsymm_64 #ifdef USE_CUDA_NAMES function hipblasDsymm_64_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasDsymm_v2_64") #else function hipblasDsymm_64_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasDsymm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasCsymm_64 #ifdef USE_CUDA_NAMES function hipblasCsymm_64_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasCsymm_v2_64") #else function hipblasCsymm_64_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasCsymm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasZsymm_64 #ifdef USE_CUDA_NAMES function hipblasZsymm_64_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasZsymm_v2_64") #else function hipblasZsymm_64_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasZsymm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> !> symmBatched performs a batch of the matrix-matrix operations: !> !> C_i := alpha*A_i*B_i + beta*C_i if side == HIPBLAS_SIDE_LEFT, !> C_i := alpha*B_i*A_i + beta*C_i if side == HIPBLAS_SIDE_RIGHT, !> !> where ``alpha`` and ``beta`` are scalars, ``B_i`` and ``C_i`` are ``m`` by ``n`` matrices, !> and !> ``A_i`` is a symmetric matrix stored as either upper or lower. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] side - [hipblasSideMode_t] !> - HIPBLAS_SIDE_LEFT: C_i := alpha*A_i*B_i + beta*C_i !> - HIPBLAS_SIDE_RIGHT: C_i := alpha*B_i*A_i + beta*C_i !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix. !> !> @param[in] m - [int] !> m specifies the number of rows of B_i and C_i. m >= 0. !> !> @param[in] n - [int] !> n specifies the number of columns of B_i and C_i. n >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A_i and B_i are not referenced. !> !> @param[in] AP - device array of device pointers storing each matrix A_i on the GPU. !> A_i is m by m if side == HIPBLAS_SIDE_LEFT. !> A_i is n by n if side == HIPBLAS_SIDE_RIGHT. !> Only the upper/lower triangular part is accessed. !> !> @param[in] lda - [int] !> lda specifies the first dimension of A_i. !> If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ). !> Otherwise, lda >= max( 1, n ). !> !> @param[in] BP - device array of device pointers storing each matrix B_i on the GPU. !> Matrix dimension is m by n. !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B_i. ldb >= max( 1, m ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C_i does not need to be set before entry. !> !> @param[in] CP - device array of device pointers storing each matrix C_i on the GPU. !> Matrix dimension is m by n. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C_i. ldc >= max( 1, m ). !> !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSsymmBatched function hipblasSsymmBatched_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc,batchCount) & bind(c, name="hipblasSsymmBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsymmBatched function hipblasDsymmBatched_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc,batchCount) & bind(c, name="hipblasDsymmBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsymmBatched function hipblasCsymmBatched_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc,batchCount) & bind(c, name="hipblasCsymmBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsymmBatched function hipblasZsymmBatched_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc,batchCount) & bind(c, name="hipblasZsymmBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSsymmBatched_64 function hipblasSsymmBatched_64_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasSsymmBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsymmBatched_64 function hipblasDsymmBatched_64_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasDsymmBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsymmBatched_64 function hipblasCsymmBatched_64_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasCsymmBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsymmBatched_64 function hipblasZsymmBatched_64_(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasZsymmBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> !> The symmStridedBatched functions perform a batch of the matrix-matrix operations: !> !> C_i := alpha*A_i*B_i + beta*C_i if side == HIPBLAS_SIDE_LEFT, !> C_i := alpha*B_i*A_i + beta*C_i if side == HIPBLAS_SIDE_RIGHT, !> !> where ``alpha`` and ``beta`` are scalars, ``B_i`` and ``C_i`` are ``m`` by ``n`` matrices, !> and !> ``A_i`` is a symmetric matrix stored as either upper or lower. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] side - [hipblasSideMode_t] !> - HIPBLAS_SIDE_LEFT: C_i := alpha*A_i*B_i + beta*C_i !> - HIPBLAS_SIDE_RIGHT: C_i := alpha*B_i*A_i + beta*C_i !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix. !> !> @param[in] m - [int] !> m specifies the number of rows of B_i and C_i. m >= 0. !> !> @param[in] n - [int] !> n specifies the number of columns of B_i and C_i. n >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A_i and B_i are not referenced. !> !> @param[in] AP - device pointer to first matrix A_1. !> A_i is m by m if side == HIPBLAS_SIDE_LEFT. !> A_i is n by n if side == HIPBLAS_SIDE_RIGHT. !> Only the upper/lower triangular part is accessed. !> !> @param[in] lda - [int] !> lda specifies the first dimension of A_i. !> If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ). !> Otherwise, lda >= max( 1, n ). !> !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[in] BP - device pointer to first matrix B_1 of dimension (ldb, n) on the GPU. !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B_i. ldb >= max( 1, m ). !> !> @param[in] strideB - [hipblasStride] !> stride from the start of one matrix (B_i) to the next one (B_i+1). !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - device pointer to first matrix C_1 of dimension (ldc, n) on the GPU. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, m ). !> !> @param[inout] strideC - [hipblasStride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSsymmStridedBatched function hipblasSsymmStridedBatched_(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP,ldb,strideB, & beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasSsymmStridedBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSsymmStridedBatched_assumed_rank #else module procedure & hipblasSsymmStridedBatched_rank_0,& hipblasSsymmStridedBatched_rank_1,& hipblasSsymmStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsymmStridedBatched function hipblasDsymmStridedBatched_(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP,ldb,strideB, & beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasDsymmStridedBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDsymmStridedBatched_assumed_rank #else module procedure & hipblasDsymmStridedBatched_rank_0,& hipblasDsymmStridedBatched_rank_1,& hipblasDsymmStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsymmStridedBatched function hipblasCsymmStridedBatched_(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP,ldb,strideB, & beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasCsymmStridedBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCsymmStridedBatched_assumed_rank #else module procedure & hipblasCsymmStridedBatched_rank_0,& hipblasCsymmStridedBatched_rank_1,& hipblasCsymmStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsymmStridedBatched function hipblasZsymmStridedBatched_(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP,ldb,strideB, & beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasZsymmStridedBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZsymmStridedBatched_assumed_rank #else module procedure & hipblasZsymmStridedBatched_rank_0,& hipblasZsymmStridedBatched_rank_1,& hipblasZsymmStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSsymmStridedBatched_64 function hipblasSsymmStridedBatched_64_(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasSsymmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsymmStridedBatched_64 function hipblasDsymmStridedBatched_64_(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasDsymmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsymmStridedBatched_64 function hipblasCsymmStridedBatched_64_(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasCsymmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsymmStridedBatched_64 function hipblasZsymmStridedBatched_64_(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasZsymmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> !> The syrk functions perform one of the matrix-matrix operations for a symmetric rank-k !> update: !> !> C := alpha*op( A )*op( A )^T + beta*C !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` is an ``n`` by ``k`` matrix, and !> ``C`` is a symmetric ``n`` by ``n`` matrix stored as either upper or lower. !> !> op( A ) = A, and A is n by k if transA == HIPBLAS_OP_N !> op( A ) = A^T and A is k by n if transA == HIPBLAS_OP_T !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: C is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: C is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_T: op(A) = A^T !> - HIPBLAS_OP_N: op(A) = A !> - HIPBLAS_OP_C: op(A) = A^T !> - HIPBLAS_OP_C is not supported for complex types. See cherk !> and zherk. !> !> @param[in] n - [int] !> n specifies the number of rows and columns of C. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and A does not need to be set before !> entry. !> !> @param[in] AP - pointer storing matrix A on the GPU. !> Matrix dimension is ( lda, k ) when transA = HIPBLAS_OP_N. Otherwise, (lda, n). !> Only the upper/lower triangular part is accessed. !> !> @param[in] lda - [int] !> lda specifies the first dimension of A. !> If transA = HIPBLAS_OP_N, lda >= max( 1, n ). !> Otherwise, lda >= max( 1, k ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - pointer storing matrix C on the GPU. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). interface hipblasSsyrk #ifdef USE_CUDA_NAMES function hipblasSsyrk_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="cublasSsyrk_v2") #else function hipblasSsyrk_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="hipblasSsyrk") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrk_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSsyrk_assumed_rank #else module procedure & hipblasSsyrk_rank_0,& hipblasSsyrk_rank_1,& hipblasSsyrk_full_rank #endif #endif end interface interface hipblasDsyrk #ifdef USE_CUDA_NAMES function hipblasDsyrk_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="cublasDsyrk_v2") #else function hipblasDsyrk_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="hipblasDsyrk") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrk_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDsyrk_assumed_rank #else module procedure & hipblasDsyrk_rank_0,& hipblasDsyrk_rank_1,& hipblasDsyrk_full_rank #endif #endif end interface interface hipblasCsyrk #ifdef USE_CUDA_NAMES function hipblasCsyrk_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="cublasCsyrk_v2") #else function hipblasCsyrk_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="hipblasCsyrk") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrk_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCsyrk_assumed_rank #else module procedure & hipblasCsyrk_rank_0,& hipblasCsyrk_rank_1,& hipblasCsyrk_full_rank #endif #endif end interface interface hipblasZsyrk #ifdef USE_CUDA_NAMES function hipblasZsyrk_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="cublasZsyrk_v2") #else function hipblasZsyrk_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="hipblasZsyrk") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrk_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZsyrk_assumed_rank #else module procedure & hipblasZsyrk_rank_0,& hipblasZsyrk_rank_1,& hipblasZsyrk_full_rank #endif #endif end interface interface hipblasSsyrk_64 #ifdef USE_CUDA_NAMES function hipblasSsyrk_64_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="cublasSsyrk_v2_64") #else function hipblasSsyrk_64_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="hipblasSsyrk_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrk_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasDsyrk_64 #ifdef USE_CUDA_NAMES function hipblasDsyrk_64_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="cublasDsyrk_v2_64") #else function hipblasDsyrk_64_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="hipblasDsyrk_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrk_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasCsyrk_64 #ifdef USE_CUDA_NAMES function hipblasCsyrk_64_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="cublasCsyrk_v2_64") #else function hipblasCsyrk_64_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="hipblasCsyrk_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrk_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasZsyrk_64 #ifdef USE_CUDA_NAMES function hipblasZsyrk_64_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="cublasZsyrk_v2_64") #else function hipblasZsyrk_64_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) & bind(c, name="hipblasZsyrk_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrk_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> !> The syrkBatched functions performs a batch of the matrix-matrix operations for a symmetric !> rank-k update: !> !> C_i := alpha*op( A_i )*op( A_i )^T + beta*C_i !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` is an ``n`` by ``k`` matrix, and !> ``C_i`` is a symmetric ``n`` by ``n`` matrix stored as either upper or lower. !> !> op( A_i ) = A_i, and A_i is n by k if transA == HIPBLAS_OP_N !> op( A_i ) = A_i^T and A_i is k by n if transA == HIPBLAS_OP_T !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_T: op(A) = A^T !> - HIPBLAS_OP_N: op(A) = A !> - HIPBLAS_OP_C: op(A) = A^T !> - HIPBLAS_OP_C is not supported for complex types. See cherk !> and zherk. !> !> @param[in] n - [int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and does not need to be set before !> entry. !> !> @param[in] AP - device array of device pointers storing each matrix_i A of dimension (lda, !> k) !> when transA is HIPBLAS_OP_N. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [int] !> lda specifies the first dimension of A_i. !> If transA = HIPBLAS_OP_N, lda >= max( 1, n ). !> Otherwise, lda >= max( 1, k ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - device array of device pointers storing each matrix C_i on the GPU. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSsyrkBatched function hipblasSsyrkBatched_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc,batchCount) & bind(c, name="hipblasSsyrkBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyrkBatched function hipblasDsyrkBatched_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc,batchCount) & bind(c, name="hipblasDsyrkBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyrkBatched function hipblasCsyrkBatched_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc,batchCount) & bind(c, name="hipblasCsyrkBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyrkBatched function hipblasZsyrkBatched_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc,batchCount) & bind(c, name="hipblasZsyrkBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSsyrkBatched_64 function hipblasSsyrkBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc,batchCount) & bind(c, name="hipblasSsyrkBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyrkBatched_64 function hipblasDsyrkBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc,batchCount) & bind(c, name="hipblasDsyrkBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyrkBatched_64 function hipblasCsyrkBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc,batchCount) & bind(c, name="hipblasCsyrkBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyrkBatched_64 function hipblasZsyrkBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc,batchCount) & bind(c, name="hipblasZsyrkBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> !> The syrkStridedBatched functions perform a batch of the matrix-matrix operations for a !> symmetric rank-k update: !> !> C_i := alpha*op( A_i )*op( A_i )^T + beta*C_i !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` is an ``n`` by ``k`` matrix, and !> ``C_i`` is a symmetric ``n`` by ``n`` matrix stored as either upper or lower. !> !> op( A_i ) = A_i, and A_i is n by k if transA == HIPBLAS_OP_N !> op( A_i ) = A_i^T and A_i is k by n if transA == HIPBLAS_OP_T !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_T: op(A) = A^T !> - HIPBLAS_OP_N: op(A) = A !> - HIPBLAS_OP_C: op(A) = A^T !> - HIPBLAS_OP_C is not supported for complex types. See cherk !> and zherk. !> !> @param[in] n - [int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and does not need to be set before !> entry. !> !> @param[in] AP - Device pointer to the first matrix A_1 on the GPU of dimension (lda, k) !> when transA is HIPBLAS_OP_N. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [int] !> lda specifies the first dimension of A_i. !> If transA = HIPBLAS_OP_N, lda >= max( 1, n ). !> Otherwise, lda >= max( 1, k ). !> !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - Device pointer to the first matrix C_1 on the GPU. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> !> @param[inout] strideC - [hipblasStride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSsyrkStridedBatched function hipblasSsyrkStridedBatched_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta,CP,ldc, & strideC,batchCount) & bind(c, name="hipblasSsyrkStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSsyrkStridedBatched_assumed_rank #else module procedure & hipblasSsyrkStridedBatched_rank_0,& hipblasSsyrkStridedBatched_rank_1,& hipblasSsyrkStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyrkStridedBatched function hipblasDsyrkStridedBatched_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta,CP,ldc, & strideC,batchCount) & bind(c, name="hipblasDsyrkStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDsyrkStridedBatched_assumed_rank #else module procedure & hipblasDsyrkStridedBatched_rank_0,& hipblasDsyrkStridedBatched_rank_1,& hipblasDsyrkStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyrkStridedBatched function hipblasCsyrkStridedBatched_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta,CP,ldc, & strideC,batchCount) & bind(c, name="hipblasCsyrkStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCsyrkStridedBatched_assumed_rank #else module procedure & hipblasCsyrkStridedBatched_rank_0,& hipblasCsyrkStridedBatched_rank_1,& hipblasCsyrkStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyrkStridedBatched function hipblasZsyrkStridedBatched_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta,CP,ldc, & strideC,batchCount) & bind(c, name="hipblasZsyrkStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZsyrkStridedBatched_assumed_rank #else module procedure & hipblasZsyrkStridedBatched_rank_0,& hipblasZsyrkStridedBatched_rank_1,& hipblasZsyrkStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSsyrkStridedBatched_64 function hipblasSsyrkStridedBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta,CP, & ldc,strideC,batchCount) & bind(c, name="hipblasSsyrkStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyrkStridedBatched_64 function hipblasDsyrkStridedBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta,CP, & ldc,strideC,batchCount) & bind(c, name="hipblasDsyrkStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyrkStridedBatched_64 function hipblasCsyrkStridedBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta,CP, & ldc,strideC,batchCount) & bind(c, name="hipblasCsyrkStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyrkStridedBatched_64 function hipblasZsyrkStridedBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta,CP, & ldc,strideC,batchCount) & bind(c, name="hipblasZsyrkStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> !> The syr2k functions perform one of the matrix-matrix operations for a symmetric rank-2k !> update: !> !> C := alpha*(op( A )*op( B )^T + op( B )*op( A )^T) + beta*C !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` and ``op(B)`` are ``n`` by ``k`` !> matrices, and !> ``C`` is a symmetric ``n`` by ``n`` matrix stored as either upper or lower. !> !> op( A ) = A, op( B ) = B, and A and B are n by k if trans == HIPBLAS_OP_N !> op( A ) = A^T, op( B ) = B^T, and A and B are k by n if trans == HIPBLAS_OP_T !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: C is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: C is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_T: op( A ) = A^T, op( B ) = B^T !> - HIPBLAS_OP_N: op( A ) = A, op( B ) = B !> !> @param[in] n - [int] !> n specifies the number of rows and columns of C. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of op(A) and op(B). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and does not need to be set before !> entry. !> !> @param[in] AP - Pointer storing matrix A on the GPU. !> Matrix dimension is ( lda, k ) when trans = HIPBLAS_OP_N. Otherwise, (lda, n). !> Only the upper/lower triangular part is accessed. !> !> @param[in] lda - [int] !> lda specifies the first dimension of A. !> If trans = HIPBLAS_OP_N, lda >= max( 1, n ). !> Otherwise, lda >= max( 1, k ). !> @param[in] BP - pointer storing matrix B on the GPU. !> Matrix dimension is ( ldb, k ) when trans = HIPBLAS_OP_N. Otherwise, (ldb, n). !> Only the upper/lower triangular part is accessed. !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B. !> If trans = HIPBLAS_OP_N, ldb >= max( 1, n ). !> Otherwise, ldb >= max( 1, k ). !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - pointer storing matrix C on the GPU. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). interface hipblasSsyr2k #ifdef USE_CUDA_NAMES function hipblasSsyr2k_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasSsyr2k_v2") #else function hipblasSsyr2k_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasSsyr2k") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2k_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSsyr2k_assumed_rank #else module procedure & hipblasSsyr2k_rank_0,& hipblasSsyr2k_rank_1,& hipblasSsyr2k_full_rank #endif #endif end interface interface hipblasDsyr2k #ifdef USE_CUDA_NAMES function hipblasDsyr2k_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasDsyr2k_v2") #else function hipblasDsyr2k_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasDsyr2k") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2k_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDsyr2k_assumed_rank #else module procedure & hipblasDsyr2k_rank_0,& hipblasDsyr2k_rank_1,& hipblasDsyr2k_full_rank #endif #endif end interface interface hipblasCsyr2k #ifdef USE_CUDA_NAMES function hipblasCsyr2k_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasCsyr2k_v2") #else function hipblasCsyr2k_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasCsyr2k") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2k_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCsyr2k_assumed_rank #else module procedure & hipblasCsyr2k_rank_0,& hipblasCsyr2k_rank_1,& hipblasCsyr2k_full_rank #endif #endif end interface interface hipblasZsyr2k #ifdef USE_CUDA_NAMES function hipblasZsyr2k_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasZsyr2k_v2") #else function hipblasZsyr2k_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasZsyr2k") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2k_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZsyr2k_assumed_rank #else module procedure & hipblasZsyr2k_rank_0,& hipblasZsyr2k_rank_1,& hipblasZsyr2k_full_rank #endif #endif end interface interface hipblasSsyr2k_64 #ifdef USE_CUDA_NAMES function hipblasSsyr2k_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasSsyr2k_v2_64") #else function hipblasSsyr2k_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasSsyr2k_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2k_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasDsyr2k_64 #ifdef USE_CUDA_NAMES function hipblasDsyr2k_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasDsyr2k_v2_64") #else function hipblasDsyr2k_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasDsyr2k_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2k_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasCsyr2k_64 #ifdef USE_CUDA_NAMES function hipblasCsyr2k_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasCsyr2k_v2_64") #else function hipblasCsyr2k_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasCsyr2k_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2k_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasZsyr2k_64 #ifdef USE_CUDA_NAMES function hipblasZsyr2k_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasZsyr2k_v2_64") #else function hipblasZsyr2k_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasZsyr2k_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2k_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> !> The syr2kBatched functions perform a batch of the matrix-matrix operations for a symmetric !> rank-2k update: !> !> C_i := alpha*(op( A_i )*op( B_i )^T + op( B_i )*op( A_i )^T) + beta*C_i !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` !> matrices, and !> ``C_i`` is a symmetric ``n`` by ``n`` matrix stored as either upper or lower. !> !> op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == HIPBLAS_OP_N !> op( A_i ) = A_i^T, op( B_i ) = B_i^T, and A_i and B_i are k by n if trans == !> HIPBLAS_OP_T !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_T: op( A_i ) = A_i^T, op( B_i ) = B_i^T !> - HIPBLAS_OP_N: op( A_i ) = A_i, op( B_i ) = B_i !> !> @param[in] n - [int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and does not need to be set before !> entry. !> !> @param[in] AP - device array of device pointers storing each matrix_i A of dimension (lda, !> k) !> when trans is HIPBLAS_OP_N. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [int] !> lda specifies the first dimension of A_i. !> If trans = HIPBLAS_OP_N, lda >= max( 1, n ). !> Otherwise, lda >= max( 1, k ). !> @param[in] BP - device array of device pointers storing each matrix_i B of dimension (ldb, !> k) !> when trans is HIPBLAS_OP_N. Otherwise, of dimension (ldb, n). !> @param[in] ldb - [int] !> ldb specifies the first dimension of B. !> If trans = HIPBLAS_OP_N, ldb >= max( 1, n ). !> Otherwise, ldb >= max( 1, k ). !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - device array of device pointers storing each matrix C_i on the GPU. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSsyr2kBatched function hipblasSsyr2kBatched_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasSsyr2kBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2kBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyr2kBatched function hipblasDsyr2kBatched_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasDsyr2kBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2kBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyr2kBatched function hipblasCsyr2kBatched_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasCsyr2kBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2kBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyr2kBatched function hipblasZsyr2kBatched_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasZsyr2kBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2kBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSsyr2kBatched_64 function hipblasSsyr2kBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasSsyr2kBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2kBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyr2kBatched_64 function hipblasDsyr2kBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasDsyr2kBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2kBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyr2kBatched_64 function hipblasCsyr2kBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasCsyr2kBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2kBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyr2kBatched_64 function hipblasZsyr2kBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasZsyr2kBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2kBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> !> The syr2kStridedBatched functions perform a batch of the matrix-matrix operations for a !> symmetric rank-2k update: !> !> C_i := alpha*(op( A_i )*op( B_i )^T + op( B_i )*op( A_i )^T) + beta*C_i !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` !> matrices, and !> ``C_i`` is a symmetric ``n`` by ``n`` matrix stored as either upper or lower. !> !> op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == HIPBLAS_OP_N !> op( A_i ) = A_i^T, op( B_i ) = B_i^T, and A_i and B_i are k by n if trans == !> HIPBLAS_OP_T !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_T: op( A_i ) = A_i^T, op( B_i ) = B_i^T !> - HIPBLAS_OP_N: op( A_i ) = A_i, op( B_i ) = B_i !> !> @param[in] n - [int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and does not need to be set before !> entry. !> !> @param[in] AP - Device pointer to the first matrix A_1 on the GPU of dimension (lda, k) !> when trans is HIPBLAS_OP_N. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [int] !> lda specifies the first dimension of A_i. !> If trans = HIPBLAS_OP_N, lda >= max( 1, n ). !> Otherwise, lda >= max( 1, k ). !> !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[in] BP - Device pointer to the first matrix B_1 on the GPU of dimension (ldb, k) !> when trans is HIPBLAS_OP_N. Otherwise, of dimension (ldb, n). !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B_i. !> If trans = HIPBLAS_OP_N, ldb >= max( 1, n ). !> Otherwise, ldb >= max( 1, k ). !> !> @param[in] strideB - [hipblasStride] !> stride from the start of one matrix (B_i) to the next one (B_i+1). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - Device pointer to the first matrix C_1 on the GPU. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> !> @param[inout] strideC - [hipblasStride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSsyr2kStridedBatched function hipblasSsyr2kStridedBatched_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasSsyr2kStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2kStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSsyr2kStridedBatched_assumed_rank #else module procedure & hipblasSsyr2kStridedBatched_rank_0,& hipblasSsyr2kStridedBatched_rank_1,& hipblasSsyr2kStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyr2kStridedBatched function hipblasDsyr2kStridedBatched_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasDsyr2kStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2kStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDsyr2kStridedBatched_assumed_rank #else module procedure & hipblasDsyr2kStridedBatched_rank_0,& hipblasDsyr2kStridedBatched_rank_1,& hipblasDsyr2kStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyr2kStridedBatched function hipblasCsyr2kStridedBatched_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasCsyr2kStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2kStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCsyr2kStridedBatched_assumed_rank #else module procedure & hipblasCsyr2kStridedBatched_rank_0,& hipblasCsyr2kStridedBatched_rank_1,& hipblasCsyr2kStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyr2kStridedBatched function hipblasZsyr2kStridedBatched_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasZsyr2kStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2kStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZsyr2kStridedBatched_assumed_rank #else module procedure & hipblasZsyr2kStridedBatched_rank_0,& hipblasZsyr2kStridedBatched_rank_1,& hipblasZsyr2kStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSsyr2kStridedBatched_64 function hipblasSsyr2kStridedBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasSsyr2kStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2kStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyr2kStridedBatched_64 function hipblasDsyr2kStridedBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasDsyr2kStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2kStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyr2kStridedBatched_64 function hipblasCsyr2kStridedBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasCsyr2kStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2kStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyr2kStridedBatched_64 function hipblasZsyr2kStridedBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasZsyr2kStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2kStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> !> The syrkx functions performs one of the matrix-matrix operations for a symmetric rank-k !> update: !> !> C := alpha*op( A )*op( B )^T + beta*C !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` and ``op(B)`` are ``n`` by ``k`` !> matrices, and !> ``C`` is a symmetric ``n`` by ``n ``matrix stored as either upper or lower. !> This routine should only be used when the caller can guarantee that the result of !> ``op( A )*op( B )^T`` will be symmetric. !> !> op( A ) = A, op( B ) = B, and A and B are n by k if trans == HIPBLAS_OP_N !> op( A ) = A^T, op( B ) = B^T, and A and B are k by n if trans == HIPBLAS_OP_T !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: C is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: C is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_T: op( A ) = A^T, op( B ) = B^T !> - HIPBLAS_OP_N: op( A ) = A, op( B ) = B !> !> @param[in] n - [int] !> n specifies the number of rows and columns of C. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of op(A) and op(B). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and does not need to be set before !> entry. !> !> @param[in] AP - pointer storing matrix A on the GPU. !> Matrix dimension is ( lda, k ) when trans = HIPBLAS_OP_N. Otherwise, (lda, n). !> Only the upper/lower triangular part is accessed. !> !> @param[in] lda - [int] !> lda specifies the first dimension of A. !> If trans = HIPBLAS_OP_N, lda >= max( 1, n ). !> Otherwise, lda >= max( 1, k ). !> !> @param[in] BP - pointer storing matrix B on the GPU. !> Matrix dimension is ( ldb, k ) when trans = HIPBLAS_OP_N. Otherwise, (ldb, n). !> Only the upper/lower triangular part is accessed. !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B. !> if trans = HIPBLAS_OP_N, ldb >= max( 1, n ). !> Otherwise, ldb >= max( 1, k ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - pointer storing matrix C on the GPU. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). interface hipblasSsyrkx #ifdef USE_CUDA_NAMES function hipblasSsyrkx_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasSsyrkx") #else function hipblasSsyrkx_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasSsyrkx") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkx_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSsyrkx_assumed_rank #else module procedure & hipblasSsyrkx_rank_0,& hipblasSsyrkx_rank_1,& hipblasSsyrkx_full_rank #endif #endif end interface interface hipblasDsyrkx #ifdef USE_CUDA_NAMES function hipblasDsyrkx_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasDsyrkx") #else function hipblasDsyrkx_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasDsyrkx") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkx_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDsyrkx_assumed_rank #else module procedure & hipblasDsyrkx_rank_0,& hipblasDsyrkx_rank_1,& hipblasDsyrkx_full_rank #endif #endif end interface interface hipblasCsyrkx #ifdef USE_CUDA_NAMES function hipblasCsyrkx_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasCsyrkx") #else function hipblasCsyrkx_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasCsyrkx") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkx_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCsyrkx_assumed_rank #else module procedure & hipblasCsyrkx_rank_0,& hipblasCsyrkx_rank_1,& hipblasCsyrkx_full_rank #endif #endif end interface interface hipblasZsyrkx #ifdef USE_CUDA_NAMES function hipblasZsyrkx_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasZsyrkx") #else function hipblasZsyrkx_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasZsyrkx") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkx_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZsyrkx_assumed_rank #else module procedure & hipblasZsyrkx_rank_0,& hipblasZsyrkx_rank_1,& hipblasZsyrkx_full_rank #endif #endif end interface interface hipblasSsyrkx_64 #ifdef USE_CUDA_NAMES function hipblasSsyrkx_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasSsyrkx_64") #else function hipblasSsyrkx_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasSsyrkx_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkx_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasDsyrkx_64 #ifdef USE_CUDA_NAMES function hipblasDsyrkx_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasDsyrkx_64") #else function hipblasDsyrkx_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasDsyrkx_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkx_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasCsyrkx_64 #ifdef USE_CUDA_NAMES function hipblasCsyrkx_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasCsyrkx_64") #else function hipblasCsyrkx_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasCsyrkx_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkx_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasZsyrkx_64 #ifdef USE_CUDA_NAMES function hipblasZsyrkx_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasZsyrkx_64") #else function hipblasZsyrkx_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasZsyrkx_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkx_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> !> The syrkxBatched functions perform a batch of the matrix-matrix operations for a symmetric !> rank-k update: !> !> C_i := alpha*op( A_i )*op( B_i )^T + beta*C_i !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are an ``n`` by ``k`` !> matrix, and !> ``C_i`` is a symmetric ``n`` x ``n`` matrix stored as either upper or lower. !> This routine should only be used when the caller can guarantee that the result of !> ``op( A_i )*op( B_i )^T`` will be symmetric. !> !> op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == HIPBLAS_OP_N !> op( A_i ) = A_i^T, op( B_i ) = B_i^T, and A_i and B_i are k by n if trans == !> HIPBLAS_OP_T !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_T: op( A_i ) = A_i^T, op( B_i ) = B_i^T !> - HIPBLAS_OP_N: op( A_i ) = A_i, op( B_i ) = B_i !> !> @param[in] n - [int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and A does not need to be set before !> entry. !> !> @param[in] AP - device array of device pointers storing each matrix_i A of dimension (lda, !> k) !> when trans is HIPBLAS_OP_N. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [int] !> lda specifies the first dimension of A_i. !> If trans = HIPBLAS_OP_N, lda >= max( 1, n ). !> Otherwise, lda >= max( 1, k ). !> !> @param[in] BP - device array of device pointers storing each matrix_i B of dimension (ldb, !> k) !> when trans is HIPBLAS_OP_N. Otherwise, of dimension (ldb, n). !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B. !> If trans = HIPBLAS_OP_N, ldb >= max( 1, n ). !> Otherwise, ldb >= max( 1, k ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - device array of device pointers storing each matrix C_i on the GPU. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSsyrkxBatched function hipblasSsyrkxBatched_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasSsyrkxBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkxBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyrkxBatched function hipblasDsyrkxBatched_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasDsyrkxBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkxBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyrkxBatched function hipblasCsyrkxBatched_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasCsyrkxBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkxBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyrkxBatched function hipblasZsyrkxBatched_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasZsyrkxBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkxBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSsyrkxBatched_64 function hipblasSsyrkxBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasSsyrkxBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkxBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyrkxBatched_64 function hipblasDsyrkxBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasDsyrkxBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkxBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyrkxBatched_64 function hipblasCsyrkxBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasCsyrkxBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkxBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyrkxBatched_64 function hipblasZsyrkxBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasZsyrkxBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkxBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> !> The syrkxStridedBatched functions perform a batch of the matrix-matrix operations for a !> symmetric rank-k update: !> !> C_i := alpha*op( A_i )*op( B_i )^T + beta*C_i !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` !> matrices, and !> ``C_i`` is a symmetric ``n`` by ``n`` matrix stored as either upper or lower. !> This routine should only be used when the caller can guarantee that the result of !> ``op( A_i )*op( B_i )^T`` will be symmetric. !> !> op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == HIPBLAS_OP_N !> op( A_i ) = A_i^T, op( B_i ) = B_i^T, and A_i and B_i are k by n if trans == !> HIPBLAS_OP_T !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: C_i is an upper triangular matrix !> - HIPBLAS_FILL_MODE_LOWER: C_i is a lower triangular matrix !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_T: op( A_i ) = A_i^T, op( B_i ) = B_i^T !> - HIPBLAS_OP_N: op( A_i ) = A_i, op( B_i ) = B_i !> !> @param[in] n - [int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and does not need to be set before !> entry. !> !> @param[in] AP - Device pointer to the first matrix A_1 on the GPU of dimension (lda, k) !> when trans is HIPBLAS_OP_N. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [int] !> lda specifies the first dimension of A_i. !> If trans = HIPBLAS_OP_N, lda >= max( 1, n ). !> Otherwise, lda >= max( 1, k ). !> !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[in] BP - Device pointer to the first matrix B_1 on the GPU of dimension (ldb, k) !> when trans is HIPBLAS_OP_N. Otherwise, of dimension (ldb, n). !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B_i. !> If trans = HIPBLAS_OP_N, ldb >= max( 1, n ). !> Otherwise, ldb >= max( 1, k ). !> !> @param[in] strideB - [hipblasStride] !> stride from the start of one matrix (B_i) to the next one (B_i+1). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - Device pointer to the first matrix C_1 on the GPU. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> !> @param[inout] strideC - [hipblasStride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSsyrkxStridedBatched function hipblasSsyrkxStridedBatched_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasSsyrkxStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkxStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB real(c_float) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSsyrkxStridedBatched_assumed_rank #else module procedure & hipblasSsyrkxStridedBatched_rank_0,& hipblasSsyrkxStridedBatched_rank_1,& hipblasSsyrkxStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyrkxStridedBatched function hipblasDsyrkxStridedBatched_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasDsyrkxStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkxStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB real(c_double) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDsyrkxStridedBatched_assumed_rank #else module procedure & hipblasDsyrkxStridedBatched_rank_0,& hipblasDsyrkxStridedBatched_rank_1,& hipblasDsyrkxStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyrkxStridedBatched function hipblasCsyrkxStridedBatched_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasCsyrkxStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkxStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCsyrkxStridedBatched_assumed_rank #else module procedure & hipblasCsyrkxStridedBatched_rank_0,& hipblasCsyrkxStridedBatched_rank_1,& hipblasCsyrkxStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyrkxStridedBatched function hipblasZsyrkxStridedBatched_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasZsyrkxStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkxStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZsyrkxStridedBatched_assumed_rank #else module procedure & hipblasZsyrkxStridedBatched_rank_0,& hipblasZsyrkxStridedBatched_rank_1,& hipblasZsyrkxStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSsyrkxStridedBatched_64 function hipblasSsyrkxStridedBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasSsyrkxStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkxStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB real(c_float) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDsyrkxStridedBatched_64 function hipblasDsyrkxStridedBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasDsyrkxStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkxStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB real(c_double) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCsyrkxStridedBatched_64 function hipblasCsyrkxStridedBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasCsyrkxStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkxStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZsyrkxStridedBatched_64 function hipblasZsyrkxStridedBatched_64_(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasZsyrkxStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkxStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> The geam functions perform one of the matrix-matrix operations: !> !> C = alpha*op( A ) + beta*op( B ), !> !> where op( X ) is one of !> !> op( X ) = X or !> op( X ) = X**T or !> op( X ) = X**H, !> !> ``alpha`` and ``beta`` are scalars, and ``A``, ``B`` and ``C`` are matrices, with !> ``op( A )`` an ``m`` by ``n`` matrix, ``op( B )`` an ``m`` by`` n`` matrix, and ``C`` an !> ``m`` by ``n`` matrix. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] transA - [hipblasOperation_t] !> specifies the form of op( A ). !> @param[in] transB - [hipblasOperation_t] !> specifies the form of op( B ). !> @param[in] m - [int] !> matrix dimension m. !> @param[in] n - [int] !> matrix dimension n. !> @param[in] alpha - device pointer or host pointer specifying the scalar alpha. !> @param[in] AP - device pointer storing matrix A. !> @param[in] lda - [int] !> specifies the leading dimension of A. !> @param[in] beta - device pointer or host pointer specifying the scalar beta. !> @param[in] BP - device pointer storing matrix B. !> @param[in] ldb - [int] !> specifies the leading dimension of B. !> @param[in, out] CP - device pointer storing matrix C. !> @param[in] ldc - [int] !> specifies the leading dimension of C. interface hipblasSgeam #ifdef USE_CUDA_NAMES function hipblasSgeam_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) & bind(c, name="cublasSgeam") #else function hipblasSgeam_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) & bind(c, name="hipblasSgeam") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda real(c_float) :: beta type(c_ptr),value :: BP integer(c_int),value :: ldb type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSgeam_assumed_rank #else module procedure & hipblasSgeam_rank_0,& hipblasSgeam_rank_1,& hipblasSgeam_full_rank #endif #endif end interface interface hipblasDgeam #ifdef USE_CUDA_NAMES function hipblasDgeam_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) & bind(c, name="cublasDgeam") #else function hipblasDgeam_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) & bind(c, name="hipblasDgeam") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda real(c_double) :: beta type(c_ptr),value :: BP integer(c_int),value :: ldb type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDgeam_assumed_rank #else module procedure & hipblasDgeam_rank_0,& hipblasDgeam_rank_1,& hipblasDgeam_full_rank #endif #endif end interface interface hipblasCgeam #ifdef USE_CUDA_NAMES function hipblasCgeam_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) & bind(c, name="cublasCgeam") #else function hipblasCgeam_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) & bind(c, name="hipblasCgeam") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda complex(c_float_complex) :: beta type(c_ptr),value :: BP integer(c_int),value :: ldb type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCgeam_assumed_rank #else module procedure & hipblasCgeam_rank_0,& hipblasCgeam_rank_1,& hipblasCgeam_full_rank #endif #endif end interface interface hipblasZgeam #ifdef USE_CUDA_NAMES function hipblasZgeam_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) & bind(c, name="cublasZgeam") #else function hipblasZgeam_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) & bind(c, name="hipblasZgeam") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda complex(c_double_complex) :: beta type(c_ptr),value :: BP integer(c_int),value :: ldb type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZgeam_assumed_rank #else module procedure & hipblasZgeam_rank_0,& hipblasZgeam_rank_1,& hipblasZgeam_full_rank #endif #endif end interface interface hipblasSgeam_64 #ifdef USE_CUDA_NAMES function hipblasSgeam_64_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) & bind(c, name="cublasSgeam_64") #else function hipblasSgeam_64_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) & bind(c, name="hipblasSgeam_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeam_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda real(c_float) :: beta type(c_ptr),value :: BP integer(c_int64_t),value :: ldb type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasDgeam_64 #ifdef USE_CUDA_NAMES function hipblasDgeam_64_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) & bind(c, name="cublasDgeam_64") #else function hipblasDgeam_64_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) & bind(c, name="hipblasDgeam_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeam_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda real(c_double) :: beta type(c_ptr),value :: BP integer(c_int64_t),value :: ldb type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasCgeam_64 #ifdef USE_CUDA_NAMES function hipblasCgeam_64_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) & bind(c, name="cublasCgeam_64") #else function hipblasCgeam_64_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) & bind(c, name="hipblasCgeam_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeam_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda complex(c_float_complex) :: beta type(c_ptr),value :: BP integer(c_int64_t),value :: ldb type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasZgeam_64 #ifdef USE_CUDA_NAMES function hipblasZgeam_64_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) & bind(c, name="cublasZgeam_64") #else function hipblasZgeam_64_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) & bind(c, name="hipblasZgeam_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeam_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda complex(c_double_complex) :: beta type(c_ptr),value :: BP integer(c_int64_t),value :: ldb type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> The geamBatched functions perform one of the batched matrix-matrix operations: !> !> C_i = alpha*op( A_i ) + beta*op( B_i ) for i = 0, 1, ... batchCount - 1 !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)``, ``op(B_i)``, and ``C_i`` are ``m`` !> by ``n`` matrices, !> and ``op( X )`` is one of: !> !> op( X ) = X or !> op( X ) = X**T !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] transA - [hipblasOperation_t] !> specifies the form of op( A ). !> @param[in] transB - [hipblasOperation_t] !> specifies the form of op( B ). !> @param[in] m - [int] !> matrix dimension m. !> @param[in] n - [int] !> matrix dimension n. !> @param[in] alpha - device pointer or host pointer specifying the scalar alpha. !> @param[in] AP - device array of device pointers storing each matrix A_i on the GPU. !> Each A_i is of dimension ( lda, k ), where k is m !> when transA == HIPBLAS_OP_N and !> is n when transA == HIPBLAS_OP_T. !> @param[in] lda - [int] !> specifies the leading dimension of A. !> @param[in] beta - device pointer or host pointer specifying the scalar beta. !> @param[in] BP - device array of device pointers storing each matrix B_i on the GPU. !> Each B_i is of dimension ( ldb, k ), where k is m !> when transB == HIPBLAS_OP_N and !> is n when transB == HIPBLAS_OP_T. !> @param[in] ldb - [int] !> specifies the leading dimension of B. !> @param[in, out] CP - device array of device pointers storing each matrix C_i on the GPU. !> Each C_i is of dimension ( ldc, n ). !> @param[in] ldc - [int] !> specifies the leading dimension of C. !> !> @param[in] batchCount - [int] !> number of instances i in the batch. #ifndef USE_CUDA_NAMES interface hipblasSgeamBatched function hipblasSgeamBatched_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc, & batchCount) & bind(c, name="hipblasSgeamBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda real(c_float) :: beta type(c_ptr),value :: BP integer(c_int),value :: ldb type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgeamBatched function hipblasDgeamBatched_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc, & batchCount) & bind(c, name="hipblasDgeamBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda real(c_double) :: beta type(c_ptr),value :: BP integer(c_int),value :: ldb type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgeamBatched function hipblasCgeamBatched_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc, & batchCount) & bind(c, name="hipblasCgeamBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda complex(c_float_complex) :: beta type(c_ptr),value :: BP integer(c_int),value :: ldb type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgeamBatched function hipblasZgeamBatched_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc, & batchCount) & bind(c, name="hipblasZgeamBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda complex(c_double_complex) :: beta type(c_ptr),value :: BP integer(c_int),value :: ldb type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSgeamBatched_64 function hipblasSgeamBatched_64_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc, & batchCount) & bind(c, name="hipblasSgeamBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeamBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda real(c_float) :: beta type(c_ptr),value :: BP integer(c_int64_t),value :: ldb type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgeamBatched_64 function hipblasDgeamBatched_64_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc, & batchCount) & bind(c, name="hipblasDgeamBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeamBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda real(c_double) :: beta type(c_ptr),value :: BP integer(c_int64_t),value :: ldb type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgeamBatched_64 function hipblasCgeamBatched_64_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc, & batchCount) & bind(c, name="hipblasCgeamBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeamBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda complex(c_float_complex) :: beta type(c_ptr),value :: BP integer(c_int64_t),value :: ldb type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgeamBatched_64 function hipblasZgeamBatched_64_(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc, & batchCount) & bind(c, name="hipblasZgeamBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeamBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda complex(c_double_complex) :: beta type(c_ptr),value :: BP integer(c_int64_t),value :: ldb type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> The geamStridedBatched functions perform one of the batched matrix-matrix operations: !> !> C_i = alpha*op( A_i ) + beta*op( B_i ) for i = 0, 1, ... batchCount - 1 !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)``, ``op(B_i)``, and ``C_i`` are ``m`` !> by ``n`` matrices, !> and ``op( X )`` is one of: !> !> op( X ) = X or !> op( X ) = X**T !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] transA - [hipblasOperation_t] !> specifies the form of op( A ). !> !> @param[in] transB - [hipblasOperation_t] !> specifies the form of op( B ). !> !> @param[in] m - [int] !> matrix dimension m. !> !> @param[in] n - [int] !> matrix dimension n. !> !> @param[in] alpha - device pointer or host pointer specifying the scalar alpha. !> !> @param[in] AP - device pointer to the first matrix A_0 on the GPU. !> Each A_i is of dimension ( lda, k ), where k is m !> when transA == HIPBLAS_OP_N and !> is n when transA == HIPBLAS_OP_T. !> !> @param[in] lda - [int] !> specifies the leading dimension of A. !> !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[in] beta - device pointer or host pointer specifying the scalar beta. !> !> @param[in] BP - pointer to the first matrix B_0 on the GPU. !> Each B_i is of dimension ( ldb, k ), where k is m !> when transB == HIPBLAS_OP_N and !> is n when transB == HIPBLAS_OP_T. !> !> @param[in] ldb - [int] !> specifies the leading dimension of B. !> !> @param[in] strideB - [hipblasStride] !> stride from the start of one matrix (B_i) to the next one (B_i+1). !> !> @param[in, out] CP - pointer to the first matrix C_0 on the GPU. !> Each C_i is of dimension ( ldc, n ). !> !> @param[in] ldc - [int] !> specifies the leading dimension of C. !> !> @param[in] strideC - [hipblasStride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> !> @param[in] batchCount - [int] !> number of instances i in the batch. #ifndef USE_CUDA_NAMES interface hipblasSgeamStridedBatched function hipblasSgeamStridedBatched_(handle,transA,transB,m,n,alpha,AP,lda,strideA,beta,BP, & ldb,strideB,CP,ldc,strideC,batchCount) & bind(c, name="hipblasSgeamStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_float) :: beta type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSgeamStridedBatched_assumed_rank #else module procedure & hipblasSgeamStridedBatched_rank_0,& hipblasSgeamStridedBatched_rank_1,& hipblasSgeamStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgeamStridedBatched function hipblasDgeamStridedBatched_(handle,transA,transB,m,n,alpha,AP,lda,strideA,beta,BP, & ldb,strideB,CP,ldc,strideC,batchCount) & bind(c, name="hipblasDgeamStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_double) :: beta type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDgeamStridedBatched_assumed_rank #else module procedure & hipblasDgeamStridedBatched_rank_0,& hipblasDgeamStridedBatched_rank_1,& hipblasDgeamStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgeamStridedBatched function hipblasCgeamStridedBatched_(handle,transA,transB,m,n,alpha,AP,lda,strideA,beta,BP, & ldb,strideB,CP,ldc,strideC,batchCount) & bind(c, name="hipblasCgeamStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA complex(c_float_complex) :: beta type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCgeamStridedBatched_assumed_rank #else module procedure & hipblasCgeamStridedBatched_rank_0,& hipblasCgeamStridedBatched_rank_1,& hipblasCgeamStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgeamStridedBatched function hipblasZgeamStridedBatched_(handle,transA,transB,m,n,alpha,AP,lda,strideA,beta,BP, & ldb,strideB,CP,ldc,strideC,batchCount) & bind(c, name="hipblasZgeamStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA complex(c_double_complex) :: beta type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZgeamStridedBatched_assumed_rank #else module procedure & hipblasZgeamStridedBatched_rank_0,& hipblasZgeamStridedBatched_rank_1,& hipblasZgeamStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSgeamStridedBatched_64 function hipblasSgeamStridedBatched_64_(handle,transA,transB,m,n,alpha,AP,lda,strideA,beta,BP, & ldb,strideB,CP,ldc,strideC,batchCount) & bind(c, name="hipblasSgeamStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeamStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA real(c_float) :: beta type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgeamStridedBatched_64 function hipblasDgeamStridedBatched_64_(handle,transA,transB,m,n,alpha,AP,lda,strideA,beta,BP, & ldb,strideB,CP,ldc,strideC,batchCount) & bind(c, name="hipblasDgeamStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeamStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA real(c_double) :: beta type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgeamStridedBatched_64 function hipblasCgeamStridedBatched_64_(handle,transA,transB,m,n,alpha,AP,lda,strideA,beta,BP, & ldb,strideB,CP,ldc,strideC,batchCount) & bind(c, name="hipblasCgeamStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeamStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA complex(c_float_complex) :: beta type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgeamStridedBatched_64 function hipblasZgeamStridedBatched_64_(handle,transA,transB,m,n,alpha,AP,lda,strideA,beta,BP, & ldb,strideB,CP,ldc,strideC,batchCount) & bind(c, name="hipblasZgeamStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeamStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA complex(c_double_complex) :: beta type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> !> The hemm functions perform one of the matrix-matrix operations: !> !> C := alpha*A*B + beta*C if side == HIPBLAS_SIDE_LEFT, !> C := alpha*B*A + beta*C if side == HIPBLAS_SIDE_RIGHT, !> !> where ``alpha`` and ``beta`` are scalars, ``B`` and ``C`` are ``m`` by ``n`` matrices, and !> ``A`` is a Hermitian matrix stored as either upper or lower. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : ``c`` and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] side - [hipblasSideMode_t] !> - HIPBLAS_SIDE_LEFT: C := alpha*A*B + beta*C !> - HIPBLAS_SIDE_RIGHT: C := alpha*B*A + beta*C !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix. !> !> @param[in] n - [int] !> n specifies the number of rows of B and C. n >= 0. !> !> @param[in] k - [int] !> n specifies the number of columns of B and C. k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A and B are not referenced. !> !> @param[in] AP - pointer storing matrix A on the GPU. !> - A is m by m if side == HIPBLAS_SIDE_LEFT. !> - A is n by n if side == HIPBLAS_SIDE_RIGHT. !> - Only the upper/lower triangular part is accessed. !> - The imaginary component of the diagonal elements is not used. !> !> @param[in] lda - [int] !> lda specifies the first dimension of A. !> If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ). !> Otherwise, lda >= max( 1, n ). !> !> @param[in] BP - pointer storing matrix B on the GPU. !> Matrix dimension is m by n. !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B. ldb >= max( 1, m ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - pointer storing matrix C on the GPU. !> Matrix dimension is m by n. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, m ). interface hipblasChemm #ifdef USE_CUDA_NAMES function hipblasChemm_(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasChemm_v2") #else function hipblasChemm_(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasChemm") #endif use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasChemm_assumed_rank #else module procedure & hipblasChemm_rank_0,& hipblasChemm_rank_1,& hipblasChemm_full_rank #endif #endif end interface interface hipblasZhemm #ifdef USE_CUDA_NAMES function hipblasZhemm_(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasZhemm_v2") #else function hipblasZhemm_(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasZhemm") #endif use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZhemm_assumed_rank #else module procedure & hipblasZhemm_rank_0,& hipblasZhemm_rank_1,& hipblasZhemm_full_rank #endif #endif end interface interface hipblasChemm_64 #ifdef USE_CUDA_NAMES function hipblasChemm_64_(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasChemm_v2_64") #else function hipblasChemm_64_(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasChemm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasZhemm_64 #ifdef USE_CUDA_NAMES function hipblasZhemm_64_(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="cublasZhemm_v2_64") #else function hipblasZhemm_64_(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) & bind(c, name="hipblasZhemm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> !> The hemmBatched functions perform a batch of the matrix-matrix operations: !> !> C_i := alpha*A_i*B_i + beta*C_i if side == HIPBLAS_SIDE_LEFT, !> C_i := alpha*B_i*A_i + beta*C_i if side == HIPBLAS_SIDE_RIGHT, !> !> where ``alpha`` and ``beta`` are scalars, ``B_i`` and ``C_i`` are ``m`` by ``n`` matrices, !> and !> ``A_i`` is a Hermitian matrix stored as either upper or lower. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] side - [hipblasSideMode_t] !> - HIPBLAS_SIDE_LEFT: C_i := alpha*A_i*B_i + beta*C_i !> - HIPBLAS_SIDE_RIGHT: C_i := alpha*B_i*A_i + beta*C_i !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix. !> !> @param[in] n - [int] !> n specifies the number of rows of B_i and C_i. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of B_i and C_i. k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A_i and B_i are not referenced. !> !> @param[in] AP - device array of device pointers storing each matrix A_i on the GPU. !> - A_i is m by m if side == HIPBLAS_SIDE_LEFT. !> - A_i is n by n if side == HIPBLAS_SIDE_RIGHT. !> - Only the upper/lower triangular part is accessed. !> - The imaginary component of the diagonal elements is not used. !> !> @param[in] lda - [int] !> lda specifies the first dimension of A_i. !> If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ). !> Otherwise, lda >= max( 1, n ). !> !> @param[in] BP - device array of device pointers storing each matrix B_i on the GPU. !> Matrix dimension is m by n. !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B_i. ldb >= max( 1, m ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C_i need not be set before entry. !> !> @param[in] CP - device array of device pointers storing each matrix C_i on the GPU. !> Matrix dimension is m by n. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C_i. ldc >= max( 1, m ). !> !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasChemmBatched function hipblasChemmBatched_(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc,batchCount) & bind(c, name="hipblasChemmBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhemmBatched function hipblasZhemmBatched_(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc,batchCount) & bind(c, name="hipblasZhemmBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasChemmBatched_64 function hipblasChemmBatched_64_(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasChemmBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhemmBatched_64 function hipblasZhemmBatched_64_(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc, & batchCount) & bind(c, name="hipblasZhemmBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> !> The hemmStridedBatched functions perform a batch of the matrix-matrix operations: !> !> C_i := alpha*A_i*B_i + beta*C_i if side == HIPBLAS_SIDE_LEFT, !> C_i := alpha*B_i*A_i + beta*C_i if side == HIPBLAS_SIDE_RIGHT, !> !> where ``alpha`` and ``beta`` are scalars, ``B_i`` and ``C_i`` are ``m`` by ``n`` matrices, !> and !> ``A_i`` is a Hermitian matrix stored as either upper or lower. !> !> - Supported precisions in rocBLAS : ``c`` and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] side - [hipblasSideMode_t] !> - HIPBLAS_SIDE_LEFT: C_i := alpha*A_i*B_i + beta*C_i !> - HIPBLAS_SIDE_RIGHT: C_i := alpha*B_i*A_i + beta*C_i !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A_i is a lower triangular matrix. !> !> @param[in] n - [int] !> n specifies the number of rows of B_i and C_i. n >= 0. !> !> @param[in] k - [int] !> k specifies the number of columns of B_i and C_i. k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A_i and B_i are not referenced. !> !> @param[in] AP - device pointer to first matrix A_1 !> - A_i is m by m if side == HIPBLAS_SIDE_LEFT. !> - A_i is n by n if side == HIPBLAS_SIDE_RIGHT. !> - Only the upper/lower triangular part is accessed. !> - The imaginary component of the diagonal elements is not used. !> !> @param[in] lda - [int] !> lda specifies the first dimension of A_i. !> If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ). !> Otherwise, lda >= max( 1, n ). !> !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[in] BP - device pointer to first matrix B_1 of dimension (ldb, n) on the GPU. !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B_i. !> If side = HIPBLAS_OP_N, ldb >= max( 1, m ). !> Otherwise, ldb >= max( 1, n ). !> !> @param[in] strideB - [hipblasStride] !> stride from the start of one matrix (B_i) to the next one (B_i+1). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C does not need to be set before entry. !> !> @param[in] CP - device pointer to first matrix C_1 of dimension (ldc, n) on the GPU. !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, m ). !> !> @param[inout] strideC - [hipblasStride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasChemmStridedBatched function hipblasChemmStridedBatched_(handle,side,uplo,n,k,alpha,AP,lda,strideA,BP,ldb,strideB, & beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasChemmStridedBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasChemmStridedBatched_assumed_rank #else module procedure & hipblasChemmStridedBatched_rank_0,& hipblasChemmStridedBatched_rank_1,& hipblasChemmStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhemmStridedBatched function hipblasZhemmStridedBatched_(handle,side,uplo,n,k,alpha,AP,lda,strideA,BP,ldb,strideB, & beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasZhemmStridedBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZhemmStridedBatched_assumed_rank #else module procedure & hipblasZhemmStridedBatched_rank_0,& hipblasZhemmStridedBatched_rank_1,& hipblasZhemmStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasChemmStridedBatched_64 function hipblasChemmStridedBatched_64_(handle,side,uplo,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasChemmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB complex(c_float_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZhemmStridedBatched_64 function hipblasZhemmStridedBatched_64_(handle,side,uplo,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) & bind(c, name="hipblasZhemmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB complex(c_double_complex) :: beta type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> !> \details !> !> The trmm functions perform one of the matrix-matrix operations: !> !> C := alpha*op( A )*B, or C := alpha*B*op( A ) !> !> where ``alpha`` is a scalar, ``B`` and ``C`` are ``m`` by ``n`` matrices, ``A`` is a unit, !> non-unit, upper, or lower triangular matrix, and ``op( A )`` is one of: !> !> op( A ) = A or op( A ) = A^T or op( A ) = A^H. !> !> Note that trmm can provide in-place functionality by passing in the same address for both !> matrices ``B`` and ``C`` and setting ``ldb`` equal to ``ldc``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] side - [hipblasSideMode_t] !> Specifies whether op(A) multiplies B from the left or right as follows: !> - HIPBLAS_SIDE_LEFT: C := alpha*op( A )*B. !> - HIPBLAS_SIDE_RIGHT: C := alpha*B*op( A ). !> !> @param[in] uplo - [hipblasFillMode_t] !> Specifies whether the matrix A is an upper or lower triangular matrix as follows: !> - HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> Specifies the form of op(A) to be used in the matrix multiplication as follows: !> - HIPBLAS_OP_N: op(A) = A. !> - HIPBLAS_OP_T: op(A) = A^T. !> - HIPBLAS_OP_C: op(A) = A^H. !> !> @param[in] diag - [hipblasDiagType_t] !> Specifies whether or not A is unit triangular as follows: !> - HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular. !> - HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular. !> !> @param[in] m - [int] !> m specifies the number of rows of B and C. m >= 0. !> !> @param[in] n - [int] !> n specifies the number of columns of B and C. n >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and B does not need to be set before !> entry. !> !> @param[in] A - Device pointer to matrix A on the GPU. !> A has dimension ( lda, k ), where k is m !> when side == HIPBLAS_SIDE_LEFT and !> is n when side == HIPBLAS_SIDE_RIGHT. !> - When uplo == HIPBLAS_FILL_MODE_UPPER, the leading k by k !> upper triangular part of the array A must contain the upper !> triangular matrix and the strictly lower triangular part of !> A is not referenced. !> - When uplo == HIPBLAS_FILL_MODE_LOWER, the leading k by k !> lower triangular part of the array A must contain the lower !> triangular matrix and the strictly upper triangular part of !> A is not referenced. !> Note that when diag == HIPBLAS_DIAG_UNIT, the diagonal elements of !> A are not referenced either, but are assumed to be unity. !> !> @param[in] lda - [int] !> lda specifies the first dimension of A. !> - If side == HIPBLAS_SIDE_LEFT, lda >= max( 1, m ). !> - If side == HIPBLAS_SIDE_RIGHT, lda >= max( 1, n ). !> !> @param[inout] B - Device pointer to the matrix B of dimension (ldb, n) on the GPU. !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B. ldb >= max( 1, m ). !> !> @param[in] C - Device pointer to the matrix C of dimension (ldc, n) on the GPU. !> Users can pass in the same matrix B to parameter C to achieve !> in-place functionality for trmm. !> @param[in] ldc - [int] !> ldc specifies the first dimension of C. ldc >= max( 1, m ). interface hipblasStrmm #ifdef USE_CUDA_NAMES function hipblasStrmm_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="cublasStrmm_v2") #else function hipblasStrmm_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="hipblasStrmm") #endif use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasStrmm_assumed_rank #else module procedure & hipblasStrmm_rank_0,& hipblasStrmm_rank_1,& hipblasStrmm_full_rank #endif #endif end interface interface hipblasDtrmm #ifdef USE_CUDA_NAMES function hipblasDtrmm_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="cublasDtrmm_v2") #else function hipblasDtrmm_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="hipblasDtrmm") #endif use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDtrmm_assumed_rank #else module procedure & hipblasDtrmm_rank_0,& hipblasDtrmm_rank_1,& hipblasDtrmm_full_rank #endif #endif end interface interface hipblasCtrmm #ifdef USE_CUDA_NAMES function hipblasCtrmm_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="cublasCtrmm_v2") #else function hipblasCtrmm_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="hipblasCtrmm") #endif use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCtrmm_assumed_rank #else module procedure & hipblasCtrmm_rank_0,& hipblasCtrmm_rank_1,& hipblasCtrmm_full_rank #endif #endif end interface interface hipblasZtrmm #ifdef USE_CUDA_NAMES function hipblasZtrmm_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="cublasZtrmm_v2") #else function hipblasZtrmm_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="hipblasZtrmm") #endif use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZtrmm_assumed_rank #else module procedure & hipblasZtrmm_rank_0,& hipblasZtrmm_rank_1,& hipblasZtrmm_full_rank #endif #endif end interface interface hipblasStrmm_64 #ifdef USE_CUDA_NAMES function hipblasStrmm_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="cublasStrmm_v2_64") #else function hipblasStrmm_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="hipblasStrmm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface hipblasDtrmm_64 #ifdef USE_CUDA_NAMES function hipblasDtrmm_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="cublasDtrmm_v2_64") #else function hipblasDtrmm_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="hipblasDtrmm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface hipblasCtrmm_64 #ifdef USE_CUDA_NAMES function hipblasCtrmm_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="cublasCtrmm_v2_64") #else function hipblasCtrmm_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="hipblasCtrmm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface hipblasZtrmm_64 #ifdef USE_CUDA_NAMES function hipblasZtrmm_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="cublasZtrmm_v2_64") #else function hipblasZtrmm_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="hipblasZtrmm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> !> The trmmBatched functions perform one of the batched matrix-matrix operations: !> !> C_i := alpha*op( A_i )*B_i, or C_i := alpha*B_i*op( A_i ) for i = 0, 1, ... batchCount !> -1 !> !> where ``alpha`` is a scalar, ``B_i`` and ``C_i`` are ``m`` by ``n`` matrices, ``A_i`` is a !> unit, !> non-unit, upper, or lower triangular matrix, and ``op( A_i )`` is one of: !> !> op( A_i ) = A_i or op( A_i ) = A_i^T or op( A_i ) = A_i^H. !> !> Note that trmmBatched can provide in-place functionality by passing in the same address for !> both !> matrices ``B`` and ``C`` and by setting ``ldb`` equal to ``ldc``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] side - [hipblasSideMode_t] !> Specifies whether op(A_i) multiplies B_i from the left or right as follows: !> - HIPBLAS_SIDE_LEFT: B_i := alpha*op( A_i )*B_i. !> - HIPBLAS_SIDE_RIGHT: B_i := alpha*B_i*op( A_i ). !> !> @param[in] uplo - [hipblasFillMode_t] !> Specifies whether the matrix A is an upper or lower triangular matrix as follows: !> - HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> Specifies the form of op(A_i) to be used in the matrix multiplication as follows: !> - HIPBLAS_OP_N: op(A_i) = A_i. !> - HIPBLAS_OP_T: op(A_i) = A_i^T. !> - HIPBLAS_OP_C: op(A_i) = A_i^H. !> !> @param[in] diag - [hipblasDiagType_t] !> Specifies whether or not A_i is unit triangular as follows: !> - HIPBLAS_DIAG_UNIT: A_i is assumed to be unit triangular. !> - HIPBLAS_DIAG_NON_UNIT: A_i is not assumed to be unit triangular. !> !> @param[in] m - [int] !> m specifies the number of rows of B_i and C_i. m >= 0. !> !> @param[in] n - [int] !> n specifies the number of columns of B_i and C_i. n >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A_i is not referenced and B_i does not need to be set before !> entry. !> !> @param[in] A - Device array of device pointers storing each matrix A_i on the GPU. !> Each A_i is of dimension ( lda, k ), where k is m !> when side == HIPBLAS_SIDE_LEFT and !> is n when side == HIPBLAS_SIDE_RIGHT. !> - When uplo == HIPBLAS_FILL_MODE_UPPER, the leading k by k !> upper triangular part of the array A must contain the upper !> triangular matrix and the strictly lower triangular part of !> A is not referenced. !> - When uplo == HIPBLAS_FILL_MODE_LOWER, the leading k by k !> lower triangular part of the array A must contain the lower !> triangular matrix and the strictly upper triangular part of !> A is not referenced. !> - Note that when diag == HIPBLAS_DIAG_UNIT, the diagonal elements of !> A_i are not referenced either, but are assumed to be unity. !> !> @param[in] lda - [int] !> lda specifies the first dimension of A. !> - If side == HIPBLAS_SIDE_LEFT, lda >= max( 1, m ). !> - If side == HIPBLAS_SIDE_RIGHT, lda >= max( 1, n ). !> !> @param[inout] B - device array of device pointers storing each matrix B_i of !> dimension (ldb, n) on the GPU. !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B_i. ldb >= max( 1, m ). !> !> @param[in] C - device array of device pointers storing each matrix C_i of !> dimension (ldc, n) on the GPU. Users can pass in the same !> matrices B to parameter C to achieve in-place functionality of trmmBatched. !> !> @param[in] ldc - ldc specifies the first dimension of C_i. ldc >= max( 1, m ). !> !> @param[in] batchCount - [int] !> number of instances i in the batch. #ifndef USE_CUDA_NAMES interface hipblasStrmmBatched function hipblasStrmmBatched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc, & batchCount) & bind(c, name="hipblasStrmmBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtrmmBatched function hipblasDtrmmBatched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc, & batchCount) & bind(c, name="hipblasDtrmmBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtrmmBatched function hipblasCtrmmBatched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc, & batchCount) & bind(c, name="hipblasCtrmmBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtrmmBatched function hipblasZtrmmBatched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc, & batchCount) & bind(c, name="hipblasZtrmmBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasStrmmBatched_64 function hipblasStrmmBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc, & batchCount) & bind(c, name="hipblasStrmmBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtrmmBatched_64 function hipblasDtrmmBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc, & batchCount) & bind(c, name="hipblasDtrmmBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtrmmBatched_64 function hipblasCtrmmBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc, & batchCount) & bind(c, name="hipblasCtrmmBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtrmmBatched_64 function hipblasZtrmmBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc, & batchCount) & bind(c, name="hipblasZtrmmBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> !> The trmmStridedBatched functions perform one of the strided_batched matrix-matrix !> operations: !> !> C_i := alpha*op( A_i )*B_i, or C_i := alpha*B_i*op( A_i ) for i = 0, 1, ... batchCount !> -1 !> !> where ``alpha`` is a scalar, ``B_i`` and ``C_i`` are ``m`` by ``n`` matrices, ``A_i`` is a !> unit, or !> non-unit, upper, or lower triangular matrix, and ``op( A_i )`` is one of: !> !> op( A_i ) = A_i or op( A_i ) = A_i^T or op( A_i ) = A_i^H. !> !> Note that trmmStridedBatched can provide in-place functionality by passing !> in the same address for both matrices ``B`` and ``C`` and by setting ``ldb`` equal to !> ``ldc``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] side - [hipblasSideMode_t] !> Specifies whether op(A_i) multiplies B_i from the left or right as follows: !> - HIPBLAS_SIDE_LEFT: C_i := alpha*op( A_i )*B_i. !> - HIPBLAS_SIDE_RIGHT: C_i := alpha*B_i*op( A_i ). !> !> @param[in] uplo - [hipblasFillMode_t] !> Specifies whether the matrix A is an upper or lower triangular matrix as follows: !> - HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> Specifies the form of op(A_i) to be used in the matrix multiplication as follows: !> - HIPBLAS_OP_N: op(A_i) = A_i. !> - HIPBLAS_OP_T: op(A_i) = A_i^T. !> - HIPBLAS_OP_C: op(A_i) = A_i^H. !> !> @param[in] diag - [hipblasDiagType_t] !> Specifies whether or not A_i is unit triangular as follows: !> - HIPBLAS_DIAG_UNIT: A_i is assumed to be unit triangular. !> - HIPBLAS_DIAG_NON_UNIT: A_i is not assumed to be unit triangular. !> !> @param[in] m - [int] !> m specifies the number of rows of B_i and C_i. m >= 0. !> !> @param[in] n - [int] !> n specifies the number of columns of B_i and C_i. n >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A_i is not referenced and B_i does not need to be set before !> entry. !> !> @param[in] A - Device pointer to the first matrix A_0 on the GPU. !> Each A_i is of dimension ( lda, k ), where k is m !> when side == HIPBLAS_SIDE_LEFT and !> is n when side == HIPBLAS_SIDE_RIGHT. !> - When uplo == HIPBLAS_FILL_MODE_UPPER, the leading k by k !> upper triangular part of the array A must contain the upper !> triangular matrix and the strictly lower triangular part of !> A is not referenced. !> - When uplo == HIPBLAS_FILL_MODE_LOWER, the leading k by k !> lower triangular part of the array A must contain the lower !> triangular matrix and the strictly upper triangular part of !> A is not referenced. !> - Note that when diag == HIPBLAS_DIAG_UNIT, the diagonal elements of !> A_i are not referenced either, but are assumed to be unity. !> !> @param[in] lda - [int] !> lda specifies the first dimension of A. !> - if side == HIPBLAS_SIDE_LEFT, lda >= max( 1, m ). !> - if side == HIPBLAS_SIDE_RIGHT, lda >= max( 1, n ). !> !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[inout] B - Device pointer to the first matrix B_0 on the GPU. Each B_i is of !> dimension ( ldb, n ). !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B_i. ldb >= max( 1, m ). !> !> @param[in] strideB - [hipblasStride] !> stride from the start of one matrix (B_i) to the next one (B_i+1). !> !> @param[in] C - Device pointer to the first matrix C_0 on the GPU. Each C_i is of !> dimension ( ldc, n ). !> !> @param[in] ldc - [int] !> ldc specifies the first dimension of C_i. ldc >= max( 1, m ). !> !> @param[in] strideC - [hipblasStride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> !> @param[in] batchCount - [int] !> number of instances i in the batch. #ifndef USE_CUDA_NAMES interface hipblasStrmmStridedBatched function hipblasStrmmStridedBatched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,strideA,B, & ldb,strideB,C,ldc,strideC,batchCount) & bind(c, name="hipblasStrmmStridedBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha 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 :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasStrmmStridedBatched_assumed_rank #else module procedure & hipblasStrmmStridedBatched_rank_0,& hipblasStrmmStridedBatched_rank_1,& hipblasStrmmStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtrmmStridedBatched function hipblasDtrmmStridedBatched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,strideA,B, & ldb,strideB,C,ldc,strideC,batchCount) & bind(c, name="hipblasDtrmmStridedBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha 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 :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDtrmmStridedBatched_assumed_rank #else module procedure & hipblasDtrmmStridedBatched_rank_0,& hipblasDtrmmStridedBatched_rank_1,& hipblasDtrmmStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtrmmStridedBatched function hipblasCtrmmStridedBatched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,strideA,B, & ldb,strideB,C,ldc,strideC,batchCount) & bind(c, name="hipblasCtrmmStridedBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha 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 :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCtrmmStridedBatched_assumed_rank #else module procedure & hipblasCtrmmStridedBatched_rank_0,& hipblasCtrmmStridedBatched_rank_1,& hipblasCtrmmStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtrmmStridedBatched function hipblasZtrmmStridedBatched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,strideA,B, & ldb,strideB,C,ldc,strideC,batchCount) & bind(c, name="hipblasZtrmmStridedBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha 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 :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZtrmmStridedBatched_assumed_rank #else module procedure & hipblasZtrmmStridedBatched_rank_0,& hipblasZtrmmStridedBatched_rank_1,& hipblasZtrmmStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasStrmmStridedBatched_64 function hipblasStrmmStridedBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,strideA, & B,ldb,strideB,C,ldc,strideC,batchCount) & bind(c, name="hipblasStrmmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtrmmStridedBatched_64 function hipblasDtrmmStridedBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,strideA, & B,ldb,strideB,C,ldc,strideC,batchCount) & bind(c, name="hipblasDtrmmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtrmmStridedBatched_64 function hipblasCtrmmStridedBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,strideA, & B,ldb,strideB,C,ldc,strideC,batchCount) & bind(c, name="hipblasCtrmmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtrmmStridedBatched_64 function hipblasZtrmmStridedBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,strideA, & B,ldb,strideB,C,ldc,strideC,batchCount) & bind(c, name="hipblasZtrmmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> !> The trsm functions solve: !> !> op(A)*X = alpha*B or X*op(A) = alpha*B, !> !> where ``alpha`` is a scalar, ``X`` and ``B`` are ``m`` by ``n`` matrices, !> ``A`` is triangular matrix, and ``op(A)`` is one of: !> !> op( A ) = A or op( A ) = A^T or op( A ) = A^H. !> !> The matrix ``X`` is overwritten on ``B``. !> !> Note about memory allocation: !> When trsm is launched with a ``k`` evenly divisible by the internal block size of 128 !> and is no larger than 10 of these blocks, the API uses preallocated !> memory found in the handle to increase overall performance (where ``k`` is ``m`` when !> ``HIPBLAS_SIDE_LEFT`` and is ``n`` when ``HIPBLAS_SIDE_RIGHT``). For more information on !> preallocated memory in the handle, see the Device Memory Allocation !> in rocBLAS section of the rocBLAS API Reference. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] side - [hipblasSideMode_t] !> - HIPBLAS_SIDE_LEFT: op(A)*X = alpha*B. !> - HIPBLAS_SIDE_RIGHT: X*op(A) = alpha*B. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_N: op(A) = A. !> - HIPBLAS_OP_T: op(A) = A^T. !> - HIPBLAS_OP_C: op(A) = A^H. !> !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular. !> - HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular. !> !> @param[in] m - [int] !> m specifies the number of rows of B. m >= 0. !> !> @param[in] n - [int] !> n specifies the number of columns of B. n >= 0. !> !> @param[in] alpha !> device pointer or host pointer specifying the scalar alpha. When alpha is !> &zero, then A is not referenced and B does not need to be set before !> entry. !> !> @param[in] AP - device pointer storing matrix A. !> Of dimension ( lda, k ), where k is m !> when HIPBLAS_SIDE_LEFT and !> is n when HIPBLAS_SIDE_RIGHT. !> Only the upper/lower triangular part is accessed. !> !> @param[in] lda - [int] !> lda specifies the first dimension of A. !> - If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ). !> - If side = HIPBLAS_SIDE_RIGHT, lda >= max( 1, n ). !> !> @param[in,out] BP - device pointer storing matrix B. !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B. ldb >= max( 1, m ). interface hipblasStrsm #ifdef USE_CUDA_NAMES function hipblasStrsm_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) & bind(c, name="cublasStrsm_v2") #else function hipblasStrsm_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) & bind(c, name="hipblasStrsm") #endif use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasStrsm_assumed_rank #else module procedure & hipblasStrsm_rank_0,& hipblasStrsm_rank_1,& hipblasStrsm_full_rank #endif #endif end interface interface hipblasDtrsm #ifdef USE_CUDA_NAMES function hipblasDtrsm_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) & bind(c, name="cublasDtrsm_v2") #else function hipblasDtrsm_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) & bind(c, name="hipblasDtrsm") #endif use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDtrsm_assumed_rank #else module procedure & hipblasDtrsm_rank_0,& hipblasDtrsm_rank_1,& hipblasDtrsm_full_rank #endif #endif end interface interface hipblasCtrsm #ifdef USE_CUDA_NAMES function hipblasCtrsm_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) & bind(c, name="cublasCtrsm_v2") #else function hipblasCtrsm_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) & bind(c, name="hipblasCtrsm") #endif use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCtrsm_assumed_rank #else module procedure & hipblasCtrsm_rank_0,& hipblasCtrsm_rank_1,& hipblasCtrsm_full_rank #endif #endif end interface interface hipblasZtrsm #ifdef USE_CUDA_NAMES function hipblasZtrsm_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) & bind(c, name="cublasZtrsm_v2") #else function hipblasZtrsm_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) & bind(c, name="hipblasZtrsm") #endif use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZtrsm_assumed_rank #else module procedure & hipblasZtrsm_rank_0,& hipblasZtrsm_rank_1,& hipblasZtrsm_full_rank #endif #endif end interface interface hipblasStrsm_64 #ifdef USE_CUDA_NAMES function hipblasStrsm_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) & bind(c, name="cublasStrsm_v2_64") #else function hipblasStrsm_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) & bind(c, name="hipblasStrsm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb end function end interface interface hipblasDtrsm_64 #ifdef USE_CUDA_NAMES function hipblasDtrsm_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) & bind(c, name="cublasDtrsm_v2_64") #else function hipblasDtrsm_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) & bind(c, name="hipblasDtrsm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb end function end interface interface hipblasCtrsm_64 #ifdef USE_CUDA_NAMES function hipblasCtrsm_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) & bind(c, name="cublasCtrsm_v2_64") #else function hipblasCtrsm_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) & bind(c, name="hipblasCtrsm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb end function end interface interface hipblasZtrsm_64 #ifdef USE_CUDA_NAMES function hipblasZtrsm_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) & bind(c, name="cublasZtrsm_v2_64") #else function hipblasZtrsm_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) & bind(c, name="hipblasZtrsm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb end function end interface !> \brief BLAS Level 3 API !> !> \details !> The trsmBatched functions perform the following batched operation: !> !> op(A_i)*X_i = alpha*B_i or X_i*op(A_i) = alpha*B_i, for i = 1, ..., batchCount. !> !> where ``alpha`` is a scalar, ``X`` and ``B`` are batched ``m`` by ``n`` matrices, !> ``A`` is a triangular batched matrix, and ``op(A)`` is one of: !> !> op( A ) = A or op( A ) = A^T or op( A ) = A^H. !> !> Each matrix ``X_i`` is overwritten on ``B_i`` for ``i`` = 1, ..., ``batchCount``. !> !> Note about memory allocation: !> When trsm is launched with a ``k`` evenly divisible by the internal block size of 128 !> and is no larger than 10 of these blocks, the API uses preallocated !> memory found in the handle to increase overall performance (where ``k`` is ``m`` when !> ``HIPBLAS_SIDE_LEFT`` and is ``n`` when ``HIPBLAS_SIDE_RIGHT``). For more information on !> preallocated memory in the handle, see the Device Memory Allocation !> in rocBLAS section of the rocBLAS API Reference. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] side - [hipblasSideMode_t] !> - HIPBLAS_SIDE_LEFT: op(A)*X = alpha*B. !> - HIPBLAS_SIDE_RIGHT: X*op(A) = alpha*B. !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: each A_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: each A_i is a lower triangular matrix. !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_N: op(A) = A. !> - HIPBLAS_OP_T: op(A) = A^T. !> - HIPBLAS_OP_C: op(A) = A^H. !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: each A_i is assumed to be unit triangular. !> - HIPBLAS_DIAG_NON_UNIT: each A_i is not assumed to be unit triangular. !> @param[in] m - [int] !> m specifies the number of rows of each B_i. m >= 0. !> @param[in] n - [int] !> n specifies the number of columns of each B_i. n >= 0. !> @param[in] alpha !> device pointer or host pointer specifying the scalar alpha. When alpha is !> &zero, then A is not referenced and B does not need to be set before !> entry. !> @param[in] AP - device array of device pointers storing each matrix A_i on the GPU. !> Matricies are of dimension ( lda, k ), where k is m !> when HIPBLAS_SIDE_LEFT and is n when HIPBLAS_SIDE_RIGHT. !> Only the upper/lower triangular part is accessed. !> @param[in] lda - [int] !> lda specifies the first dimension of each A_i. !> - If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ). !> - If side = HIPBLAS_SIDE_RIGHT, lda >= max( 1, n ). !> @param[in,out] BP - device array of device pointers storing each matrix B_i on the GPU. !> @param[in] ldb - [int] !> ldb specifies the first dimension of each B_i. ldb >= max( 1, m ). !> @param[in] batchCount - [int] !> number of trsm operatons in the batch. interface hipblasStrsmBatched #ifdef USE_CUDA_NAMES function hipblasStrsmBatched_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb,batchCount) & bind(c, name="cublasStrsmBatched") #else function hipblasStrsmBatched_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb,batchCount) & bind(c, name="hipblasStrsmBatched") #endif use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int),value :: batchCount end function end interface interface hipblasDtrsmBatched #ifdef USE_CUDA_NAMES function hipblasDtrsmBatched_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb,batchCount) & bind(c, name="cublasDtrsmBatched") #else function hipblasDtrsmBatched_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb,batchCount) & bind(c, name="hipblasDtrsmBatched") #endif use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int),value :: batchCount end function end interface interface hipblasCtrsmBatched #ifdef USE_CUDA_NAMES function hipblasCtrsmBatched_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb,batchCount) & bind(c, name="cublasCtrsmBatched") #else function hipblasCtrsmBatched_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb,batchCount) & bind(c, name="hipblasCtrsmBatched") #endif use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int),value :: batchCount end function end interface interface hipblasZtrsmBatched #ifdef USE_CUDA_NAMES function hipblasZtrsmBatched_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb,batchCount) & bind(c, name="cublasZtrsmBatched") #else function hipblasZtrsmBatched_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb,batchCount) & bind(c, name="hipblasZtrsmBatched") #endif use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int),value :: batchCount end function end interface interface hipblasStrsmBatched_64 #ifdef USE_CUDA_NAMES function hipblasStrsmBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb, & batchCount) & bind(c, name="cublasStrsmBatched_64") #else function hipblasStrsmBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb, & batchCount) & bind(c, name="hipblasStrsmBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batchCount end function end interface interface hipblasDtrsmBatched_64 #ifdef USE_CUDA_NAMES function hipblasDtrsmBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb, & batchCount) & bind(c, name="cublasDtrsmBatched_64") #else function hipblasDtrsmBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb, & batchCount) & bind(c, name="hipblasDtrsmBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batchCount end function end interface interface hipblasCtrsmBatched_64 #ifdef USE_CUDA_NAMES function hipblasCtrsmBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb, & batchCount) & bind(c, name="cublasCtrsmBatched_64") #else function hipblasCtrsmBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb, & batchCount) & bind(c, name="hipblasCtrsmBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batchCount end function end interface interface hipblasZtrsmBatched_64 #ifdef USE_CUDA_NAMES function hipblasZtrsmBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb, & batchCount) & bind(c, name="cublasZtrsmBatched_64") #else function hipblasZtrsmBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb, & batchCount) & bind(c, name="hipblasZtrsmBatched_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batchCount end function end interface !> \brief BLAS Level 3 API !> !> \details !> The trsmStridedBatched functions perform the following strided batched operation: !> !> op(A_i)*X_i = alpha*B_i or X_i*op(A_i) = alpha*B_i, for i = 1, ..., batchCount. !> !> where ``alpha`` is a scalar, ``X`` and ``B`` are strided batched ``m`` by ``n`` matrices, !> ``A`` is a triangular strided batched matrix, and ``op(A)`` is one of: !> !> op( A ) = A or op( A ) = A^T or op( A ) = A^H. !> !> Each matrix ``X_i`` is overwritten on ``B_i`` for ``i`` = 1, ..., ``batchCount``. !> !> Note about memory allocation: !> When trsm is launched with a ``k`` evenly divisible by the internal block size of 128 !> and is no larger than 10 of these blocks, the API uses preallocated !> memory found in the handle to increase overall performance (where ``k`` is ``m`` when !> ``HIPBLAS_SIDE_LEFT`` and is ``n`` when ``HIPBLAS_SIDE_RIGHT``). For more information on !> preallocated memory in the handle, see the Device Memory Allocation !> in rocBLAS section of the rocBLAS API Reference. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] side - [hipblasSideMode_t] !> - HIPBLAS_SIDE_LEFT: op(A)*X = alpha*B. !> - HIPBLAS_SIDE_RIGHT: X*op(A) = alpha*B. !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: each A_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: each A_i is a lower triangular matrix. !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_N: op(A) = A. !> - HIPBLAS_OP_T: op(A) = A^T. !> - HIPBLAS_OP_C: op(A) = A^H. !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: each A_i is assumed to be unit triangular. !> - HIPBLAS_DIAG_NON_UNIT: each A_i is not assumed to be unit triangular. !> @param[in] m - [int] !> m specifies the number of rows of each B_i. m >= 0. !> @param[in] n - [int] !> n specifies the number of columns of each B_i. n >= 0. !> @param[in] alpha !> device pointer or host pointer specifying the scalar alpha. When alpha is !> &zero, then A is not referenced and B does not need to be set before !> entry. !> @param[in] AP - device pointer pointing to the first matrix A_1. !> Of dimension ( lda, k ), where k is m !> when HIPBLAS_SIDE_LEFT and !> is n when HIPBLAS_SIDE_RIGHT. !> Only the upper/lower triangular part is accessed. !> @param[in] lda - [int] !> lda specifies the first dimension of each A_i. !> - If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ). !> - If side = HIPBLAS_SIDE_RIGHT, lda >= max( 1, n ). !> @param[in] strideA - [hipblasStride] !> stride from the start of one A_i matrix to the next A_(i + 1). !> @param[in,out] BP - device pointer pointing to the first matrix B_1. !> @param[in] ldb - [int] !> ldb specifies the first dimension of each B_i. ldb >= max( 1, m ). !> @param[in] strideB - [hipblasStride] !> stride from the start of one B_i matrix to the next B_(i + 1). !> @param[in] batchCount - [int] !> number of trsm operatons in the batch. #ifndef USE_CUDA_NAMES interface hipblasStrsmStridedBatched function hipblasStrsmStridedBatched_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,strideA,BP, & ldb,strideB,batchCount) & bind(c, name="hipblasStrsmStridedBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasStrsmStridedBatched_assumed_rank #else module procedure & hipblasStrsmStridedBatched_rank_0,& hipblasStrsmStridedBatched_rank_1,& hipblasStrsmStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtrsmStridedBatched function hipblasDtrsmStridedBatched_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,strideA,BP, & ldb,strideB,batchCount) & bind(c, name="hipblasDtrsmStridedBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDtrsmStridedBatched_assumed_rank #else module procedure & hipblasDtrsmStridedBatched_rank_0,& hipblasDtrsmStridedBatched_rank_1,& hipblasDtrsmStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtrsmStridedBatched function hipblasCtrsmStridedBatched_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,strideA,BP, & ldb,strideB,batchCount) & bind(c, name="hipblasCtrsmStridedBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCtrsmStridedBatched_assumed_rank #else module procedure & hipblasCtrsmStridedBatched_rank_0,& hipblasCtrsmStridedBatched_rank_1,& hipblasCtrsmStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtrsmStridedBatched function hipblasZtrsmStridedBatched_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,strideA,BP, & ldb,strideB,batchCount) & bind(c, name="hipblasZtrsmStridedBatched") use iso_c_binding use hipfort_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_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int),value :: ldb integer(c_int64_t),value :: strideB integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZtrsmStridedBatched_assumed_rank #else module procedure & hipblasZtrsmStridedBatched_rank_0,& hipblasZtrsmStridedBatched_rank_1,& hipblasZtrsmStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasStrsmStridedBatched_64 function hipblasStrsmStridedBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,strideA, & BP,ldb,strideB,batchCount) & bind(c, name="hipblasStrsmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtrsmStridedBatched_64 function hipblasDtrsmStridedBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,strideA, & BP,ldb,strideB,batchCount) & bind(c, name="hipblasDtrsmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtrsmStridedBatched_64 function hipblasCtrsmStridedBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,strideA, & BP,ldb,strideB,batchCount) & bind(c, name="hipblasCtrsmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtrsmStridedBatched_64 function hipblasZtrsmStridedBatched_64_(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,strideA, & BP,ldb,strideB,batchCount) & bind(c, name="hipblasZtrsmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: BP integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> The trtri functions compute the inverse of a matrix A, namely: !> !> invA !> !> and write the result into ``invA``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> - If HIPBLAS_FILL_MODE_UPPER, the lower part of A is not referenced. !> - If HIPBLAS_FILL_MODE_LOWER, the upper part of A is not referenced. !> @param[in] diag - [hipblasDiagType_t] !> - 'HIPBLAS_DIAG_NON_UNIT', A is non-unit triangular. !> - 'HIPBLAS_DIAG_UNIT', A is unit triangular. !> @param[in] n - [int] !> size of matrix A and invA. !> @param[in] AP - device pointer storing matrix A. !> @param[in] lda - [int] !> specifies the leading dimension of A. !> @param[out] invA - device pointer storing matrix invA. !> @param[in] ldinvA - [int] !> specifies the leading dimension of invA. #ifndef USE_CUDA_NAMES interface hipblasStrtri function hipblasStrtri_(handle,uplo,diag,n,AP,lda,invA,ldinvA) bind(c, name="hipblasStrtri") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrtri_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: invA integer(c_int),value :: ldinvA end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasStrtri_assumed_rank #else module procedure & hipblasStrtri_rank_0,& hipblasStrtri_rank_1,& hipblasStrtri_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtrtri function hipblasDtrtri_(handle,uplo,diag,n,AP,lda,invA,ldinvA) bind(c, name="hipblasDtrtri") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrtri_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: invA integer(c_int),value :: ldinvA end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDtrtri_assumed_rank #else module procedure & hipblasDtrtri_rank_0,& hipblasDtrtri_rank_1,& hipblasDtrtri_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtrtri function hipblasCtrtri_(handle,uplo,diag,n,AP,lda,invA,ldinvA) bind(c, name="hipblasCtrtri") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrtri_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: invA integer(c_int),value :: ldinvA end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCtrtri_assumed_rank #else module procedure & hipblasCtrtri_rank_0,& hipblasCtrtri_rank_1,& hipblasCtrtri_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtrtri function hipblasZtrtri_(handle,uplo,diag,n,AP,lda,invA,ldinvA) bind(c, name="hipblasZtrtri") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrtri_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: invA integer(c_int),value :: ldinvA end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZtrtri_assumed_rank #else module procedure & hipblasZtrtri_rank_0,& hipblasZtrtri_rank_1,& hipblasZtrtri_full_rank #endif #endif end interface #endif !> \brief BLAS Level 3 API !> !> \details !> The trtriBatched functions compute the inverse of ``A_i`` and write into ``invA_i``, where !> ``A_i`` and ``invA_i`` are the ``i``-th matrices in the batch, !> for ``i`` = 1, ..., ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> @param[in] diag - [hipblasDiagType_t] !> - 'HIPBLAS_DIAG_NON_UNIT', A is non-unit triangular. !> - 'HIPBLAS_DIAG_UNIT', A is unit triangular. !> @param[in] n - [int] !> @param[in] AP - device array of device pointers storing each matrix A_i. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. !> @param[out] invA - device array of device pointers storing the inverse of each matrix A_i. !> Partial inplace operation is supported, see below. !> - If UPLO = 'U', the leading N-by-N upper triangular part of the invA will store !> the inverse of the upper triangular matrix, and the strictly lower !> triangular part of invA is cleared. !> - If UPLO = 'L', the leading N-by-N lower triangular part of the invA will store !> the inverse of the lower triangular matrix, and the strictly upper !> triangular part of invA is cleared. !> @param[in] ldinvA - [int] !> specifies the leading dimension of each invA_i. !> @param[in] batchCount - [int] !> numbers of matrices in the batch. #ifndef USE_CUDA_NAMES interface hipblasStrtriBatched function hipblasStrtriBatched_(handle,uplo,diag,n,AP,lda,invA,ldinvA,batchCount) & bind(c, name="hipblasStrtriBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrtriBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: invA integer(c_int),value :: ldinvA integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtrtriBatched function hipblasDtrtriBatched_(handle,uplo,diag,n,AP,lda,invA,ldinvA,batchCount) & bind(c, name="hipblasDtrtriBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrtriBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: invA integer(c_int),value :: ldinvA integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtrtriBatched function hipblasCtrtriBatched_(handle,uplo,diag,n,AP,lda,invA,ldinvA,batchCount) & bind(c, name="hipblasCtrtriBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrtriBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: invA integer(c_int),value :: ldinvA integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtrtriBatched function hipblasZtrtriBatched_(handle,uplo,diag,n,AP,lda,invA,ldinvA,batchCount) & bind(c, name="hipblasZtrtriBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrtriBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: invA integer(c_int),value :: ldinvA integer(c_int),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> The trtriStridedBatched functions compute the inverse of ``A_i`` and write into ``invA_i``, !> where !> ``A_i`` and ``invA_i`` are the ``i``-th matrices in the batch, !> for ``i`` = 1, ..., ``batchCount``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> specifies either upper (HIPBLAS_FILL_MODE_UPPER) or lower !> (HIPBLAS_FILL_MODE_LOWER): !> @param[in] diag - [hipblasDiagType_t] !> - 'HIPBLAS_DIAG_NON_UNIT', A is non-unit triangular. !> - 'HIPBLAS_DIAG_UNIT', A is unit triangular. !> @param[in] n - [int] !> @param[in] AP - device pointer pointing to address of first matrix A_1. !> @param[in] lda - [int] !> specifies the leading dimension of each A. !> @param[in] strideA - [hipblasStride] !> "batch stride a": stride from the start of one A_i matrix to the next A_(i + 1). !> @param[out] invA - device pointer storing the inverses of each matrix A_i. !> Partial inplace operation is supported, see below. !> - If UPLO = 'U', the leading N-by-N upper triangular part of the invA will store !> the inverse of the upper triangular matrix, and the strictly lower !> triangular part of invA is cleared. !> - If UPLO = 'L', the leading N-by-N lower triangular part of the invA will store !> the inverse of the lower triangular matrix, and the strictly upper !> triangular part of invA is cleared. !> @param[in] ldinvA - [int] !> specifies the leading dimension of each invA_i. !> @param[in] stride_invA - [hipblasStride] !> "batch stride invA": stride from the start of one invA_i matrix to the next !> invA_(i + 1). !> @param[in] batchCount - [int] !> numbers of matrices in the batch. #ifndef USE_CUDA_NAMES interface hipblasStrtriStridedBatched function hipblasStrtriStridedBatched_(handle,uplo,diag,n,AP,lda,strideA,invA,ldinvA, & stride_invA,batchCount) & bind(c, name="hipblasStrtriStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrtriStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: invA integer(c_int),value :: ldinvA integer(c_int64_t),value :: stride_invA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasStrtriStridedBatched_assumed_rank #else module procedure & hipblasStrtriStridedBatched_rank_0,& hipblasStrtriStridedBatched_rank_1,& hipblasStrtriStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDtrtriStridedBatched function hipblasDtrtriStridedBatched_(handle,uplo,diag,n,AP,lda,strideA,invA,ldinvA, & stride_invA,batchCount) & bind(c, name="hipblasDtrtriStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrtriStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: invA integer(c_int),value :: ldinvA integer(c_int64_t),value :: stride_invA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDtrtriStridedBatched_assumed_rank #else module procedure & hipblasDtrtriStridedBatched_rank_0,& hipblasDtrtriStridedBatched_rank_1,& hipblasDtrtriStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCtrtriStridedBatched function hipblasCtrtriStridedBatched_(handle,uplo,diag,n,AP,lda,strideA,invA,ldinvA, & stride_invA,batchCount) & bind(c, name="hipblasCtrtriStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrtriStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: invA integer(c_int),value :: ldinvA integer(c_int64_t),value :: stride_invA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCtrtriStridedBatched_assumed_rank #else module procedure & hipblasCtrtriStridedBatched_rank_0,& hipblasCtrtriStridedBatched_rank_1,& hipblasCtrtriStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZtrtriStridedBatched function hipblasZtrtriStridedBatched_(handle,uplo,diag,n,AP,lda,strideA,invA,ldinvA, & stride_invA,batchCount) & bind(c, name="hipblasZtrtriStridedBatched") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrtriStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: invA integer(c_int),value :: ldinvA integer(c_int64_t),value :: stride_invA integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZtrtriStridedBatched_assumed_rank #else module procedure & hipblasZtrtriStridedBatched_rank_0,& hipblasZtrtriStridedBatched_rank_1,& hipblasZtrtriStridedBatched_full_rank #endif #endif end interface #endif !> \brief BLAS Level 3 API !> !> \details !> The dgmm functions perform one of the matrix-matrix operations: !> !> C = A * diag(x) if side == HIPBLAS_SIDE_RIGHT !> C = diag(x) * A if side == HIPBLAS_SIDE_LEFT !> !> where ``C`` and ``A`` are ``m`` by ``n`` dimensional matrices, ``diag( x )`` is a diagonal !> matrix, !> and ``x`` is a vector of dimension ``n`` if ``side == HIPBLAS_SIDE_RIGHT`` and dimension !> ``m`` !> if ``side == HIPBLAS_SIDE_LEFT``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] side - [hipblasSideMode_t] !> specifies the side of diag(x). !> @param[in] m - [int] !> matrix dimension m. !> @param[in] n - [int] !> matrix dimension n. !> @param[in] AP - device pointer storing matrix A. !> @param[in] lda - [int] !> specifies the leading dimension of A. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [int] !> specifies the increment between values of x !> @param[in, out] CP - device pointer storing matrix C. !> @param[in] ldc - [int] !> specifies the leading dimension of C. interface hipblasSdgmm #ifdef USE_CUDA_NAMES function hipblasSdgmm_(handle,side,m,n,AP,lda,x,incx,CP,ldc) bind(c, name="cublasSdgmm") #else function hipblasSdgmm_(handle,side,m,n,AP,lda,x,incx,CP,ldc) bind(c, name="hipblasSdgmm") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSdgmm_assumed_rank #else module procedure & hipblasSdgmm_rank_0,& hipblasSdgmm_rank_1,& hipblasSdgmm_full_rank #endif #endif end interface interface hipblasDdgmm #ifdef USE_CUDA_NAMES function hipblasDdgmm_(handle,side,m,n,AP,lda,x,incx,CP,ldc) bind(c, name="cublasDdgmm") #else function hipblasDdgmm_(handle,side,m,n,AP,lda,x,incx,CP,ldc) bind(c, name="hipblasDdgmm") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDdgmm_assumed_rank #else module procedure & hipblasDdgmm_rank_0,& hipblasDdgmm_rank_1,& hipblasDdgmm_full_rank #endif #endif end interface interface hipblasCdgmm #ifdef USE_CUDA_NAMES function hipblasCdgmm_(handle,side,m,n,AP,lda,x,incx,CP,ldc) bind(c, name="cublasCdgmm") #else function hipblasCdgmm_(handle,side,m,n,AP,lda,x,incx,CP,ldc) bind(c, name="hipblasCdgmm") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCdgmm_assumed_rank #else module procedure & hipblasCdgmm_rank_0,& hipblasCdgmm_rank_1,& hipblasCdgmm_full_rank #endif #endif end interface interface hipblasZdgmm #ifdef USE_CUDA_NAMES function hipblasZdgmm_(handle,side,m,n,AP,lda,x,incx,CP,ldc) bind(c, name="cublasZdgmm") #else function hipblasZdgmm_(handle,side,m,n,AP,lda,x,incx,CP,ldc) bind(c, name="hipblasZdgmm") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: CP integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZdgmm_assumed_rank #else module procedure & hipblasZdgmm_rank_0,& hipblasZdgmm_rank_1,& hipblasZdgmm_full_rank #endif #endif end interface interface hipblasSdgmm_64 #ifdef USE_CUDA_NAMES function hipblasSdgmm_64_(handle,side,m,n,AP,lda,x,incx,CP,ldc) bind(c, name="cublasSdgmm_64") #else function hipblasSdgmm_64_(handle,side,m,n,AP,lda,x,incx,CP,ldc) bind(c, name="hipblasSdgmm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdgmm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasDdgmm_64 #ifdef USE_CUDA_NAMES function hipblasDdgmm_64_(handle,side,m,n,AP,lda,x,incx,CP,ldc) bind(c, name="cublasDdgmm_64") #else function hipblasDdgmm_64_(handle,side,m,n,AP,lda,x,incx,CP,ldc) bind(c, name="hipblasDdgmm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdgmm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasCdgmm_64 #ifdef USE_CUDA_NAMES function hipblasCdgmm_64_(handle,side,m,n,AP,lda,x,incx,CP,ldc) bind(c, name="cublasCdgmm_64") #else function hipblasCdgmm_64_(handle,side,m,n,AP,lda,x,incx,CP,ldc) bind(c, name="hipblasCdgmm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdgmm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface interface hipblasZdgmm_64 #ifdef USE_CUDA_NAMES function hipblasZdgmm_64_(handle,side,m,n,AP,lda,x,incx,CP,ldc) bind(c, name="cublasZdgmm_64") #else function hipblasZdgmm_64_(handle,side,m,n,AP,lda,x,incx,CP,ldc) bind(c, name="hipblasZdgmm_64") #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdgmm_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: CP integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> The dgmmBatched functions perform one of the batched matrix-matrix operations: !> !> C_i = A_i * diag(x_i) for i = 0, 1, ... batchCount-1 if side == HIPBLAS_SIDE_RIGHT !> C_i = diag(x_i) * A_i for i = 0, 1, ... batchCount-1 if side == HIPBLAS_SIDE_LEFT !> !> where ``C_i`` and ``A_i`` are ``m`` by ``n`` dimensional matrices, ``diag(x_i)`` is a !> diagonal matrix !> and ``x_i`` is vector of dimension ``n`` if ``side == HIPBLAS_SIDE_RIGHT`` and dimension !> ``m`` !> if ``side == HIPBLAS_SIDE_LEFT``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] side - [hipblasSideMode_t] !> specifies the side of diag(x). !> @param[in] m - [int] !> matrix dimension m. !> @param[in] n - [int] !> matrix dimension n. !> @param[in] AP - device array of device pointers storing each matrix A_i on the GPU. !> Each A_i is of dimension ( lda, n ). !> @param[in] lda - [int] !> specifies the leading dimension of A_i. !> @param[in] x - device array of device pointers storing each vector x_i on the GPU. !> Each x_i is of dimension n if side == HIPBLAS_SIDE_RIGHT and dimension !> m if side == HIPBLAS_SIDE_LEFT. !> @param[in] incx - [int] !> specifies the increment between values of x_i. !> @param[in, out] CP - device array of device pointers storing each matrix C_i on the GPU. !> Each C_i is of dimension ( ldc, n ). !> @param[in] ldc - [int] !> specifies the leading dimension of C_i. !> @param[in] batchCount - [int] !> number of instances in the batch. #ifndef USE_CUDA_NAMES interface hipblasSdgmmBatched function hipblasSdgmmBatched_(handle,side,m,n,AP,lda,x,incx,CP,ldc,batchCount) & bind(c, name="hipblasSdgmmBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDdgmmBatched function hipblasDdgmmBatched_(handle,side,m,n,AP,lda,x,incx,CP,ldc,batchCount) & bind(c, name="hipblasDdgmmBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCdgmmBatched function hipblasCdgmmBatched_(handle,side,m,n,AP,lda,x,incx,CP,ldc,batchCount) & bind(c, name="hipblasCdgmmBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdgmmBatched function hipblasZdgmmBatched_(handle,side,m,n,AP,lda,x,incx,CP,ldc,batchCount) & bind(c, name="hipblasZdgmmBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSdgmmBatched_64 function hipblasSdgmmBatched_64_(handle,side,m,n,AP,lda,x,incx,CP,ldc,batchCount) & bind(c, name="hipblasSdgmmBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdgmmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDdgmmBatched_64 function hipblasDdgmmBatched_64_(handle,side,m,n,AP,lda,x,incx,CP,ldc,batchCount) & bind(c, name="hipblasDdgmmBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdgmmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCdgmmBatched_64 function hipblasCdgmmBatched_64_(handle,side,m,n,AP,lda,x,incx,CP,ldc,batchCount) & bind(c, name="hipblasCdgmmBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdgmmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdgmmBatched_64 function hipblasZdgmmBatched_64_(handle,side,m,n,AP,lda,x,incx,CP,ldc,batchCount) & bind(c, name="hipblasZdgmmBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdgmmBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief BLAS Level 3 API !> !> \details !> The dgmmStridedBatched functions perform one of the batched matrix-matrix operations: !> !> C_i = A_i * diag(x_i) if side == HIPBLAS_SIDE_RIGHT for i = 0, 1, ... batchCount-1 !> C_i = diag(x_i) * A_i if side == HIPBLAS_SIDE_LEFT for i = 0, 1, ... batchCount-1 !> !> where ``C_i`` and ``A_i`` are ``m`` by ``n`` dimensional matrices, ``diag(x_i)`` is a !> diagonal matrix, !> and ``x_i`` is a vector of dimension ``n`` if ``side == HIPBLAS_SIDE_RIGHT`` and dimension !> ``m`` !> if ``side == HIPBLAS_SIDE_LEFT``. !> !> - Supported precisions in rocBLAS : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] side - [hipblasSideMode_t] !> specifies the side of diag(x). !> @param[in] m - [int] !> matrix dimension m. !> @param[in] n - [int] !> matrix dimension n. !> @param[in] AP - device pointer to the first matrix A_0 on the GPU. !> Each A_i is of dimension ( lda, n ). !> @param[in] lda - [int] !> specifies the leading dimension of A. !> @param[in] strideA - [hipblasStride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> @param[in] x - pointer to the first vector x_0 on the GPU. !> Each x_i is of dimension n if side == HIPBLAS_SIDE_RIGHT and dimension !> m if side == HIPBLAS_SIDE_LEFT. !> @param[in] incx - [int] !> specifies the increment between values of x. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector(x_i) to the next one (x_i+1). !> @param[in, out] CP - device pointer to the first matrix C_0 on the GPU. !> Each C_i is of dimension ( ldc, n ). !> @param[in] ldc - [int] !> specifies the leading dimension of C. !> @param[in] strideC - [hipblasStride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> @param[in] batchCount - [int] !> number of instances i in the batch. #ifndef USE_CUDA_NAMES interface hipblasSdgmmStridedBatched function hipblasSdgmmStridedBatched_(handle,side,m,n,AP,lda,strideA,x,incx,stridex,CP,ldc, & strideC,batchCount) & bind(c, name="hipblasSdgmmStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSdgmmStridedBatched_assumed_rank #else module procedure & hipblasSdgmmStridedBatched_rank_0,& hipblasSdgmmStridedBatched_rank_1,& hipblasSdgmmStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDdgmmStridedBatched function hipblasDdgmmStridedBatched_(handle,side,m,n,AP,lda,strideA,x,incx,stridex,CP,ldc, & strideC,batchCount) & bind(c, name="hipblasDdgmmStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDdgmmStridedBatched_assumed_rank #else module procedure & hipblasDdgmmStridedBatched_rank_0,& hipblasDdgmmStridedBatched_rank_1,& hipblasDdgmmStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCdgmmStridedBatched function hipblasCdgmmStridedBatched_(handle,side,m,n,AP,lda,strideA,x,incx,stridex,CP,ldc, & strideC,batchCount) & bind(c, name="hipblasCdgmmStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCdgmmStridedBatched_assumed_rank #else module procedure & hipblasCdgmmStridedBatched_rank_0,& hipblasCdgmmStridedBatched_rank_1,& hipblasCdgmmStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdgmmStridedBatched function hipblasZdgmmStridedBatched_(handle,side,m,n,AP,lda,strideA,x,incx,stridex,CP,ldc, & strideC,batchCount) & bind(c, name="hipblasZdgmmStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: CP integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZdgmmStridedBatched_assumed_rank #else module procedure & hipblasZdgmmStridedBatched_rank_0,& hipblasZdgmmStridedBatched_rank_1,& hipblasZdgmmStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasSdgmmStridedBatched_64 function hipblasSdgmmStridedBatched_64_(handle,side,m,n,AP,lda,strideA,x,incx,stridex,CP,ldc, & strideC,batchCount) & bind(c, name="hipblasSdgmmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdgmmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDdgmmStridedBatched_64 function hipblasDdgmmStridedBatched_64_(handle,side,m,n,AP,lda,strideA,x,incx,stridex,CP,ldc, & strideC,batchCount) & bind(c, name="hipblasDdgmmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdgmmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCdgmmStridedBatched_64 function hipblasCdgmmStridedBatched_64_(handle,side,m,n,AP,lda,strideA,x,incx,stridex,CP,ldc, & strideC,batchCount) & bind(c, name="hipblasCdgmmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdgmmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZdgmmStridedBatched_64 function hipblasZdgmmStridedBatched_64_(handle,side,m,n,AP,lda,strideA,x,incx,stridex,CP,ldc, & strideC,batchCount) & bind(c, name="hipblasZdgmmStridedBatched_64") use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdgmmStridedBatched_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_SIDE_LEFT)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: CP integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount end function end interface #endif !> \brief SOLVER API !> !> \details !> The getrf functions compute the LU factorization of a general ``n``-by-``n`` matrix ``A`` !> using partial pivoting with row interchanges. The LU factorization can !> be done without pivoting if ``ipiv`` is passed as a nullptr. !> !> When ``ipiv`` is not null, the factorization has the form: !> !> \f[ !> A = PLU !> \f] !> !> where ``P`` is a permutation matrix, ``L`` is lower triangular with unit !> diagonal elements, and ``U`` is upper triangular. !> !> When ``ipiv`` is null, the factorization is done without pivoting: !> !> \f[ !> A = LU !> \f] !> !> - Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - hipblasHandle_t. !> @param[in] n - int. n >= 0. !> The number of columns and rows of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> - On entry, the n-by-n matrix A to be factored. !> - On exit, the factors L and U from the factorization. !> - The unit diagonal elements of L are not stored. !> @param[in] lda - int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] ipiv - pointer to int. Array on the GPU of dimension n. !> The vector of pivot indices. Elements of ipiv are 1-based indices. !> For 1 <= i <= n, row i of the !> matrix was interchanged with row ipiv[i]. !> Matrix P of the factorization can be derived from ipiv. !> This factorization can be done without pivoting if ipiv is passed !> in as a nullptr. !> @param[out] myInfo - pointer to a int on the GPU. !> - If info = 0, successful exit. !> - If info = j > 0, U is singular. U[j,j] is the first zero pivot. #ifndef USE_CUDA_NAMES interface hipblasSgetrf function hipblasSgetrf_(handle,n,A,lda,ipiv,myInfo) bind(c, name="hipblasSgetrf") use iso_c_binding use hipfort_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 integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSgetrf_assumed_rank #else module procedure & hipblasSgetrf_rank_0,& hipblasSgetrf_rank_1,& hipblasSgetrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgetrf function hipblasDgetrf_(handle,n,A,lda,ipiv,myInfo) bind(c, name="hipblasDgetrf") use iso_c_binding use hipfort_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 integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDgetrf_assumed_rank #else module procedure & hipblasDgetrf_rank_0,& hipblasDgetrf_rank_1,& hipblasDgetrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgetrf function hipblasCgetrf_(handle,n,A,lda,ipiv,myInfo) bind(c, name="hipblasCgetrf") use iso_c_binding use hipfort_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 integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCgetrf_assumed_rank #else module procedure & hipblasCgetrf_rank_0,& hipblasCgetrf_rank_1,& hipblasCgetrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgetrf function hipblasZgetrf_(handle,n,A,lda,ipiv,myInfo) bind(c, name="hipblasZgetrf") use iso_c_binding use hipfort_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 integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZgetrf_assumed_rank #else module procedure & hipblasZgetrf_rank_0,& hipblasZgetrf_rank_1,& hipblasZgetrf_full_rank #endif #endif end interface #endif !> \brief SOLVER API !> !> \details !> The getrfBatched functions compute the LU factorization of a batch of general !> ``n`` -by-``n`` matrices using partial pivoting with row interchanges. The LU factorization !> can !> be done without pivoting if ``ipiv`` is passed as a nullptr. !> !> When ipiv is not null, the factorization of matrix \f$A_i\f$ in the batch has the form: !> !> \f[ !> A_i = P_iL_iU_i !> \f] !> !> where \f$P_i\f$ is a permutation matrix, \f$L_i\f$ is lower triangular with unit !> diagonal elements, and \f$U_i\f$ is upper triangular. !> !> When ``ipiv`` is null, the factorization is done without pivoting: !> !> \f[ !> A_i = L_iU_i !> \f] !> !> - Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - hipblasHandle_t. !> @param[in] n - int. n >= 0. !> The number of columns and rows of all matrices A_i in the batch. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> - On entry, the n-by-n matrices A_i to be factored. !> - On exit, the factors L_i and U_i from the factorizations. !> - The unit diagonal elements of L_i are not stored. !> @param[in] lda - int. lda >= n. !> Specifies the leading dimension of matrices A_i. !> @param[out] ipiv - pointer to int. Array on the GPU. !> Contains the vectors of pivot indices ipiv_i (corresponding to A_i). !> Dimension of ipiv_i is n. !> Elements of ipiv_i are 1-based indices. !> For each instance A_i in the batch and for 1 <= j <= n, row j of the !> matrix A_i was interchanged with row ipiv_i[j]. !> Matrix P_i of the factorization can be derived from ipiv_i. !> This factorization can be done without pivoting if ipiv is passed !> in as a nullptr. !> @param[out] myInfo - pointer to int. Array of batchCount integers on the GPU. !> - If info[i] = 0, successful exit for factorization of A_i. !> - If info[i] = j > 0, U_i is singular. U_i[j,j] is the first zero pivot. !> @param[in] batchCount - int. batchCount >= 0. !> Number of matrices in the batch. interface hipblasSgetrfBatched #ifdef USE_CUDA_NAMES function hipblasSgetrfBatched_(handle,n,A,lda,ipiv,myInfo,batchCount) & bind(c, name="cublasSgetrfBatched") #else function hipblasSgetrfBatched_(handle,n,A,lda,ipiv,myInfo,batchCount) & bind(c, name="hipblasSgetrfBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function end interface interface hipblasDgetrfBatched #ifdef USE_CUDA_NAMES function hipblasDgetrfBatched_(handle,n,A,lda,ipiv,myInfo,batchCount) & bind(c, name="cublasDgetrfBatched") #else function hipblasDgetrfBatched_(handle,n,A,lda,ipiv,myInfo,batchCount) & bind(c, name="hipblasDgetrfBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function end interface interface hipblasCgetrfBatched #ifdef USE_CUDA_NAMES function hipblasCgetrfBatched_(handle,n,A,lda,ipiv,myInfo,batchCount) & bind(c, name="cublasCgetrfBatched") #else function hipblasCgetrfBatched_(handle,n,A,lda,ipiv,myInfo,batchCount) & bind(c, name="hipblasCgetrfBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function end interface interface hipblasZgetrfBatched #ifdef USE_CUDA_NAMES function hipblasZgetrfBatched_(handle,n,A,lda,ipiv,myInfo,batchCount) & bind(c, name="cublasZgetrfBatched") #else function hipblasZgetrfBatched_(handle,n,A,lda,ipiv,myInfo,batchCount) & bind(c, name="hipblasZgetrfBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function end interface !> \brief SOLVER API !> !> \details !> The getrfStridedBatched functions compute the LU factorization of a batch of !> general ``n`` -by-``n`` matrices using partial pivoting with row interchanges. The LU !> factorization can !> be done without pivoting if ``ipiv`` is passed as a nullptr. !> !> When ``ipiv`` is not null, the factorization of matrix \f$A_i\f$ in the batch has the form: !> !> \f[ !> A_i = P_iL_iU_i !> \f] !> !> where \f$P_i\f$ is a permutation matrix, \f$L_i\f$ is lower triangular with unit !> diagonal elements, and \f$U_i\f$ is upper triangular. !> !> When ``ipiv`` is null, the factorization is done without pivoting: !> !> \f[ !> A_i = L_iU_i !> \f] !> !> - Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - hipblasHandle_t. !> @param[in] n - int. n >= 0. !> The number of columns and rows of all matrices A_i in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> - On entry, the n-by-n matrices A_i to be factored. !> - On exit, the factors L_i and U_i from the factorization. !> - The unit diagonal elements of L_i are not stored. !> @param[in] lda - int. lda >= n. !> Specifies the leading dimension of matrices A_i. !> @param[in] strideA - hipblasStride. !> Stride from the start of one matrix A_i to the next one A_(i+1). !> There is no restriction for the value of strideA. Normal use case is strideA >= !> lda*n. !> @param[out] ipiv - pointer to int. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors of pivots indices ipiv_i (corresponding to A_i). !> Dimension of ipiv_i is n. !> Elements of ipiv_i are 1-based indices. !> For each instance A_i in the batch and for 1 <= j <= n, row j of the !> matrix A_i was interchanged with row ipiv_i[j]. !> Matrix P_i of the factorization can be derived from ipiv_i. !> The factorization here can be done without pivoting if ipiv is passed !> in as a nullptr. !> @param[in] strideP - hipblasStride. !> Stride from the start of one vector ipiv_i to the next one ipiv_(i+1). !> There is no restriction for the value of strideP. Normal use case is strideP >= !> n. !> @param[out] myInfo - pointer to int. Array of batchCount integers on the GPU. !> - If info[i] = 0, successful exit for factorization of A_i. !> - If info[i] = j > 0, U_i is singular. U_i[j,j] is the first zero pivot. !> @param[in] batchCount - int. batchCount >= 0. !> Number of matrices in the batch. #ifndef USE_CUDA_NAMES interface hipblasSgetrfStridedBatched function hipblasSgetrfStridedBatched_(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batchCount) & bind(c, name="hipblasSgetrfStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSgetrfStridedBatched_assumed_rank #else module procedure & hipblasSgetrfStridedBatched_rank_0,& hipblasSgetrfStridedBatched_rank_1,& hipblasSgetrfStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgetrfStridedBatched function hipblasDgetrfStridedBatched_(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batchCount) & bind(c, name="hipblasDgetrfStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDgetrfStridedBatched_assumed_rank #else module procedure & hipblasDgetrfStridedBatched_rank_0,& hipblasDgetrfStridedBatched_rank_1,& hipblasDgetrfStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgetrfStridedBatched function hipblasCgetrfStridedBatched_(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batchCount) & bind(c, name="hipblasCgetrfStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCgetrfStridedBatched_assumed_rank #else module procedure & hipblasCgetrfStridedBatched_rank_0,& hipblasCgetrfStridedBatched_rank_1,& hipblasCgetrfStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgetrfStridedBatched function hipblasZgetrfStridedBatched_(handle,n,A,lda,strideA,ipiv,strideP,myInfo,batchCount) & bind(c, name="hipblasZgetrfStridedBatched") use iso_c_binding use hipfort_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 integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZgetrfStridedBatched_assumed_rank #else module procedure & hipblasZgetrfStridedBatched_rank_0,& hipblasZgetrfStridedBatched_rank_1,& hipblasZgetrfStridedBatched_full_rank #endif #endif end interface #endif !> \brief SOLVER API !> !> \details !> The getrs functions solve a system of ``n`` linear equations on ``n`` variables in its !> factorized form. !> !> They solve one of the following systems, depending on the value of ``trans``: !> !> \f[ !> \begin{array}{cl} !> A X = B & \: \text{not transposed,}\\% !> A^T X = B & \: \text{transposed, or}\\% !> A^H X = B & \: \text{conjugate transposed.} !> \end{array} !> \f] !> !> Matrix A is defined by its triangular factors as returned by `hipblasSgetrf` "getrf". !> !> - Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> !> @param[in] handle - hipblasHandle_t. !> @param[in] trans - hipblasOperation_t. !> Specifies the form of the system of equations. !> @param[in] n - int. n >= 0. !> The order of the system, that is, the number of columns and rows of A. !> @param[in] nrhs - int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of the matrix B. !> @param[in] A - pointer to type. Array on the GPU of dimension lda*n. !> The factors L and U of the factorization A = P*L*U returned by `hipblasSgetrf` !> "getrf". !> @param[in] lda - int. lda >= n. !> The leading dimension of A. !> @param[in] ipiv - pointer to int. Array on the GPU of dimension n. !> The pivot indices returned by `hipblasSgetrf` "getrf". !> @param[in,out] B - pointer to type. Array on the GPU of dimension ldb*nrhs. !> - On entry, the right hand side matrix B. !> - On exit, the solution matrix X. !> @param[in] ldb - int. ldb >= n. !> The leading dimension of B. !> @param[out] myInfo - pointer to a int on the host. !> - If info = 0, successful exit. !> - If info = j < 0, the argument at position -j is invalid. #ifndef USE_CUDA_NAMES interface hipblasSgetrs function hipblasSgetrs_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) & bind(c, name="hipblasSgetrs") use iso_c_binding use hipfort_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 integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSgetrs_assumed_rank #else module procedure & hipblasSgetrs_rank_0,& hipblasSgetrs_rank_1,& hipblasSgetrs_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgetrs function hipblasDgetrs_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) & bind(c, name="hipblasDgetrs") use iso_c_binding use hipfort_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 integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDgetrs_assumed_rank #else module procedure & hipblasDgetrs_rank_0,& hipblasDgetrs_rank_1,& hipblasDgetrs_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgetrs function hipblasCgetrs_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) & bind(c, name="hipblasCgetrs") use iso_c_binding use hipfort_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 integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCgetrs_assumed_rank #else module procedure & hipblasCgetrs_rank_0,& hipblasCgetrs_rank_1,& hipblasCgetrs_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgetrs function hipblasZgetrs_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) & bind(c, name="hipblasZgetrs") use iso_c_binding use hipfort_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 integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZgetrs_assumed_rank #else module procedure & hipblasZgetrs_rank_0,& hipblasZgetrs_rank_1,& hipblasZgetrs_full_rank #endif #endif end interface #endif !> \brief SOLVER API !> !> \details The getrsBatched functions solve a batch of systems of ``n`` linear equations on !> ``n`` !> variables in its factorized forms. !> !> For each instance ``i`` in the batch, they solve one of the following systems, depending on !> the value of ``trans``: !> !> \f[ !> \begin{array}{cl} !> A_i X_i = B_i & \: \text{not transposed,}\\% !> A_i^T X_i = B_i & \: \text{transposed, or}\\% !> A_i^H X_i = B_i & \: \text{conjugate transposed.} !> \end{array} !> \f] !> !> Matrix \f$A_i\f$ is defined by its triangular factors as returned by `hipblasSgetrfBatched` !> "getrfBatched". !> !> - Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - hipblasHandle_t. !> @param[in] trans - hipblasOperation_t. !> Specifies the form of the system of equations of each instance in the batch. !> @param[in] n - int. n >= 0. !> The order of the system, that is, the number of columns and rows of all A_i !> matrices. !> @param[in] nrhs - int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of all the matrices B_i. !> @param[in] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> The factors L_i and U_i of the factorization A_i = P_i*L_i*U_i returned by !> `hipblasSgetrfBatched` "getrfBatched". !> @param[in] lda - int. lda >= n. !> The leading dimension of matrices A_i. !> @param[in] ipiv - pointer to int. Array on the GPU. !> Contains the vectors ipiv_i of pivot indices returned by `hipblasSgetrfBatched` !> "getrfBatched". !> @param[in,out] B - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*nrhs. !> - On entry, the right hand side matrices B_i. !> - On exit, the solution matrix X_i of each system in the batch. !> @param[in] ldb - int. ldb >= n. !> The leading dimension of matrices B_i. !> @param[out] myInfo - pointer to a int on the host. !> - If info = 0, successful exit. !> - If info = j < 0, the argument at position -j is invalid. !> @param[in] batchCount - int. batchCount >= 0. !> Number of instances (systems) in the batch. interface hipblasSgetrsBatched #ifdef USE_CUDA_NAMES function hipblasSgetrsBatched_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo,batchCount) & bind(c, name="cublasSgetrsBatched") #else function hipblasSgetrsBatched_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo,batchCount) & bind(c, name="hipblasSgetrsBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function end interface interface hipblasDgetrsBatched #ifdef USE_CUDA_NAMES function hipblasDgetrsBatched_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo,batchCount) & bind(c, name="cublasDgetrsBatched") #else function hipblasDgetrsBatched_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo,batchCount) & bind(c, name="hipblasDgetrsBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function end interface interface hipblasCgetrsBatched #ifdef USE_CUDA_NAMES function hipblasCgetrsBatched_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo,batchCount) & bind(c, name="cublasCgetrsBatched") #else function hipblasCgetrsBatched_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo,batchCount) & bind(c, name="hipblasCgetrsBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function end interface interface hipblasZgetrsBatched #ifdef USE_CUDA_NAMES function hipblasZgetrsBatched_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo,batchCount) & bind(c, name="cublasZgetrsBatched") #else function hipblasZgetrsBatched_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo,batchCount) & bind(c, name="hipblasZgetrsBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function end interface !> \brief SOLVER API !> !> \details !> The getrsStridedBatched functions solve a batch of systems of ``n`` linear equations !> on ``n`` variables in its factorized forms. !> !> For each instance ``i`` in the batch, they solve one of the following systems, depending on !> the value of ``trans``: !> !> \f[ !> \begin{array}{cl} !> A_i X_i = B_i & \: \text{not transposed,}\\% !> A_i^T X_i = B_i & \: \text{transposed, or}\\% !> A_i^H X_i = B_i & \: \text{conjugate transposed.} !> \end{array} !> \f] !> !> Matrix \f$A_i\f$ is defined by its triangular factors as returned by !> `hipblasSgetrfStridedBatched` "getrfStridedBatched". !> !> - Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - hipblasHandle_t. !> @param[in] trans - hipblasOperation_t. !> Specifies the form of the system of equations of each instance in the batch. !> @param[in] n - int. n >= 0. !> The order of the system, that is, the number of columns and rows of all A_i !> matrices. !> @param[in] nrhs - int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of all the matrices B_i. !> @param[in] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> The factors L_i and U_i of the factorization A_i = P_i*L_i*U_i returned by !> `hipblasSgetrfStridedBatched` "getrfStridedBatched". !> @param[in] lda - int. lda >= n. !> The leading dimension of matrices A_i. !> @param[in] strideA - hipblasStride. !> Stride from the start of one matrix A_i to the next one A_(i+1). !> There is no restriction for the value of strideA. Normal use case is strideA >= !> lda*n. !> @param[in] ipiv - pointer to int. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors ipiv_i of pivot indices returned by !> `hipblasSgetrfStridedBatched` "getrfStridedBatched". !> @param[in] strideP - hipblasStride. !> Stride from the start of one vector ipiv_i to the next one ipiv_(i+1). !> There is no restriction for the value of strideP. Normal use case is strideP >= !> n. !> @param[in,out] B - pointer to type. Array on the GPU (size depends on the value of !> strideB). !> - On entry, the right hand side matrices B_i. !> - On exit, the solution matrix X_i of each system in the batch. !> @param[in] ldb - int. ldb >= n. !> The leading dimension of matrices B_i. !> @param[in] strideB - hipblasStride. !> Stride from the start of one matrix B_i to the next one B_(i+1). !> There is no restriction for the value of strideB. Normal use case is strideB >= !> ldb*nrhs. !> @param[out] myInfo - pointer to a int on the host. !> - If info = 0, successful exit. !> - If info = j < 0, the argument at position -j is invalid. !> @param[in] batchCount - int. batchCount >= 0. !> Number of instances (systems) in the batch. #ifndef USE_CUDA_NAMES interface hipblasSgetrsStridedBatched function hipblasSgetrsStridedBatched_(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb, & strideB,myInfo,batchCount) & bind(c, name="hipblasSgetrsStridedBatched") use iso_c_binding use hipfort_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 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 :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSgetrsStridedBatched_assumed_rank #else module procedure & hipblasSgetrsStridedBatched_rank_0,& hipblasSgetrsStridedBatched_rank_1,& hipblasSgetrsStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgetrsStridedBatched function hipblasDgetrsStridedBatched_(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb, & strideB,myInfo,batchCount) & bind(c, name="hipblasDgetrsStridedBatched") use iso_c_binding use hipfort_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 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 :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDgetrsStridedBatched_assumed_rank #else module procedure & hipblasDgetrsStridedBatched_rank_0,& hipblasDgetrsStridedBatched_rank_1,& hipblasDgetrsStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgetrsStridedBatched function hipblasCgetrsStridedBatched_(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb, & strideB,myInfo,batchCount) & bind(c, name="hipblasCgetrsStridedBatched") use iso_c_binding use hipfort_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 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 :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCgetrsStridedBatched_assumed_rank #else module procedure & hipblasCgetrsStridedBatched_rank_0,& hipblasCgetrsStridedBatched_rank_1,& hipblasCgetrsStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgetrsStridedBatched function hipblasZgetrsStridedBatched_(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb, & strideB,myInfo,batchCount) & bind(c, name="hipblasZgetrsStridedBatched") use iso_c_binding use hipfort_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 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 :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZgetrsStridedBatched_assumed_rank #else module procedure & hipblasZgetrsStridedBatched_rank_0,& hipblasZgetrsStridedBatched_rank_1,& hipblasZgetrsStridedBatched_full_rank #endif #endif end interface #endif !> \brief SOLVER API !> !> \details !> The getriBatched functions computes the inverse \f$C_i = A_i^{-1}\f$ of a batch of general !> n-by-n matrices \f$A_i\f$. !> !> The inverse is computed by solving the linear system !> !> \f[ !> A_i C_i = I !> \f] !> !> where I is the identity matrix and \f$A_i\f$ is factorized as \f$A_i = P_i L_i U_i\f$, as !> given by `hipblasSgetrfBatched` "getrfBatched". !> !> - Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - hipblasHandle_t. !> @param[in] n - int. n >= 0. !> The number of rows and columns of all matrices A_i in the batch. !> @param[in] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> The factors L_i and U_i of the factorization A_i = P_i*L_i*U_i returned by !> `hipblasSgetrfBatched` "getrfBatched". !> @param[in] lda - int. lda >= n. !> Specifies the leading dimension of matrices A_i. !> @param[in] ipiv - pointer to int. Array on the GPU (the size depends on the value of !> strideP). !> The pivot indices returned by `hipblasSgetrfBatched` "getrfBatched". !> ipiv can be passed in as a nullptr. This will assume that getrfBatched was called !> without partial pivoting. !> @param[out] C - array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldc*n. !> If info[i] = 0, the inverse of matrices A_i. Otherwise, undefined. !> @param[in] ldc - int. ldc >= n. !> Specifies the leading dimension of C_i. !> @param[out] myInfo - pointer to int. Array of batchCount integers on the GPU. !> - If info[i] = 0, successful exit for inversion of A_i. !> - If info[i] = j > 0, U_i is singular. U_i[j,j] is the first zero pivot. !> @param[in] batchCount - int. batchCount >= 0. !> Number of matrices in the batch. interface hipblasSgetriBatched #ifdef USE_CUDA_NAMES function hipblasSgetriBatched_(handle,n,A,lda,ipiv,C,ldc,myInfo,batchCount) & bind(c, name="cublasSgetriBatched") #else function hipblasSgetriBatched_(handle,n,A,lda,ipiv,C,ldc,myInfo,batchCount) & bind(c, name="hipblasSgetriBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function end interface interface hipblasDgetriBatched #ifdef USE_CUDA_NAMES function hipblasDgetriBatched_(handle,n,A,lda,ipiv,C,ldc,myInfo,batchCount) & bind(c, name="cublasDgetriBatched") #else function hipblasDgetriBatched_(handle,n,A,lda,ipiv,C,ldc,myInfo,batchCount) & bind(c, name="hipblasDgetriBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function end interface interface hipblasCgetriBatched #ifdef USE_CUDA_NAMES function hipblasCgetriBatched_(handle,n,A,lda,ipiv,C,ldc,myInfo,batchCount) & bind(c, name="cublasCgetriBatched") #else function hipblasCgetriBatched_(handle,n,A,lda,ipiv,C,ldc,myInfo,batchCount) & bind(c, name="hipblasCgetriBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function end interface interface hipblasZgetriBatched #ifdef USE_CUDA_NAMES function hipblasZgetriBatched_(handle,n,A,lda,ipiv,C,ldc,myInfo,batchCount) & bind(c, name="cublasZgetriBatched") #else function hipblasZgetriBatched_(handle,n,A,lda,ipiv,C,ldc,myInfo,batchCount) & bind(c, name="hipblasZgetriBatched") #endif use iso_c_binding use hipfort_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 integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function end interface !> \brief SOLVER API !> !> \details !> The gels functions solve 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 !> `hipblasSgeqrf` "GEQRF" (or the LQ !> factorization computed by ``GELQF``). !> !> 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``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - hipblasHandle_t. !> @param[in] trans - hipblasOperation_t. !> Specifies the form of the system of equations. !> @param[in] m - int. m >= 0. !> The number of rows of matrix A. !> @param[in] n - int. n >= 0. !> The number of columns of matrix A. !> @param[in] nrhs - int. nrhs >= 0. !> The number of columns of matrices B and X, !> that is, the columns on the right hand side. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*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. !> Specifies the leading dimension of matrix A. !> @param[inout] B - pointer to type. Array on the GPU of dimension ldb*nrhs. !> - 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). !> Specifies the leading dimension of matrix B. !> @param[out] myInfo - pointer to an int on the host. !> - If info = 0, successful exit. !> - If info = j < 0, the argument at position -j is invalid. !> @param[out] deviceInfo - pointer to int on the GPU. !> - 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. #ifndef USE_CUDA_NAMES interface hipblasSgels function hipblasSgels_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,deviceInfo) & bind(c, name="hipblasSgels") use iso_c_binding use hipfort_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 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 :: myInfo type(c_ptr),value :: deviceInfo end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgels function hipblasDgels_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,deviceInfo) & bind(c, name="hipblasDgels") use iso_c_binding use hipfort_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 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 :: myInfo type(c_ptr),value :: deviceInfo end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgels function hipblasCgels_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,deviceInfo) & bind(c, name="hipblasCgels") use iso_c_binding use hipfort_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 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 :: myInfo type(c_ptr),value :: deviceInfo end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgels function hipblasZgels_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,deviceInfo) & bind(c, name="hipblasZgels") use iso_c_binding use hipfort_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 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 :: myInfo type(c_ptr),value :: deviceInfo end function end interface #endif !> \brief SOLVER API !> !> \details !> The gelsBatched functions solve 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`` ). !> !> 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``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> Note that the 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. !> Specifies the form of the system of equations. !> @param[in] m - int. m >= 0. !> The number of rows of all matrices A_j in the batch. !> @param[in] n - int. n >= 0. !> The number of columns of all matrices A_j in the batch. !> @param[in] nrhs - int. nrhs >= 0. !> The number of columns of all matrices B_j and X_j in the batch, !> that is, 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. !> - 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. !> 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. !> - 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). !> Specifies the leading dimension of matrices B_j. !> @param[out] myInfo - pointer to an int on the host. !> If info = 0, successful exit. !> If info = j < 0, the argument at position -j is invalid. !> @param[out] deviceInfo - pointer to int. Array of batchCount integers on the GPU. !> - 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. !> Number of matrices in the batch. interface hipblasSgelsBatched #ifdef USE_CUDA_NAMES function hipblasSgelsBatched_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,deviceInfo,batchCount) & bind(c, name="cublasSgelsBatched") #else function hipblasSgelsBatched_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,deviceInfo,batchCount) & bind(c, name="hipblasSgelsBatched") #endif use iso_c_binding use hipfort_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 :: myInfo type(c_ptr),value :: deviceInfo integer(c_int),value :: batchCount end function end interface interface hipblasDgelsBatched #ifdef USE_CUDA_NAMES function hipblasDgelsBatched_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,deviceInfo,batchCount) & bind(c, name="cublasDgelsBatched") #else function hipblasDgelsBatched_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,deviceInfo,batchCount) & bind(c, name="hipblasDgelsBatched") #endif use iso_c_binding use hipfort_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 :: myInfo type(c_ptr),value :: deviceInfo integer(c_int),value :: batchCount end function end interface interface hipblasCgelsBatched #ifdef USE_CUDA_NAMES function hipblasCgelsBatched_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,deviceInfo,batchCount) & bind(c, name="cublasCgelsBatched") #else function hipblasCgelsBatched_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,deviceInfo,batchCount) & bind(c, name="hipblasCgelsBatched") #endif use iso_c_binding use hipfort_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 :: myInfo type(c_ptr),value :: deviceInfo integer(c_int),value :: batchCount end function end interface interface hipblasZgelsBatched #ifdef USE_CUDA_NAMES function hipblasZgelsBatched_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,deviceInfo,batchCount) & bind(c, name="cublasZgelsBatched") #else function hipblasZgelsBatched_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,deviceInfo,batchCount) & bind(c, name="hipblasZgelsBatched") #endif use iso_c_binding use hipfort_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 :: myInfo type(c_ptr),value :: deviceInfo integer(c_int),value :: batchCount end function end interface !> \brief SOLVER API !> !> \details !> The gelsStridedBatched functions solve 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``). !> !> 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``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - hipblasHandle_t. !> @param[in] trans - hipblasOperation_t. !> Specifies the form of the system of equations. !> @param[in] m - int. m >= 0. !> The number of rows of all matrices A_j in the batch. !> @param[in] n - int. n >= 0. !> The number of columns of all matrices A_j in the batch. !> @param[in] nrhs - int. nrhs >= 0. !> The number of columns of all matrices B_j and X_j in the batch, !> that is, 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). !> - 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. !> Specifies the leading dimension of matrices A_j. !> @param[in] strideA - hipblasStride. !> 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). !> - 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). !> Specifies the leading dimension of matrices B_j. !> @param[in] strideB - hipblasStride. !> 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] myInfo - pointer to an int on the host. !> - If info = 0, successful exit. !> - If info = j < 0, the argument at position -j is invalid. !> @param[out] deviceInfo - pointer to int. Array of batchCount integers on the GPU. !> - 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. !> Number of matrices in the batch. #ifndef USE_CUDA_NAMES interface hipblasSgelsStridedBatched function hipblasSgelsStridedBatched_(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo, & deviceInfo,batchCount) & bind(c, name="hipblasSgelsStridedBatched") use iso_c_binding use hipfort_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 :: myInfo type(c_ptr),value :: deviceInfo integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgelsStridedBatched function hipblasDgelsStridedBatched_(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo, & deviceInfo,batchCount) & bind(c, name="hipblasDgelsStridedBatched") use iso_c_binding use hipfort_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 :: myInfo type(c_ptr),value :: deviceInfo integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgelsStridedBatched function hipblasCgelsStridedBatched_(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo, & deviceInfo,batchCount) & bind(c, name="hipblasCgelsStridedBatched") use iso_c_binding use hipfort_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 :: myInfo type(c_ptr),value :: deviceInfo integer(c_int),value :: batchCount end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgelsStridedBatched function hipblasZgelsStridedBatched_(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB,myInfo, & deviceInfo,batchCount) & bind(c, name="hipblasZgelsStridedBatched") use iso_c_binding use hipfort_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 :: myInfo type(c_ptr),value :: deviceInfo integer(c_int),value :: batchCount end function end interface #endif !> \brief SOLVER API !> !> \details !> The geqrf functions compute a QR factorization of a general ``m`` -by-``n`` matrix ``A``. !> The factorization has the form: !> !> \f[ !> A = Q\left[\begin{array}{c} !> R\\% !> 0 !> \end{array}\right] !> \f] !> !> where ``R`` is upper triangular (upper trapezoidal if ``m < n``), and ``Q`` is !> an ``m`` -by-``m`` orthogonal/unitary matrix represented as the product of Householder !> matrices: !> !> \f[ !> Q = H_1H_2\cdots H_k, \quad \text{with} \: k = \text{min}(m,n) !> \f] !> !> Each Householder matrix \f$H_i\f$ is given by: !> !> \f[ !> H_i = I - \text{ipiv}[i] \cdot v_i v_i' !> \f] !> !> where the first ``i`` -1 elements of the Householder vector \f$v_i\f$ are zero, and !> \f$v_i[i] = 1\f$. !> !> - Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - hipblasHandle_t. !> @param[in] m - int. m >= 0. !> The number of rows of the matrix A. !> @param[in] n - int. n >= 0. !> The number of columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> - On entry, the m-by-n matrix to be factored. !> - On exit, the elements on and above the diagonal contain the !> factor R. The elements below the diagonal are the last m - i elements !> of Householder vector v_i. !> @param[in] lda - int. lda >= m. !> Specifies the leading dimension of A. !> @param[out] ipiv - pointer to type. Array on the GPU of dimension min(m,n). !> The Householder scalars. !> @param[out] myInfo - pointer to a int on the host. !> - If info = 0, successful exit. !> - If info = j < 0, the argument at position -j is invalid. #ifndef USE_CUDA_NAMES interface hipblasSgeqrf function hipblasSgeqrf_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="hipblasSgeqrf") use iso_c_binding use hipfort_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 type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSgeqrf_assumed_rank #else module procedure & hipblasSgeqrf_rank_0,& hipblasSgeqrf_rank_1,& hipblasSgeqrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgeqrf function hipblasDgeqrf_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="hipblasDgeqrf") use iso_c_binding use hipfort_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 type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDgeqrf_assumed_rank #else module procedure & hipblasDgeqrf_rank_0,& hipblasDgeqrf_rank_1,& hipblasDgeqrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgeqrf function hipblasCgeqrf_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="hipblasCgeqrf") use iso_c_binding use hipfort_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 type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCgeqrf_assumed_rank #else module procedure & hipblasCgeqrf_rank_0,& hipblasCgeqrf_rank_1,& hipblasCgeqrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgeqrf function hipblasZgeqrf_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="hipblasZgeqrf") use iso_c_binding use hipfort_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 type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZgeqrf_assumed_rank #else module procedure & hipblasZgeqrf_rank_0,& hipblasZgeqrf_rank_1,& hipblasZgeqrf_full_rank #endif #endif end interface #endif !> \brief SOLVER API !> !> \details !> The geqrfBatched function computes the QR factorization of a batch of general !> ``m``-by-``n`` matrices. !> !> The factorization of matrix \f$A_i\f$ in the batch has the form: !> !> \f[ !> A_i = Q_i\left[\begin{array}{c} !> R_i\\% !> 0 !> \end{array}\right] !> \f] !> !> where \f$R_i\f$ is upper triangular (upper trapezoidal if ``m`` < ``n``) and \f$Q_i\f$ is !> an ``m`` -by-``m`` orthogonal/unitary matrix represented as the product of Householder !> matrices: !> !> \f[ !> Q_i = H_{i_1}H_{i_2}\cdots H_{i_k}, \quad \text{with} \: k = \text{min}(m,n) !> \f] !> !> Each Householder matrix \f$H_{i_j}\f$ is given by: !> !> \f[ !> H_{i_j} = I - \text{ipiv}_i[j] \cdot v_{i_j} v_{i_j}' !> \f] !> !> where the first ``j`` -1 elements of Householder vector \f$v_{i_j}\f$ are zero and !> \f$v_{i_j}[j] = 1\f$. !> !> - Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : ``s``, ``d``, ``c``, and ``z``. !> !> @param[in] handle - hipblasHandle_t. !> @param[in] m - int. m >= 0. !> The number of rows of all the matrices A_i in the batch. !> @param[in] n - int. n >= 0. !> The number of columns of all the matrices A_i in the batch. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> - On entry, the m-by-n matrices A_i to be factored. !> - On exit, the elements on and above the diagonal contain the !> factor R_i. The elements below the diagonal are the last m - j elements !> of Householder vector v_(i_j). !> @param[in] lda - int. lda >= m. !> Specifies the leading dimension of matrices A_i. !> @param[out] ipiv - array of pointers to type. Each pointer points to an array on the GPU !> of dimension min(m, n). !> Contains the vectors ipiv_i of corresponding Householder scalars. !> @param[out] myInfo - pointer to a int on the host. !> - If info = 0, successful exit. !> - If info = j < 0, the argument at position -j is invalid. !> @param[in] batchCount - int. batchCount >= 0. !> Number of matrices in the batch. interface hipblasSgeqrfBatched #ifdef USE_CUDA_NAMES function hipblasSgeqrfBatched_(handle,m,n,A,lda,ipiv,myInfo,batchCount) & bind(c, name="cublasSgeqrfBatched") #else function hipblasSgeqrfBatched_(handle,m,n,A,lda,ipiv,myInfo,batchCount) & bind(c, name="hipblasSgeqrfBatched") #endif use iso_c_binding use hipfort_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 type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function end interface interface hipblasDgeqrfBatched #ifdef USE_CUDA_NAMES function hipblasDgeqrfBatched_(handle,m,n,A,lda,ipiv,myInfo,batchCount) & bind(c, name="cublasDgeqrfBatched") #else function hipblasDgeqrfBatched_(handle,m,n,A,lda,ipiv,myInfo,batchCount) & bind(c, name="hipblasDgeqrfBatched") #endif use iso_c_binding use hipfort_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 type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function end interface interface hipblasCgeqrfBatched #ifdef USE_CUDA_NAMES function hipblasCgeqrfBatched_(handle,m,n,A,lda,ipiv,myInfo,batchCount) & bind(c, name="cublasCgeqrfBatched") #else function hipblasCgeqrfBatched_(handle,m,n,A,lda,ipiv,myInfo,batchCount) & bind(c, name="hipblasCgeqrfBatched") #endif use iso_c_binding use hipfort_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 type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function end interface interface hipblasZgeqrfBatched #ifdef USE_CUDA_NAMES function hipblasZgeqrfBatched_(handle,m,n,A,lda,ipiv,myInfo,batchCount) & bind(c, name="cublasZgeqrfBatched") #else function hipblasZgeqrfBatched_(handle,m,n,A,lda,ipiv,myInfo,batchCount) & bind(c, name="hipblasZgeqrfBatched") #endif use iso_c_binding use hipfort_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 type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function end interface !> \brief SOLVER API !> !> \details !> The geqrfStridedBatched functions compute the QR factorization of a batch of !> general ``m``-by-``n`` matrices. !> !> The factorization of matrix \f$A_i\f$ in the batch has the form: !> !> \f[ !> A_i = Q_i\left[\begin{array}{c} !> R_i\\% !> 0 !> \end{array}\right] !> \f] !> !> where \f$R_i\f$ is upper triangular (upper trapezoidal if ``m`` < ``n``), and \f$Q_i\f$ is !> an ``m`` -by-``m`` orthogonal/unitary matrix represented as the product of Householder !> matrices: !> !> \f[ !> Q_i = H_{i_1}H_{i_2}\cdots H_{i_k}, \quad \text{with} \: k = \text{min}(m,n) !> \f] !> !> Each Householder matrix \f$H_{i_j}\f$ is given by: !> !> \f[ !> H_{i_j} = I - \text{ipiv}_j[j] \cdot v_{i_j} v_{i_j}' !> \f] !> !> where the first ``j`` -1 elements of Householder vector \f$v_{i_j}\f$ are zero, and !> \f$v_{i_j}[j] = 1\f$. !> !> - Supported precisions in rocSOLVER : ``s``, ``d``, ``c``, and ``z``. !> - Supported precisions in cuBLAS : No support. !> !> @param[in] handle - hipblasHandle_t. !> @param[in] m - int. m >= 0. !> The number of rows of all the matrices A_i in the batch. !> @param[in] n - int. n >= 0. !> The number of columns of all the matrices A_i in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> - On entry, the m-by-n matrices A_i to be factored. !> - On exit, the elements on and above the diagonal contain the !> factor R_i. The elements below the diagonal are the last m - j elements !> of Householder vector v_(i_j). !> @param[in] lda - int. lda >= m. !> Specifies the leading dimension of matrices A_i. !> @param[in] strideA - hipblasStride. !> Stride from the start of one matrix A_i to the next one A_(i+1). !> There is no restriction for the value of strideA. Normal use case is strideA >= !> lda*n. !> @param[out] ipiv - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors ipiv_i of corresponding Householder scalars. !> @param[in] strideP - hipblasStride. !> Stride from the start of one vector ipiv_i to the next one ipiv_(i+1). !> There is no restriction for the value !> of strideP. Normal use is strideP >= min(m,n). !> @param[out] myInfo - pointer to a int on the host. !> - If info = 0, successful exit. !> - If info = j < 0, the argument at position -j is invalid. !> @param[in] batchCount - int. batchCount >= 0. !> Number of matrices in the batch. #ifndef USE_CUDA_NAMES interface hipblasSgeqrfStridedBatched function hipblasSgeqrfStridedBatched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batchCount) & bind(c, name="hipblasSgeqrfStridedBatched") use iso_c_binding use hipfort_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 type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSgeqrfStridedBatched_assumed_rank #else module procedure & hipblasSgeqrfStridedBatched_rank_0,& hipblasSgeqrfStridedBatched_rank_1,& hipblasSgeqrfStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDgeqrfStridedBatched function hipblasDgeqrfStridedBatched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batchCount) & bind(c, name="hipblasDgeqrfStridedBatched") use iso_c_binding use hipfort_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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasDgeqrfStridedBatched_assumed_rank #else module procedure & hipblasDgeqrfStridedBatched_rank_0,& hipblasDgeqrfStridedBatched_rank_1,& hipblasDgeqrfStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasCgeqrfStridedBatched function hipblasCgeqrfStridedBatched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batchCount) & bind(c, name="hipblasCgeqrfStridedBatched") use iso_c_binding use hipfort_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 type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasCgeqrfStridedBatched_assumed_rank #else module procedure & hipblasCgeqrfStridedBatched_rank_0,& hipblasCgeqrfStridedBatched_rank_1,& hipblasCgeqrfStridedBatched_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipblasZgeqrfStridedBatched function hipblasZgeqrfStridedBatched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo,batchCount) & bind(c, name="hipblasZgeqrfStridedBatched") use iso_c_binding use hipfort_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 type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batchCount end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasZgeqrfStridedBatched_assumed_rank #else module procedure & hipblasZgeqrfStridedBatched_rank_0,& hipblasZgeqrfStridedBatched_rank_1,& hipblasZgeqrfStridedBatched_full_rank #endif #endif end interface #endif !> \brief BLAS EX API !> !> \details !> The gemmEx functions perform one of the matrix-matrix operations: !> !> C = alpha*op( A )*op( B ) + beta*C, !> !> where ``op( X )`` is one of: !> !> op( X ) = X or !> op( X ) = X**T or !> op( X ) = X**H, !> !> ``alpha`` and ``beta`` are scalars, and ``A``, ``B``, and ``C`` are matrices, with !> ``op( A )`` an ``m`` by ``k`` matrix, ``op( B )`` a ``k`` by ``n`` matrix, and ``C`` an !> ``m`` by ``n`` matrix. !> !> - Supported types are determined by the backend. See the cuBLAS documentation for cuBLAS !> backend information. !> For the rocBLAS backend, conversion from ``hipblasComputeType_t`` to !> ``rocblas_datatype_t`` happens within hipBLAS. !> Supported types are as follows: !> !> | aType | bType | cType | computeType | !> | ---------- | ---------- | ---------- | ------------------- | !> | HIP_R_16F | HIP_R_16F | HIP_R_16F | HIPBLAS_COMPUTE_16F | !> | HIP_R_16F | HIP_R_16F | HIP_R_16F | HIPBLAS_COMPUTE_32F | !> | HIP_R_16F | HIP_R_16F | HIP_R_32F | HIPBLAS_COMPUTE_32F | !> | HIP_R_16BF | HIP_R_16BF | HIP_R_16BF | HIPBLAS_COMPUTE_32F | !> | HIP_R_16BF | HIP_R_16BF | HIP_R_32F | HIPBLAS_COMPUTE_32F | !> | HIP_R_32F | HIP_R_32F | HIP_R_32F | HIPBLAS_COMPUTE_32F | !> | HIP_R_64F | HIP_R_64F | HIP_R_64F | HIPBLAS_COMPUTE_64F | !> | HIP_R_8I | HIP_R_8I | HIP_R_32I | HIPBLAS_COMPUTE_32I | !> | HIP_C_32F | HIP_C_32F | HIP_C_32F | HIPBLAS_COMPUTE_32F | !> | HIP_C_64F | HIP_C_64F | HIP_C_64F | HIPBLAS_COMPUTE_64F | !> !> ``hipblasGemmExWithFlags`` is also available. This is identical to ``hipblasGemmEx`` !> with the addition of a ``flags`` parameter which controls the flags used in Tensile to !> control gemm algorithms with the !> rocBLAS backend. When using a cuBLAS backend, this parameter is ignored. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] transA - [hipblasOperation_t] !> specifies the form of op( A ). !> @param[in] transB - [hipblasOperation_t] !> specifies the form of op( B ). !> @param[in] m - [int] !> matrix dimension m. !> @param[in] n - [int] !> matrix dimension n. !> @param[in] k - [int] !> matrix dimension k. !> @param[in] alpha - [const void *] !> device pointer or host pointer specifying the scalar alpha. Same datatype as !> computeType. !> @param[in] A - [void *] !> device pointer storing matrix A. !> @param[in] aType !> [hipDataType] !> specifies the datatype of matrix A. !> @param[in] lda - [int] !> specifies the leading dimension of A. !> @param[in] B - [void *] !> device pointer storing matrix B. !> @param[in] bType !> [hipDataType] !> specifies the datatype of matrix B. !> @param[in] ldb - [int] !> specifies the leading dimension of B. !> @param[in] beta - [const void *] !> device pointer or host pointer specifying the scalar beta. Same datatype as !> computeType. !> @param[in] C - [void *] !> device pointer storing matrix C. !> @param[in] cType !> [hipDataType] !> specifies the datatype of matrix C. !> @param[in] ldc - [int] !> specifies the leading dimension of C. !> @param[in] computeType !> [hipblasComputeType_t] !> specifies the datatype of computation. !> @param[in] algo - [hipblasGemmAlgo_t] !> enumerant specifying the algorithm type. interface hipblasGemmEx #ifdef USE_CUDA_NAMES function hipblasGemmEx_(handle,transA,transB,m,n,k,alpha,A,aType,lda,B,bType,ldb,beta,C,cType, & ldc,computeType,algo) & bind(c, name="cublasGemmEx") #else function hipblasGemmEx_(handle,transA,transB,m,n,k,alpha,A,aType,lda,B,bType,ldb,beta,C,cType, & ldc,computeType,algo) & bind(c, name="hipblasGemmEx") #endif use iso_c_binding use hipfort_hipblas_enums use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: A integer(kind(HIP_R_32F)),value :: aType integer(c_int),value :: lda type(c_ptr),value :: B integer(kind(HIP_R_32F)),value :: bType integer(c_int),value :: ldb type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(HIP_R_32F)),value :: cType integer(c_int),value :: ldc integer(kind(HIPBLAS_COMPUTE_16F)),value :: computeType integer(kind(HIPBLAS_GEMM_DEFAULT)),value :: algo end function end interface #ifndef USE_CUDA_NAMES interface hipblasGemmExWithFlags function hipblasGemmExWithFlags_(handle,transA,transB,m,n,k,alpha,A,aType,lda,B,bType,ldb, & beta,C,cType,ldc,computeType,algo,flags) & bind(c, name="hipblasGemmExWithFlags") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGemmExWithFlags_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: A integer(kind(HIP_R_32F)),value :: aType integer(c_int),value :: lda type(c_ptr),value :: B integer(kind(HIP_R_32F)),value :: bType integer(c_int),value :: ldb type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(HIP_R_32F)),value :: cType integer(c_int),value :: ldc integer(kind(HIPBLAS_COMPUTE_16F)),value :: computeType integer(kind(HIPBLAS_GEMM_DEFAULT)),value :: algo integer(kind(HIPBLAS_GEMM_FLAGS_NONE)),value :: flags end function end interface #endif interface hipblasGemmEx_64 #ifdef USE_CUDA_NAMES function hipblasGemmEx_64_(handle,transA,transB,m,n,k,alpha,A,aType,lda,B,bType,ldb,beta,C, & cType,ldc,computeType,algo) & bind(c, name="cublasGemmEx_64") #else function hipblasGemmEx_64_(handle,transA,transB,m,n,k,alpha,A,aType,lda,B,bType,ldb,beta,C, & cType,ldc,computeType,algo) & bind(c, name="hipblasGemmEx_64") #endif use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGemmEx_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: A integer(kind(HIP_R_32F)),value :: aType integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(kind(HIP_R_32F)),value :: bType integer(c_int64_t),value :: ldb type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(HIP_R_32F)),value :: cType integer(c_int64_t),value :: ldc integer(kind(HIPBLAS_COMPUTE_16F)),value :: computeType integer(kind(HIPBLAS_GEMM_DEFAULT)),value :: algo end function end interface #ifndef USE_CUDA_NAMES interface hipblasGemmExWithFlags_64 function hipblasGemmExWithFlags_64_(handle,transA,transB,m,n,k,alpha,A,aType,lda,B,bType,ldb, & beta,C,cType,ldc,computeType,algo,flags) & bind(c, name="hipblasGemmExWithFlags_64") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGemmExWithFlags_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: A integer(kind(HIP_R_32F)),value :: aType integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(kind(HIP_R_32F)),value :: bType integer(c_int64_t),value :: ldb type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(HIP_R_32F)),value :: cType integer(c_int64_t),value :: ldc integer(kind(HIPBLAS_COMPUTE_16F)),value :: computeType integer(kind(HIPBLAS_GEMM_DEFAULT)),value :: algo integer(kind(HIPBLAS_GEMM_FLAGS_NONE)),value :: flags end function end interface #endif !> \brief BLAS EX API !> !> \details !> The gemmBatchedEx functions perform one of the batched matrix-matrix operations: !> !> C_i = alpha*op(A_i)*op(B_i) + beta*C_i, for i = 1, ..., batchCount. !> !> where ``op( X )`` is one of: !> !> op( X ) = X or !> op( X ) = X**T or !> op( X ) = X**H, !> !> ``alpha`` and ``beta`` are scalars, and ``A``, ``B``, and ``C`` are batched pointers to !> matrices, with !> ``op( A )`` an ``m`` by ``k`` by ``batchCount`` batched matrix, !> ``op( B )`` a ``k`` by ``n`` by ``batchCount`` batched matrix, and !> ``C`` an ``m`` by ``n`` by ``batchCount`` batched matrix. !> The batched matrices are an array of pointers to matrices. !> The number of pointers to matrices is ``batchCount``. !> !> - Supported types are determined by the backend. See the rocBLAS or cuBLAS documentation. !> !> ``hipblasGemmBatchedExWithFlags`` is also available. This is identical to !> ``hipblasGemmBatchedEx`` !> with the addition of a ``flags`` parameter which controls the flags used in Tensile to !> control gemm algorithms with the !> rocBLAS backend. When using a cuBLAS backend, this parameter is ignored. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] transA - [hipblasOperation_t] !> specifies the form of op( A ). !> @param[in] transB - [hipblasOperation_t] !> specifies the form of op( B ). !> @param[in] m - [int] !> matrix dimension m. !> @param[in] n - [int] !> matrix dimension n. !> @param[in] k - [int] !> matrix dimension k. !> @param[in] alpha - [const void *] !> device pointer or host pointer specifying the scalar alpha. Same datatype as !> computeType. !> @param[in] A - [void *] !> device pointer storing array of pointers to each matrix A_i. !> @param[in] aType !> [hipDataType] !> specifies the datatype of each matrix A_i. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. !> @param[in] B - [void *] !> device pointer storing array of pointers to each matrix B_i. !> @param[in] bType !> [hipDataType] !> specifies the datatype of each matrix B_i. !> @param[in] ldb - [int] !> specifies the leading dimension of each B_i. !> @param[in] beta - [const void *] !> device pointer or host pointer specifying the scalar beta. Same datatype as !> computeType. !> @param[in] C - [void *] !> device array of device pointers to each matrix C_i. !> @param[in] cType !> [hipDataType] !> specifies the datatype of each matrix C_i. !> @param[in] ldc - [int] !> specifies the leading dimension of each C_i. !> @param[in] batchCount !> [int] !> number of gemm operations in the batch. !> @param[in] computeType !> [hipblasComputeType_t] !> specifies the datatype of computation. !> @param[in] algo - [hipblasGemmAlgo_t] !> enumerant specifying the algorithm type. interface hipblasGemmBatchedEx #ifdef USE_CUDA_NAMES function hipblasGemmBatchedEx_(handle,transA,transB,m,n,k,alpha,A,aType,lda,B,bType,ldb,beta, & C,cType,ldc,batchCount,computeType,algo) & bind(c, name="cublasGemmBatchedEx") #else function hipblasGemmBatchedEx_(handle,transA,transB,m,n,k,alpha,A,aType,lda,B,bType,ldb,beta, & C,cType,ldc,batchCount,computeType,algo) & bind(c, name="hipblasGemmBatchedEx") #endif use iso_c_binding use hipfort_hipblas_enums use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: A integer(kind(HIP_R_32F)),value :: aType integer(c_int),value :: lda type(c_ptr),value :: B integer(kind(HIP_R_32F)),value :: bType integer(c_int),value :: ldb type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(HIP_R_32F)),value :: cType integer(c_int),value :: ldc integer(c_int),value :: batchCount integer(kind(HIPBLAS_COMPUTE_16F)),value :: computeType integer(kind(HIPBLAS_GEMM_DEFAULT)),value :: algo end function end interface #ifndef USE_CUDA_NAMES interface hipblasGemmBatchedExWithFlags function hipblasGemmBatchedExWithFlags_(handle,transA,transB,m,n,k,alpha,A,aType,lda,B,bType, & ldb,beta,C,cType,ldc,batchCount,computeType,algo,flags) & bind(c, name="hipblasGemmBatchedExWithFlags") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGemmBatchedExWithFlags_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: A integer(kind(HIP_R_32F)),value :: aType integer(c_int),value :: lda type(c_ptr),value :: B integer(kind(HIP_R_32F)),value :: bType integer(c_int),value :: ldb type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(HIP_R_32F)),value :: cType integer(c_int),value :: ldc integer(c_int),value :: batchCount integer(kind(HIPBLAS_COMPUTE_16F)),value :: computeType integer(kind(HIPBLAS_GEMM_DEFAULT)),value :: algo integer(kind(HIPBLAS_GEMM_FLAGS_NONE)),value :: flags end function end interface #endif interface hipblasGemmBatchedEx_64 #ifdef USE_CUDA_NAMES function hipblasGemmBatchedEx_64_(handle,transA,transB,m,n,k,alpha,A,aType,lda,B,bType,ldb, & beta,C,cType,ldc,batchCount,computeType,algo) & bind(c, name="cublasGemmBatchedEx_64") #else function hipblasGemmBatchedEx_64_(handle,transA,transB,m,n,k,alpha,A,aType,lda,B,bType,ldb, & beta,C,cType,ldc,batchCount,computeType,algo) & bind(c, name="hipblasGemmBatchedEx_64") #endif use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGemmBatchedEx_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: A integer(kind(HIP_R_32F)),value :: aType integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(kind(HIP_R_32F)),value :: bType integer(c_int64_t),value :: ldb type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(HIP_R_32F)),value :: cType integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount integer(kind(HIPBLAS_COMPUTE_16F)),value :: computeType integer(kind(HIPBLAS_GEMM_DEFAULT)),value :: algo end function end interface #ifndef USE_CUDA_NAMES interface hipblasGemmBatchedExWithFlags_64 function hipblasGemmBatchedExWithFlags_64_(handle,transA,transB,m,n,k,alpha,A,aType,lda,B, & bType,ldb,beta,C,cType,ldc,batchCount,computeType,algo,flags) & bind(c, name="hipblasGemmBatchedExWithFlags_64") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGemmBatchedExWithFlags_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: A integer(kind(HIP_R_32F)),value :: aType integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(kind(HIP_R_32F)),value :: bType integer(c_int64_t),value :: ldb type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(HIP_R_32F)),value :: cType integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batchCount integer(kind(HIPBLAS_COMPUTE_16F)),value :: computeType integer(kind(HIPBLAS_GEMM_DEFAULT)),value :: algo integer(kind(HIPBLAS_GEMM_FLAGS_NONE)),value :: flags end function end interface #endif !> \brief BLAS EX API !> !> \details !> The gemmStridedBatchedEx functions perform one of the strided_batched matrix-matrix !> operations: !> !> C_i = alpha*op(A_i)*op(B_i) + beta*C_i, for i = 1, ..., batchCount !> !> where ``op( X )`` is one of: !> !> op( X ) = X or !> op( X ) = X**T or !> op( X ) = X**H, !> !> ``alpha`` and ``beta`` are scalars, and ``A``, ``B``, and ``C`` are strided_batched !> matrices, with !> ``op( A )`` an ``m`` by ``k`` by ``batchCount`` strided_batched matrix, !> ``op( B )`` a ``k`` by ``n`` by ``batchCount`` strided_batched matrix, and !> ``C`` an ``m`` by ``n`` by ``batchCount`` strided_batched matrix. !> !> The strided_batched matrices are multiple matrices separated by a constant stride. !> The number of matrices is ``batchCount``. !> !> - Supported types are determined by the backend. See the rocBLAS or cuBLAS documentation. !> !> ``hipblasGemmStridedBatchedExWithFlags`` is also available. This is identical to !> ``hipblasStridedBatchedGemmEx`` !> with the addition of a ``flags`` parameter which controls the flags used in Tensile to !> control gemm algorithms with the !> rocBLAS backend. When using a cuBLAS backend, this parameter is ignored. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] transA - [hipblasOperation_t] !> specifies the form of op( A ). !> @param[in] transB - [hipblasOperation_t] !> specifies the form of op( B ). !> @param[in] m - [int] !> matrix dimension m. !> @param[in] n - [int] !> matrix dimension n. !> @param[in] k - [int] !> matrix dimension k. !> @param[in] alpha - [const void *] !> device pointer or host pointer specifying the scalar alpha. Same datatype as !> computeType. !> @param[in] A - [void *] !> device pointer pointing to first matrix A_1. !> @param[in] aType !> [hipDataType] !> specifies the datatype of each matrix A_i. !> @param[in] lda - [int] !> specifies the leading dimension of each A_i. !> @param[in] strideA - [hipblasStride] !> specifies stride from start of one A_i matrix to the next A_(i + 1). !> @param[in] B - [void *] !> device pointer pointing to first matrix B_1. !> @param[in] bType !> [hipDataType] !> specifies the datatype of each matrix B_i. !> @param[in] ldb - [int] !> specifies the leading dimension of each B_i. !> @param[in] strideB - [hipblasStride] !> specifies stride from start of one B_i matrix to the next B_(i + 1). !> @param[in] beta - [const void *] !> device pointer or host pointer specifying the scalar beta. Same datatype as !> computeType. !> @param[in] C - [void *] !> device pointer pointing to first matrix C_1. !> @param[in] cType !> [hipDataType] !> specifies the datatype of each matrix C_i. !> @param[in] ldc - [int] !> specifies the leading dimension of each C_i. !> @param[in] strideC - [hipblasStride] !> specifies stride from start of one C_i matrix to the next C_(i + 1). !> @param[in] batchCount !> [int] !> number of gemm operations in the batch. !> @param[in] computeType !> [hipblasComputeType_t] !> specifies the datatype of computation. !> @param[in] algo - [hipblasGemmAlgo_t] !> enumerant specifying the algorithm type. interface hipblasGemmStridedBatchedEx #ifdef USE_CUDA_NAMES function hipblasGemmStridedBatchedEx_(handle,transA,transB,m,n,k,alpha,A,aType,lda,strideA,B, & bType,ldb,strideB,beta,C,cType,ldc,strideC,batchCount,computeType,algo) & bind(c, name="cublasGemmStridedBatchedEx") #else function hipblasGemmStridedBatchedEx_(handle,transA,transB,m,n,k,alpha,A,aType,lda,strideA,B, & bType,ldb,strideB,beta,C,cType,ldc,strideC,batchCount,computeType,algo) & bind(c, name="hipblasGemmStridedBatchedEx") #endif use iso_c_binding use hipfort_hipblas_enums use hipfort_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 integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: A integer(kind(HIP_R_32F)),value :: aType integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(kind(HIP_R_32F)),value :: bType integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(HIP_R_32F)),value :: cType integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount integer(kind(HIPBLAS_COMPUTE_16F)),value :: computeType integer(kind(HIPBLAS_GEMM_DEFAULT)),value :: algo end function end interface #ifndef USE_CUDA_NAMES interface hipblasGemmStridedBatchedExWithFlags function hipblasGemmStridedBatchedExWithFlags_(handle,transA,transB,m,n,k,alpha,A,aType,lda, & strideA,B,bType,ldb,strideB,beta,C,cType,ldc,strideC,batchCount,computeType,algo,flags) & bind(c, name="hipblasGemmStridedBatchedExWithFlags") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGemmStridedBatchedExWithFlags_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: A integer(kind(HIP_R_32F)),value :: aType integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(kind(HIP_R_32F)),value :: bType integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(HIP_R_32F)),value :: cType integer(c_int),value :: ldc integer(c_int64_t),value :: strideC integer(c_int),value :: batchCount integer(kind(HIPBLAS_COMPUTE_16F)),value :: computeType integer(kind(HIPBLAS_GEMM_DEFAULT)),value :: algo integer(kind(HIPBLAS_GEMM_FLAGS_NONE)),value :: flags end function end interface #endif interface hipblasGemmStridedBatchedEx_64 #ifdef USE_CUDA_NAMES function hipblasGemmStridedBatchedEx_64_(handle,transA,transB,m,n,k,alpha,A,aType,lda,strideA, & B,bType,ldb,strideB,beta,C,cType,ldc,strideC,batchCount,computeType,algo) & bind(c, name="cublasGemmStridedBatchedEx_64") #else function hipblasGemmStridedBatchedEx_64_(handle,transA,transB,m,n,k,alpha,A,aType,lda,strideA, & B,bType,ldb,strideB,beta,C,cType,ldc,strideC,batchCount,computeType,algo) & bind(c, name="hipblasGemmStridedBatchedEx_64") #endif use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGemmStridedBatchedEx_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: A integer(kind(HIP_R_32F)),value :: aType integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(kind(HIP_R_32F)),value :: bType integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(HIP_R_32F)),value :: cType integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount integer(kind(HIPBLAS_COMPUTE_16F)),value :: computeType integer(kind(HIPBLAS_GEMM_DEFAULT)),value :: algo end function end interface #ifndef USE_CUDA_NAMES interface hipblasGemmStridedBatchedExWithFlags_64 function hipblasGemmStridedBatchedExWithFlags_64_(handle,transA,transB,m,n,k,alpha,A,aType, & lda,strideA,B,bType,ldb,strideB,beta,C,cType,ldc,strideC,batchCount,computeType,algo, & flags) & bind(c, name="hipblasGemmStridedBatchedExWithFlags_64") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasGemmStridedBatchedExWithFlags_64_ type(c_ptr),value :: handle integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_OP_N)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: A integer(kind(HIP_R_32F)),value :: aType integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(kind(HIP_R_32F)),value :: bType integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(HIP_R_32F)),value :: cType integer(c_int64_t),value :: ldc integer(c_int64_t),value :: strideC integer(c_int64_t),value :: batchCount integer(kind(HIPBLAS_COMPUTE_16F)),value :: computeType integer(kind(HIPBLAS_GEMM_DEFAULT)),value :: algo integer(kind(HIPBLAS_GEMM_FLAGS_NONE)),value :: flags end function end interface #endif !> \brief BLAS EX API !> !> \details !> !> The syrkEx function performs one of the matrix-matrix operations for a symmetric rank-k !> update: !> !> C := alpha*op( A )*op( A )^T + beta*C !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` is an ``n`` by ``k`` matrix, and !> ``C`` is a symmetric ``n`` x ``n`` matrix stored as either upper or lower. !> !> op( A ) = A, and A is n by k if transA == HIPBLAS_OP_N !> op( A ) = A^T and A is k by n if transA == HIPBLAS_OP_T !> !> - Supported types are determined by the backend. See the rocBLAS or cuBLAS documentation. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> Specifies whether the matrix C is an upper or lower triangular matrix as follows: !> - HIPBLAS_FILL_MODE_UPPER: C is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: C is a lower triangular matrix. !> @param[in] transA - [hipblasOperation_t] !> specifies the form of op( A ). !> @param[in] n - [int] !> matrix dimension n. !> @param[in] k - [int] !> matrix dimension k. !> @param[in] alpha - [const void *] !> device pointer or host pointer specifying the scalar alpha. Same datatype as !> computeType. !> @param[in] A - [void *] !> device pointer storing matrix A. !> @param[in] aType !> [hipDataType] !> specifies the datatype of matrix A. !> @param[in] lda - [int] !> specifies the leading dimension of A. !> @param[in] beta - [const void *] !> device pointer or host pointer specifying the scalar beta. Same datatype as !> computeType. !> @param[in] C - [void *] !> device pointer storing matrix C. !> @param[in] cType !> [hipDataType] !> specifies the datatype of matrix C. !> @param[in] ldc - [int] !> specifies the leading dimension of C. !> @param[in] computeType !> [hipDataType] !> specifies the datatype of the computation. #ifndef USE_CUDA_NAMES interface hipblasSyrkEx function hipblasSyrkEx_(handle,uplo,transA,n,k,alpha,A,aType,lda,beta,C,cType,ldc,computeType) & bind(c, name="hipblasSyrkEx") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSyrkEx_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: A integer(kind(HIP_R_32F)),value :: aType integer(c_int),value :: lda type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(HIP_R_32F)),value :: cType integer(c_int),value :: ldc integer(kind(HIP_R_32F)),value :: computeType end function end interface #endif !> BLAS EX API !> !> \details !> The trsmEx functions solve: !> !> op(A)*X = alpha*B or X*op(A) = alpha*B, !> !> where ``alpha`` is a scalar, ``X`` and ``B`` are ``m`` by ``n`` matrices, !> ``A`` is a triangular matrix, and ``op(A)`` is one of !> !> op( A ) = A or op( A ) = A^T or op( A ) = A^H. !> !> The matrix ``X`` is overwritten on ``B``. !> !> This function gives the user the ability to reuse the ``invA`` matrix between runs. !> If ``invA == NULL``, ``hipblasTrsmEx`` will automatically calculate ``invA`` on every run. !> !> Setting up invA: !> The accepted ``invA`` matrix consists of the packed 128x128 inverses of the diagonal blocks !> of !> matrix ``A``, followed by any smaller diagonal block that remains. !> To set up ``invA``, it is recommended that ``hipblasTrtriBatched`` be used with matrix !> ``A`` as the input. !> !> Device memory of size 128 x ``k`` should be allocated for ``invA`` ahead of time, where !> ``k`` is ``m`` when !> ``HIPBLAS_SIDE_LEFT`` and is ``n`` when ``HIPBLAS_SIDE_RIGHT``. The actual number of !> elements in ``invA`` !> should be passed as ``invAsize``. !> !> To begin, ``hipblasTrtriBatched`` must be called on the full 128x128 sized diagonal blocks !> of !> matrix ``A``. Here are the restricted parameters: !> - ``n`` = 128 !> - ``ldinvA`` = 128 !> - ``stride_invA`` = 128x128 !> - ``batchCount`` = ``k / 128``, !> !> Then any remaining block can be added: !> - ``n`` = ``k % 128`` !> - ``invA`` = ``invA + stride_invA * previousBatchCount`` !> - ``ldinvA`` = 128 !> - ``batchCount`` = 1 !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] side - [hipblasSideMode_t] !> - HIPBLAS_SIDE_LEFT: op(A)*X = alpha*B. !> - HIPBLAS_SIDE_RIGHT: X*op(A) = alpha*B. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: A is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: A is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_N: op(A) = A. !> - HIPBLAS_OP_T: op(A) = A^T. !> - HIPBLAS_ON_C: op(A) = A^H. !> !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: A is assumed to be unit triangular. !> - HIPBLAS_DIAG_NON_UNIT: A is not assumed to be unit triangular. !> !> @param[in] m - [int] !> m specifies the number of rows of B. m >= 0. !> !> @param[in] n - [int] !> n specifies the number of columns of B. n >= 0. !> !> @param[in] alpha - [void *] !> device pointer or host pointer specifying the scalar alpha. When alpha is !> &zero, then A is not referenced, and B does not need to be set before !> entry. !> !> @param[in] A - [void *] !> device pointer storing matrix A. !> Of dimension ( lda, k ), where k is m !> when HIPBLAS_SIDE_LEFT and !> is n when HIPBLAS_SIDE_RIGHT. !> Only the upper/lower triangular part is accessed. !> !> @param[in] lda - [int] !> lda specifies the first dimension of A. !> - If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ). !> - If side = HIPBLAS_SIDE_RIGHT, lda >= max( 1, n ). !> !> @param[in, out] B - [void *] !> device pointer storing matrix B. !> B is of dimension ( ldb, n ). !> Before entry, the leading m by n part of the array B must !> contain the right-hand side matrix B, and on exit is !> overwritten by the solution matrix X. !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of B. ldb >= max( 1, m ). !> !> @param[in] invA - [void *] !> device pointer storing the inverse diagonal blocks of A. !> invA is of dimension ( ld_invA, k ), where k is m !> when HIPBLAS_SIDE_LEFT and !> is n when HIPBLAS_SIDE_RIGHT. !> ld_invA must be equal to 128. !> !> @param[in] invAsize - [int] !> invAsize specifies the number of elements of device memory in invA. !> !> @param[in] computeType !> [hipDataType] !> specifies the datatype of computation. #ifndef USE_CUDA_NAMES interface hipblasTrsmEx function hipblasTrsmEx_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,invA,invAsize, & computeType) & bind(c, name="hipblasTrsmEx") use iso_c_binding use hipfort_hipblas_enums use hipfort_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 integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: invA integer(c_int),value :: invAsize integer(kind(HIP_R_32F)),value :: computeType end function end interface #endif !> \brief BLAS EX API !> !> \details !> !> The herkEx function performs one of the matrix-matrix operations for a Hermitian rank-k !> update: !> !> C := alpha*op( A )*op( A )^H + beta*C !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` is an ``n`` by ``k`` matrix, and !> ``C`` is a Hermitian ``n`` x ``n`` matrix stored as either upper or lower. !> !> op( A ) = A, and A is n by k if transA == HIPBLAS_OP_N !> op( A ) = A^H and A is k by n if transA == HIPBLAS_OP_C !> !> - Supported types are determined by the backend. See the rocBLAS or cuBLAS documentation. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] uplo - [hipblasFillMode_t] !> Specifies whether the matrix C is an upper or lower triangular matrix as follows: !> - HIPBLAS_FILL_MODE_UPPER: C is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: C is a lower triangular matrix. !> @param[in] transA - [hipblasOperation_t] !> specifies the form of op( A ). !> @param[in] n - [int] !> matrix dimension n. !> @param[in] k - [int] !> matrix dimension k. !> @param[in] alpha - [const void *] !> device pointer or host pointer specifying the scalar alpha. Same datatype as !> computeType. !> @param[in] A - [void *] !> device pointer storing matrix A. !> @param[in] aType !> [hipDataType] !> specifies the datatype of matrix A. !> @param[in] lda - [int] !> specifies the leading dimension of A. !> @param[in] beta - [const void *] !> device pointer or host pointer specifying the scalar beta. Same datatype as !> computeType. !> @param[in] C - [void *] !> device pointer storing matrix C. !> @param[in] cType !> [hipDataType] !> specifies the datatype of matrix C. !> @param[in] ldc - [int] !> specifies the leading dimension of C. !> @param[in] computeType !> [hipDataType] !> specifies the datatype of the computation. #ifndef USE_CUDA_NAMES interface hipblasHerkEx function hipblasHerkEx_(handle,uplo,transA,n,k,alpha,A,aType,lda,beta,C,cType,ldc,computeType) & bind(c, name="hipblasHerkEx") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasHerkEx_ type(c_ptr),value :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPBLAS_OP_N)),value :: transA integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: A integer(kind(HIP_R_32F)),value :: aType integer(c_int),value :: lda type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(HIP_R_32F)),value :: cType integer(c_int),value :: ldc integer(kind(HIP_R_32F)),value :: computeType end function end interface #endif !> BLAS EX API !> !> \details !> The trsmBatchedEx functions solve: !> !> op(A_i)*X_i = alpha*B_i or X_i*op(A_i) = alpha*B_i, !> !> for ``i`` = 1, ..., ``batchCount``, where ``alpha`` is a scalar, ``X`` and ``B`` are arrays !> of ``m`` by ``n`` matrices, !> ``A`` is an array of triangular matrices, and each ``op(A_i)`` is one of: !> !> op( A_i ) = A_i or op( A_i ) = A_i^T or op( A_i ) = A_i^H. !> !> Each matrix ``X_i`` is overwritten on ``B_i``. !> !> This function gives the user the ability to reuse the ``invA`` matrix between runs. !> If ``invA == NULL``, ``hipblasTrsmBatchedEx`` will automatically calculate each ``invA_i`` !> on every run. !> !> Setting up ``invA``: !> Each accepted ``invA_i`` matrix consists of the packed 128x128 inverses of the diagonal !> blocks of !> matrix ``A_i``, followed by any smaller diagonal block that remains. !> To set up each ``invA_i``, it is recommended that ``hipblasTrtriBatched`` be used with !> matrix ``A_i`` as the input. !> ``invA`` is an array of pointers of ``batchCount`` length holding each ``invA_i``. !> !> Device memory of size 128 x ``k`` should be allocated for each ``invA_i`` ahead of time, !> where ``k`` is ``m`` when !> ``HIPBLAS_SIDE_LEFT`` and is ``n`` when ``HIPBLAS_SIDE_RIGHT``. The actual number of !> elements in each ``invA_i`` !> should be passed as ``invAsize``. !> !> To begin, ``hipblasTrtriBatched`` must be called on the full 128x128 sized diagonal blocks !> of each !> matrix ``A_i``. Below are the restricted parameters: !> - ``n`` = 128 !> - ``ldinvA`` = 128 !> - ``stride_invA`` = 128x128 !> - ``batchCount`` = ``k / 128``, !> !> Then any remaining block can be added: !> - ``n`` = ``k % 128`` !> - ``invA`` = ``invA + stride_invA * previousBatchCount`` !> - ``ldinvA`` = 128 !> - ``batchCount`` = 1 !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] side - [hipblasSideMode_t] !> - HIPBLAS_SIDE_LEFT: op(A)*X = alpha*B. !> - HIPBLAS_SIDE_RIGHT: X*op(A) = alpha*B. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: each A_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: each A_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_N: op(A) = A. !> - HIPBLAS_OP_T: op(A) = A^T. !> - HIPBLAS_OP_C: op(A) = A^H. !> !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: each A_i is assumed to be unit triangular. !> - HIPBLAS_DIAG_NON_UNIT: each A_i is not assumed to be unit triangular. !> !> @param[in] m - [int] !> m specifies the number of rows of each B_i. m >= 0. !> !> @param[in] n - [int] !> n specifies the number of columns of each B_i. n >= 0. !> !> @param[in] alpha - [void *] !> device pointer or host pointer alpha specifying the scalar alpha. When alpha is !> &zero, then A is not referenced, and B does not need to be set before !> entry. !> !> @param[in] A - [void *] !> device array of device pointers storing each matrix A_i. !> Each A_i is of dimension ( lda, k ), where k is m !> when HIPBLAS_SIDE_LEFT and !> is n when HIPBLAS_SIDE_RIGHT. !> Only the upper/lower triangular part is accessed. !> !> @param[in] lda - [int] !> lda specifies the first dimension of each A_i. !> - If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ). !> - If side = HIPBLAS_SIDE_RIGHT, lda >= max( 1, n ). !> !> @param[in, out] B - [void *] !> device array of device pointers storing each matrix B_i. !> Each B_i is of dimension ( ldb, n ). !> Before entry, the leading m by n part of the array B_i must !> contain the right-hand side matrix B_i, and on exit is !> overwritten by the solution matrix X_i. !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of each B_i. ldb >= max( 1, m ). !> !> @param[in] batchCount - [int] !> specifies how many batches. !> !> @param[in] invA - [void *] !> device array of device pointers storing the inverse diagonal blocks of each A_i. !> Each invA_i is of dimension ( ld_invA, k ), where k is m !> when HIPBLAS_SIDE_LEFT and !> is n when HIPBLAS_SIDE_RIGHT. !> ld_invA must be equal to 128. !> !> @param[in] invAsize - [int] !> invAsize specifies the number of elements of device memory in each invA_i. !> !> @param[in] computeType !> [hipDataType] !> specifies the datatype of computation. #ifndef USE_CUDA_NAMES interface hipblasTrsmBatchedEx function hipblasTrsmBatchedEx_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,batchCount, & invA,invAsize,computeType) & bind(c, name="hipblasTrsmBatchedEx") use iso_c_binding use hipfort_hipblas_enums use hipfort_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 integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batchCount type(c_ptr),value :: invA integer(c_int),value :: invAsize integer(kind(HIP_R_32F)),value :: computeType end function end interface #endif !> \brief BLAS EX API !> !> \details !> The trsmStridedBatchedEx functions solve: !> !> op(A_i)*X_i = alpha*B_i or X_i*op(A_i) = alpha*B_i, !> !> for ``i`` = 1, ..., ``batchCount``, where ``alpha`` is a scalar, ``X`` and ``B`` are !> strided batched ``m`` by ``n`` matrices, !> ``A`` is a strided batched triangular matrix, and ``op(A_i)`` is one of: !> !> op( A_i ) = A_i or op( A_i ) = A_i^T or op( A_i ) = A_i^H. !> !> Each matrix ``X_i`` is overwritten on ``B_i``. !> !> This function gives the user the ability to reuse each ``invA_i`` matrix between runs. !> If ``invA == NULL``, ``hipblasTrsmStridedBatchedEx`` will automatically calculate each !> ``invA_i`` on every run. !> !> Setting up invA: !> Each accepted ``invA_i`` matrix consists of the packed 128x128 inverses of the diagonal !> blocks of !> matrix ``A_i``, followed by any smaller diagonal block that remains. !> To set up ``invA_i``, it is recommended that ``hipblasTrtriBatched`` be used with matrix !> ``A_i`` as the input. !> ``invA`` is a contiguous piece of memory holding each ``invA_i``. !> !> Device memory of size 128 x ``k`` should be allocated for each ``invA_i`` ahead of time, !> where ``k`` is ``m`` when !> ``HIPBLAS_SIDE_LEFT`` and is ``n`` when ``HIPBLAS_SIDE_RIGHT``. The actual number of !> elements in each ``invA_i`` !> should be passed as ``invAsize``. !> !> To begin, ``hipblasTrtriBatched`` must be called on the full 128x128 sized diagonal blocks !> of each !> matrix ``A_i``. Below are the restricted parameters: !> - ``n`` = 128 !> - ``ldinvA`` = 128 !> - ``stride_invA`` = 128x128 !> - ``batchCount`` = ``k / 128``, !> !> Then any remaining block can be added: !> - ``n`` = ``k % 128`` !> - ``invA`` = ``invA + stride_invA * previousBatchCount`` !> - ``ldinvA`` = 128 !> - ``batchCount`` = 1 !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> !> @param[in] side - [hipblasSideMode_t] !> - HIPBLAS_SIDE_LEFT: op(A)*X = alpha*B. !> - HIPBLAS_SIDE_RIGHT: X*op(A) = alpha*B. !> !> @param[in] uplo - [hipblasFillMode_t] !> - HIPBLAS_FILL_MODE_UPPER: each A_i is an upper triangular matrix. !> - HIPBLAS_FILL_MODE_LOWER: each A_i is a lower triangular matrix. !> !> @param[in] transA - [hipblasOperation_t] !> - HIPBLAS_OP_N: op(A) = A. !> - HIPBLAS_OP_T: op(A) = A^T. !> - HIPBLAS_OP_C: op(A) = A^H. !> !> @param[in] diag - [hipblasDiagType_t] !> - HIPBLAS_DIAG_UNIT: each A_i is assumed to be unit triangular. !> - HIPBLAS_DIAG_NON_UNIT: each A_i is not assumed to be unit triangular. !> !> @param[in] m - [int] !> m specifies the number of rows of each B_i. m >= 0. !> !> @param[in] n - [int] !> n specifies the number of columns of each B_i. n >= 0. !> !> @param[in] alpha - [void *] !> device pointer or host pointer specifying the scalar alpha. When alpha is !> &zero, then A is not referenced, and B does not need to be set before !> entry. !> !> @param[in] A - [void *] !> device pointer storing matrix A. !> Of dimension ( lda, k ), where k is m !> when HIPBLAS_SIDE_LEFT and !> is n when HIPBLAS_SIDE_RIGHT. !> Only the upper/lower triangular part is accessed. !> !> @param[in] lda - [int] !> lda specifies the first dimension of A. !> - If side = HIPBLAS_SIDE_LEFT, lda >= max( 1, m ). !> - If side = HIPBLAS_SIDE_RIGHT, lda >= max( 1, n ). !> !> @param[in] strideA - [hipblasStride] !> The stride between each A matrix. !> !> @param[in, out] B - [void *] !> device pointer pointing to first matrix B_i. !> Each B_i is of dimension ( ldb, n ). !> Before entry, the leading m by n part of each array B_i must !> contain the right-hand side of matrix B_i, and on exit is !> overwritten by the solution matrix X_i. !> !> @param[in] ldb - [int] !> ldb specifies the first dimension of each B_i. ldb >= max( 1, m ). !> !> @param[in] strideB - [hipblasStride] !> The stride between each B_i matrix. !> !> @param[in] batchCount - [int] !> specifies how many batches. !> !> @param[in] invA - [void *] !> device pointer storing the inverse diagonal blocks of each A_i. !> invA points to the first invA_1. !> Each invA_i is of dimension ( ld_invA, k ), where k is m !> when HIPBLAS_SIDE_LEFT and !> is n when HIPBLAS_SIDE_RIGHT. !> ld_invA must be equal to 128. !> !> @param[in] invAsize - [int] !> invAsize specifies the number of elements of device memory in each invA_i. !> !> @param[in] strideInvA - [hipblasStride] !> The stride between each invA matrix. !> !> @param[in] computeType !> [hipDataType] !> specifies the datatype of computation. #ifndef USE_CUDA_NAMES interface hipblasTrsmStridedBatchedEx function hipblasTrsmStridedBatchedEx_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,strideA,B, & ldb,strideB,batchCount,invA,invAsize,strideInvA,computeType) & bind(c, name="hipblasTrsmStridedBatchedEx") use iso_c_binding use hipfort_hipblas_enums use hipfort_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 integer(kind(HIPBLAS_OP_N)),value :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)),value :: diag integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: alpha 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 integer(c_int),value :: batchCount type(c_ptr),value :: invA integer(c_int),value :: invAsize integer(c_int64_t),value :: strideInvA integer(kind(HIP_R_32F)),value :: computeType end function end interface #endif !> \brief BLAS EX API !> !> \details !> The axpyEx funtions compute a constant ``alpha`` multiplied by vector ``x``, plus vector !> ``y``: !> !> y := alpha * x + y !> !> The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in x and y. !> @param[in] alpha - device pointer or host pointer to specify the scalar alpha. !> @param[in] alphaType !> [hipDataType] !> specifies the datatype of alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] xType !> [hipDataType] !> specifies the datatype of vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[inout] y - device pointer storing vector y. !> @param[in] yType !> [hipDataType] !> specifies the datatype of vector y. !> @param[in] incy - [int] !> specifies the increment for the elements of y. !> @param[in] executionType !> [hipDataType] !> specifies the datatype of computation. interface hipblasAxpyEx #ifdef USE_CUDA_NAMES function hipblasAxpyEx_(handle,n,alpha,alphaType,x,xType,incx,y,yType,incy,executionType) & bind(c, name="cublasAxpyEx") #else function hipblasAxpyEx_(handle,n,alpha,alphaType,x,xType,incx,y,yType,incy,executionType) & bind(c, name="hipblasAxpyEx") #endif use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasAxpyEx_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: alpha integer(kind(HIP_R_32F)),value :: alphaType type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int),value :: incx type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int),value :: incy integer(kind(HIP_R_32F)),value :: executionType end function end interface interface hipblasAxpyEx_64 #ifdef USE_CUDA_NAMES function hipblasAxpyEx_64_(handle,n,alpha,alphaType,x,xType,incx,y,yType,incy,executionType) & bind(c, name="cublasAxpyEx_64") #else function hipblasAxpyEx_64_(handle,n,alpha,alphaType,x,xType,incx,y,yType,incy,executionType) & bind(c, name="hipblasAxpyEx_64") #endif use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasAxpyEx_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: alpha integer(kind(HIP_R_32F)),value :: alphaType type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int64_t),value :: incy integer(kind(HIP_R_32F)),value :: executionType end function end interface !> \brief BLAS EX API !> !> \details !> The axpyBatchedEx functions compute a constant ``alpha`` multiplied by vector ``x``, plus !> vector ``y``, over !> a set of batched vectors. !> !> y := alpha * x + y !> !> The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in each x_i and y_i. !> @param[in] alpha - device pointer or host pointer to specify the scalar alpha. !> @param[in] alphaType !> [hipDataType] !> specifies the datatype of alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] xType !> [hipDataType] !> specifies the datatype of each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[inout] y - device array of device pointers storing each vector y_i. !> @param[in] yType !> [hipDataType] !> specifies the datatype of each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of each y_i. !> @param[in] batchCount - [int] !> number of instances in the batch. !> @param[in] executionType !> [hipDataType] !> specifies the datatype of computation. #ifndef USE_CUDA_NAMES interface hipblasAxpyBatchedEx function hipblasAxpyBatchedEx_(handle,n,alpha,alphaType,x,xType,incx,y,yType,incy,batchCount, & executionType) & bind(c, name="hipblasAxpyBatchedEx") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasAxpyBatchedEx_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: alpha integer(kind(HIP_R_32F)),value :: alphaType type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int),value :: incx type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int),value :: incy integer(c_int),value :: batchCount integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasAxpyBatchedEx_64 function hipblasAxpyBatchedEx_64_(handle,n,alpha,alphaType,x,xType,incx,y,yType,incy, & batchCount,executionType) & bind(c, name="hipblasAxpyBatchedEx_64") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasAxpyBatchedEx_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: alpha integer(kind(HIP_R_32F)),value :: alphaType type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif !> \brief BLAS EX API !> !> \details !> The axpyStridedBatchedEx functions compute a constant ``alpha`` multiplied by vector ``x``, !> plus vector ``y``, over !> a set of strided batched vectors. !> !> y := alpha * x + y !> !> The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in each x_i and y_i. !> @param[in] alpha - device pointer or host pointer to specify the scalar alpha. !> @param[in] alphaType !> [hipDataType] !> specifies the datatype of alpha. !> @param[in] x - device pointer to the first vector x_1. !> @param[in] xType !> [hipDataType] !> specifies the datatype of each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stridex. However, the user should !> ensure that stridex is of an appropriate size. For a typical !> case, this means stridex >= n * incx. !> @param[inout] y - device pointer to the first vector y_1. !> @param[in] yType !> [hipDataType] !> specifies the datatype of each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of each y_i. !> @param[in] stridey - [hipblasStride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> There are no restrictions placed on stridey. However, the user should !> ensure that stridey is of appropriate size. For a typical !> case, this means stridey >= n * incy. !> @param[in] batchCount - [int] !> number of instances in the batch. !> @param[in] executionType !> [hipDataType] !> specifies the datatype of computation. #ifndef USE_CUDA_NAMES interface hipblasAxpyStridedBatchedEx function hipblasAxpyStridedBatchedEx_(handle,n,alpha,alphaType,x,xType,incx,stridex,y,yType, & incy,stridey,batchCount,executionType) & bind(c, name="hipblasAxpyStridedBatchedEx") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasAxpyStridedBatchedEx_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: alpha integer(kind(HIP_R_32F)),value :: alphaType type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasAxpyStridedBatchedEx_64 function hipblasAxpyStridedBatchedEx_64_(handle,n,alpha,alphaType,x,xType,incx,stridex,y, & yType,incy,stridey,batchCount,executionType) & bind(c, name="hipblasAxpyStridedBatchedEx_64") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasAxpyStridedBatchedEx_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: alpha integer(kind(HIP_R_32F)),value :: alphaType type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif !> \brief BLAS EX API !> !> \details !> The dotEx functions perform the dot product of vectors ``x`` and ``y``: !> !> result = x * y; !> !> The dotcEx functions perform the dot product of the conjugate of complex vector ``x`` and !> complex vector ``y``: !> !> result = conjugate (x) * y; !> !> The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in x and y. !> @param[in] x - device pointer storing vector x. !> @param[in] xType !> [hipDataType] !> specifies the datatype of vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of y. !> @param[in] y - device pointer storing vector y. !> @param[in] yType !> [hipDataType] !> specifies the datatype of vector y. !> @param[in] incy - [int] !> specifies the increment for the elements of y. !> @param[inout] myResult !> device pointer or host pointer to store the dot product. !> Return value is 0.0 if n <= 0. !> @param[in] resultType !> [hipDataType] !> specifies the datatype of the result. !> @param[in] executionType !> [hipDataType] !> specifies the datatype of computation. interface hipblasDotEx #ifdef USE_CUDA_NAMES function hipblasDotEx_(handle,n,x,xType,incx,y,yType,incy,myResult,resultType,executionType) & bind(c, name="cublasDotEx") #else function hipblasDotEx_(handle,n,x,xType,incx,y,yType,incy,myResult,resultType,executionType) & bind(c, name="hipblasDotEx") #endif use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotEx_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int),value :: incx type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int),value :: incy type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: resultType integer(kind(HIP_R_32F)),value :: executionType end function end interface interface hipblasDotcEx #ifdef USE_CUDA_NAMES function hipblasDotcEx_(handle,n,x,xType,incx,y,yType,incy,myResult,resultType,executionType) & bind(c, name="cublasDotcEx") #else function hipblasDotcEx_(handle,n,x,xType,incx,y,yType,incy,myResult,resultType,executionType) & bind(c, name="hipblasDotcEx") #endif use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotcEx_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int),value :: incx type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int),value :: incy type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: resultType integer(kind(HIP_R_32F)),value :: executionType end function end interface interface hipblasDotEx_64 #ifdef USE_CUDA_NAMES function hipblasDotEx_64_(handle,n,x,xType,incx,y,yType,incy,myResult,resultType, & executionType) & bind(c, name="cublasDotEx_64") #else function hipblasDotEx_64_(handle,n,x,xType,incx,y,yType,incy,myResult,resultType, & executionType) & bind(c, name="hipblasDotEx_64") #endif use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotEx_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int64_t),value :: incy type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: resultType integer(kind(HIP_R_32F)),value :: executionType end function end interface interface hipblasDotcEx_64 #ifdef USE_CUDA_NAMES function hipblasDotcEx_64_(handle,n,x,xType,incx,y,yType,incy,myResult,resultType, & executionType) & bind(c, name="cublasDotcEx_64") #else function hipblasDotcEx_64_(handle,n,x,xType,incx,y,yType,incy,myResult,resultType, & executionType) & bind(c, name="hipblasDotcEx_64") #endif use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotcEx_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int64_t),value :: incy type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: resultType integer(kind(HIP_R_32F)),value :: executionType end function end interface !> \brief BLAS EX API !> !> \details !> The dotBatchedEx functions perform a batch of dot products of vectors ``x`` and ``y``: !> !> result_i = x_i * y_i; !> !> The dotcBatchedEx functions performs a batch of dot products of the conjugate of complex !> vector ``x`` and complex vector ``y``: !> !> result_i = conjugate (x_i) * y_i; !> !> where ``(x_i, y_i)`` is the ``i``-th instance of the batch and !> ``x_i`` and ``y_i`` are vectors, for ``i`` = 1, ..., ``batchCount``. !> !> The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in each x_i and y_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] xType !> [hipDataType] !> specifies the datatype of each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] y - device array of device pointers storing each vector y_i. !> @param[in] yType !> [hipDataType] !> specifies the datatype of each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of each y_i. !> @param[in] batchCount - [int] !> number of instances in the batch. !> @param[inout] myResult !> device array or host array of batchCount size to store the dot products of each !> batch. !> Returns 0.0 for each element if n <= 0. !> @param[in] resultType !> [hipDataType] !> specifies the datatype of the result. !> @param[in] executionType !> [hipDataType] !> specifies the datatype of computation. #ifndef USE_CUDA_NAMES interface hipblasDotBatchedEx function hipblasDotBatchedEx_(handle,n,x,xType,incx,y,yType,incy,batchCount,myResult, & resultType,executionType) & bind(c, name="hipblasDotBatchedEx") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotBatchedEx_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int),value :: incx type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int),value :: incy integer(c_int),value :: batchCount type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: resultType integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDotcBatchedEx function hipblasDotcBatchedEx_(handle,n,x,xType,incx,y,yType,incy,batchCount,myResult, & resultType,executionType) & bind(c, name="hipblasDotcBatchedEx") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotcBatchedEx_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int),value :: incx type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int),value :: incy integer(c_int),value :: batchCount type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: resultType integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDotBatchedEx_64 function hipblasDotBatchedEx_64_(handle,n,x,xType,incx,y,yType,incy,batchCount,myResult, & resultType,executionType) & bind(c, name="hipblasDotBatchedEx_64") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotBatchedEx_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: resultType integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDotcBatchedEx_64 function hipblasDotcBatchedEx_64_(handle,n,x,xType,incx,y,yType,incy,batchCount,myResult, & resultType,executionType) & bind(c, name="hipblasDotcBatchedEx_64") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotcBatchedEx_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int64_t),value :: incy integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: resultType integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif !> \brief BLAS EX API !> !> \details !> The dotStridedBatchedEx functions perform a batch of dot products of vectors ``x`` and !> ``y``: !> !> result_i = x_i * y_i; !> !> The dotc_strided_batched_ex functions performs a batch of dot products of the conjugate of !> complex vector ``x`` and complex vector ``y``: !> !> result_i = conjugate (x_i) * y_i; !> !> where ``(x_i, y_i)`` is the ``i``-th instance of the batch and !> ``x_i`` and ``y_i`` are vectors, for ``i`` = 1, ..., ``batchCount``. !> !> The supported types are determined by the backend. See rocBLAS/cuBLAS documentation. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in each x_i and y_i. !> @param[in] x - device pointer to the first vector (x_1) in the batch. !> @param[in] xType !> [hipDataType] !> specifies the datatype of each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[in] y - device pointer to the first vector (y_1) in the batch. !> @param[in] yType !> [hipDataType] !> specifies the datatype of each vector y_i. !> @param[in] incy - [int] !> specifies the increment for the elements of each y_i. !> @param[in] stridey - [hipblasStride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> @param[in] batchCount - [int] !> number of instances in the batch. !> @param[inout] myResult !> device array or host array of batchCount size to store the dot products of each !> batch. !> Returns 0.0 for each element if n <= 0. !> @param[in] resultType !> [hipDataType] !> specifies the datatype of the result. !> @param[in] executionType !> [hipDataType] !> specifies the datatype of computation. #ifndef USE_CUDA_NAMES interface hipblasDotStridedBatchedEx function hipblasDotStridedBatchedEx_(handle,n,x,xType,incx,stridex,y,yType,incy,stridey, & batchCount,myResult,resultType,executionType) & bind(c, name="hipblasDotStridedBatchedEx") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotStridedBatchedEx_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: resultType integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDotcStridedBatchedEx function hipblasDotcStridedBatchedEx_(handle,n,x,xType,incx,stridex,y,yType,incy,stridey, & batchCount,myResult,resultType,executionType) & bind(c, name="hipblasDotcStridedBatchedEx") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotcStridedBatchedEx_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batchCount type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: resultType integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDotStridedBatchedEx_64 function hipblasDotStridedBatchedEx_64_(handle,n,x,xType,incx,stridex,y,yType,incy,stridey, & batchCount,myResult,resultType,executionType) & bind(c, name="hipblasDotStridedBatchedEx_64") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotStridedBatchedEx_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: resultType integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasDotcStridedBatchedEx_64 function hipblasDotcStridedBatchedEx_64_(handle,n,x,xType,incx,stridex,y,yType,incy,stridey, & batchCount,myResult,resultType,executionType) & bind(c, name="hipblasDotcStridedBatchedEx_64") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDotcStridedBatchedEx_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: resultType integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif !> \brief BLAS EX API !> !> \details !> The nrm2Ex functions compute the Euclidean norm of a real or complex vector: !> !> result := sqrt( x'*x ) for real vectors !> result := sqrt( x**H*x ) for complex vectors !> !> The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in x. !> @param[in] x - device pointer storing vector x. !> @param[in] xType !> [hipDataType] !> specifies the datatype of the vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of y. !> @param[inout] myResult !> device pointer or host pointer to store the nrm2 product. !> The return value is 0.0 if n, incx<=0. !> @param[in] resultType !> [hipDataType] !> specifies the datatype of the result. !> @param[in] executionType !> [hipDataType] !> specifies the datatype of computation. interface hipblasNrm2Ex #ifdef USE_CUDA_NAMES function hipblasNrm2Ex_(handle,n,x,xType,incx,myResult,resultType,executionType) & bind(c, name="cublasNrm2Ex") #else function hipblasNrm2Ex_(handle,n,x,xType,incx,myResult,resultType,executionType) & bind(c, name="hipblasNrm2Ex") #endif use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasNrm2Ex_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int),value :: incx type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: resultType integer(kind(HIP_R_32F)),value :: executionType end function end interface interface hipblasNrm2Ex_64 #ifdef USE_CUDA_NAMES function hipblasNrm2Ex_64_(handle,n,x,xType,incx,myResult,resultType,executionType) & bind(c, name="cublasNrm2Ex_64") #else function hipblasNrm2Ex_64_(handle,n,x,xType,incx,myResult,resultType,executionType) & bind(c, name="hipblasNrm2Ex_64") #endif use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasNrm2Ex_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int64_t),value :: incx type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: resultType integer(kind(HIP_R_32F)),value :: executionType end function end interface !> \brief BLAS EX API !> !> \details !> The nrm2BatchedEx functions compute the Euclidean norm over a batch of real or complex !> vectors: !> !> result := sqrt( x_i'*x_i ) for real vectors x, for i = 1, ..., batchCount !> result := sqrt( x_i**H*x_i ) for complex vectors x, for i = 1, ..., batchCount !> !> The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> number of elements in each x_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] xType !> [hipDataType] !> specifies the datatype of each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] batchCount - [int] !> number of instances in the batch. !> @param[out] myResult !> device pointer or host pointer to array of batchCount size for nrm2 results. !> Returns 0.0 for each element if n <= 0, incx<=0. !> @param[in] resultType !> [hipDataType] !> specifies the datatype of the result. !> @param[in] executionType !> [hipDataType] !> specifies the datatype of computation. #ifndef USE_CUDA_NAMES interface hipblasNrm2BatchedEx function hipblasNrm2BatchedEx_(handle,n,x,xType,incx,batchCount,myResult,resultType, & executionType) & bind(c, name="hipblasNrm2BatchedEx") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasNrm2BatchedEx_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int),value :: incx integer(c_int),value :: batchCount type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: resultType integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasNrm2BatchedEx_64 function hipblasNrm2BatchedEx_64_(handle,n,x,xType,incx,batchCount,myResult,resultType, & executionType) & bind(c, name="hipblasNrm2BatchedEx_64") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasNrm2BatchedEx_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: resultType integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif !> \brief BLAS EX API !> !> \details !> The nrm2StridedBatchedEx computes the Euclidean norm over a batch of real or complex !> vectors: !> !> := sqrt( x_i'*x_i ) for real vectors x, for i = 1, ..., batchCount !> := sqrt( x_i**H*x_i ) for complex vectors, for i = 1, ..., batchCount !> !> The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> number of elements in each x_i. !> @param[in] x - device pointer to the first vector x_1. !> @param[in] xType !> [hipDataType] !> specifies the datatype of each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) and the next one (x_i+1). !> There are no restrictions placed on stridex. However, the user should !> ensure that stridex is of an appropriate size. For a typical !> case, this means stridex >= n * incx. !> @param[in] batchCount - [int] !> number of instances in the batch. !> @param[out] myResult !> device pointer or host pointer to array for storing contiguous batchCount !> results. !> Returns 0.0 for each element if n <= 0, incx<=0. !> @param[in] resultType !> [hipDataType] !> specifies the datatype of the result. !> @param[in] executionType !> [hipDataType] !> specifies the datatype of computation. #ifndef USE_CUDA_NAMES interface hipblasNrm2StridedBatchedEx function hipblasNrm2StridedBatchedEx_(handle,n,x,xType,incx,stridex,batchCount,myResult, & resultType,executionType) & bind(c, name="hipblasNrm2StridedBatchedEx") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasNrm2StridedBatchedEx_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: resultType integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasNrm2StridedBatchedEx_64 function hipblasNrm2StridedBatchedEx_64_(handle,n,x,xType,incx,stridex,batchCount,myResult, & resultType,executionType) & bind(c, name="hipblasNrm2StridedBatchedEx_64") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasNrm2StridedBatchedEx_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: resultType integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif !> \brief BLAS EX API !> !> \details !> The rotEx functions applies the Givens rotation matrix defined by ``c=cos(alpha)`` and !> ``s=sin(alpha)`` to vectors ``x`` and ``y``. !> Scalars ``c`` and ``s`` can be stored in either the host or device memory. The location is !> specified by calling ``hipblasSetPointerMode``. !> !> If ``cs_type`` is real: !> !> x := c * x + s * y !> y := c * y - s * x !> !> If ``cs_type`` is complex, the imaginary part of ``c`` is ignored: !> !> x := real(c) * x + s * y !> y := real(c) * y - conj(s) * x !> !> The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> number of elements in the x and y vectors. !> @param[inout] x - device pointer storing vector x. !> @param[in] xType !> [hipDataType] !> specifies the datatype of vector x. !> @param[in] incx - [int] !> specifies the increment between elements of x. !> @param[inout] y - device pointer storing vector y. !> @param[in] yType !> [hipDataType] !> specifies the datatype of vector y. !> @param[in] incy - [int] !> specifies the increment between elements of y. !> @param[in] c - device pointer or host pointer storing scalar cosine component of the !> rotation matrix. !> @param[in] s - device pointer or host pointer storing scalar sine component of the rotation !> matrix. !> @param[in] csType !> [hipDataType] !> specifies the datatype of c and s. !> @param[in] executionType !> [hipDataType] !> specifies the datatype of computation. interface hipblasRotEx #ifdef USE_CUDA_NAMES function hipblasRotEx_(handle,n,x,xType,incx,y,yType,incy,c,s,csType,executionType) & bind(c, name="cublasRotEx") #else function hipblasRotEx_(handle,n,x,xType,incx,y,yType,incy,c,s,csType,executionType) & bind(c, name="hipblasRotEx") #endif use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasRotEx_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int),value :: incx type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(kind(HIP_R_32F)),value :: csType integer(kind(HIP_R_32F)),value :: executionType end function end interface interface hipblasRotEx_64 #ifdef USE_CUDA_NAMES function hipblasRotEx_64_(handle,n,x,xType,incx,y,yType,incy,c,s,csType,executionType) & bind(c, name="cublasRotEx_64") #else function hipblasRotEx_64_(handle,n,x,xType,incx,y,yType,incy,c,s,csType,executionType) & bind(c, name="hipblasRotEx_64") #endif use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasRotEx_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int64_t),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(kind(HIP_R_32F)),value :: csType integer(kind(HIP_R_32F)),value :: executionType end function end interface !> \brief BLAS EX API !> !> \details !> The rotBatchedEx functions apply the Givens rotation matrix defined by ``c=cos(alpha)`` and !> ``s=sin(alpha)`` to batched vectors ``x_i`` and`` y_i``, for ``i`` = 1, ..., !> ``batchCount``. !> Scalars ``c`` and ``s`` can be stored in either host or device memory. The location is !> specified by calling ``hipblasSetPointerMode``. !> !> If ``cs_type`` is real: !> !> x := c * x + s * y !> y := c * y - s * x !> !> If ``cs_type`` is complex, the imaginary part of ``c`` is ignored: !> !> x := real(c) * x + s * y !> y := real(c) * y - conj(s) * x !> !> The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> number of elements in each x_i and y_i vectors. !> @param[inout] x - device array of device pointers storing each vector x_i. !> @param[in] xType !> [hipDataType] !> specifies the datatype of each vector x_i. !> @param[in] incx - [int] !> specifies the increment between elements of each x_i. !> @param[inout] y - device array of device pointers storing each vector y_i. !> @param[in] yType !> [hipDataType] !> specifies the datatype of each vector y_i. !> @param[in] incy - [int] !> specifies the increment between elements of each y_i. !> @param[in] c - device pointer or host pointer to scalar cosine component of the rotation !> matrix. !> @param[in] s - device pointer or host pointer to scalar sine component of the rotation !> matrix. !> @param[in] csType !> [hipDataType] !> specifies the datatype of c and s. !> @param[in] batchCount - [int] !> the number of x and y arrays, that is, the number of batches. !> @param[in] executionType !> [hipDataType] !> specifies the datatype of computation. #ifndef USE_CUDA_NAMES interface hipblasRotBatchedEx function hipblasRotBatchedEx_(handle,n,x,xType,incx,y,yType,incy,c,s,csType,batchCount, & executionType) & bind(c, name="hipblasRotBatchedEx") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasRotBatchedEx_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int),value :: incx type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(kind(HIP_R_32F)),value :: csType integer(c_int),value :: batchCount integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasRotBatchedEx_64 function hipblasRotBatchedEx_64_(handle,n,x,xType,incx,y,yType,incy,c,s,csType,batchCount, & executionType) & bind(c, name="hipblasRotBatchedEx_64") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasRotBatchedEx_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int64_t),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(kind(HIP_R_32F)),value :: csType integer(c_int64_t),value :: batchCount integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif !> \brief BLAS EX API !> !> \details !> The rotStridedBatchedEx functions apply the Givens rotation matrix defined by !> ``c=cos(alpha)`` and ``s=sin(alpha)`` to strided batched vectors ``x_i`` and ``y_i``, for !> ``i`` = 1, ..., ``batchCount``. !> Scalars ``c`` and ``s`` can be stored in either host or device memory. The location is !> specified by calling ``hipblasSetPointerMode``. !> !> If ``cs_type`` is real: !> !> x := c * x + s * y !> y := c * y - s * x !> !> If ``cs_type`` is complex, the imaginary part of ``c`` is ignored: !> !> x := real(c) * x + s * y !> y := real(c) * y - conj(s) * x !> !> The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipblas library context queue. !> @param[in] n - [int] !> number of elements in each x_i and y_i vectors. !> @param[inout] x - device pointer to the first vector x_1. !> @param[in] xType !> [hipDataType] !> specifies the datatype of each vector x_i. !> @param[in] incx - [int] !> specifies the increment between elements of each x_i. !> @param[in] stridex - [hipblasStride] !> specifies the increment from the beginning of x_i to the beginning of x_(i+1). !> @param[inout] y - device pointer to the first vector y_1. !> @param[in] yType !> [hipDataType] !> specifies the datatype of each vector y_i. !> @param[in] incy - [int] !> specifies the increment between elements of each y_i. !> @param[in] stridey - [hipblasStride] !> specifies the increment from the beginning of y_i to the beginning of y_(i+1). !> @param[in] c - device pointer or host pointer to scalar cosine component of the rotation !> matrix. !> @param[in] s - device pointer or host pointer to scalar sine component of the rotation !> matrix. !> @param[in] csType !> [hipDataType] !> specifies the datatype of c and s. !> @param[in] batchCount - [int] !> the number of x and y arrays, that is, the number of batches. !> @param[in] executionType !> [hipDataType] !> specifies the datatype of computation. #ifndef USE_CUDA_NAMES interface hipblasRotStridedBatchedEx function hipblasRotStridedBatchedEx_(handle,n,x,xType,incx,stridex,y,yType,incy,stridey,c,s, & csType,batchCount,executionType) & bind(c, name="hipblasRotStridedBatchedEx") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasRotStridedBatchedEx_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: c type(c_ptr),value :: s integer(kind(HIP_R_32F)),value :: csType integer(c_int),value :: batchCount integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasRotStridedBatchedEx_64 function hipblasRotStridedBatchedEx_64_(handle,n,x,xType,incx,stridex,y,yType,incy,stridey,c, & s,csType,batchCount,executionType) & bind(c, name="hipblasRotStridedBatchedEx_64") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasRotStridedBatchedEx_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: yType integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: c type(c_ptr),value :: s integer(kind(HIP_R_32F)),value :: csType integer(c_int64_t),value :: batchCount integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif !> \brief BLAS EX API !> !> \details !> The scalEx functions scale each element of vector ``x`` with scalar ``alpha``. !> !> x := alpha * x !> !> The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in x. !> @param[in] alpha - device pointer or host pointer for the scalar alpha. !> @param[in] alphaType !> [hipDataType] !> specifies the datatype of alpha. !> @param[inout] x - device pointer storing vector x. !> @param[in] xType !> [hipDataType] !> specifies the datatype of vector x. !> @param[in] incx - [int] !> specifies the increment for the elements of x. !> @param[in] executionType !> [hipDataType] !> specifies the datatype of computation. interface hipblasScalEx #ifdef USE_CUDA_NAMES function hipblasScalEx_(handle,n,alpha,alphaType,x,xType,incx,executionType) & bind(c, name="cublasScalEx") #else function hipblasScalEx_(handle,n,alpha,alphaType,x,xType,incx,executionType) & bind(c, name="hipblasScalEx") #endif use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScalEx_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: alpha integer(kind(HIP_R_32F)),value :: alphaType type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int),value :: incx integer(kind(HIP_R_32F)),value :: executionType end function end interface interface hipblasScalEx_64 #ifdef USE_CUDA_NAMES function hipblasScalEx_64_(handle,n,alpha,alphaType,x,xType,incx,executionType) & bind(c, name="cublasScalEx_64") #else function hipblasScalEx_64_(handle,n,alpha,alphaType,x,xType,incx,executionType) & bind(c, name="hipblasScalEx_64") #endif use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScalEx_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: alpha integer(kind(HIP_R_32F)),value :: alphaType type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int64_t),value :: incx integer(kind(HIP_R_32F)),value :: executionType end function end interface !> \brief BLAS EX API !> !> \details !> The scalBatchedEx functions scale each element of each vector ``x_i`` with scalar !> ``alpha``: !> !> x_i := alpha * x_i !> !> The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in x. !> @param[in] alpha - device pointer or host pointer for the scalar alpha. !> @param[in] alphaType !> [hipDataType] !> specifies the datatype of alpha. !> @param[inout] x - device array of device pointers storing each vector x_i. !> @param[in] xType !> [hipDataType] !> specifies the datatype of each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] batchCount - [int] !> number of instances in the batch. !> @param[in] executionType !> [hipDataType] !> specifies the datatype of computation. #ifndef USE_CUDA_NAMES interface hipblasScalBatchedEx function hipblasScalBatchedEx_(handle,n,alpha,alphaType,x,xType,incx,batchCount,executionType) & bind(c, name="hipblasScalBatchedEx") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScalBatchedEx_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: alpha integer(kind(HIP_R_32F)),value :: alphaType type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int),value :: incx integer(c_int),value :: batchCount integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasScalBatchedEx_64 function hipblasScalBatchedEx_64_(handle,n,alpha,alphaType,x,xType,incx,batchCount, & executionType) & bind(c, name="hipblasScalBatchedEx_64") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScalBatchedEx_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: alpha integer(kind(HIP_R_32F)),value :: alphaType type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int64_t),value :: incx integer(c_int64_t),value :: batchCount integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif !> \brief BLAS EX API !> !> \details !> The scalStridedBatchedEx functions scale each element of vector ``x`` with scalar alpha !> over a set !> of strided batched vectors. !> !> x := alpha * x !> !> The supported types are determined by the backend. See the rocBLAS or cuBLAS documentation. !> !> @param[in] handle - [hipblasHandle_t] !> handle to the hipBLAS library context queue. !> @param[in] n - [int] !> the number of elements in x. !> @param[in] alpha - device pointer or host pointer for the scalar alpha. !> @param[in] alphaType !> [hipDataType] !> specifies the datatype of alpha. !> @param[inout] x - device pointer to the first vector x_1. !> @param[in] xType !> [hipDataType] !> specifies the datatype of each vector x_i. !> @param[in] incx - [int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [hipblasStride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stridex. However, the user should !> take care to ensure that stridex is of an appropriate size. For a typical !> case, this means stridex >= n * incx. !> @param[in] batchCount - [int] !> number of instances in the batch. !> @param[in] executionType !> [hipDataType] !> specifies the datatype of computation. #ifndef USE_CUDA_NAMES interface hipblasScalStridedBatchedEx function hipblasScalStridedBatchedEx_(handle,n,alpha,alphaType,x,xType,incx,stridex, & batchCount,executionType) & bind(c, name="hipblasScalStridedBatchedEx") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScalStridedBatchedEx_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: alpha integer(kind(HIP_R_32F)),value :: alphaType type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batchCount integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif #ifndef USE_CUDA_NAMES interface hipblasScalStridedBatchedEx_64 function hipblasScalStridedBatchedEx_64_(handle,n,alpha,alphaType,x,xType,incx,stridex, & batchCount,executionType) & bind(c, name="hipblasScalStridedBatchedEx_64") use iso_c_binding use hipfort_hipblas_enums use hipfort_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScalStridedBatchedEx_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: alpha integer(kind(HIP_R_32F)),value :: alphaType type(c_ptr),value :: x integer(kind(HIP_R_32F)),value :: xType integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batchCount integer(kind(HIP_R_32F)),value :: executionType end function end interface #endif !> \brief Auxiliary API !> !> \details !> Returns a string representing the ``hipblasStatus_t`` value. !> !> @param[in] status - [hipblasStatus_t] !> hipBLAS status to convert to string. #ifndef USE_CUDA_NAMES interface hipblasStatusToString function hipblasStatusToString_(status) bind(c, name="hipblasStatusToString") use iso_c_binding use hipfort_hipblas_enums implicit none type(c_ptr) :: hipblasStatusToString_ integer(kind(HIPBLAS_STATUS_SUCCESS)),value :: status end function end interface #endif interface hipblasSetVector #ifdef USE_CUDA_NAMES function hipblasSetVector_(n,elem_size,x,incx,y,incy) bind(c, name="cublasSetVector") result(ret) #else function hipblasSetVector_(n,elem_size,x,incx,y,incy) bind(c, name="hipblasSetVector") result(ret) #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_int),value :: elem_size type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSetVector_l_assumed_rank,hipblasSetVector_i4_assumed_rank,& hipblasSetVector_i8_assumed_rank,hipblasSetVector_r4_assumed_rank,& hipblasSetVector_r8_assumed_rank,hipblasSetVector_c4_assumed_rank,& hipblasSetVector_c8_assumed_rank #else module procedure hipblasSetVector_l_rank_0,hipblasSetVector_l_full_rank,& hipblasSetVector_i4_rank_0,hipblasSetVector_i4_full_rank,& hipblasSetVector_i8_rank_0,hipblasSetVector_i8_full_rank,& hipblasSetVector_r4_rank_0,hipblasSetVector_r4_full_rank,& hipblasSetVector_r8_rank_0,hipblasSetVector_r8_full_rank,& hipblasSetVector_c4_rank_0,hipblasSetVector_c4_full_rank,& hipblasSetVector_c8_rank_0,hipblasSetVector_c8_full_rank #endif #endif end interface interface hipblasGetVector #ifdef USE_CUDA_NAMES function hipblasGetVector_(n,elem_size,x,incx,y,incy) bind(c, name="cublasGetVector") result(ret) #else function hipblasGetVector_(n,elem_size,x,incx,y,incy) bind(c, name="hipblasGetVector") result(ret) #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_int),value :: elem_size type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasGetVector_l_assumed_rank,hipblasGetVector_i4_assumed_rank,& hipblasGetVector_i8_assumed_rank,hipblasGetVector_r4_assumed_rank,& hipblasGetVector_r8_assumed_rank,hipblasGetVector_c4_assumed_rank,& hipblasGetVector_c8_assumed_rank #else module procedure hipblasGetVector_l_rank_0,hipblasGetVector_l_full_rank,& hipblasGetVector_i4_rank_0,hipblasGetVector_i4_full_rank,& hipblasGetVector_i8_rank_0,hipblasGetVector_i8_full_rank,& hipblasGetVector_r4_rank_0,hipblasGetVector_r4_full_rank,& hipblasGetVector_r8_rank_0,hipblasGetVector_r8_full_rank,& hipblasGetVector_c4_rank_0,hipblasGetVector_c4_full_rank,& hipblasGetVector_c8_rank_0,hipblasGetVector_c8_full_rank #endif #endif end interface interface hipblasSetMatrix #ifdef USE_CUDA_NAMES function hipblasSetMatrix_(rows,cols,elem_size,A,lda,B,ldb) bind(c, name="cublasSetMatrix") result(ret) #else function hipblasSetMatrix_(rows,cols,elem_size,A,lda,B,ldb) bind(c, name="hipblasSetMatrix") result(ret) #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),value :: elem_size type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSetMatrix_l_assumed_rank,hipblasSetMatrix_i4_assumed_rank,& hipblasSetMatrix_i8_assumed_rank,hipblasSetMatrix_r4_assumed_rank,& hipblasSetMatrix_r8_assumed_rank,hipblasSetMatrix_c4_assumed_rank,& hipblasSetMatrix_c8_assumed_rank #else module procedure hipblasSetMatrix_l_full_rank,hipblasSetMatrix_l_rank_0,hipblasSetMatrix_l_rank_1,& hipblasSetMatrix_i4_full_rank,hipblasSetMatrix_i4_rank_0,hipblasSetMatrix_i4_rank_1,& hipblasSetMatrix_i8_full_rank,hipblasSetMatrix_i8_rank_0,hipblasSetMatrix_i8_rank_1,& hipblasSetMatrix_r4_full_rank,hipblasSetMatrix_r4_rank_0,hipblasSetMatrix_r4_rank_1,& hipblasSetMatrix_r8_full_rank,hipblasSetMatrix_r8_rank_0,hipblasSetMatrix_r8_rank_1,& hipblasSetMatrix_c4_full_rank,hipblasSetMatrix_c4_rank_0,hipblasSetMatrix_c4_rank_1,& hipblasSetMatrix_c8_full_rank,hipblasSetMatrix_c8_rank_0,hipblasSetMatrix_c8_rank_1 #endif #endif end interface interface hipblasGetMatrix #ifdef USE_CUDA_NAMES function hipblasGetMatrix_(rows,cols,elem_size,A,lda,B,ldb) bind(c, name="cublasGetMatrix") result(ret) #else function hipblasGetMatrix_(rows,cols,elem_size,A,lda,B,ldb) bind(c, name="hipblasGetMatrix") result(ret) #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),value :: elem_size type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasGetMatrix_l_assumed_rank,hipblasGetMatrix_i4_assumed_rank,& hipblasGetMatrix_i8_assumed_rank,hipblasGetMatrix_r4_assumed_rank,& hipblasGetMatrix_r8_assumed_rank,hipblasGetMatrix_c4_assumed_rank,& hipblasGetMatrix_c8_assumed_rank #else module procedure hipblasGetMatrix_l_full_rank,hipblasGetMatrix_l_rank_0,hipblasGetMatrix_l_rank_1,& hipblasGetMatrix_i4_full_rank,hipblasGetMatrix_i4_rank_0,hipblasGetMatrix_i4_rank_1,& hipblasGetMatrix_i8_full_rank,hipblasGetMatrix_i8_rank_0,hipblasGetMatrix_i8_rank_1,& hipblasGetMatrix_r4_full_rank,hipblasGetMatrix_r4_rank_0,hipblasGetMatrix_r4_rank_1,& hipblasGetMatrix_r8_full_rank,hipblasGetMatrix_r8_rank_0,hipblasGetMatrix_r8_rank_1,& hipblasGetMatrix_c4_full_rank,hipblasGetMatrix_c4_rank_0,hipblasGetMatrix_c4_rank_1,& hipblasGetMatrix_c8_full_rank,hipblasGetMatrix_c8_rank_0,hipblasGetMatrix_c8_rank_1 #endif #endif end interface interface hipblasSetVectorAsync #ifdef USE_CUDA_NAMES function hipblasSetVectorAsync_(n,elem_size,x,incx,y,incy,stream) bind(c, name="cublasSetVectorAsync") result(ret) #else function hipblasSetVectorAsync_(n,elem_size,x,incx,y,incy,stream) bind(c, name="hipblasSetVectorAsync") result(ret) #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_int),value :: elem_size type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: stream end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSetVectorAsync_l_assumed_rank,hipblasSetVectorAsync_i4_assumed_rank,& hipblasSetVectorAsync_i8_assumed_rank,hipblasSetVectorAsync_r4_assumed_rank,& hipblasSetVectorAsync_r8_assumed_rank,hipblasSetVectorAsync_c4_assumed_rank,& hipblasSetVectorAsync_c8_assumed_rank #else module procedure hipblasSetVectorAsync_l_rank_0,hipblasSetVectorAsync_l_full_rank,& hipblasSetVectorAsync_i4_rank_0,hipblasSetVectorAsync_i4_full_rank,& hipblasSetVectorAsync_i8_rank_0,hipblasSetVectorAsync_i8_full_rank,& hipblasSetVectorAsync_r4_rank_0,hipblasSetVectorAsync_r4_full_rank,& hipblasSetVectorAsync_r8_rank_0,hipblasSetVectorAsync_r8_full_rank,& hipblasSetVectorAsync_c4_rank_0,hipblasSetVectorAsync_c4_full_rank,& hipblasSetVectorAsync_c8_rank_0,hipblasSetVectorAsync_c8_full_rank #endif #endif end interface interface hipblasGetVectorAsync #ifdef USE_CUDA_NAMES function hipblasGetVectorAsync_(n,elem_size,x,incx,y,incy,stream) bind(c, name="cublasGetVectorAsync") result(ret) #else function hipblasGetVectorAsync_(n,elem_size,x,incx,y,incy,stream) bind(c, name="hipblasGetVectorAsync") result(ret) #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_int),value :: elem_size type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: stream end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasGetVectorAsync_l_assumed_rank,hipblasGetVectorAsync_i4_assumed_rank,& hipblasGetVectorAsync_i8_assumed_rank,hipblasGetVectorAsync_r4_assumed_rank,& hipblasGetVectorAsync_r8_assumed_rank,hipblasGetVectorAsync_c4_assumed_rank,& hipblasGetVectorAsync_c8_assumed_rank #else module procedure hipblasGetVectorAsync_l_rank_0,hipblasGetVectorAsync_l_full_rank,& hipblasGetVectorAsync_i4_rank_0,hipblasGetVectorAsync_i4_full_rank,& hipblasGetVectorAsync_i8_rank_0,hipblasGetVectorAsync_i8_full_rank,& hipblasGetVectorAsync_r4_rank_0,hipblasGetVectorAsync_r4_full_rank,& hipblasGetVectorAsync_r8_rank_0,hipblasGetVectorAsync_r8_full_rank,& hipblasGetVectorAsync_c4_rank_0,hipblasGetVectorAsync_c4_full_rank,& hipblasGetVectorAsync_c8_rank_0,hipblasGetVectorAsync_c8_full_rank #endif #endif end interface interface hipblasSetMatrixAsync #ifdef USE_CUDA_NAMES function hipblasSetMatrixAsync_(rows,cols,elem_size,A,lda,B,ldb,stream) bind(c, name="cublasSetMatrixAsync") result(ret) #else function hipblasSetMatrixAsync_(rows,cols,elem_size,A,lda,B,ldb,stream) bind(c, name="hipblasSetMatrixAsync") result(ret) #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),value :: elem_size type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: stream end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasSetMatrixAsync_l_assumed_rank,hipblasSetMatrixAsync_i4_assumed_rank,& hipblasSetMatrixAsync_i8_assumed_rank,hipblasSetMatrixAsync_r4_assumed_rank,& hipblasSetMatrixAsync_r8_assumed_rank,hipblasSetMatrixAsync_c4_assumed_rank,& hipblasSetMatrixAsync_c8_assumed_rank #else module procedure hipblasSetMatrixAsync_l_full_rank,hipblasSetMatrixAsync_l_rank_0,hipblasSetMatrixAsync_l_rank_1,& hipblasSetMatrixAsync_i4_full_rank,hipblasSetMatrixAsync_i4_rank_0,hipblasSetMatrixAsync_i4_rank_1,& hipblasSetMatrixAsync_i8_full_rank,hipblasSetMatrixAsync_i8_rank_0,hipblasSetMatrixAsync_i8_rank_1,& hipblasSetMatrixAsync_r4_full_rank,hipblasSetMatrixAsync_r4_rank_0,hipblasSetMatrixAsync_r4_rank_1,& hipblasSetMatrixAsync_r8_full_rank,hipblasSetMatrixAsync_r8_rank_0,hipblasSetMatrixAsync_r8_rank_1,& hipblasSetMatrixAsync_c4_full_rank,hipblasSetMatrixAsync_c4_rank_0,hipblasSetMatrixAsync_c4_rank_1,& hipblasSetMatrixAsync_c8_full_rank,hipblasSetMatrixAsync_c8_rank_0,hipblasSetMatrixAsync_c8_rank_1 #endif #endif end interface interface hipblasGetMatrixAsync #ifdef USE_CUDA_NAMES function hipblasGetMatrixAsync_(rows,cols,elem_size,A,lda,B,ldb,stream) bind(c, name="cublasGetMatrixAsync") result(ret) #else function hipblasGetMatrixAsync_(rows,cols,elem_size,A,lda,B,ldb,stream) bind(c, name="hipblasGetMatrixAsync") result(ret) #endif use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),value :: elem_size type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: stream end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipblasGetMatrixAsync_l_assumed_rank,hipblasGetMatrixAsync_i4_assumed_rank,& hipblasGetMatrixAsync_i8_assumed_rank,hipblasGetMatrixAsync_r4_assumed_rank,& hipblasGetMatrixAsync_r8_assumed_rank,hipblasGetMatrixAsync_c4_assumed_rank,& hipblasGetMatrixAsync_c8_assumed_rank #else module procedure hipblasGetMatrixAsync_l_full_rank,hipblasGetMatrixAsync_l_rank_0,hipblasGetMatrixAsync_l_rank_1,& hipblasGetMatrixAsync_i4_full_rank,hipblasGetMatrixAsync_i4_rank_0,hipblasGetMatrixAsync_i4_rank_1,& hipblasGetMatrixAsync_i8_full_rank,hipblasGetMatrixAsync_i8_rank_0,hipblasGetMatrixAsync_i8_rank_1,& hipblasGetMatrixAsync_r4_full_rank,hipblasGetMatrixAsync_r4_rank_0,hipblasGetMatrixAsync_r4_rank_1,& hipblasGetMatrixAsync_r8_full_rank,hipblasGetMatrixAsync_r8_rank_0,hipblasGetMatrixAsync_r8_rank_1,& hipblasGetMatrixAsync_c4_full_rank,hipblasGetMatrixAsync_c4_rank_0,hipblasGetMatrixAsync_c4_rank_1,& hipblasGetMatrixAsync_c8_full_rank,hipblasGetMatrixAsync_c8_rank_0,hipblasGetMatrixAsync_c8_rank_1 #endif #endif end interface #ifdef USE_FPOINTER_INTERFACES contains #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasIsamax_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamax_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIsamax_assumed_rank = hipblasIsamax_(handle,n,c_loc(x),incx,myResult) end function #else function hipblasIsamax_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamax_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIsamax_rank_0 = hipblasIsamax_(handle,n,c_loc(x),incx,myResult) end function function hipblasIsamax_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamax_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIsamax_rank_1 = hipblasIsamax_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasIdamax_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamax_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIdamax_assumed_rank = hipblasIdamax_(handle,n,c_loc(x),incx,myResult) end function #else function hipblasIdamax_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamax_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIdamax_rank_0 = hipblasIdamax_(handle,n,c_loc(x),incx,myResult) end function function hipblasIdamax_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamax_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIdamax_rank_1 = hipblasIdamax_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasIcamax_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamax_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIcamax_assumed_rank = hipblasIcamax_(handle,n,c_loc(x),incx,myResult) end function #else function hipblasIcamax_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamax_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIcamax_rank_0 = hipblasIcamax_(handle,n,c_loc(x),incx,myResult) end function function hipblasIcamax_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamax_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIcamax_rank_1 = hipblasIcamax_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasIzamax_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamax_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIzamax_assumed_rank = hipblasIzamax_(handle,n,c_loc(x),incx,myResult) end function #else function hipblasIzamax_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamax_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIzamax_rank_0 = hipblasIzamax_(handle,n,c_loc(x),incx,myResult) end function function hipblasIzamax_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamax_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIzamax_rank_1 = hipblasIzamax_(handle,n,c_loc(x),incx,myResult) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasIsamaxStridedBatched_assumed_rank(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamaxStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIsamaxStridedBatched_assumed_rank = hipblasIsamaxStridedBatched_(handle,n,c_loc(x), & incx,stridex,batchCount,myResult) end function #else function hipblasIsamaxStridedBatched_rank_0(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamaxStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIsamaxStridedBatched_rank_0 = hipblasIsamaxStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function function hipblasIsamaxStridedBatched_rank_1(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamaxStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIsamaxStridedBatched_rank_1 = hipblasIsamaxStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasIdamaxStridedBatched_assumed_rank(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamaxStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIdamaxStridedBatched_assumed_rank = hipblasIdamaxStridedBatched_(handle,n,c_loc(x), & incx,stridex,batchCount,myResult) end function #else function hipblasIdamaxStridedBatched_rank_0(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamaxStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIdamaxStridedBatched_rank_0 = hipblasIdamaxStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function function hipblasIdamaxStridedBatched_rank_1(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamaxStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIdamaxStridedBatched_rank_1 = hipblasIdamaxStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasIcamaxStridedBatched_assumed_rank(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamaxStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIcamaxStridedBatched_assumed_rank = hipblasIcamaxStridedBatched_(handle,n,c_loc(x), & incx,stridex,batchCount,myResult) end function #else function hipblasIcamaxStridedBatched_rank_0(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamaxStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIcamaxStridedBatched_rank_0 = hipblasIcamaxStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function function hipblasIcamaxStridedBatched_rank_1(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamaxStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIcamaxStridedBatched_rank_1 = hipblasIcamaxStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasIzamaxStridedBatched_assumed_rank(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamaxStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIzamaxStridedBatched_assumed_rank = hipblasIzamaxStridedBatched_(handle,n,c_loc(x), & incx,stridex,batchCount,myResult) end function #else function hipblasIzamaxStridedBatched_rank_0(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamaxStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIzamaxStridedBatched_rank_0 = hipblasIzamaxStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function function hipblasIzamaxStridedBatched_rank_1(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamaxStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIzamaxStridedBatched_rank_1 = hipblasIzamaxStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasIsamin_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamin_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIsamin_assumed_rank = hipblasIsamin_(handle,n,c_loc(x),incx,myResult) end function #else function hipblasIsamin_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamin_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIsamin_rank_0 = hipblasIsamin_(handle,n,c_loc(x),incx,myResult) end function function hipblasIsamin_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsamin_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIsamin_rank_1 = hipblasIsamin_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasIdamin_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamin_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIdamin_assumed_rank = hipblasIdamin_(handle,n,c_loc(x),incx,myResult) end function #else function hipblasIdamin_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamin_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIdamin_rank_0 = hipblasIdamin_(handle,n,c_loc(x),incx,myResult) end function function hipblasIdamin_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdamin_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIdamin_rank_1 = hipblasIdamin_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasIcamin_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamin_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIcamin_assumed_rank = hipblasIcamin_(handle,n,c_loc(x),incx,myResult) end function #else function hipblasIcamin_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamin_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIcamin_rank_0 = hipblasIcamin_(handle,n,c_loc(x),incx,myResult) end function function hipblasIcamin_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcamin_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIcamin_rank_1 = hipblasIcamin_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasIzamin_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamin_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIzamin_assumed_rank = hipblasIzamin_(handle,n,c_loc(x),incx,myResult) end function #else function hipblasIzamin_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamin_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIzamin_rank_0 = hipblasIzamin_(handle,n,c_loc(x),incx,myResult) end function function hipblasIzamin_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzamin_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasIzamin_rank_1 = hipblasIzamin_(handle,n,c_loc(x),incx,myResult) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasIsaminStridedBatched_assumed_rank(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsaminStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIsaminStridedBatched_assumed_rank = hipblasIsaminStridedBatched_(handle,n,c_loc(x), & incx,stridex,batchCount,myResult) end function #else function hipblasIsaminStridedBatched_rank_0(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsaminStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIsaminStridedBatched_rank_0 = hipblasIsaminStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function function hipblasIsaminStridedBatched_rank_1(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIsaminStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIsaminStridedBatched_rank_1 = hipblasIsaminStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasIdaminStridedBatched_assumed_rank(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdaminStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIdaminStridedBatched_assumed_rank = hipblasIdaminStridedBatched_(handle,n,c_loc(x), & incx,stridex,batchCount,myResult) end function #else function hipblasIdaminStridedBatched_rank_0(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdaminStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIdaminStridedBatched_rank_0 = hipblasIdaminStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function function hipblasIdaminStridedBatched_rank_1(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIdaminStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIdaminStridedBatched_rank_1 = hipblasIdaminStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasIcaminStridedBatched_assumed_rank(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcaminStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIcaminStridedBatched_assumed_rank = hipblasIcaminStridedBatched_(handle,n,c_loc(x), & incx,stridex,batchCount,myResult) end function #else function hipblasIcaminStridedBatched_rank_0(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcaminStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIcaminStridedBatched_rank_0 = hipblasIcaminStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function function hipblasIcaminStridedBatched_rank_1(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIcaminStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIcaminStridedBatched_rank_1 = hipblasIcaminStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasIzaminStridedBatched_assumed_rank(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzaminStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIzaminStridedBatched_assumed_rank = hipblasIzaminStridedBatched_(handle,n,c_loc(x), & incx,stridex,batchCount,myResult) end function #else function hipblasIzaminStridedBatched_rank_0(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzaminStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIzaminStridedBatched_rank_0 = hipblasIzaminStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function function hipblasIzaminStridedBatched_rank_1(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasIzaminStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasIzaminStridedBatched_rank_1 = hipblasIzaminStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSasum_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSasum_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasSasum_assumed_rank = hipblasSasum_(handle,n,c_loc(x),incx,myResult) end function #else function hipblasSasum_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSasum_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasSasum_rank_0 = hipblasSasum_(handle,n,c_loc(x),incx,myResult) end function function hipblasSasum_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSasum_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasSasum_rank_1 = hipblasSasum_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDasum_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDasum_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasDasum_assumed_rank = hipblasDasum_(handle,n,c_loc(x),incx,myResult) end function #else function hipblasDasum_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDasum_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasDasum_rank_0 = hipblasDasum_(handle,n,c_loc(x),incx,myResult) end function function hipblasDasum_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDasum_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasDasum_rank_1 = hipblasDasum_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasScasum_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScasum_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasScasum_assumed_rank = hipblasScasum_(handle,n,c_loc(x),incx,myResult) end function #else function hipblasScasum_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScasum_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasScasum_rank_0 = hipblasScasum_(handle,n,c_loc(x),incx,myResult) end function function hipblasScasum_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScasum_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasScasum_rank_1 = hipblasScasum_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDzasum_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDzasum_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasDzasum_assumed_rank = hipblasDzasum_(handle,n,c_loc(x),incx,myResult) end function #else function hipblasDzasum_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDzasum_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasDzasum_rank_0 = hipblasDzasum_(handle,n,c_loc(x),incx,myResult) end function function hipblasDzasum_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDzasum_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasDzasum_rank_1 = hipblasDzasum_(handle,n,c_loc(x),incx,myResult) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSasumStridedBatched_assumed_rank(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSasumStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasSasumStridedBatched_assumed_rank = hipblasSasumStridedBatched_(handle,n,c_loc(x), & incx,stridex,batchCount,myResult) end function #else function hipblasSasumStridedBatched_rank_0(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSasumStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasSasumStridedBatched_rank_0 = hipblasSasumStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function function hipblasSasumStridedBatched_rank_1(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSasumStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasSasumStridedBatched_rank_1 = hipblasSasumStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDasumStridedBatched_assumed_rank(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDasumStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasDasumStridedBatched_assumed_rank = hipblasDasumStridedBatched_(handle,n,c_loc(x), & incx,stridex,batchCount,myResult) end function #else function hipblasDasumStridedBatched_rank_0(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDasumStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasDasumStridedBatched_rank_0 = hipblasDasumStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function function hipblasDasumStridedBatched_rank_1(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDasumStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasDasumStridedBatched_rank_1 = hipblasDasumStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasScasumStridedBatched_assumed_rank(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScasumStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasScasumStridedBatched_assumed_rank = hipblasScasumStridedBatched_(handle,n,c_loc(x), & incx,stridex,batchCount,myResult) end function #else function hipblasScasumStridedBatched_rank_0(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScasumStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasScasumStridedBatched_rank_0 = hipblasScasumStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function function hipblasScasumStridedBatched_rank_1(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScasumStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasScasumStridedBatched_rank_1 = hipblasScasumStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDzasumStridedBatched_assumed_rank(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDzasumStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasDzasumStridedBatched_assumed_rank = hipblasDzasumStridedBatched_(handle,n,c_loc(x), & incx,stridex,batchCount,myResult) end function #else function hipblasDzasumStridedBatched_rank_0(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDzasumStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasDzasumStridedBatched_rank_0 = hipblasDzasumStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function function hipblasDzasumStridedBatched_rank_1(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDzasumStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasDzasumStridedBatched_rank_1 = hipblasDzasumStridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSaxpy_assumed_rank(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSaxpy_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasSaxpy_assumed_rank = hipblasSaxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function #else function hipblasSaxpy_rank_0(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSaxpy_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: y integer(c_int) :: incy ! hipblasSaxpy_rank_0 = hipblasSaxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function function hipblasSaxpy_rank_1(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSaxpy_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! hipblasSaxpy_rank_1 = hipblasSaxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDaxpy_assumed_rank(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDaxpy_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasDaxpy_assumed_rank = hipblasDaxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function #else function hipblasDaxpy_rank_0(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDaxpy_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: y integer(c_int) :: incy ! hipblasDaxpy_rank_0 = hipblasDaxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function function hipblasDaxpy_rank_1(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDaxpy_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! hipblasDaxpy_rank_1 = hipblasDaxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCaxpy_assumed_rank(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCaxpy_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasCaxpy_assumed_rank = hipblasCaxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function #else function hipblasCaxpy_rank_0(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCaxpy_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy ! hipblasCaxpy_rank_0 = hipblasCaxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function function hipblasCaxpy_rank_1(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCaxpy_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasCaxpy_rank_1 = hipblasCaxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZaxpy_assumed_rank(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZaxpy_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasZaxpy_assumed_rank = hipblasZaxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function #else function hipblasZaxpy_rank_0(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZaxpy_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy ! hipblasZaxpy_rank_0 = hipblasZaxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function function hipblasZaxpy_rank_1(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZaxpy_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasZaxpy_rank_1 = hipblasZaxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSaxpyStridedBatched_assumed_rank(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSaxpyStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSaxpyStridedBatched_assumed_rank = hipblasSaxpyStridedBatched_(handle,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batchCount) end function #else function hipblasSaxpyStridedBatched_rank_0(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSaxpyStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSaxpyStridedBatched_rank_0 = hipblasSaxpyStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount) end function function hipblasSaxpyStridedBatched_rank_1(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSaxpyStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSaxpyStridedBatched_rank_1 = hipblasSaxpyStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDaxpyStridedBatched_assumed_rank(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDaxpyStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDaxpyStridedBatched_assumed_rank = hipblasDaxpyStridedBatched_(handle,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batchCount) end function #else function hipblasDaxpyStridedBatched_rank_0(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDaxpyStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDaxpyStridedBatched_rank_0 = hipblasDaxpyStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount) end function function hipblasDaxpyStridedBatched_rank_1(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDaxpyStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDaxpyStridedBatched_rank_1 = hipblasDaxpyStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCaxpyStridedBatched_assumed_rank(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCaxpyStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCaxpyStridedBatched_assumed_rank = hipblasCaxpyStridedBatched_(handle,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batchCount) end function #else function hipblasCaxpyStridedBatched_rank_0(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCaxpyStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCaxpyStridedBatched_rank_0 = hipblasCaxpyStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount) end function function hipblasCaxpyStridedBatched_rank_1(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCaxpyStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCaxpyStridedBatched_rank_1 = hipblasCaxpyStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZaxpyStridedBatched_assumed_rank(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZaxpyStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZaxpyStridedBatched_assumed_rank = hipblasZaxpyStridedBatched_(handle,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batchCount) end function #else function hipblasZaxpyStridedBatched_rank_0(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZaxpyStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZaxpyStridedBatched_rank_0 = hipblasZaxpyStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount) end function function hipblasZaxpyStridedBatched_rank_1(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZaxpyStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZaxpyStridedBatched_rank_1 = hipblasZaxpyStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasScopy_assumed_rank(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScopy_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasScopy_assumed_rank = hipblasScopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #else function hipblasScopy_rank_0(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScopy_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: y integer(c_int) :: incy ! hipblasScopy_rank_0 = hipblasScopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function function hipblasScopy_rank_1(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScopy_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! hipblasScopy_rank_1 = hipblasScopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDcopy_assumed_rank(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDcopy_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasDcopy_assumed_rank = hipblasDcopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #else function hipblasDcopy_rank_0(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDcopy_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: y integer(c_int) :: incy ! hipblasDcopy_rank_0 = hipblasDcopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function function hipblasDcopy_rank_1(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDcopy_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! hipblasDcopy_rank_1 = hipblasDcopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCcopy_assumed_rank(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCcopy_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasCcopy_assumed_rank = hipblasCcopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #else function hipblasCcopy_rank_0(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCcopy_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy ! hipblasCcopy_rank_0 = hipblasCcopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function function hipblasCcopy_rank_1(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCcopy_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasCcopy_rank_1 = hipblasCcopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZcopy_assumed_rank(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZcopy_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasZcopy_assumed_rank = hipblasZcopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #else function hipblasZcopy_rank_0(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZcopy_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy ! hipblasZcopy_rank_0 = hipblasZcopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function function hipblasZcopy_rank_1(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZcopy_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasZcopy_rank_1 = hipblasZcopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasScopyStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScopyStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasScopyStridedBatched_assumed_rank = hipblasScopyStridedBatched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount) end function #else function hipblasScopyStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScopyStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasScopyStridedBatched_rank_0 = hipblasScopyStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount) end function function hipblasScopyStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScopyStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasScopyStridedBatched_rank_1 = hipblasScopyStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDcopyStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDcopyStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDcopyStridedBatched_assumed_rank = hipblasDcopyStridedBatched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount) end function #else function hipblasDcopyStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDcopyStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDcopyStridedBatched_rank_0 = hipblasDcopyStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount) end function function hipblasDcopyStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDcopyStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDcopyStridedBatched_rank_1 = hipblasDcopyStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCcopyStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCcopyStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCcopyStridedBatched_assumed_rank = hipblasCcopyStridedBatched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount) end function #else function hipblasCcopyStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCcopyStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCcopyStridedBatched_rank_0 = hipblasCcopyStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount) end function function hipblasCcopyStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCcopyStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCcopyStridedBatched_rank_1 = hipblasCcopyStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZcopyStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZcopyStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZcopyStridedBatched_assumed_rank = hipblasZcopyStridedBatched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount) end function #else function hipblasZcopyStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZcopyStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZcopyStridedBatched_rank_0 = hipblasZcopyStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount) end function function hipblasZcopyStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZcopyStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZcopyStridedBatched_rank_1 = hipblasZcopyStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSdot_assumed_rank(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdot_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! hipblasSdot_assumed_rank = hipblasSdot_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #else function hipblasSdot_rank_0(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdot_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: y integer(c_int) :: incy type(c_ptr) :: myResult ! hipblasSdot_rank_0 = hipblasSdot_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function function hipblasSdot_rank_1(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdot_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! hipblasSdot_rank_1 = hipblasSdot_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDdot_assumed_rank(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdot_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! hipblasDdot_assumed_rank = hipblasDdot_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #else function hipblasDdot_rank_0(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdot_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: y integer(c_int) :: incy type(c_ptr) :: myResult ! hipblasDdot_rank_0 = hipblasDdot_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function function hipblasDdot_rank_1(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdot_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! hipblasDdot_rank_1 = hipblasDdot_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCdotc_assumed_rank(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotc_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! hipblasCdotc_assumed_rank = hipblasCdotc_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #else function hipblasCdotc_rank_0(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotc_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy type(c_ptr) :: myResult ! hipblasCdotc_rank_0 = hipblasCdotc_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function function hipblasCdotc_rank_1(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotc_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! hipblasCdotc_rank_1 = hipblasCdotc_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCdotu_assumed_rank(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotu_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! hipblasCdotu_assumed_rank = hipblasCdotu_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #else function hipblasCdotu_rank_0(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotu_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy type(c_ptr) :: myResult ! hipblasCdotu_rank_0 = hipblasCdotu_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function function hipblasCdotu_rank_1(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotu_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! hipblasCdotu_rank_1 = hipblasCdotu_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZdotc_assumed_rank(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotc_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! hipblasZdotc_assumed_rank = hipblasZdotc_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #else function hipblasZdotc_rank_0(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotc_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy type(c_ptr) :: myResult ! hipblasZdotc_rank_0 = hipblasZdotc_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function function hipblasZdotc_rank_1(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotc_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! hipblasZdotc_rank_1 = hipblasZdotc_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZdotu_assumed_rank(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotu_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! hipblasZdotu_assumed_rank = hipblasZdotu_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #else function hipblasZdotu_rank_0(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotu_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy type(c_ptr) :: myResult ! hipblasZdotu_rank_0 = hipblasZdotu_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function function hipblasZdotu_rank_1(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotu_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! hipblasZdotu_rank_1 = hipblasZdotu_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSdotStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdotStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasSdotStridedBatched_assumed_rank = hipblasSdotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount,myResult) end function #else function hipblasSdotStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdotStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasSdotStridedBatched_rank_0 = hipblasSdotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount,myResult) end function function hipblasSdotStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdotStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasSdotStridedBatched_rank_1 = hipblasSdotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount,myResult) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDdotStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdotStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasDdotStridedBatched_assumed_rank = hipblasDdotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount,myResult) end function #else function hipblasDdotStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdotStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasDdotStridedBatched_rank_0 = hipblasDdotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount,myResult) end function function hipblasDdotStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdotStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasDdotStridedBatched_rank_1 = hipblasDdotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount,myResult) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCdotcStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotcStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasCdotcStridedBatched_assumed_rank = hipblasCdotcStridedBatched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount,myResult) end function #else function hipblasCdotcStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotcStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasCdotcStridedBatched_rank_0 = hipblasCdotcStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount,myResult) end function function hipblasCdotcStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotcStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasCdotcStridedBatched_rank_1 = hipblasCdotcStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount,myResult) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCdotuStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotuStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasCdotuStridedBatched_assumed_rank = hipblasCdotuStridedBatched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount,myResult) end function #else function hipblasCdotuStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotuStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasCdotuStridedBatched_rank_0 = hipblasCdotuStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount,myResult) end function function hipblasCdotuStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdotuStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasCdotuStridedBatched_rank_1 = hipblasCdotuStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount,myResult) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZdotcStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotcStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasZdotcStridedBatched_assumed_rank = hipblasZdotcStridedBatched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount,myResult) end function #else function hipblasZdotcStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotcStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasZdotcStridedBatched_rank_0 = hipblasZdotcStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount,myResult) end function function hipblasZdotcStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotcStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasZdotcStridedBatched_rank_1 = hipblasZdotcStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount,myResult) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZdotuStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotuStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasZdotuStridedBatched_assumed_rank = hipblasZdotuStridedBatched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount,myResult) end function #else function hipblasZdotuStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotuStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasZdotuStridedBatched_rank_0 = hipblasZdotuStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount,myResult) end function function hipblasZdotuStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,batchCount, & myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdotuStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasZdotuStridedBatched_rank_1 = hipblasZdotuStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount,myResult) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSnrm2_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSnrm2_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasSnrm2_assumed_rank = hipblasSnrm2_(handle,n,c_loc(x),incx,myResult) end function #else function hipblasSnrm2_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSnrm2_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasSnrm2_rank_0 = hipblasSnrm2_(handle,n,c_loc(x),incx,myResult) end function function hipblasSnrm2_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSnrm2_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasSnrm2_rank_1 = hipblasSnrm2_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDnrm2_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDnrm2_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasDnrm2_assumed_rank = hipblasDnrm2_(handle,n,c_loc(x),incx,myResult) end function #else function hipblasDnrm2_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDnrm2_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasDnrm2_rank_0 = hipblasDnrm2_(handle,n,c_loc(x),incx,myResult) end function function hipblasDnrm2_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDnrm2_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasDnrm2_rank_1 = hipblasDnrm2_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasScnrm2_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScnrm2_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasScnrm2_assumed_rank = hipblasScnrm2_(handle,n,c_loc(x),incx,myResult) end function #else function hipblasScnrm2_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScnrm2_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasScnrm2_rank_0 = hipblasScnrm2_(handle,n,c_loc(x),incx,myResult) end function function hipblasScnrm2_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScnrm2_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasScnrm2_rank_1 = hipblasScnrm2_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDznrm2_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDznrm2_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasDznrm2_assumed_rank = hipblasDznrm2_(handle,n,c_loc(x),incx,myResult) end function #else function hipblasDznrm2_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDznrm2_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasDznrm2_rank_0 = hipblasDznrm2_(handle,n,c_loc(x),incx,myResult) end function function hipblasDznrm2_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDznrm2_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! hipblasDznrm2_rank_1 = hipblasDznrm2_(handle,n,c_loc(x),incx,myResult) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSnrm2StridedBatched_assumed_rank(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSnrm2StridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasSnrm2StridedBatched_assumed_rank = hipblasSnrm2StridedBatched_(handle,n,c_loc(x), & incx,stridex,batchCount,myResult) end function #else function hipblasSnrm2StridedBatched_rank_0(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSnrm2StridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasSnrm2StridedBatched_rank_0 = hipblasSnrm2StridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function function hipblasSnrm2StridedBatched_rank_1(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSnrm2StridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasSnrm2StridedBatched_rank_1 = hipblasSnrm2StridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDnrm2StridedBatched_assumed_rank(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDnrm2StridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasDnrm2StridedBatched_assumed_rank = hipblasDnrm2StridedBatched_(handle,n,c_loc(x), & incx,stridex,batchCount,myResult) end function #else function hipblasDnrm2StridedBatched_rank_0(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDnrm2StridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasDnrm2StridedBatched_rank_0 = hipblasDnrm2StridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function function hipblasDnrm2StridedBatched_rank_1(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDnrm2StridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasDnrm2StridedBatched_rank_1 = hipblasDnrm2StridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasScnrm2StridedBatched_assumed_rank(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScnrm2StridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasScnrm2StridedBatched_assumed_rank = hipblasScnrm2StridedBatched_(handle,n,c_loc(x), & incx,stridex,batchCount,myResult) end function #else function hipblasScnrm2StridedBatched_rank_0(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScnrm2StridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasScnrm2StridedBatched_rank_0 = hipblasScnrm2StridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function function hipblasScnrm2StridedBatched_rank_1(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasScnrm2StridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasScnrm2StridedBatched_rank_1 = hipblasScnrm2StridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDznrm2StridedBatched_assumed_rank(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDznrm2StridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasDznrm2StridedBatched_assumed_rank = hipblasDznrm2StridedBatched_(handle,n,c_loc(x), & incx,stridex,batchCount,myResult) end function #else function hipblasDznrm2StridedBatched_rank_0(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDznrm2StridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasDznrm2StridedBatched_rank_0 = hipblasDznrm2StridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function function hipblasDznrm2StridedBatched_rank_1(handle,n,x,incx,stridex,batchCount,myResult) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDznrm2StridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount type(c_ptr) :: myResult ! hipblasDznrm2StridedBatched_rank_1 = hipblasDznrm2StridedBatched_(handle,n,c_loc(x),incx, & stridex,batchCount,myResult) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSrot_assumed_rank(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrot_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: c type(c_ptr) :: s ! hipblasSrot_assumed_rank = hipblasSrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #else function hipblasSrot_rank_0(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrot_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: y integer(c_int) :: incy type(c_ptr) :: c type(c_ptr) :: s ! hipblasSrot_rank_0 = hipblasSrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function function hipblasSrot_rank_1(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrot_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: c type(c_ptr) :: s ! hipblasSrot_rank_1 = hipblasSrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDrot_assumed_rank(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrot_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: c type(c_ptr) :: s ! hipblasDrot_assumed_rank = hipblasDrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #else function hipblasDrot_rank_0(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrot_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: y integer(c_int) :: incy type(c_ptr) :: c type(c_ptr) :: s ! hipblasDrot_rank_0 = hipblasDrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function function hipblasDrot_rank_1(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrot_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: c type(c_ptr) :: s ! hipblasDrot_rank_1 = hipblasDrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCrot_assumed_rank(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrot_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: c type(c_ptr) :: s ! hipblasCrot_assumed_rank = hipblasCrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #else function hipblasCrot_rank_0(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrot_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy type(c_ptr) :: c type(c_ptr) :: s ! hipblasCrot_rank_0 = hipblasCrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function function hipblasCrot_rank_1(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrot_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: c type(c_ptr) :: s ! hipblasCrot_rank_1 = hipblasCrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCsrot_assumed_rank(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsrot_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: c type(c_ptr) :: s ! hipblasCsrot_assumed_rank = hipblasCsrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #else function hipblasCsrot_rank_0(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsrot_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy type(c_ptr) :: c type(c_ptr) :: s ! hipblasCsrot_rank_0 = hipblasCsrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function function hipblasCsrot_rank_1(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsrot_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: c type(c_ptr) :: s ! hipblasCsrot_rank_1 = hipblasCsrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZrot_assumed_rank(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrot_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: c type(c_ptr) :: s ! hipblasZrot_assumed_rank = hipblasZrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #else function hipblasZrot_rank_0(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrot_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy type(c_ptr) :: c type(c_ptr) :: s ! hipblasZrot_rank_0 = hipblasZrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function function hipblasZrot_rank_1(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrot_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: c type(c_ptr) :: s ! hipblasZrot_rank_1 = hipblasZrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZdrot_assumed_rank(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdrot_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: c type(c_ptr) :: s ! hipblasZdrot_assumed_rank = hipblasZdrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #else function hipblasZdrot_rank_0(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdrot_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy type(c_ptr) :: c type(c_ptr) :: s ! hipblasZdrot_rank_0 = hipblasZdrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function function hipblasZdrot_rank_1(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdrot_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: c type(c_ptr) :: s ! hipblasZdrot_rank_1 = hipblasZdrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSrotStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey,c,s, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: c type(c_ptr) :: s integer(c_int) :: batchCount ! hipblasSrotStridedBatched_assumed_rank = hipblasSrotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,c,s,batchCount) end function #else function hipblasSrotStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: c type(c_ptr) :: s integer(c_int) :: batchCount ! hipblasSrotStridedBatched_rank_0 = hipblasSrotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,c,s,batchCount) end function function hipblasSrotStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: c type(c_ptr) :: s integer(c_int) :: batchCount ! hipblasSrotStridedBatched_rank_1 = hipblasSrotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,c,s,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDrotStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey,c,s, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: c type(c_ptr) :: s integer(c_int) :: batchCount ! hipblasDrotStridedBatched_assumed_rank = hipblasDrotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,c,s,batchCount) end function #else function hipblasDrotStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: c type(c_ptr) :: s integer(c_int) :: batchCount ! hipblasDrotStridedBatched_rank_0 = hipblasDrotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,c,s,batchCount) end function function hipblasDrotStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: c type(c_ptr) :: s integer(c_int) :: batchCount ! hipblasDrotStridedBatched_rank_1 = hipblasDrotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,c,s,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCrotStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey,c,s, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrotStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: c type(c_ptr) :: s integer(c_int) :: batchCount ! hipblasCrotStridedBatched_assumed_rank = hipblasCrotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,c,s,batchCount) end function #else function hipblasCrotStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrotStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: c type(c_ptr) :: s integer(c_int) :: batchCount ! hipblasCrotStridedBatched_rank_0 = hipblasCrotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,c,s,batchCount) end function function hipblasCrotStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCrotStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: c type(c_ptr) :: s integer(c_int) :: batchCount ! hipblasCrotStridedBatched_rank_1 = hipblasCrotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,c,s,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCsrotStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey,c,s, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsrotStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: c type(c_ptr) :: s integer(c_int) :: batchCount ! hipblasCsrotStridedBatched_assumed_rank = hipblasCsrotStridedBatched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,c,s,batchCount) end function #else function hipblasCsrotStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,c,s, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsrotStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: c type(c_ptr) :: s integer(c_int) :: batchCount ! hipblasCsrotStridedBatched_rank_0 = hipblasCsrotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,c,s,batchCount) end function function hipblasCsrotStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,c,s, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsrotStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: c type(c_ptr) :: s integer(c_int) :: batchCount ! hipblasCsrotStridedBatched_rank_1 = hipblasCsrotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,c,s,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZrotStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey,c,s, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrotStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: c type(c_ptr) :: s integer(c_int) :: batchCount ! hipblasZrotStridedBatched_assumed_rank = hipblasZrotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,c,s,batchCount) end function #else function hipblasZrotStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrotStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: c type(c_ptr) :: s integer(c_int) :: batchCount ! hipblasZrotStridedBatched_rank_0 = hipblasZrotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,c,s,batchCount) end function function hipblasZrotStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,c,s,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZrotStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: c type(c_ptr) :: s integer(c_int) :: batchCount ! hipblasZrotStridedBatched_rank_1 = hipblasZrotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,c,s,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZdrotStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey,c,s, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdrotStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: c type(c_ptr) :: s integer(c_int) :: batchCount ! hipblasZdrotStridedBatched_assumed_rank = hipblasZdrotStridedBatched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,c,s,batchCount) end function #else function hipblasZdrotStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,c,s, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdrotStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: c type(c_ptr) :: s integer(c_int) :: batchCount ! hipblasZdrotStridedBatched_rank_0 = hipblasZdrotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,c,s,batchCount) end function function hipblasZdrotStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,c,s, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdrotStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: c type(c_ptr) :: s integer(c_int) :: batchCount ! hipblasZdrotStridedBatched_rank_1 = hipblasZdrotStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,c,s,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSrotm_assumed_rank(handle,n,x,incx,y,incy,param) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotm_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: param ! hipblasSrotm_assumed_rank = hipblasSrotm_(handle,n,c_loc(x),incx,c_loc(y),incy,param) end function #else function hipblasSrotm_rank_0(handle,n,x,incx,y,incy,param) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotm_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: y integer(c_int) :: incy type(c_ptr) :: param ! hipblasSrotm_rank_0 = hipblasSrotm_(handle,n,c_loc(x),incx,c_loc(y),incy,param) end function function hipblasSrotm_rank_1(handle,n,x,incx,y,incy,param) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotm_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: param ! hipblasSrotm_rank_1 = hipblasSrotm_(handle,n,c_loc(x),incx,c_loc(y),incy,param) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDrotm_assumed_rank(handle,n,x,incx,y,incy,param) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotm_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: param ! hipblasDrotm_assumed_rank = hipblasDrotm_(handle,n,c_loc(x),incx,c_loc(y),incy,param) end function #else function hipblasDrotm_rank_0(handle,n,x,incx,y,incy,param) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotm_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: y integer(c_int) :: incy type(c_ptr) :: param ! hipblasDrotm_rank_0 = hipblasDrotm_(handle,n,c_loc(x),incx,c_loc(y),incy,param) end function function hipblasDrotm_rank_1(handle,n,x,incx,y,incy,param) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotm_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: param ! hipblasDrotm_rank_1 = hipblasDrotm_(handle,n,c_loc(x),incx,c_loc(y),incy,param) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSrotmStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey,param, & strideParam,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotmStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: param integer(c_int64_t) :: strideParam integer(c_int) :: batchCount ! hipblasSrotmStridedBatched_assumed_rank = hipblasSrotmStridedBatched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,param,strideParam,batchCount) end function #else function hipblasSrotmStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,param, & strideParam,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotmStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: param integer(c_int64_t) :: strideParam integer(c_int) :: batchCount ! hipblasSrotmStridedBatched_rank_0 = hipblasSrotmStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,param,strideParam,batchCount) end function function hipblasSrotmStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,param, & strideParam,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSrotmStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: param integer(c_int64_t) :: strideParam integer(c_int) :: batchCount ! hipblasSrotmStridedBatched_rank_1 = hipblasSrotmStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,param,strideParam,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDrotmStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey,param, & strideParam,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotmStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: param integer(c_int64_t) :: strideParam integer(c_int) :: batchCount ! hipblasDrotmStridedBatched_assumed_rank = hipblasDrotmStridedBatched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,param,strideParam,batchCount) end function #else function hipblasDrotmStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,param, & strideParam,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotmStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: param integer(c_int64_t) :: strideParam integer(c_int) :: batchCount ! hipblasDrotmStridedBatched_rank_0 = hipblasDrotmStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,param,strideParam,batchCount) end function function hipblasDrotmStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,param, & strideParam,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDrotmStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey type(c_ptr) :: param integer(c_int64_t) :: strideParam integer(c_int) :: batchCount ! hipblasDrotmStridedBatched_rank_1 = hipblasDrotmStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,param,strideParam,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSscal_assumed_rank(handle,n,alpha,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSscal_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasSscal_assumed_rank = hipblasSscal_(handle,n,alpha,c_loc(x),incx) end function #else function hipblasSscal_rank_0(handle,n,alpha,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSscal_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx ! hipblasSscal_rank_0 = hipblasSscal_(handle,n,alpha,c_loc(x),incx) end function function hipblasSscal_rank_1(handle,n,alpha,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSscal_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! hipblasSscal_rank_1 = hipblasSscal_(handle,n,alpha,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDscal_assumed_rank(handle,n,alpha,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDscal_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasDscal_assumed_rank = hipblasDscal_(handle,n,alpha,c_loc(x),incx) end function #else function hipblasDscal_rank_0(handle,n,alpha,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDscal_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx ! hipblasDscal_rank_0 = hipblasDscal_(handle,n,alpha,c_loc(x),incx) end function function hipblasDscal_rank_1(handle,n,alpha,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDscal_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! hipblasDscal_rank_1 = hipblasDscal_(handle,n,alpha,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCscal_assumed_rank(handle,n,alpha,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCscal_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasCscal_assumed_rank = hipblasCscal_(handle,n,alpha,c_loc(x),incx) end function #else function hipblasCscal_rank_0(handle,n,alpha,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCscal_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx ! hipblasCscal_rank_0 = hipblasCscal_(handle,n,alpha,c_loc(x),incx) end function function hipblasCscal_rank_1(handle,n,alpha,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCscal_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasCscal_rank_1 = hipblasCscal_(handle,n,alpha,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCsscal_assumed_rank(handle,n,alpha,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsscal_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasCsscal_assumed_rank = hipblasCsscal_(handle,n,alpha,c_loc(x),incx) end function #else function hipblasCsscal_rank_0(handle,n,alpha,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsscal_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx ! hipblasCsscal_rank_0 = hipblasCsscal_(handle,n,alpha,c_loc(x),incx) end function function hipblasCsscal_rank_1(handle,n,alpha,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsscal_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasCsscal_rank_1 = hipblasCsscal_(handle,n,alpha,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZscal_assumed_rank(handle,n,alpha,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZscal_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasZscal_assumed_rank = hipblasZscal_(handle,n,alpha,c_loc(x),incx) end function #else function hipblasZscal_rank_0(handle,n,alpha,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZscal_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx ! hipblasZscal_rank_0 = hipblasZscal_(handle,n,alpha,c_loc(x),incx) end function function hipblasZscal_rank_1(handle,n,alpha,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZscal_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasZscal_rank_1 = hipblasZscal_(handle,n,alpha,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZdscal_assumed_rank(handle,n,alpha,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdscal_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasZdscal_assumed_rank = hipblasZdscal_(handle,n,alpha,c_loc(x),incx) end function #else function hipblasZdscal_rank_0(handle,n,alpha,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdscal_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx ! hipblasZdscal_rank_0 = hipblasZdscal_(handle,n,alpha,c_loc(x),incx) end function function hipblasZdscal_rank_1(handle,n,alpha,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdscal_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasZdscal_rank_1 = hipblasZdscal_(handle,n,alpha,c_loc(x),incx) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSscalStridedBatched_assumed_rank(handle,n,alpha,x,incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSscalStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasSscalStridedBatched_assumed_rank = hipblasSscalStridedBatched_(handle,n,alpha, & c_loc(x),incx,stridex,batchCount) end function #else function hipblasSscalStridedBatched_rank_0(handle,n,alpha,x,incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSscalStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasSscalStridedBatched_rank_0 = hipblasSscalStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,batchCount) end function function hipblasSscalStridedBatched_rank_1(handle,n,alpha,x,incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSscalStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasSscalStridedBatched_rank_1 = hipblasSscalStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDscalStridedBatched_assumed_rank(handle,n,alpha,x,incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDscalStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDscalStridedBatched_assumed_rank = hipblasDscalStridedBatched_(handle,n,alpha, & c_loc(x),incx,stridex,batchCount) end function #else function hipblasDscalStridedBatched_rank_0(handle,n,alpha,x,incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDscalStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDscalStridedBatched_rank_0 = hipblasDscalStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,batchCount) end function function hipblasDscalStridedBatched_rank_1(handle,n,alpha,x,incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDscalStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDscalStridedBatched_rank_1 = hipblasDscalStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCscalStridedBatched_assumed_rank(handle,n,alpha,x,incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCscalStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCscalStridedBatched_assumed_rank = hipblasCscalStridedBatched_(handle,n,alpha, & c_loc(x),incx,stridex,batchCount) end function #else function hipblasCscalStridedBatched_rank_0(handle,n,alpha,x,incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCscalStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCscalStridedBatched_rank_0 = hipblasCscalStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,batchCount) end function function hipblasCscalStridedBatched_rank_1(handle,n,alpha,x,incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCscalStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCscalStridedBatched_rank_1 = hipblasCscalStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZscalStridedBatched_assumed_rank(handle,n,alpha,x,incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZscalStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZscalStridedBatched_assumed_rank = hipblasZscalStridedBatched_(handle,n,alpha, & c_loc(x),incx,stridex,batchCount) end function #else function hipblasZscalStridedBatched_rank_0(handle,n,alpha,x,incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZscalStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZscalStridedBatched_rank_0 = hipblasZscalStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,batchCount) end function function hipblasZscalStridedBatched_rank_1(handle,n,alpha,x,incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZscalStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZscalStridedBatched_rank_1 = hipblasZscalStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCsscalStridedBatched_assumed_rank(handle,n,alpha,x,incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsscalStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCsscalStridedBatched_assumed_rank = hipblasCsscalStridedBatched_(handle,n,alpha, & c_loc(x),incx,stridex,batchCount) end function #else function hipblasCsscalStridedBatched_rank_0(handle,n,alpha,x,incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsscalStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCsscalStridedBatched_rank_0 = hipblasCsscalStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,batchCount) end function function hipblasCsscalStridedBatched_rank_1(handle,n,alpha,x,incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsscalStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCsscalStridedBatched_rank_1 = hipblasCsscalStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZdscalStridedBatched_assumed_rank(handle,n,alpha,x,incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdscalStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZdscalStridedBatched_assumed_rank = hipblasZdscalStridedBatched_(handle,n,alpha, & c_loc(x),incx,stridex,batchCount) end function #else function hipblasZdscalStridedBatched_rank_0(handle,n,alpha,x,incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdscalStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZdscalStridedBatched_rank_0 = hipblasZdscalStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,batchCount) end function function hipblasZdscalStridedBatched_rank_1(handle,n,alpha,x,incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdscalStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZdscalStridedBatched_rank_1 = hipblasZdscalStridedBatched_(handle,n,alpha,c_loc(x), & incx,stridex,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSswap_assumed_rank(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSswap_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasSswap_assumed_rank = hipblasSswap_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #else function hipblasSswap_rank_0(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSswap_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: y integer(c_int) :: incy ! hipblasSswap_rank_0 = hipblasSswap_(handle,n,c_loc(x),incx,c_loc(y),incy) end function function hipblasSswap_rank_1(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSswap_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! hipblasSswap_rank_1 = hipblasSswap_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDswap_assumed_rank(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDswap_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasDswap_assumed_rank = hipblasDswap_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #else function hipblasDswap_rank_0(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDswap_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: y integer(c_int) :: incy ! hipblasDswap_rank_0 = hipblasDswap_(handle,n,c_loc(x),incx,c_loc(y),incy) end function function hipblasDswap_rank_1(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDswap_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! hipblasDswap_rank_1 = hipblasDswap_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCswap_assumed_rank(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCswap_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasCswap_assumed_rank = hipblasCswap_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #else function hipblasCswap_rank_0(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCswap_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy ! hipblasCswap_rank_0 = hipblasCswap_(handle,n,c_loc(x),incx,c_loc(y),incy) end function function hipblasCswap_rank_1(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCswap_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasCswap_rank_1 = hipblasCswap_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZswap_assumed_rank(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZswap_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasZswap_assumed_rank = hipblasZswap_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #else function hipblasZswap_rank_0(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZswap_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy ! hipblasZswap_rank_0 = hipblasZswap_(handle,n,c_loc(x),incx,c_loc(y),incy) end function function hipblasZswap_rank_1(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZswap_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasZswap_rank_1 = hipblasZswap_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSswapStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSswapStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSswapStridedBatched_assumed_rank = hipblasSswapStridedBatched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount) end function #else function hipblasSswapStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSswapStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSswapStridedBatched_rank_0 = hipblasSswapStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount) end function function hipblasSswapStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSswapStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSswapStridedBatched_rank_1 = hipblasSswapStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDswapStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDswapStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDswapStridedBatched_assumed_rank = hipblasDswapStridedBatched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount) end function #else function hipblasDswapStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDswapStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDswapStridedBatched_rank_0 = hipblasDswapStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount) end function function hipblasDswapStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDswapStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDswapStridedBatched_rank_1 = hipblasDswapStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCswapStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCswapStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCswapStridedBatched_assumed_rank = hipblasCswapStridedBatched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount) end function #else function hipblasCswapStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCswapStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCswapStridedBatched_rank_0 = hipblasCswapStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount) end function function hipblasCswapStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCswapStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCswapStridedBatched_rank_1 = hipblasCswapStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZswapStridedBatched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZswapStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZswapStridedBatched_assumed_rank = hipblasZswapStridedBatched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batchCount) end function #else function hipblasZswapStridedBatched_rank_0(handle,n,x,incx,stridex,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZswapStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZswapStridedBatched_rank_0 = hipblasZswapStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount) end function function hipblasZswapStridedBatched_rank_1(handle,n,x,incx,stridex,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZswapStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZswapStridedBatched_rank_1 = hipblasZswapStridedBatched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSgbmv_assumed_rank(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgbmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasSgbmv_assumed_rank = hipblasSgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(AP),lda, & c_loc(x),incx,beta,c_loc(y),incy) end function #else function hipblasSgbmv_rank_0(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgbmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda real(c_float),target :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy ! hipblasSgbmv_rank_0 = hipblasSgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(AP),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function function hipblasSgbmv_rank_1(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgbmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! hipblasSgbmv_rank_1 = hipblasSgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(AP),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function function hipblasSgbmv_full_rank(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgbmv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! hipblasSgbmv_full_rank = hipblasSgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(AP),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDgbmv_assumed_rank(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgbmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasDgbmv_assumed_rank = hipblasDgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(AP),lda, & c_loc(x),incx,beta,c_loc(y),incy) end function #else function hipblasDgbmv_rank_0(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgbmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda real(c_double),target :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy ! hipblasDgbmv_rank_0 = hipblasDgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(AP),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function function hipblasDgbmv_rank_1(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgbmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! hipblasDgbmv_rank_1 = hipblasDgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(AP),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function function hipblasDgbmv_full_rank(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgbmv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! hipblasDgbmv_full_rank = hipblasDgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(AP),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCgbmv_assumed_rank(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgbmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasCgbmv_assumed_rank = hipblasCgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(AP),lda, & c_loc(x),incx,beta,c_loc(y),incy) end function #else function hipblasCgbmv_rank_0(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgbmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy ! hipblasCgbmv_rank_0 = hipblasCgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(AP),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function function hipblasCgbmv_rank_1(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgbmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasCgbmv_rank_1 = hipblasCgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(AP),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function function hipblasCgbmv_full_rank(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgbmv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasCgbmv_full_rank = hipblasCgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(AP),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZgbmv_assumed_rank(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgbmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasZgbmv_assumed_rank = hipblasZgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(AP),lda, & c_loc(x),incx,beta,c_loc(y),incy) end function #else function hipblasZgbmv_rank_0(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgbmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy ! hipblasZgbmv_rank_0 = hipblasZgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(AP),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function function hipblasZgbmv_rank_1(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgbmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasZgbmv_rank_1 = hipblasZgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(AP),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function function hipblasZgbmv_full_rank(handle,trans,m,n,kl,ku,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgbmv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasZgbmv_full_rank = hipblasZgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(AP),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSgbmvStridedBatched_assumed_rank(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA, & x,incx,stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgbmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSgbmvStridedBatched_assumed_rank = hipblasSgbmvStridedBatched_(handle,trans,m,n,kl, & ku,alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasSgbmvStridedBatched_rank_0(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgbmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSgbmvStridedBatched_rank_0 = hipblasSgbmvStridedBatched_(handle,trans,m,n,kl,ku, & alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasSgbmvStridedBatched_rank_1(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgbmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSgbmvStridedBatched_rank_1 = hipblasSgbmvStridedBatched_(handle,trans,m,n,kl,ku, & alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasSgbmvStridedBatched_full_rank(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x, & incx,stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgbmvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSgbmvStridedBatched_full_rank = hipblasSgbmvStridedBatched_(handle,trans,m,n,kl,ku, & alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDgbmvStridedBatched_assumed_rank(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA, & x,incx,stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgbmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDgbmvStridedBatched_assumed_rank = hipblasDgbmvStridedBatched_(handle,trans,m,n,kl, & ku,alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasDgbmvStridedBatched_rank_0(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgbmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDgbmvStridedBatched_rank_0 = hipblasDgbmvStridedBatched_(handle,trans,m,n,kl,ku, & alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasDgbmvStridedBatched_rank_1(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgbmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDgbmvStridedBatched_rank_1 = hipblasDgbmvStridedBatched_(handle,trans,m,n,kl,ku, & alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasDgbmvStridedBatched_full_rank(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x, & incx,stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgbmvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDgbmvStridedBatched_full_rank = hipblasDgbmvStridedBatched_(handle,trans,m,n,kl,ku, & alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCgbmvStridedBatched_assumed_rank(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA, & x,incx,stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgbmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCgbmvStridedBatched_assumed_rank = hipblasCgbmvStridedBatched_(handle,trans,m,n,kl, & ku,alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasCgbmvStridedBatched_rank_0(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgbmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCgbmvStridedBatched_rank_0 = hipblasCgbmvStridedBatched_(handle,trans,m,n,kl,ku, & alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasCgbmvStridedBatched_rank_1(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgbmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCgbmvStridedBatched_rank_1 = hipblasCgbmvStridedBatched_(handle,trans,m,n,kl,ku, & alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasCgbmvStridedBatched_full_rank(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x, & incx,stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgbmvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCgbmvStridedBatched_full_rank = hipblasCgbmvStridedBatched_(handle,trans,m,n,kl,ku, & alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZgbmvStridedBatched_assumed_rank(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA, & x,incx,stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgbmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZgbmvStridedBatched_assumed_rank = hipblasZgbmvStridedBatched_(handle,trans,m,n,kl, & ku,alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasZgbmvStridedBatched_rank_0(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgbmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZgbmvStridedBatched_rank_0 = hipblasZgbmvStridedBatched_(handle,trans,m,n,kl,ku, & alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasZgbmvStridedBatched_rank_1(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgbmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZgbmvStridedBatched_rank_1 = hipblasZgbmvStridedBatched_(handle,trans,m,n,kl,ku, & alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasZgbmvStridedBatched_full_rank(handle,trans,m,n,kl,ku,alpha,AP,lda,strideA,x, & incx,stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgbmvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZgbmvStridedBatched_full_rank = hipblasZgbmvStridedBatched_(handle,trans,m,n,kl,ku, & alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSgemv_assumed_rank(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasSgemv_assumed_rank = hipblasSgemv_(handle,trans,m,n,alpha,c_loc(AP),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #else function hipblasSgemv_rank_0(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda real(c_float),target :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy ! hipblasSgemv_rank_0 = hipblasSgemv_(handle,trans,m,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasSgemv_rank_1(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! hipblasSgemv_rank_1 = hipblasSgemv_(handle,trans,m,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasSgemv_full_rank(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! hipblasSgemv_full_rank = hipblasSgemv_(handle,trans,m,n,alpha,c_loc(AP),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDgemv_assumed_rank(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasDgemv_assumed_rank = hipblasDgemv_(handle,trans,m,n,alpha,c_loc(AP),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #else function hipblasDgemv_rank_0(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda real(c_double),target :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy ! hipblasDgemv_rank_0 = hipblasDgemv_(handle,trans,m,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasDgemv_rank_1(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! hipblasDgemv_rank_1 = hipblasDgemv_(handle,trans,m,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasDgemv_full_rank(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! hipblasDgemv_full_rank = hipblasDgemv_(handle,trans,m,n,alpha,c_loc(AP),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCgemv_assumed_rank(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasCgemv_assumed_rank = hipblasCgemv_(handle,trans,m,n,alpha,c_loc(AP),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #else function hipblasCgemv_rank_0(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy ! hipblasCgemv_rank_0 = hipblasCgemv_(handle,trans,m,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasCgemv_rank_1(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasCgemv_rank_1 = hipblasCgemv_(handle,trans,m,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasCgemv_full_rank(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasCgemv_full_rank = hipblasCgemv_(handle,trans,m,n,alpha,c_loc(AP),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZgemv_assumed_rank(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasZgemv_assumed_rank = hipblasZgemv_(handle,trans,m,n,alpha,c_loc(AP),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #else function hipblasZgemv_rank_0(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy ! hipblasZgemv_rank_0 = hipblasZgemv_(handle,trans,m,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasZgemv_rank_1(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasZgemv_rank_1 = hipblasZgemv_(handle,trans,m,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasZgemv_full_rank(handle,trans,m,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasZgemv_full_rank = hipblasZgemv_(handle,trans,m,n,alpha,c_loc(AP),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSgemvStridedBatched_assumed_rank(handle,transA,m,n,alpha,AP,lda,strideA,x, & incx,stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSgemvStridedBatched_assumed_rank = hipblasSgemvStridedBatched_(handle,transA,m,n, & alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasSgemvStridedBatched_rank_0(handle,transA,m,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSgemvStridedBatched_rank_0 = hipblasSgemvStridedBatched_(handle,transA,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasSgemvStridedBatched_rank_1(handle,transA,m,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSgemvStridedBatched_rank_1 = hipblasSgemvStridedBatched_(handle,transA,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasSgemvStridedBatched_full_rank(handle,transA,m,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSgemvStridedBatched_full_rank = hipblasSgemvStridedBatched_(handle,transA,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDgemvStridedBatched_assumed_rank(handle,transA,m,n,alpha,AP,lda,strideA,x, & incx,stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDgemvStridedBatched_assumed_rank = hipblasDgemvStridedBatched_(handle,transA,m,n, & alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasDgemvStridedBatched_rank_0(handle,transA,m,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDgemvStridedBatched_rank_0 = hipblasDgemvStridedBatched_(handle,transA,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasDgemvStridedBatched_rank_1(handle,transA,m,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDgemvStridedBatched_rank_1 = hipblasDgemvStridedBatched_(handle,transA,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasDgemvStridedBatched_full_rank(handle,transA,m,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDgemvStridedBatched_full_rank = hipblasDgemvStridedBatched_(handle,transA,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCgemvStridedBatched_assumed_rank(handle,transA,m,n,alpha,AP,lda,strideA,x, & incx,stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCgemvStridedBatched_assumed_rank = hipblasCgemvStridedBatched_(handle,transA,m,n, & alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasCgemvStridedBatched_rank_0(handle,transA,m,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCgemvStridedBatched_rank_0 = hipblasCgemvStridedBatched_(handle,transA,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasCgemvStridedBatched_rank_1(handle,transA,m,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCgemvStridedBatched_rank_1 = hipblasCgemvStridedBatched_(handle,transA,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasCgemvStridedBatched_full_rank(handle,transA,m,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCgemvStridedBatched_full_rank = hipblasCgemvStridedBatched_(handle,transA,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZgemvStridedBatched_assumed_rank(handle,transA,m,n,alpha,AP,lda,strideA,x, & incx,stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZgemvStridedBatched_assumed_rank = hipblasZgemvStridedBatched_(handle,transA,m,n, & alpha,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasZgemvStridedBatched_rank_0(handle,transA,m,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZgemvStridedBatched_rank_0 = hipblasZgemvStridedBatched_(handle,transA,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasZgemvStridedBatched_rank_1(handle,transA,m,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZgemvStridedBatched_rank_1 = hipblasZgemvStridedBatched_(handle,transA,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasZgemvStridedBatched_full_rank(handle,transA,m,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZgemvStridedBatched_full_rank = hipblasZgemvStridedBatched_(handle,transA,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSger_assumed_rank(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSger_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda ! hipblasSger_assumed_rank = hipblasSger_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #else function hipblasSger_rank_0(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSger_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: y integer(c_int) :: incy real(c_float),target :: AP integer(c_int) :: lda ! hipblasSger_rank_0 = hipblasSger_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP),lda) end function function hipblasSger_rank_1(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSger_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy real(c_float),target,dimension(:) :: AP integer(c_int) :: lda ! hipblasSger_rank_1 = hipblasSger_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP),lda) end function function hipblasSger_full_rank(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSger_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda ! hipblasSger_full_rank = hipblasSger_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP), & lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDger_assumed_rank(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDger_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda ! hipblasDger_assumed_rank = hipblasDger_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #else function hipblasDger_rank_0(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDger_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: y integer(c_int) :: incy real(c_double),target :: AP integer(c_int) :: lda ! hipblasDger_rank_0 = hipblasDger_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP),lda) end function function hipblasDger_rank_1(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDger_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy real(c_double),target,dimension(:) :: AP integer(c_int) :: lda ! hipblasDger_rank_1 = hipblasDger_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP),lda) end function function hipblasDger_full_rank(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDger_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda ! hipblasDger_full_rank = hipblasDger_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP), & lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCgeru_assumed_rank(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeru_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda ! hipblasCgeru_assumed_rank = hipblasCgeru_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #else function hipblasCgeru_rank_0(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeru_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy complex(c_float_complex),target :: AP integer(c_int) :: lda ! hipblasCgeru_rank_0 = hipblasCgeru_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP), & lda) end function function hipblasCgeru_rank_1(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeru_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda ! hipblasCgeru_rank_1 = hipblasCgeru_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP), & lda) end function function hipblasCgeru_full_rank(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeru_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda ! hipblasCgeru_full_rank = hipblasCgeru_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCgerc_assumed_rank(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgerc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda ! hipblasCgerc_assumed_rank = hipblasCgerc_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #else function hipblasCgerc_rank_0(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgerc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy complex(c_float_complex),target :: AP integer(c_int) :: lda ! hipblasCgerc_rank_0 = hipblasCgerc_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP), & lda) end function function hipblasCgerc_rank_1(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgerc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda ! hipblasCgerc_rank_1 = hipblasCgerc_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP), & lda) end function function hipblasCgerc_full_rank(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgerc_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda ! hipblasCgerc_full_rank = hipblasCgerc_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZgeru_assumed_rank(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeru_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda ! hipblasZgeru_assumed_rank = hipblasZgeru_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #else function hipblasZgeru_rank_0(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeru_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy complex(c_double_complex),target :: AP integer(c_int) :: lda ! hipblasZgeru_rank_0 = hipblasZgeru_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP), & lda) end function function hipblasZgeru_rank_1(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeru_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda ! hipblasZgeru_rank_1 = hipblasZgeru_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP), & lda) end function function hipblasZgeru_full_rank(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeru_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda ! hipblasZgeru_full_rank = hipblasZgeru_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZgerc_assumed_rank(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgerc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda ! hipblasZgerc_assumed_rank = hipblasZgerc_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #else function hipblasZgerc_rank_0(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgerc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy complex(c_double_complex),target :: AP integer(c_int) :: lda ! hipblasZgerc_rank_0 = hipblasZgerc_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP), & lda) end function function hipblasZgerc_rank_1(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgerc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda ! hipblasZgerc_rank_1 = hipblasZgerc_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP), & lda) end function function hipblasZgerc_full_rank(handle,m,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgerc_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda ! hipblasZgerc_full_rank = hipblasZgerc_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSgerStridedBatched_assumed_rank(handle,m,n,alpha,x,incx,stridex,y,incy, & stridey,AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgerStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasSgerStridedBatched_assumed_rank = hipblasSgerStridedBatched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #else function hipblasSgerStridedBatched_rank_0(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP, & lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgerStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasSgerStridedBatched_rank_0 = hipblasSgerStridedBatched_(handle,m,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasSgerStridedBatched_rank_1(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP, & lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgerStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasSgerStridedBatched_rank_1 = hipblasSgerStridedBatched_(handle,m,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasSgerStridedBatched_full_rank(handle,m,n,alpha,x,incx,stridex,y,incy,stridey, & AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgerStridedBatched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasSgerStridedBatched_full_rank = hipblasSgerStridedBatched_(handle,m,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDgerStridedBatched_assumed_rank(handle,m,n,alpha,x,incx,stridex,y,incy, & stridey,AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgerStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasDgerStridedBatched_assumed_rank = hipblasDgerStridedBatched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #else function hipblasDgerStridedBatched_rank_0(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP, & lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgerStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasDgerStridedBatched_rank_0 = hipblasDgerStridedBatched_(handle,m,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasDgerStridedBatched_rank_1(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP, & lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgerStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasDgerStridedBatched_rank_1 = hipblasDgerStridedBatched_(handle,m,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasDgerStridedBatched_full_rank(handle,m,n,alpha,x,incx,stridex,y,incy,stridey, & AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgerStridedBatched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasDgerStridedBatched_full_rank = hipblasDgerStridedBatched_(handle,m,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCgeruStridedBatched_assumed_rank(handle,m,n,alpha,x,incx,stridex,y,incy, & stridey,AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeruStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCgeruStridedBatched_assumed_rank = hipblasCgeruStridedBatched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #else function hipblasCgeruStridedBatched_rank_0(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP, & lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeruStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCgeruStridedBatched_rank_0 = hipblasCgeruStridedBatched_(handle,m,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasCgeruStridedBatched_rank_1(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP, & lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeruStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCgeruStridedBatched_rank_1 = hipblasCgeruStridedBatched_(handle,m,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasCgeruStridedBatched_full_rank(handle,m,n,alpha,x,incx,stridex,y,incy,stridey, & AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeruStridedBatched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCgeruStridedBatched_full_rank = hipblasCgeruStridedBatched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCgercStridedBatched_assumed_rank(handle,m,n,alpha,x,incx,stridex,y,incy, & stridey,AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgercStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCgercStridedBatched_assumed_rank = hipblasCgercStridedBatched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #else function hipblasCgercStridedBatched_rank_0(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP, & lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgercStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCgercStridedBatched_rank_0 = hipblasCgercStridedBatched_(handle,m,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasCgercStridedBatched_rank_1(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP, & lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgercStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCgercStridedBatched_rank_1 = hipblasCgercStridedBatched_(handle,m,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasCgercStridedBatched_full_rank(handle,m,n,alpha,x,incx,stridex,y,incy,stridey, & AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgercStridedBatched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCgercStridedBatched_full_rank = hipblasCgercStridedBatched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZgeruStridedBatched_assumed_rank(handle,m,n,alpha,x,incx,stridex,y,incy, & stridey,AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeruStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZgeruStridedBatched_assumed_rank = hipblasZgeruStridedBatched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #else function hipblasZgeruStridedBatched_rank_0(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP, & lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeruStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZgeruStridedBatched_rank_0 = hipblasZgeruStridedBatched_(handle,m,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasZgeruStridedBatched_rank_1(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP, & lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeruStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZgeruStridedBatched_rank_1 = hipblasZgeruStridedBatched_(handle,m,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasZgeruStridedBatched_full_rank(handle,m,n,alpha,x,incx,stridex,y,incy,stridey, & AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeruStridedBatched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZgeruStridedBatched_full_rank = hipblasZgeruStridedBatched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZgercStridedBatched_assumed_rank(handle,m,n,alpha,x,incx,stridex,y,incy, & stridey,AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgercStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZgercStridedBatched_assumed_rank = hipblasZgercStridedBatched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #else function hipblasZgercStridedBatched_rank_0(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP, & lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgercStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZgercStridedBatched_rank_0 = hipblasZgercStridedBatched_(handle,m,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasZgercStridedBatched_rank_1(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,AP, & lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgercStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZgercStridedBatched_rank_1 = hipblasZgercStridedBatched_(handle,m,n,alpha,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasZgercStridedBatched_full_rank(handle,m,n,alpha,x,incx,stridex,y,incy,stridey, & AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgercStridedBatched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZgercStridedBatched_full_rank = hipblasZgercStridedBatched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasChbmv_assumed_rank(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasChbmv_assumed_rank = hipblasChbmv_(handle,uplo,n,k,alpha,c_loc(AP),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #else function hipblasChbmv_rank_0(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy ! hipblasChbmv_rank_0 = hipblasChbmv_(handle,uplo,n,k,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasChbmv_rank_1(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasChbmv_rank_1 = hipblasChbmv_(handle,uplo,n,k,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasChbmv_full_rank(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasChbmv_full_rank = hipblasChbmv_(handle,uplo,n,k,alpha,c_loc(AP),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZhbmv_assumed_rank(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasZhbmv_assumed_rank = hipblasZhbmv_(handle,uplo,n,k,alpha,c_loc(AP),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #else function hipblasZhbmv_rank_0(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy ! hipblasZhbmv_rank_0 = hipblasZhbmv_(handle,uplo,n,k,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasZhbmv_rank_1(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasZhbmv_rank_1 = hipblasZhbmv_(handle,uplo,n,k,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasZhbmv_full_rank(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasZhbmv_full_rank = hipblasZhbmv_(handle,uplo,n,k,alpha,c_loc(AP),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasChbmvStridedBatched_assumed_rank(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasChbmvStridedBatched_assumed_rank = hipblasChbmvStridedBatched_(handle,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasChbmvStridedBatched_rank_0(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasChbmvStridedBatched_rank_0 = hipblasChbmvStridedBatched_(handle,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasChbmvStridedBatched_rank_1(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasChbmvStridedBatched_rank_1 = hipblasChbmvStridedBatched_(handle,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasChbmvStridedBatched_full_rank(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChbmvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasChbmvStridedBatched_full_rank = hipblasChbmvStridedBatched_(handle,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZhbmvStridedBatched_assumed_rank(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZhbmvStridedBatched_assumed_rank = hipblasZhbmvStridedBatched_(handle,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasZhbmvStridedBatched_rank_0(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZhbmvStridedBatched_rank_0 = hipblasZhbmvStridedBatched_(handle,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasZhbmvStridedBatched_rank_1(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZhbmvStridedBatched_rank_1 = hipblasZhbmvStridedBatched_(handle,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasZhbmvStridedBatched_full_rank(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhbmvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZhbmvStridedBatched_full_rank = hipblasZhbmvStridedBatched_(handle,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasChemv_assumed_rank(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasChemv_assumed_rank = hipblasChemv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #else function hipblasChemv_rank_0(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy ! hipblasChemv_rank_0 = hipblasChemv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasChemv_rank_1(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasChemv_rank_1 = hipblasChemv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasChemv_full_rank(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasChemv_full_rank = hipblasChemv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZhemv_assumed_rank(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasZhemv_assumed_rank = hipblasZhemv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #else function hipblasZhemv_rank_0(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy ! hipblasZhemv_rank_0 = hipblasZhemv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasZhemv_rank_1(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasZhemv_rank_1 = hipblasZhemv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasZhemv_full_rank(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasZhemv_full_rank = hipblasZhemv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasChemvStridedBatched_assumed_rank(handle,uplo,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasChemvStridedBatched_assumed_rank = hipblasChemvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasChemvStridedBatched_rank_0(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasChemvStridedBatched_rank_0 = hipblasChemvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasChemvStridedBatched_rank_1(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasChemvStridedBatched_rank_1 = hipblasChemvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasChemvStridedBatched_full_rank(handle,uplo,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasChemvStridedBatched_full_rank = hipblasChemvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZhemvStridedBatched_assumed_rank(handle,uplo,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZhemvStridedBatched_assumed_rank = hipblasZhemvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasZhemvStridedBatched_rank_0(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZhemvStridedBatched_rank_0 = hipblasZhemvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasZhemvStridedBatched_rank_1(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZhemvStridedBatched_rank_1 = hipblasZhemvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasZhemvStridedBatched_full_rank(handle,uplo,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZhemvStridedBatched_full_rank = hipblasZhemvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCher_assumed_rank(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda ! hipblasCher_assumed_rank = hipblasCher_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function #else function hipblasCher_rank_0(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: AP integer(c_int) :: lda ! hipblasCher_rank_0 = hipblasCher_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function function hipblasCher_rank_1(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda ! hipblasCher_rank_1 = hipblasCher_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function function hipblasCher_full_rank(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda ! hipblasCher_full_rank = hipblasCher_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZher_assumed_rank(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda ! hipblasZher_assumed_rank = hipblasZher_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function #else function hipblasZher_rank_0(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: AP integer(c_int) :: lda ! hipblasZher_rank_0 = hipblasZher_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function function hipblasZher_rank_1(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda ! hipblasZher_rank_1 = hipblasZher_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function function hipblasZher_full_rank(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda ! hipblasZher_full_rank = hipblasZher_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCherStridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,AP,lda, & strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCherStridedBatched_assumed_rank = hipblasCherStridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(AP),lda,strideA,batchCount) end function #else function hipblasCherStridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCherStridedBatched_rank_0 = hipblasCherStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),lda,strideA,batchCount) end function function hipblasCherStridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCherStridedBatched_rank_1 = hipblasCherStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),lda,strideA,batchCount) end function function hipblasCherStridedBatched_full_rank(handle,uplo,n,alpha,x,incx,stridex,AP,lda, & strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCherStridedBatched_full_rank = hipblasCherStridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(AP),lda,strideA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZherStridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,AP,lda, & strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZherStridedBatched_assumed_rank = hipblasZherStridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(AP),lda,strideA,batchCount) end function #else function hipblasZherStridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZherStridedBatched_rank_0 = hipblasZherStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),lda,strideA,batchCount) end function function hipblasZherStridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZherStridedBatched_rank_1 = hipblasZherStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),lda,strideA,batchCount) end function function hipblasZherStridedBatched_full_rank(handle,uplo,n,alpha,x,incx,stridex,AP,lda, & strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZherStridedBatched_full_rank = hipblasZherStridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(AP),lda,strideA,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCher2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda ! hipblasCher2_assumed_rank = hipblasCher2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #else function hipblasCher2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy complex(c_float_complex),target :: AP integer(c_int) :: lda ! hipblasCher2_rank_0 = hipblasCher2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function function hipblasCher2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda ! hipblasCher2_rank_1 = hipblasCher2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function function hipblasCher2_full_rank(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda ! hipblasCher2_full_rank = hipblasCher2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZher2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda ! hipblasZher2_assumed_rank = hipblasZher2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #else function hipblasZher2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy complex(c_double_complex),target :: AP integer(c_int) :: lda ! hipblasZher2_rank_0 = hipblasZher2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function function hipblasZher2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda ! hipblasZher2_rank_1 = hipblasZher2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function function hipblasZher2_full_rank(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda ! hipblasZher2_full_rank = hipblasZher2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCher2StridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2StridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCher2StridedBatched_assumed_rank = hipblasCher2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #else function hipblasCher2StridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2StridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCher2StridedBatched_rank_0 = hipblasCher2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasCher2StridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2StridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCher2StridedBatched_rank_1 = hipblasCher2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasCher2StridedBatched_full_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2StridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCher2StridedBatched_full_rank = hipblasCher2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZher2StridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2StridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZher2StridedBatched_assumed_rank = hipblasZher2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #else function hipblasZher2StridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2StridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZher2StridedBatched_rank_0 = hipblasZher2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasZher2StridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2StridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZher2StridedBatched_rank_1 = hipblasZher2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasZher2StridedBatched_full_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2StridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZher2StridedBatched_full_rank = hipblasZher2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasChpmv_assumed_rank(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasChpmv_assumed_rank = hipblasChpmv_(handle,uplo,n,alpha,c_loc(AP),c_loc(x),incx,beta, & c_loc(y),incy) end function #else function hipblasChpmv_rank_0(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy ! hipblasChpmv_rank_0 = hipblasChpmv_(handle,uplo,n,alpha,c_loc(AP),c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasChpmv_rank_1(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasChpmv_rank_1 = hipblasChpmv_(handle,uplo,n,alpha,c_loc(AP),c_loc(x),incx,beta, & c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZhpmv_assumed_rank(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasZhpmv_assumed_rank = hipblasZhpmv_(handle,uplo,n,alpha,c_loc(AP),c_loc(x),incx,beta, & c_loc(y),incy) end function #else function hipblasZhpmv_rank_0(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy ! hipblasZhpmv_rank_0 = hipblasZhpmv_(handle,uplo,n,alpha,c_loc(AP),c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasZhpmv_rank_1(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasZhpmv_rank_1 = hipblasZhpmv_(handle,uplo,n,alpha,c_loc(AP),c_loc(x),incx,beta, & c_loc(y),incy) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasChpmvStridedBatched_assumed_rank(handle,uplo,n,alpha,AP,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasChpmvStridedBatched_assumed_rank = hipblasChpmvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasChpmvStridedBatched_rank_0(handle,uplo,n,alpha,AP,strideA,x,incx,stridex,beta, & y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int64_t) :: strideA complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasChpmvStridedBatched_rank_0 = hipblasChpmvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasChpmvStridedBatched_rank_1(handle,uplo,n,alpha,AP,strideA,x,incx,stridex,beta, & y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasChpmvStridedBatched_rank_1 = hipblasChpmvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZhpmvStridedBatched_assumed_rank(handle,uplo,n,alpha,AP,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZhpmvStridedBatched_assumed_rank = hipblasZhpmvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasZhpmvStridedBatched_rank_0(handle,uplo,n,alpha,AP,strideA,x,incx,stridex,beta, & y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int64_t) :: strideA complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZhpmvStridedBatched_rank_0 = hipblasZhpmvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasZhpmvStridedBatched_rank_1(handle,uplo,n,alpha,AP,strideA,x,incx,stridex,beta, & y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZhpmvStridedBatched_rank_1 = hipblasZhpmvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasChpr_assumed_rank(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: AP ! hipblasChpr_assumed_rank = hipblasChpr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #else function hipblasChpr_rank_0(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: AP ! hipblasChpr_rank_0 = hipblasChpr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function function hipblasChpr_rank_1(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: AP ! hipblasChpr_rank_1 = hipblasChpr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZhpr_assumed_rank(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: AP ! hipblasZhpr_assumed_rank = hipblasZhpr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #else function hipblasZhpr_rank_0(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: AP ! hipblasZhpr_rank_0 = hipblasZhpr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function function hipblasZhpr_rank_1(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: AP ! hipblasZhpr_rank_1 = hipblasZhpr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasChprStridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChprStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasChprStridedBatched_assumed_rank = hipblasChprStridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(AP),strideA,batchCount) end function #else function hipblasChprStridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChprStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasChprStridedBatched_rank_0 = hipblasChprStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),strideA,batchCount) end function function hipblasChprStridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChprStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasChprStridedBatched_rank_1 = hipblasChprStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),strideA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZhprStridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhprStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZhprStridedBatched_assumed_rank = hipblasZhprStridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(AP),strideA,batchCount) end function #else function hipblasZhprStridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhprStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZhprStridedBatched_rank_0 = hipblasZhprStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),strideA,batchCount) end function function hipblasZhprStridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhprStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZhprStridedBatched_rank_1 = hipblasZhprStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),strideA,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasChpr2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr2_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_float_complex),target,contiguous,dimension(..) :: AP ! hipblasChpr2_assumed_rank = hipblasChpr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP)) end function #else function hipblasChpr2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr2_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy complex(c_float_complex),target :: AP ! hipblasChpr2_rank_0 = hipblasChpr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP)) end function function hipblasChpr2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr2_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_float_complex),target,dimension(:) :: AP ! hipblasChpr2_rank_1 = hipblasChpr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZhpr2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr2_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_double_complex),target,contiguous,dimension(..) :: AP ! hipblasZhpr2_assumed_rank = hipblasZhpr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP)) end function #else function hipblasZhpr2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr2_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy complex(c_double_complex),target :: AP ! hipblasZhpr2_rank_0 = hipblasZhpr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP)) end function function hipblasZhpr2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr2_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_double_complex),target,dimension(:) :: AP ! hipblasZhpr2_rank_1 = hipblasZhpr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP)) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasChpr2StridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,AP,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr2StridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasChpr2StridedBatched_assumed_rank = hipblasChpr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),strideA,batchCount) end function #else function hipblasChpr2StridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr2StridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasChpr2StridedBatched_rank_0 = hipblasChpr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),strideA,batchCount) end function function hipblasChpr2StridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChpr2StridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,dimension(:) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasChpr2StridedBatched_rank_1 = hipblasChpr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),strideA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZhpr2StridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,AP,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr2StridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZhpr2StridedBatched_assumed_rank = hipblasZhpr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),strideA,batchCount) end function #else function hipblasZhpr2StridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr2StridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZhpr2StridedBatched_rank_0 = hipblasZhpr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),strideA,batchCount) end function function hipblasZhpr2StridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhpr2StridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,dimension(:) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZhpr2StridedBatched_rank_1 = hipblasZhpr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),strideA,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSsbmv_assumed_rank(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasSsbmv_assumed_rank = hipblasSsbmv_(handle,uplo,n,k,alpha,c_loc(AP),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #else function hipblasSsbmv_rank_0(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda real(c_float),target :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy ! hipblasSsbmv_rank_0 = hipblasSsbmv_(handle,uplo,n,k,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasSsbmv_rank_1(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! hipblasSsbmv_rank_1 = hipblasSsbmv_(handle,uplo,n,k,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasSsbmv_full_rank(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! hipblasSsbmv_full_rank = hipblasSsbmv_(handle,uplo,n,k,alpha,c_loc(AP),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDsbmv_assumed_rank(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasDsbmv_assumed_rank = hipblasDsbmv_(handle,uplo,n,k,alpha,c_loc(AP),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #else function hipblasDsbmv_rank_0(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda real(c_double),target :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy ! hipblasDsbmv_rank_0 = hipblasDsbmv_(handle,uplo,n,k,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasDsbmv_rank_1(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! hipblasDsbmv_rank_1 = hipblasDsbmv_(handle,uplo,n,k,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasDsbmv_full_rank(handle,uplo,n,k,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! hipblasDsbmv_full_rank = hipblasDsbmv_(handle,uplo,n,k,alpha,c_loc(AP),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSsbmvStridedBatched_assumed_rank(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSsbmvStridedBatched_assumed_rank = hipblasSsbmvStridedBatched_(handle,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasSsbmvStridedBatched_rank_0(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSsbmvStridedBatched_rank_0 = hipblasSsbmvStridedBatched_(handle,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasSsbmvStridedBatched_rank_1(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSsbmvStridedBatched_rank_1 = hipblasSsbmvStridedBatched_(handle,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasSsbmvStridedBatched_full_rank(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsbmvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSsbmvStridedBatched_full_rank = hipblasSsbmvStridedBatched_(handle,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDsbmvStridedBatched_assumed_rank(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDsbmvStridedBatched_assumed_rank = hipblasDsbmvStridedBatched_(handle,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasDsbmvStridedBatched_rank_0(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDsbmvStridedBatched_rank_0 = hipblasDsbmvStridedBatched_(handle,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasDsbmvStridedBatched_rank_1(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDsbmvStridedBatched_rank_1 = hipblasDsbmvStridedBatched_(handle,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasDsbmvStridedBatched_full_rank(handle,uplo,n,k,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsbmvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDsbmvStridedBatched_full_rank = hipblasDsbmvStridedBatched_(handle,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSspmv_assumed_rank(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasSspmv_assumed_rank = hipblasSspmv_(handle,uplo,n,alpha,c_loc(AP),c_loc(x),incx,beta, & c_loc(y),incy) end function #else function hipblasSspmv_rank_0(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: AP real(c_float),target :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy ! hipblasSspmv_rank_0 = hipblasSspmv_(handle,uplo,n,alpha,c_loc(AP),c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasSspmv_rank_1(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: AP real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! hipblasSspmv_rank_1 = hipblasSspmv_(handle,uplo,n,alpha,c_loc(AP),c_loc(x),incx,beta, & c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDspmv_assumed_rank(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasDspmv_assumed_rank = hipblasDspmv_(handle,uplo,n,alpha,c_loc(AP),c_loc(x),incx,beta, & c_loc(y),incy) end function #else function hipblasDspmv_rank_0(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: AP real(c_double),target :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy ! hipblasDspmv_rank_0 = hipblasDspmv_(handle,uplo,n,alpha,c_loc(AP),c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasDspmv_rank_1(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: AP real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! hipblasDspmv_rank_1 = hipblasDspmv_(handle,uplo,n,alpha,c_loc(AP),c_loc(x),incx,beta, & c_loc(y),incy) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSspmvStridedBatched_assumed_rank(handle,uplo,n,alpha,AP,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSspmvStridedBatched_assumed_rank = hipblasSspmvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasSspmvStridedBatched_rank_0(handle,uplo,n,alpha,AP,strideA,x,incx,stridex,beta, & y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: AP integer(c_int64_t) :: strideA real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSspmvStridedBatched_rank_0 = hipblasSspmvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasSspmvStridedBatched_rank_1(handle,uplo,n,alpha,AP,strideA,x,incx,stridex,beta, & y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSspmvStridedBatched_rank_1 = hipblasSspmvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDspmvStridedBatched_assumed_rank(handle,uplo,n,alpha,AP,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDspmvStridedBatched_assumed_rank = hipblasDspmvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasDspmvStridedBatched_rank_0(handle,uplo,n,alpha,AP,strideA,x,incx,stridex,beta, & y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: AP integer(c_int64_t) :: strideA real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDspmvStridedBatched_rank_0 = hipblasDspmvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasDspmvStridedBatched_rank_1(handle,uplo,n,alpha,AP,strideA,x,incx,stridex,beta, & y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDspmvStridedBatched_rank_1 = hipblasDspmvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSspr_assumed_rank(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: AP ! hipblasSspr_assumed_rank = hipblasSspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #else function hipblasSspr_rank_0(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: AP ! hipblasSspr_rank_0 = hipblasSspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function function hipblasSspr_rank_1(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: AP ! hipblasSspr_rank_1 = hipblasSspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDspr_assumed_rank(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: AP ! hipblasDspr_assumed_rank = hipblasDspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #else function hipblasDspr_rank_0(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: AP ! hipblasDspr_rank_0 = hipblasDspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function function hipblasDspr_rank_1(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: AP ! hipblasDspr_rank_1 = hipblasDspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCspr_assumed_rank(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCspr_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: AP ! hipblasCspr_assumed_rank = hipblasCspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #else function hipblasCspr_rank_0(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCspr_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: AP ! hipblasCspr_rank_0 = hipblasCspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function function hipblasCspr_rank_1(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCspr_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: AP ! hipblasCspr_rank_1 = hipblasCspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZspr_assumed_rank(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZspr_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: AP ! hipblasZspr_assumed_rank = hipblasZspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #else function hipblasZspr_rank_0(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZspr_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: AP ! hipblasZspr_rank_0 = hipblasZspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function function hipblasZspr_rank_1(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZspr_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: AP ! hipblasZspr_rank_1 = hipblasZspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSsprStridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsprStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasSsprStridedBatched_assumed_rank = hipblasSsprStridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(AP),strideA,batchCount) end function #else function hipblasSsprStridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsprStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasSsprStridedBatched_rank_0 = hipblasSsprStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),strideA,batchCount) end function function hipblasSsprStridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsprStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasSsprStridedBatched_rank_1 = hipblasSsprStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),strideA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDsprStridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsprStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasDsprStridedBatched_assumed_rank = hipblasDsprStridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(AP),strideA,batchCount) end function #else function hipblasDsprStridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsprStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasDsprStridedBatched_rank_0 = hipblasDsprStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),strideA,batchCount) end function function hipblasDsprStridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsprStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasDsprStridedBatched_rank_1 = hipblasDsprStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),strideA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCsprStridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsprStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCsprStridedBatched_assumed_rank = hipblasCsprStridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(AP),strideA,batchCount) end function #else function hipblasCsprStridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsprStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCsprStridedBatched_rank_0 = hipblasCsprStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),strideA,batchCount) end function function hipblasCsprStridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsprStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCsprStridedBatched_rank_1 = hipblasCsprStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),strideA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZsprStridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsprStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZsprStridedBatched_assumed_rank = hipblasZsprStridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(AP),strideA,batchCount) end function #else function hipblasZsprStridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsprStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZsprStridedBatched_rank_0 = hipblasZsprStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),strideA,batchCount) end function function hipblasZsprStridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,AP,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsprStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZsprStridedBatched_rank_1 = hipblasZsprStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),strideA,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSspr2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr2_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy real(c_float),target,contiguous,dimension(..) :: AP ! hipblasSspr2_assumed_rank = hipblasSspr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP)) end function #else function hipblasSspr2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr2_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: y integer(c_int) :: incy real(c_float),target :: AP ! hipblasSspr2_rank_0 = hipblasSspr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP)) end function function hipblasSspr2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr2_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy real(c_float),target,dimension(:) :: AP ! hipblasSspr2_rank_1 = hipblasSspr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDspr2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr2_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy real(c_double),target,contiguous,dimension(..) :: AP ! hipblasDspr2_assumed_rank = hipblasDspr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP)) end function #else function hipblasDspr2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr2_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: y integer(c_int) :: incy real(c_double),target :: AP ! hipblasDspr2_rank_0 = hipblasDspr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP)) end function function hipblasDspr2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr2_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy real(c_double),target,dimension(:) :: AP ! hipblasDspr2_rank_1 = hipblasDspr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(AP)) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSspr2StridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,AP,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr2StridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_float),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasSspr2StridedBatched_assumed_rank = hipblasSspr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),strideA,batchCount) end function #else function hipblasSspr2StridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr2StridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_float),target :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasSspr2StridedBatched_rank_0 = hipblasSspr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),strideA,batchCount) end function function hipblasSspr2StridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSspr2StridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_float),target,dimension(:) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasSspr2StridedBatched_rank_1 = hipblasSspr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),strideA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDspr2StridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,AP,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr2StridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_double),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasDspr2StridedBatched_assumed_rank = hipblasDspr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),strideA,batchCount) end function #else function hipblasDspr2StridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr2StridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_double),target :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasDspr2StridedBatched_rank_0 = hipblasDspr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),strideA,batchCount) end function function hipblasDspr2StridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDspr2StridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_double),target,dimension(:) :: AP integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasDspr2StridedBatched_rank_1 = hipblasDspr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),strideA,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSsymv_assumed_rank(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasSsymv_assumed_rank = hipblasSsymv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #else function hipblasSsymv_rank_0(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda real(c_float),target :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy ! hipblasSsymv_rank_0 = hipblasSsymv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasSsymv_rank_1(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! hipblasSsymv_rank_1 = hipblasSsymv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasSsymv_full_rank(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! hipblasSsymv_full_rank = hipblasSsymv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDsymv_assumed_rank(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasDsymv_assumed_rank = hipblasDsymv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #else function hipblasDsymv_rank_0(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda real(c_double),target :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy ! hipblasDsymv_rank_0 = hipblasDsymv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasDsymv_rank_1(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! hipblasDsymv_rank_1 = hipblasDsymv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasDsymv_full_rank(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! hipblasDsymv_full_rank = hipblasDsymv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCsymv_assumed_rank(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasCsymv_assumed_rank = hipblasCsymv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #else function hipblasCsymv_rank_0(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy ! hipblasCsymv_rank_0 = hipblasCsymv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasCsymv_rank_1(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasCsymv_rank_1 = hipblasCsymv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasCsymv_full_rank(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasCsymv_full_rank = hipblasCsymv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZsymv_assumed_rank(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! hipblasZsymv_assumed_rank = hipblasZsymv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #else function hipblasZsymv_rank_0(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy ! hipblasZsymv_rank_0 = hipblasZsymv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasZsymv_rank_1(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasZsymv_rank_1 = hipblasZsymv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function hipblasZsymv_full_rank(handle,uplo,n,alpha,AP,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! hipblasZsymv_full_rank = hipblasZsymv_(handle,uplo,n,alpha,c_loc(AP),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSsymvStridedBatched_assumed_rank(handle,uplo,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSsymvStridedBatched_assumed_rank = hipblasSsymvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasSsymvStridedBatched_rank_0(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSsymvStridedBatched_rank_0 = hipblasSsymvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasSsymvStridedBatched_rank_1(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSsymvStridedBatched_rank_1 = hipblasSsymvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasSsymvStridedBatched_full_rank(handle,uplo,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasSsymvStridedBatched_full_rank = hipblasSsymvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDsymvStridedBatched_assumed_rank(handle,uplo,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDsymvStridedBatched_assumed_rank = hipblasDsymvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasDsymvStridedBatched_rank_0(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDsymvStridedBatched_rank_0 = hipblasDsymvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasDsymvStridedBatched_rank_1(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDsymvStridedBatched_rank_1 = hipblasDsymvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasDsymvStridedBatched_full_rank(handle,uplo,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasDsymvStridedBatched_full_rank = hipblasDsymvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCsymvStridedBatched_assumed_rank(handle,uplo,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCsymvStridedBatched_assumed_rank = hipblasCsymvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasCsymvStridedBatched_rank_0(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCsymvStridedBatched_rank_0 = hipblasCsymvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasCsymvStridedBatched_rank_1(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCsymvStridedBatched_rank_1 = hipblasCsymvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasCsymvStridedBatched_full_rank(handle,uplo,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasCsymvStridedBatched_full_rank = hipblasCsymvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZsymvStridedBatched_assumed_rank(handle,uplo,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZsymvStridedBatched_assumed_rank = hipblasZsymvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #else function hipblasZsymvStridedBatched_rank_0(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZsymvStridedBatched_rank_0 = hipblasZsymvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasZsymvStridedBatched_rank_1(handle,uplo,n,alpha,AP,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZsymvStridedBatched_rank_1 = hipblasZsymvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function function hipblasZsymvStridedBatched_full_rank(handle,uplo,n,alpha,AP,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batchCount ! hipblasZsymvStridedBatched_full_rank = hipblasZsymvStridedBatched_(handle,uplo,n,alpha, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSsyr_assumed_rank(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda ! hipblasSsyr_assumed_rank = hipblasSsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function #else function hipblasSsyr_rank_0(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: AP integer(c_int) :: lda ! hipblasSsyr_rank_0 = hipblasSsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function function hipblasSsyr_rank_1(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: AP integer(c_int) :: lda ! hipblasSsyr_rank_1 = hipblasSsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function function hipblasSsyr_full_rank(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda ! hipblasSsyr_full_rank = hipblasSsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDsyr_assumed_rank(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda ! hipblasDsyr_assumed_rank = hipblasDsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function #else function hipblasDsyr_rank_0(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: AP integer(c_int) :: lda ! hipblasDsyr_rank_0 = hipblasDsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function function hipblasDsyr_rank_1(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: AP integer(c_int) :: lda ! hipblasDsyr_rank_1 = hipblasDsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function function hipblasDsyr_full_rank(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda ! hipblasDsyr_full_rank = hipblasDsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCsyr_assumed_rank(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda ! hipblasCsyr_assumed_rank = hipblasCsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function #else function hipblasCsyr_rank_0(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: AP integer(c_int) :: lda ! hipblasCsyr_rank_0 = hipblasCsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function function hipblasCsyr_rank_1(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda ! hipblasCsyr_rank_1 = hipblasCsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function function hipblasCsyr_full_rank(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda ! hipblasCsyr_full_rank = hipblasCsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZsyr_assumed_rank(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda ! hipblasZsyr_assumed_rank = hipblasZsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function #else function hipblasZsyr_rank_0(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: AP integer(c_int) :: lda ! hipblasZsyr_rank_0 = hipblasZsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function function hipblasZsyr_rank_1(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda ! hipblasZsyr_rank_1 = hipblasZsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function function hipblasZsyr_full_rank(handle,uplo,n,alpha,x,incx,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda ! hipblasZsyr_full_rank = hipblasZsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP),lda) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSsyrStridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,AP,lda, & strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasSsyrStridedBatched_assumed_rank = hipblasSsyrStridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(AP),lda,strideA,batchCount) end function #else function hipblasSsyrStridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasSsyrStridedBatched_rank_0 = hipblasSsyrStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),lda,strideA,batchCount) end function function hipblasSsyrStridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasSsyrStridedBatched_rank_1 = hipblasSsyrStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),lda,strideA,batchCount) end function function hipblasSsyrStridedBatched_full_rank(handle,uplo,n,alpha,x,incx,stridex,AP,lda, & strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasSsyrStridedBatched_full_rank = hipblasSsyrStridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(AP),lda,strideA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDsyrStridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,AP,lda, & strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasDsyrStridedBatched_assumed_rank = hipblasDsyrStridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(AP),lda,strideA,batchCount) end function #else function hipblasDsyrStridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasDsyrStridedBatched_rank_0 = hipblasDsyrStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),lda,strideA,batchCount) end function function hipblasDsyrStridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasDsyrStridedBatched_rank_1 = hipblasDsyrStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),lda,strideA,batchCount) end function function hipblasDsyrStridedBatched_full_rank(handle,uplo,n,alpha,x,incx,stridex,AP,lda, & strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasDsyrStridedBatched_full_rank = hipblasDsyrStridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(AP),lda,strideA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCsyrStridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,AP,lda, & strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCsyrStridedBatched_assumed_rank = hipblasCsyrStridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(AP),lda,strideA,batchCount) end function #else function hipblasCsyrStridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCsyrStridedBatched_rank_0 = hipblasCsyrStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),lda,strideA,batchCount) end function function hipblasCsyrStridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCsyrStridedBatched_rank_1 = hipblasCsyrStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),lda,strideA,batchCount) end function function hipblasCsyrStridedBatched_full_rank(handle,uplo,n,alpha,x,incx,stridex,AP,lda, & strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCsyrStridedBatched_full_rank = hipblasCsyrStridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(AP),lda,strideA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZsyrStridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,AP,lda, & strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZsyrStridedBatched_assumed_rank = hipblasZsyrStridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(AP),lda,strideA,batchCount) end function #else function hipblasZsyrStridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZsyrStridedBatched_rank_0 = hipblasZsyrStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),lda,strideA,batchCount) end function function hipblasZsyrStridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,AP,lda,strideA, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZsyrStridedBatched_rank_1 = hipblasZsyrStridedBatched_(handle,uplo,n,alpha,c_loc(x), & incx,stridex,c_loc(AP),lda,strideA,batchCount) end function function hipblasZsyrStridedBatched_full_rank(handle,uplo,n,alpha,x,incx,stridex,AP,lda, & strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZsyrStridedBatched_full_rank = hipblasZsyrStridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(AP),lda,strideA,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSsyr2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda ! hipblasSsyr2_assumed_rank = hipblasSsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #else function hipblasSsyr2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: y integer(c_int) :: incy real(c_float),target :: AP integer(c_int) :: lda ! hipblasSsyr2_rank_0 = hipblasSsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function function hipblasSsyr2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy real(c_float),target,dimension(:) :: AP integer(c_int) :: lda ! hipblasSsyr2_rank_1 = hipblasSsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function function hipblasSsyr2_full_rank(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda ! hipblasSsyr2_full_rank = hipblasSsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDsyr2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda ! hipblasDsyr2_assumed_rank = hipblasDsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #else function hipblasDsyr2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: y integer(c_int) :: incy real(c_double),target :: AP integer(c_int) :: lda ! hipblasDsyr2_rank_0 = hipblasDsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function function hipblasDsyr2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy real(c_double),target,dimension(:) :: AP integer(c_int) :: lda ! hipblasDsyr2_rank_1 = hipblasDsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function function hipblasDsyr2_full_rank(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda ! hipblasDsyr2_full_rank = hipblasDsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCsyr2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda ! hipblasCsyr2_assumed_rank = hipblasCsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #else function hipblasCsyr2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy complex(c_float_complex),target :: AP integer(c_int) :: lda ! hipblasCsyr2_rank_0 = hipblasCsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function function hipblasCsyr2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda ! hipblasCsyr2_rank_1 = hipblasCsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function function hipblasCsyr2_full_rank(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda ! hipblasCsyr2_full_rank = hipblasCsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZsyr2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda ! hipblasZsyr2_assumed_rank = hipblasZsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #else function hipblasZsyr2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy complex(c_double_complex),target :: AP integer(c_int) :: lda ! hipblasZsyr2_rank_0 = hipblasZsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function function hipblasZsyr2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda ! hipblasZsyr2_rank_1 = hipblasZsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function function hipblasZsyr2_full_rank(handle,uplo,n,alpha,x,incx,y,incy,AP,lda) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda ! hipblasZsyr2_full_rank = hipblasZsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP),lda) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSsyr2StridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2StridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasSsyr2StridedBatched_assumed_rank = hipblasSsyr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #else function hipblasSsyr2StridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2StridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasSsyr2StridedBatched_rank_0 = hipblasSsyr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasSsyr2StridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2StridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasSsyr2StridedBatched_rank_1 = hipblasSsyr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasSsyr2StridedBatched_full_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2StridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasSsyr2StridedBatched_full_rank = hipblasSsyr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDsyr2StridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2StridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasDsyr2StridedBatched_assumed_rank = hipblasDsyr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #else function hipblasDsyr2StridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2StridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasDsyr2StridedBatched_rank_0 = hipblasDsyr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasDsyr2StridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2StridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasDsyr2StridedBatched_rank_1 = hipblasDsyr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasDsyr2StridedBatched_full_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2StridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasDsyr2StridedBatched_full_rank = hipblasDsyr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCsyr2StridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2StridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCsyr2StridedBatched_assumed_rank = hipblasCsyr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #else function hipblasCsyr2StridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2StridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCsyr2StridedBatched_rank_0 = hipblasCsyr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasCsyr2StridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2StridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCsyr2StridedBatched_rank_1 = hipblasCsyr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasCsyr2StridedBatched_full_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2StridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasCsyr2StridedBatched_full_rank = hipblasCsyr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZsyr2StridedBatched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2StridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZsyr2StridedBatched_assumed_rank = hipblasZsyr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #else function hipblasZsyr2StridedBatched_rank_0(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2StridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZsyr2StridedBatched_rank_0 = hipblasZsyr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasZsyr2StridedBatched_rank_1(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2StridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZsyr2StridedBatched_rank_1 = hipblasZsyr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function function hipblasZsyr2StridedBatched_full_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,AP,lda,strideA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2StridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batchCount ! hipblasZsyr2StridedBatched_full_rank = hipblasZsyr2StridedBatched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(AP),lda,strideA,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasStbmv_assumed_rank(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasStbmv_assumed_rank = hipblasStbmv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda, & c_loc(x),incx) end function #else function hipblasStbmv_rank_0(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target :: AP integer(c_int) :: lda real(c_float),target :: x integer(c_int) :: incx ! hipblasStbmv_rank_0 = hipblasStbmv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x),incx) end function function hipblasStbmv_rank_1(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! hipblasStbmv_rank_1 = hipblasStbmv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x),incx) end function function hipblasStbmv_full_rank(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! hipblasStbmv_full_rank = hipblasStbmv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x), & incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDtbmv_assumed_rank(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasDtbmv_assumed_rank = hipblasDtbmv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda, & c_loc(x),incx) end function #else function hipblasDtbmv_rank_0(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target :: AP integer(c_int) :: lda real(c_double),target :: x integer(c_int) :: incx ! hipblasDtbmv_rank_0 = hipblasDtbmv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x),incx) end function function hipblasDtbmv_rank_1(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! hipblasDtbmv_rank_1 = hipblasDtbmv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x),incx) end function function hipblasDtbmv_full_rank(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! hipblasDtbmv_full_rank = hipblasDtbmv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x), & incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCtbmv_assumed_rank(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasCtbmv_assumed_rank = hipblasCtbmv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda, & c_loc(x),incx) end function #else function hipblasCtbmv_rank_0(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx ! hipblasCtbmv_rank_0 = hipblasCtbmv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x),incx) end function function hipblasCtbmv_rank_1(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasCtbmv_rank_1 = hipblasCtbmv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x),incx) end function function hipblasCtbmv_full_rank(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasCtbmv_full_rank = hipblasCtbmv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x), & incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZtbmv_assumed_rank(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasZtbmv_assumed_rank = hipblasZtbmv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda, & c_loc(x),incx) end function #else function hipblasZtbmv_rank_0(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx ! hipblasZtbmv_rank_0 = hipblasZtbmv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x),incx) end function function hipblasZtbmv_rank_1(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasZtbmv_rank_1 = hipblasZtbmv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x),incx) end function function hipblasZtbmv_full_rank(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasZtbmv_full_rank = hipblasZtbmv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x), & incx) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasStbmvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,k,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStbmvStridedBatched_assumed_rank = hipblasStbmvStridedBatched_(handle,uplo,transA, & diag,n,k,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasStbmvStridedBatched_rank_0(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStbmvStridedBatched_rank_0 = hipblasStbmvStridedBatched_(handle,uplo,transA,diag,n,k, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasStbmvStridedBatched_rank_1(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStbmvStridedBatched_rank_1 = hipblasStbmvStridedBatched_(handle,uplo,transA,diag,n,k, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasStbmvStridedBatched_full_rank(handle,uplo,transA,diag,n,k,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbmvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStbmvStridedBatched_full_rank = hipblasStbmvStridedBatched_(handle,uplo,transA,diag, & n,k,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDtbmvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,k,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtbmvStridedBatched_assumed_rank = hipblasDtbmvStridedBatched_(handle,uplo,transA, & diag,n,k,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasDtbmvStridedBatched_rank_0(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtbmvStridedBatched_rank_0 = hipblasDtbmvStridedBatched_(handle,uplo,transA,diag,n,k, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasDtbmvStridedBatched_rank_1(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtbmvStridedBatched_rank_1 = hipblasDtbmvStridedBatched_(handle,uplo,transA,diag,n,k, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasDtbmvStridedBatched_full_rank(handle,uplo,transA,diag,n,k,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbmvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtbmvStridedBatched_full_rank = hipblasDtbmvStridedBatched_(handle,uplo,transA,diag, & n,k,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCtbmvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,k,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtbmvStridedBatched_assumed_rank = hipblasCtbmvStridedBatched_(handle,uplo,transA, & diag,n,k,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasCtbmvStridedBatched_rank_0(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtbmvStridedBatched_rank_0 = hipblasCtbmvStridedBatched_(handle,uplo,transA,diag,n,k, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasCtbmvStridedBatched_rank_1(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtbmvStridedBatched_rank_1 = hipblasCtbmvStridedBatched_(handle,uplo,transA,diag,n,k, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasCtbmvStridedBatched_full_rank(handle,uplo,transA,diag,n,k,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbmvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtbmvStridedBatched_full_rank = hipblasCtbmvStridedBatched_(handle,uplo,transA,diag, & n,k,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZtbmvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,k,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtbmvStridedBatched_assumed_rank = hipblasZtbmvStridedBatched_(handle,uplo,transA, & diag,n,k,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasZtbmvStridedBatched_rank_0(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtbmvStridedBatched_rank_0 = hipblasZtbmvStridedBatched_(handle,uplo,transA,diag,n,k, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasZtbmvStridedBatched_rank_1(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtbmvStridedBatched_rank_1 = hipblasZtbmvStridedBatched_(handle,uplo,transA,diag,n,k, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasZtbmvStridedBatched_full_rank(handle,uplo,transA,diag,n,k,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbmvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtbmvStridedBatched_full_rank = hipblasZtbmvStridedBatched_(handle,uplo,transA,diag, & n,k,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasStbsv_assumed_rank(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasStbsv_assumed_rank = hipblasStbsv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda, & c_loc(x),incx) end function #else function hipblasStbsv_rank_0(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target :: AP integer(c_int) :: lda real(c_float),target :: x integer(c_int) :: incx ! hipblasStbsv_rank_0 = hipblasStbsv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x),incx) end function function hipblasStbsv_rank_1(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! hipblasStbsv_rank_1 = hipblasStbsv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x),incx) end function function hipblasStbsv_full_rank(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! hipblasStbsv_full_rank = hipblasStbsv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x), & incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDtbsv_assumed_rank(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasDtbsv_assumed_rank = hipblasDtbsv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda, & c_loc(x),incx) end function #else function hipblasDtbsv_rank_0(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target :: AP integer(c_int) :: lda real(c_double),target :: x integer(c_int) :: incx ! hipblasDtbsv_rank_0 = hipblasDtbsv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x),incx) end function function hipblasDtbsv_rank_1(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! hipblasDtbsv_rank_1 = hipblasDtbsv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x),incx) end function function hipblasDtbsv_full_rank(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! hipblasDtbsv_full_rank = hipblasDtbsv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x), & incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCtbsv_assumed_rank(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasCtbsv_assumed_rank = hipblasCtbsv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda, & c_loc(x),incx) end function #else function hipblasCtbsv_rank_0(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx ! hipblasCtbsv_rank_0 = hipblasCtbsv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x),incx) end function function hipblasCtbsv_rank_1(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasCtbsv_rank_1 = hipblasCtbsv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x),incx) end function function hipblasCtbsv_full_rank(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasCtbsv_full_rank = hipblasCtbsv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x), & incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZtbsv_assumed_rank(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasZtbsv_assumed_rank = hipblasZtbsv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda, & c_loc(x),incx) end function #else function hipblasZtbsv_rank_0(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx ! hipblasZtbsv_rank_0 = hipblasZtbsv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x),incx) end function function hipblasZtbsv_rank_1(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasZtbsv_rank_1 = hipblasZtbsv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x),incx) end function function hipblasZtbsv_full_rank(handle,uplo,transA,diag,n,k,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasZtbsv_full_rank = hipblasZtbsv_(handle,uplo,transA,diag,n,k,c_loc(AP),lda,c_loc(x), & incx) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasStbsvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,k,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStbsvStridedBatched_assumed_rank = hipblasStbsvStridedBatched_(handle,uplo,transA, & diag,n,k,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasStbsvStridedBatched_rank_0(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStbsvStridedBatched_rank_0 = hipblasStbsvStridedBatched_(handle,uplo,transA,diag,n,k, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasStbsvStridedBatched_rank_1(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStbsvStridedBatched_rank_1 = hipblasStbsvStridedBatched_(handle,uplo,transA,diag,n,k, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasStbsvStridedBatched_full_rank(handle,uplo,transA,diag,n,k,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStbsvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStbsvStridedBatched_full_rank = hipblasStbsvStridedBatched_(handle,uplo,transA,diag, & n,k,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDtbsvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,k,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtbsvStridedBatched_assumed_rank = hipblasDtbsvStridedBatched_(handle,uplo,transA, & diag,n,k,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasDtbsvStridedBatched_rank_0(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtbsvStridedBatched_rank_0 = hipblasDtbsvStridedBatched_(handle,uplo,transA,diag,n,k, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasDtbsvStridedBatched_rank_1(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtbsvStridedBatched_rank_1 = hipblasDtbsvStridedBatched_(handle,uplo,transA,diag,n,k, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasDtbsvStridedBatched_full_rank(handle,uplo,transA,diag,n,k,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtbsvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtbsvStridedBatched_full_rank = hipblasDtbsvStridedBatched_(handle,uplo,transA,diag, & n,k,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCtbsvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,k,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtbsvStridedBatched_assumed_rank = hipblasCtbsvStridedBatched_(handle,uplo,transA, & diag,n,k,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasCtbsvStridedBatched_rank_0(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtbsvStridedBatched_rank_0 = hipblasCtbsvStridedBatched_(handle,uplo,transA,diag,n,k, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasCtbsvStridedBatched_rank_1(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtbsvStridedBatched_rank_1 = hipblasCtbsvStridedBatched_(handle,uplo,transA,diag,n,k, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasCtbsvStridedBatched_full_rank(handle,uplo,transA,diag,n,k,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtbsvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtbsvStridedBatched_full_rank = hipblasCtbsvStridedBatched_(handle,uplo,transA,diag, & n,k,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZtbsvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,k,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtbsvStridedBatched_assumed_rank = hipblasZtbsvStridedBatched_(handle,uplo,transA, & diag,n,k,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasZtbsvStridedBatched_rank_0(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtbsvStridedBatched_rank_0 = hipblasZtbsvStridedBatched_(handle,uplo,transA,diag,n,k, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasZtbsvStridedBatched_rank_1(handle,uplo,transA,diag,n,k,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtbsvStridedBatched_rank_1 = hipblasZtbsvStridedBatched_(handle,uplo,transA,diag,n,k, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasZtbsvStridedBatched_full_rank(handle,uplo,transA,diag,n,k,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtbsvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtbsvStridedBatched_full_rank = hipblasZtbsvStridedBatched_(handle,uplo,transA,diag, & n,k,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasStpmv_assumed_rank(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: AP real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasStpmv_assumed_rank = hipblasStpmv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #else function hipblasStpmv_rank_0(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target :: AP real(c_float),target :: x integer(c_int) :: incx ! hipblasStpmv_rank_0 = hipblasStpmv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function function hipblasStpmv_rank_1(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: AP real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! hipblasStpmv_rank_1 = hipblasStpmv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDtpmv_assumed_rank(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: AP real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasDtpmv_assumed_rank = hipblasDtpmv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #else function hipblasDtpmv_rank_0(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target :: AP real(c_double),target :: x integer(c_int) :: incx ! hipblasDtpmv_rank_0 = hipblasDtpmv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function function hipblasDtpmv_rank_1(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: AP real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! hipblasDtpmv_rank_1 = hipblasDtpmv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCtpmv_assumed_rank(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: AP complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasCtpmv_assumed_rank = hipblasCtpmv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #else function hipblasCtpmv_rank_0(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target :: AP complex(c_float_complex),target :: x integer(c_int) :: incx ! hipblasCtpmv_rank_0 = hipblasCtpmv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function function hipblasCtpmv_rank_1(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: AP complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasCtpmv_rank_1 = hipblasCtpmv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZtpmv_assumed_rank(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: AP complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasZtpmv_assumed_rank = hipblasZtpmv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #else function hipblasZtpmv_rank_0(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target :: AP complex(c_double_complex),target :: x integer(c_int) :: incx ! hipblasZtpmv_rank_0 = hipblasZtpmv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function function hipblasZtpmv_rank_1(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: AP complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasZtpmv_rank_1 = hipblasZtpmv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasStpmvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStpmvStridedBatched_assumed_rank = hipblasStpmvStridedBatched_(handle,uplo,transA, & diag,n,c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasStpmvStridedBatched_rank_0(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target :: AP integer(c_int64_t) :: strideA real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStpmvStridedBatched_rank_0 = hipblasStpmvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasStpmvStridedBatched_rank_1(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: AP integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStpmvStridedBatched_rank_1 = hipblasStpmvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDtpmvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtpmvStridedBatched_assumed_rank = hipblasDtpmvStridedBatched_(handle,uplo,transA, & diag,n,c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasDtpmvStridedBatched_rank_0(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target :: AP integer(c_int64_t) :: strideA real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtpmvStridedBatched_rank_0 = hipblasDtpmvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasDtpmvStridedBatched_rank_1(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: AP integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtpmvStridedBatched_rank_1 = hipblasDtpmvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCtpmvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtpmvStridedBatched_assumed_rank = hipblasCtpmvStridedBatched_(handle,uplo,transA, & diag,n,c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasCtpmvStridedBatched_rank_0(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target :: AP integer(c_int64_t) :: strideA complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtpmvStridedBatched_rank_0 = hipblasCtpmvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasCtpmvStridedBatched_rank_1(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: AP integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtpmvStridedBatched_rank_1 = hipblasCtpmvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZtpmvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtpmvStridedBatched_assumed_rank = hipblasZtpmvStridedBatched_(handle,uplo,transA, & diag,n,c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasZtpmvStridedBatched_rank_0(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target :: AP integer(c_int64_t) :: strideA complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtpmvStridedBatched_rank_0 = hipblasZtpmvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasZtpmvStridedBatched_rank_1(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: AP integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtpmvStridedBatched_rank_1 = hipblasZtpmvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasStpsv_assumed_rank(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpsv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: AP real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasStpsv_assumed_rank = hipblasStpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #else function hipblasStpsv_rank_0(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpsv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target :: AP real(c_float),target :: x integer(c_int) :: incx ! hipblasStpsv_rank_0 = hipblasStpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function function hipblasStpsv_rank_1(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpsv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: AP real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! hipblasStpsv_rank_1 = hipblasStpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDtpsv_assumed_rank(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpsv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: AP real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasDtpsv_assumed_rank = hipblasDtpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #else function hipblasDtpsv_rank_0(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpsv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target :: AP real(c_double),target :: x integer(c_int) :: incx ! hipblasDtpsv_rank_0 = hipblasDtpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function function hipblasDtpsv_rank_1(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpsv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: AP real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! hipblasDtpsv_rank_1 = hipblasDtpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCtpsv_assumed_rank(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpsv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: AP complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasCtpsv_assumed_rank = hipblasCtpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #else function hipblasCtpsv_rank_0(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpsv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target :: AP complex(c_float_complex),target :: x integer(c_int) :: incx ! hipblasCtpsv_rank_0 = hipblasCtpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function function hipblasCtpsv_rank_1(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpsv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: AP complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasCtpsv_rank_1 = hipblasCtpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZtpsv_assumed_rank(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpsv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: AP complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasZtpsv_assumed_rank = hipblasZtpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #else function hipblasZtpsv_rank_0(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpsv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target :: AP complex(c_double_complex),target :: x integer(c_int) :: incx ! hipblasZtpsv_rank_0 = hipblasZtpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function function hipblasZtpsv_rank_1(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpsv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: AP complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasZtpsv_rank_1 = hipblasZtpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasStpsvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpsvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStpsvStridedBatched_assumed_rank = hipblasStpsvStridedBatched_(handle,uplo,transA, & diag,n,c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasStpsvStridedBatched_rank_0(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpsvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target :: AP integer(c_int64_t) :: strideA real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStpsvStridedBatched_rank_0 = hipblasStpsvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasStpsvStridedBatched_rank_1(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStpsvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: AP integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStpsvStridedBatched_rank_1 = hipblasStpsvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDtpsvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpsvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtpsvStridedBatched_assumed_rank = hipblasDtpsvStridedBatched_(handle,uplo,transA, & diag,n,c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasDtpsvStridedBatched_rank_0(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpsvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target :: AP integer(c_int64_t) :: strideA real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtpsvStridedBatched_rank_0 = hipblasDtpsvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasDtpsvStridedBatched_rank_1(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtpsvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: AP integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtpsvStridedBatched_rank_1 = hipblasDtpsvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCtpsvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpsvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtpsvStridedBatched_assumed_rank = hipblasCtpsvStridedBatched_(handle,uplo,transA, & diag,n,c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasCtpsvStridedBatched_rank_0(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpsvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target :: AP integer(c_int64_t) :: strideA complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtpsvStridedBatched_rank_0 = hipblasCtpsvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasCtpsvStridedBatched_rank_1(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtpsvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: AP integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtpsvStridedBatched_rank_1 = hipblasCtpsvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZtpsvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpsvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtpsvStridedBatched_assumed_rank = hipblasZtpsvStridedBatched_(handle,uplo,transA, & diag,n,c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasZtpsvStridedBatched_rank_0(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpsvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target :: AP integer(c_int64_t) :: strideA complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtpsvStridedBatched_rank_0 = hipblasZtpsvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasZtpsvStridedBatched_rank_1(handle,uplo,transA,diag,n,AP,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtpsvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: AP integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtpsvStridedBatched_rank_1 = hipblasZtpsvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasStrmv_assumed_rank(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasStrmv_assumed_rank = hipblasStrmv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x), & incx) end function #else function hipblasStrmv_rank_0(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target :: AP integer(c_int) :: lda real(c_float),target :: x integer(c_int) :: incx ! hipblasStrmv_rank_0 = hipblasStrmv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function function hipblasStrmv_rank_1(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! hipblasStrmv_rank_1 = hipblasStrmv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function function hipblasStrmv_full_rank(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! hipblasStrmv_full_rank = hipblasStrmv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDtrmv_assumed_rank(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasDtrmv_assumed_rank = hipblasDtrmv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x), & incx) end function #else function hipblasDtrmv_rank_0(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target :: AP integer(c_int) :: lda real(c_double),target :: x integer(c_int) :: incx ! hipblasDtrmv_rank_0 = hipblasDtrmv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function function hipblasDtrmv_rank_1(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! hipblasDtrmv_rank_1 = hipblasDtrmv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function function hipblasDtrmv_full_rank(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! hipblasDtrmv_full_rank = hipblasDtrmv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCtrmv_assumed_rank(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasCtrmv_assumed_rank = hipblasCtrmv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x), & incx) end function #else function hipblasCtrmv_rank_0(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx ! hipblasCtrmv_rank_0 = hipblasCtrmv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function function hipblasCtrmv_rank_1(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasCtrmv_rank_1 = hipblasCtrmv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function function hipblasCtrmv_full_rank(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasCtrmv_full_rank = hipblasCtrmv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZtrmv_assumed_rank(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasZtrmv_assumed_rank = hipblasZtrmv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x), & incx) end function #else function hipblasZtrmv_rank_0(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx ! hipblasZtrmv_rank_0 = hipblasZtrmv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function function hipblasZtrmv_rank_1(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasZtrmv_rank_1 = hipblasZtrmv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function function hipblasZtrmv_full_rank(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasZtrmv_full_rank = hipblasZtrmv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasStrmvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStrmvStridedBatched_assumed_rank = hipblasStrmvStridedBatched_(handle,uplo,transA, & diag,n,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasStrmvStridedBatched_rank_0(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStrmvStridedBatched_rank_0 = hipblasStrmvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasStrmvStridedBatched_rank_1(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStrmvStridedBatched_rank_1 = hipblasStrmvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasStrmvStridedBatched_full_rank(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStrmvStridedBatched_full_rank = hipblasStrmvStridedBatched_(handle,uplo,transA,diag, & n,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDtrmvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtrmvStridedBatched_assumed_rank = hipblasDtrmvStridedBatched_(handle,uplo,transA, & diag,n,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasDtrmvStridedBatched_rank_0(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtrmvStridedBatched_rank_0 = hipblasDtrmvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasDtrmvStridedBatched_rank_1(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtrmvStridedBatched_rank_1 = hipblasDtrmvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasDtrmvStridedBatched_full_rank(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtrmvStridedBatched_full_rank = hipblasDtrmvStridedBatched_(handle,uplo,transA,diag, & n,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCtrmvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtrmvStridedBatched_assumed_rank = hipblasCtrmvStridedBatched_(handle,uplo,transA, & diag,n,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasCtrmvStridedBatched_rank_0(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtrmvStridedBatched_rank_0 = hipblasCtrmvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasCtrmvStridedBatched_rank_1(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtrmvStridedBatched_rank_1 = hipblasCtrmvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasCtrmvStridedBatched_full_rank(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtrmvStridedBatched_full_rank = hipblasCtrmvStridedBatched_(handle,uplo,transA,diag, & n,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZtrmvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtrmvStridedBatched_assumed_rank = hipblasZtrmvStridedBatched_(handle,uplo,transA, & diag,n,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasZtrmvStridedBatched_rank_0(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtrmvStridedBatched_rank_0 = hipblasZtrmvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasZtrmvStridedBatched_rank_1(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtrmvStridedBatched_rank_1 = hipblasZtrmvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasZtrmvStridedBatched_full_rank(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtrmvStridedBatched_full_rank = hipblasZtrmvStridedBatched_(handle,uplo,transA,diag, & n,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasStrsv_assumed_rank(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasStrsv_assumed_rank = hipblasStrsv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x), & incx) end function #else function hipblasStrsv_rank_0(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target :: AP integer(c_int) :: lda real(c_float),target :: x integer(c_int) :: incx ! hipblasStrsv_rank_0 = hipblasStrsv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function function hipblasStrsv_rank_1(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! hipblasStrsv_rank_1 = hipblasStrsv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function function hipblasStrsv_full_rank(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! hipblasStrsv_full_rank = hipblasStrsv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDtrsv_assumed_rank(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasDtrsv_assumed_rank = hipblasDtrsv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x), & incx) end function #else function hipblasDtrsv_rank_0(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target :: AP integer(c_int) :: lda real(c_double),target :: x integer(c_int) :: incx ! hipblasDtrsv_rank_0 = hipblasDtrsv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function function hipblasDtrsv_rank_1(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! hipblasDtrsv_rank_1 = hipblasDtrsv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function function hipblasDtrsv_full_rank(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! hipblasDtrsv_full_rank = hipblasDtrsv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCtrsv_assumed_rank(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasCtrsv_assumed_rank = hipblasCtrsv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x), & incx) end function #else function hipblasCtrsv_rank_0(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx ! hipblasCtrsv_rank_0 = hipblasCtrsv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function function hipblasCtrsv_rank_1(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasCtrsv_rank_1 = hipblasCtrsv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function function hipblasCtrsv_full_rank(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasCtrsv_full_rank = hipblasCtrsv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZtrsv_assumed_rank(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsv_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! hipblasZtrsv_assumed_rank = hipblasZtrsv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x), & incx) end function #else function hipblasZtrsv_rank_0(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsv_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx ! hipblasZtrsv_rank_0 = hipblasZtrsv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function function hipblasZtrsv_rank_1(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsv_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasZtrsv_rank_1 = hipblasZtrsv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function function hipblasZtrsv_full_rank(handle,uplo,transA,diag,n,AP,lda,x,incx) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsv_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! hipblasZtrsv_full_rank = hipblasZtrsv_(handle,uplo,transA,diag,n,c_loc(AP),lda,c_loc(x),incx) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasStrsvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStrsvStridedBatched_assumed_rank = hipblasStrsvStridedBatched_(handle,uplo,transA, & diag,n,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasStrsvStridedBatched_rank_0(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStrsvStridedBatched_rank_0 = hipblasStrsvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasStrsvStridedBatched_rank_1(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStrsvStridedBatched_rank_1 = hipblasStrsvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasStrsvStridedBatched_full_rank(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasStrsvStridedBatched_full_rank = hipblasStrsvStridedBatched_(handle,uplo,transA,diag, & n,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDtrsvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtrsvStridedBatched_assumed_rank = hipblasDtrsvStridedBatched_(handle,uplo,transA, & diag,n,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasDtrsvStridedBatched_rank_0(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtrsvStridedBatched_rank_0 = hipblasDtrsvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasDtrsvStridedBatched_rank_1(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtrsvStridedBatched_rank_1 = hipblasDtrsvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasDtrsvStridedBatched_full_rank(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasDtrsvStridedBatched_full_rank = hipblasDtrsvStridedBatched_(handle,uplo,transA,diag, & n,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCtrsvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtrsvStridedBatched_assumed_rank = hipblasCtrsvStridedBatched_(handle,uplo,transA, & diag,n,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasCtrsvStridedBatched_rank_0(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtrsvStridedBatched_rank_0 = hipblasCtrsvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasCtrsvStridedBatched_rank_1(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtrsvStridedBatched_rank_1 = hipblasCtrsvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasCtrsvStridedBatched_full_rank(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasCtrsvStridedBatched_full_rank = hipblasCtrsvStridedBatched_(handle,uplo,transA,diag, & n,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZtrsvStridedBatched_assumed_rank(handle,uplo,transA,diag,n,AP,lda,strideA,x, & incx,stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsvStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtrsvStridedBatched_assumed_rank = hipblasZtrsvStridedBatched_(handle,uplo,transA, & diag,n,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #else function hipblasZtrsvStridedBatched_rank_0(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsvStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtrsvStridedBatched_rank_0 = hipblasZtrsvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasZtrsvStridedBatched_rank_1(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsvStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtrsvStridedBatched_rank_1 = hipblasZtrsvStridedBatched_(handle,uplo,transA,diag,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function function hipblasZtrsvStridedBatched_full_rank(handle,uplo,transA,diag,n,AP,lda,strideA,x,incx, & stridex,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsvStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batchCount ! hipblasZtrsvStridedBatched_full_rank = hipblasZtrsvStridedBatched_(handle,uplo,transA,diag, & n,c_loc(AP),lda,strideA,c_loc(x),incx,stridex,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSgemm_assumed_rank(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasSgemm_assumed_rank = hipblasSgemm_(handle,transA,transB,m,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasSgemm_rank_0(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda real(c_float),target :: BP integer(c_int) :: ldb real(c_float) :: beta real(c_float),target :: CP integer(c_int) :: ldc ! hipblasSgemm_rank_0 = hipblasSgemm_(handle,transA,transB,m,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function function hipblasSgemm_rank_1(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: BP integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasSgemm_rank_1 = hipblasSgemm_(handle,transA,transB,m,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function function hipblasSgemm_full_rank(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:,:) :: BP integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasSgemm_full_rank = hipblasSgemm_(handle,transA,transB,m,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDgemm_assumed_rank(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasDgemm_assumed_rank = hipblasDgemm_(handle,transA,transB,m,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasDgemm_rank_0(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda real(c_double),target :: BP integer(c_int) :: ldb real(c_double) :: beta real(c_double),target :: CP integer(c_int) :: ldc ! hipblasDgemm_rank_0 = hipblasDgemm_(handle,transA,transB,m,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function function hipblasDgemm_rank_1(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: BP integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasDgemm_rank_1 = hipblasDgemm_(handle,transA,transB,m,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function function hipblasDgemm_full_rank(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:,:) :: BP integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasDgemm_full_rank = hipblasDgemm_(handle,transA,transB,m,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCgemm_assumed_rank(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasCgemm_assumed_rank = hipblasCgemm_(handle,transA,transB,m,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasCgemm_rank_0(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex),target :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target :: CP integer(c_int) :: ldc ! hipblasCgemm_rank_0 = hipblasCgemm_(handle,transA,transB,m,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function function hipblasCgemm_rank_1(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasCgemm_rank_1 = hipblasCgemm_(handle,transA,transB,m,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function function hipblasCgemm_full_rank(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasCgemm_full_rank = hipblasCgemm_(handle,transA,transB,m,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZgemm_assumed_rank(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasZgemm_assumed_rank = hipblasZgemm_(handle,transA,transB,m,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasZgemm_rank_0(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex),target :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target :: CP integer(c_int) :: ldc ! hipblasZgemm_rank_0 = hipblasZgemm_(handle,transA,transB,m,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function function hipblasZgemm_rank_1(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasZgemm_rank_1 = hipblasZgemm_(handle,transA,transB,m,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function function hipblasZgemm_full_rank(handle,transA,transB,m,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasZgemm_full_rank = hipblasZgemm_(handle,transA,transB,m,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSgemmStridedBatched_assumed_rank(handle,transA,transB,m,n,k,alpha,AP,lda, & strideA,BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSgemmStridedBatched_assumed_rank = hipblasSgemmStridedBatched_(handle,transA,transB, & m,n,k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC, & batchCount) end function #else function hipblasSgemmStridedBatched_rank_0(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta real(c_float),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSgemmStridedBatched_rank_0 = hipblasSgemmStridedBatched_(handle,transA,transB,m,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasSgemmStridedBatched_rank_1(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta real(c_float),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSgemmStridedBatched_rank_1 = hipblasSgemmStridedBatched_(handle,transA,transB,m,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasSgemmStridedBatched_full_rank(handle,transA,transB,m,n,k,alpha,AP,lda,strideA, & BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgemmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta real(c_float),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSgemmStridedBatched_full_rank = hipblasSgemmStridedBatched_(handle,transA,transB,m,n, & k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDgemmStridedBatched_assumed_rank(handle,transA,transB,m,n,k,alpha,AP,lda, & strideA,BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDgemmStridedBatched_assumed_rank = hipblasDgemmStridedBatched_(handle,transA,transB, & m,n,k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC, & batchCount) end function #else function hipblasDgemmStridedBatched_rank_0(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta real(c_double),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDgemmStridedBatched_rank_0 = hipblasDgemmStridedBatched_(handle,transA,transB,m,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasDgemmStridedBatched_rank_1(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta real(c_double),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDgemmStridedBatched_rank_1 = hipblasDgemmStridedBatched_(handle,transA,transB,m,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasDgemmStridedBatched_full_rank(handle,transA,transB,m,n,k,alpha,AP,lda,strideA, & BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgemmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta real(c_double),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDgemmStridedBatched_full_rank = hipblasDgemmStridedBatched_(handle,transA,transB,m,n, & k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCgemmStridedBatched_assumed_rank(handle,transA,transB,m,n,k,alpha,AP,lda, & strideA,BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCgemmStridedBatched_assumed_rank = hipblasCgemmStridedBatched_(handle,transA,transB, & m,n,k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC, & batchCount) end function #else function hipblasCgemmStridedBatched_rank_0(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCgemmStridedBatched_rank_0 = hipblasCgemmStridedBatched_(handle,transA,transB,m,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCgemmStridedBatched_rank_1(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCgemmStridedBatched_rank_1 = hipblasCgemmStridedBatched_(handle,transA,transB,m,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCgemmStridedBatched_full_rank(handle,transA,transB,m,n,k,alpha,AP,lda,strideA, & BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgemmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCgemmStridedBatched_full_rank = hipblasCgemmStridedBatched_(handle,transA,transB,m,n, & k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZgemmStridedBatched_assumed_rank(handle,transA,transB,m,n,k,alpha,AP,lda, & strideA,BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZgemmStridedBatched_assumed_rank = hipblasZgemmStridedBatched_(handle,transA,transB, & m,n,k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC, & batchCount) end function #else function hipblasZgemmStridedBatched_rank_0(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZgemmStridedBatched_rank_0 = hipblasZgemmStridedBatched_(handle,transA,transB,m,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZgemmStridedBatched_rank_1(handle,transA,transB,m,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZgemmStridedBatched_rank_1 = hipblasZgemmStridedBatched_(handle,transA,transB,m,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZgemmStridedBatched_full_rank(handle,transA,transB,m,n,k,alpha,AP,lda,strideA, & BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgemmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZgemmStridedBatched_full_rank = hipblasZgemmStridedBatched_(handle,transA,transB,m,n, & k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCherk_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherk_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_float) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasCherk_assumed_rank = hipblasCherk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function #else function hipblasCherk_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherk_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda real(c_float) :: beta complex(c_float_complex),target :: CP integer(c_int) :: ldc ! hipblasCherk_rank_0 = hipblasCherk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function function hipblasCherk_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherk_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda real(c_float) :: beta complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasCherk_rank_1 = hipblasCherk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function function hipblasCherk_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherk_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_float) :: beta complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasCherk_full_rank = hipblasCherk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZherk_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherk_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_double) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasZherk_assumed_rank = hipblasZherk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function #else function hipblasZherk_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherk_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda real(c_double) :: beta complex(c_double_complex),target :: CP integer(c_int) :: ldc ! hipblasZherk_rank_0 = hipblasZherk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function function hipblasZherk_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherk_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda real(c_double) :: beta complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasZherk_rank_1 = hipblasZherk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function function hipblasZherk_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherk_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_double) :: beta complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasZherk_full_rank = hipblasZherk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCherkStridedBatched_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCherkStridedBatched_assumed_rank = hipblasCherkStridedBatched_(handle,uplo,transA,n, & k,alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasCherkStridedBatched_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta, & CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float) :: beta complex(c_float_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCherkStridedBatched_rank_0 = hipblasCherkStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCherkStridedBatched_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta, & CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float) :: beta complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCherkStridedBatched_rank_1 = hipblasCherkStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCherkStridedBatched_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float) :: beta complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCherkStridedBatched_full_rank = hipblasCherkStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZherkStridedBatched_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZherkStridedBatched_assumed_rank = hipblasZherkStridedBatched_(handle,uplo,transA,n, & k,alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasZherkStridedBatched_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta, & CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double) :: beta complex(c_double_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZherkStridedBatched_rank_0 = hipblasZherkStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZherkStridedBatched_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta, & CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double) :: beta complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZherkStridedBatched_rank_1 = hipblasZherkStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZherkStridedBatched_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double) :: beta complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZherkStridedBatched_full_rank = hipblasZherkStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCherkx_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkx_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb real(c_float) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasCherkx_assumed_rank = hipblasCherkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasCherkx_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkx_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex),target :: BP integer(c_int) :: ldb real(c_float) :: beta complex(c_float_complex),target :: CP integer(c_int) :: ldc ! hipblasCherkx_rank_0 = hipblasCherkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasCherkx_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkx_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: BP integer(c_int) :: ldb real(c_float) :: beta complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasCherkx_rank_1 = hipblasCherkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasCherkx_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkx_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb real(c_float) :: beta complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasCherkx_full_rank = hipblasCherkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZherkx_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkx_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb real(c_double) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasZherkx_assumed_rank = hipblasZherkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasZherkx_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkx_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex),target :: BP integer(c_int) :: ldb real(c_double) :: beta complex(c_double_complex),target :: CP integer(c_int) :: ldc ! hipblasZherkx_rank_0 = hipblasZherkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasZherkx_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkx_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: BP integer(c_int) :: ldb real(c_double) :: beta complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasZherkx_rank_1 = hipblasZherkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasZherkx_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkx_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb real(c_double) :: beta complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasZherkx_full_rank = hipblasZherkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCherkxStridedBatched_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkxStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCherkxStridedBatched_assumed_rank = hipblasCherkxStridedBatched_(handle,uplo,transA, & n,k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasCherkxStridedBatched_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkxStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta complex(c_float_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCherkxStridedBatched_rank_0 = hipblasCherkxStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCherkxStridedBatched_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkxStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCherkxStridedBatched_rank_1 = hipblasCherkxStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCherkxStridedBatched_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCherkxStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCherkxStridedBatched_full_rank = hipblasCherkxStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZherkxStridedBatched_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkxStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZherkxStridedBatched_assumed_rank = hipblasZherkxStridedBatched_(handle,uplo,transA, & n,k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasZherkxStridedBatched_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkxStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta complex(c_double_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZherkxStridedBatched_rank_0 = hipblasZherkxStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZherkxStridedBatched_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkxStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZherkxStridedBatched_rank_1 = hipblasZherkxStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZherkxStridedBatched_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZherkxStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZherkxStridedBatched_full_rank = hipblasZherkxStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCher2k_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2k_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb real(c_float) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasCher2k_assumed_rank = hipblasCher2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasCher2k_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2k_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex),target :: BP integer(c_int) :: ldb real(c_float) :: beta complex(c_float_complex),target :: CP integer(c_int) :: ldc ! hipblasCher2k_rank_0 = hipblasCher2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasCher2k_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2k_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: BP integer(c_int) :: ldb real(c_float) :: beta complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasCher2k_rank_1 = hipblasCher2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasCher2k_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2k_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb real(c_float) :: beta complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasCher2k_full_rank = hipblasCher2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZher2k_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2k_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb real(c_double) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasZher2k_assumed_rank = hipblasZher2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasZher2k_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2k_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex),target :: BP integer(c_int) :: ldb real(c_double) :: beta complex(c_double_complex),target :: CP integer(c_int) :: ldc ! hipblasZher2k_rank_0 = hipblasZher2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasZher2k_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2k_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: BP integer(c_int) :: ldb real(c_double) :: beta complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasZher2k_rank_1 = hipblasZher2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasZher2k_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2k_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb real(c_double) :: beta complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasZher2k_full_rank = hipblasZher2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCher2kStridedBatched_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2kStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCher2kStridedBatched_assumed_rank = hipblasCher2kStridedBatched_(handle,uplo,transA, & n,k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasCher2kStridedBatched_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2kStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta complex(c_float_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCher2kStridedBatched_rank_0 = hipblasCher2kStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCher2kStridedBatched_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2kStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCher2kStridedBatched_rank_1 = hipblasCher2kStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCher2kStridedBatched_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCher2kStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCher2kStridedBatched_full_rank = hipblasCher2kStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZher2kStridedBatched_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2kStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZher2kStridedBatched_assumed_rank = hipblasZher2kStridedBatched_(handle,uplo,transA, & n,k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasZher2kStridedBatched_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2kStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta complex(c_double_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZher2kStridedBatched_rank_0 = hipblasZher2kStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZher2kStridedBatched_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2kStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZher2kStridedBatched_rank_1 = hipblasZher2kStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZher2kStridedBatched_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZher2kStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZher2kStridedBatched_full_rank = hipblasZher2kStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSsymm_assumed_rank(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasSsymm_assumed_rank = hipblasSsymm_(handle,side,uplo,m,n,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasSsymm_rank_0(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda real(c_float),target :: BP integer(c_int) :: ldb real(c_float) :: beta real(c_float),target :: CP integer(c_int) :: ldc ! hipblasSsymm_rank_0 = hipblasSsymm_(handle,side,uplo,m,n,alpha,c_loc(AP),lda,c_loc(BP),ldb, & beta,c_loc(CP),ldc) end function function hipblasSsymm_rank_1(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: BP integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasSsymm_rank_1 = hipblasSsymm_(handle,side,uplo,m,n,alpha,c_loc(AP),lda,c_loc(BP),ldb, & beta,c_loc(CP),ldc) end function function hipblasSsymm_full_rank(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:,:) :: BP integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasSsymm_full_rank = hipblasSsymm_(handle,side,uplo,m,n,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDsymm_assumed_rank(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasDsymm_assumed_rank = hipblasDsymm_(handle,side,uplo,m,n,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasDsymm_rank_0(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda real(c_double),target :: BP integer(c_int) :: ldb real(c_double) :: beta real(c_double),target :: CP integer(c_int) :: ldc ! hipblasDsymm_rank_0 = hipblasDsymm_(handle,side,uplo,m,n,alpha,c_loc(AP),lda,c_loc(BP),ldb, & beta,c_loc(CP),ldc) end function function hipblasDsymm_rank_1(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: BP integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasDsymm_rank_1 = hipblasDsymm_(handle,side,uplo,m,n,alpha,c_loc(AP),lda,c_loc(BP),ldb, & beta,c_loc(CP),ldc) end function function hipblasDsymm_full_rank(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:,:) :: BP integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasDsymm_full_rank = hipblasDsymm_(handle,side,uplo,m,n,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCsymm_assumed_rank(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasCsymm_assumed_rank = hipblasCsymm_(handle,side,uplo,m,n,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasCsymm_rank_0(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex),target :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target :: CP integer(c_int) :: ldc ! hipblasCsymm_rank_0 = hipblasCsymm_(handle,side,uplo,m,n,alpha,c_loc(AP),lda,c_loc(BP),ldb, & beta,c_loc(CP),ldc) end function function hipblasCsymm_rank_1(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasCsymm_rank_1 = hipblasCsymm_(handle,side,uplo,m,n,alpha,c_loc(AP),lda,c_loc(BP),ldb, & beta,c_loc(CP),ldc) end function function hipblasCsymm_full_rank(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasCsymm_full_rank = hipblasCsymm_(handle,side,uplo,m,n,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZsymm_assumed_rank(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasZsymm_assumed_rank = hipblasZsymm_(handle,side,uplo,m,n,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasZsymm_rank_0(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex),target :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target :: CP integer(c_int) :: ldc ! hipblasZsymm_rank_0 = hipblasZsymm_(handle,side,uplo,m,n,alpha,c_loc(AP),lda,c_loc(BP),ldb, & beta,c_loc(CP),ldc) end function function hipblasZsymm_rank_1(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasZsymm_rank_1 = hipblasZsymm_(handle,side,uplo,m,n,alpha,c_loc(AP),lda,c_loc(BP),ldb, & beta,c_loc(CP),ldc) end function function hipblasZsymm_full_rank(handle,side,uplo,m,n,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasZsymm_full_rank = hipblasZsymm_(handle,side,uplo,m,n,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSsymmStridedBatched_assumed_rank(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSsymmStridedBatched_assumed_rank = hipblasSsymmStridedBatched_(handle,side,uplo,m,n, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasSsymmStridedBatched_rank_0(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta real(c_float),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSsymmStridedBatched_rank_0 = hipblasSsymmStridedBatched_(handle,side,uplo,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasSsymmStridedBatched_rank_1(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta real(c_float),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSsymmStridedBatched_rank_1 = hipblasSsymmStridedBatched_(handle,side,uplo,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasSsymmStridedBatched_full_rank(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsymmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta real(c_float),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSsymmStridedBatched_full_rank = hipblasSsymmStridedBatched_(handle,side,uplo,m,n, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDsymmStridedBatched_assumed_rank(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDsymmStridedBatched_assumed_rank = hipblasDsymmStridedBatched_(handle,side,uplo,m,n, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasDsymmStridedBatched_rank_0(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta real(c_double),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDsymmStridedBatched_rank_0 = hipblasDsymmStridedBatched_(handle,side,uplo,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasDsymmStridedBatched_rank_1(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta real(c_double),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDsymmStridedBatched_rank_1 = hipblasDsymmStridedBatched_(handle,side,uplo,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasDsymmStridedBatched_full_rank(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsymmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta real(c_double),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDsymmStridedBatched_full_rank = hipblasDsymmStridedBatched_(handle,side,uplo,m,n, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCsymmStridedBatched_assumed_rank(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCsymmStridedBatched_assumed_rank = hipblasCsymmStridedBatched_(handle,side,uplo,m,n, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasCsymmStridedBatched_rank_0(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCsymmStridedBatched_rank_0 = hipblasCsymmStridedBatched_(handle,side,uplo,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCsymmStridedBatched_rank_1(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCsymmStridedBatched_rank_1 = hipblasCsymmStridedBatched_(handle,side,uplo,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCsymmStridedBatched_full_rank(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsymmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCsymmStridedBatched_full_rank = hipblasCsymmStridedBatched_(handle,side,uplo,m,n, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZsymmStridedBatched_assumed_rank(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZsymmStridedBatched_assumed_rank = hipblasZsymmStridedBatched_(handle,side,uplo,m,n, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasZsymmStridedBatched_rank_0(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZsymmStridedBatched_rank_0 = hipblasZsymmStridedBatched_(handle,side,uplo,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZsymmStridedBatched_rank_1(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZsymmStridedBatched_rank_1 = hipblasZsymmStridedBatched_(handle,side,uplo,m,n,alpha, & c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZsymmStridedBatched_full_rank(handle,side,uplo,m,n,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsymmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZsymmStridedBatched_full_rank = hipblasZsymmStridedBatched_(handle,side,uplo,m,n, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSsyrk_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrk_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasSsyrk_assumed_rank = hipblasSsyrk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function #else function hipblasSsyrk_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrk_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda real(c_float) :: beta real(c_float),target :: CP integer(c_int) :: ldc ! hipblasSsyrk_rank_0 = hipblasSsyrk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function function hipblasSsyrk_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrk_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda real(c_float) :: beta real(c_float),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasSsyrk_rank_1 = hipblasSsyrk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function function hipblasSsyrk_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrk_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_float) :: beta real(c_float),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasSsyrk_full_rank = hipblasSsyrk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDsyrk_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrk_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasDsyrk_assumed_rank = hipblasDsyrk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function #else function hipblasDsyrk_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrk_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda real(c_double) :: beta real(c_double),target :: CP integer(c_int) :: ldc ! hipblasDsyrk_rank_0 = hipblasDsyrk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function function hipblasDsyrk_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrk_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda real(c_double) :: beta real(c_double),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasDsyrk_rank_1 = hipblasDsyrk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function function hipblasDsyrk_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrk_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_double) :: beta real(c_double),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasDsyrk_full_rank = hipblasDsyrk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCsyrk_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrk_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasCsyrk_assumed_rank = hipblasCsyrk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function #else function hipblasCsyrk_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrk_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex) :: beta complex(c_float_complex),target :: CP integer(c_int) :: ldc ! hipblasCsyrk_rank_0 = hipblasCsyrk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function function hipblasCsyrk_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrk_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasCsyrk_rank_1 = hipblasCsyrk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function function hipblasCsyrk_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrk_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasCsyrk_full_rank = hipblasCsyrk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZsyrk_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrk_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasZsyrk_assumed_rank = hipblasZsyrk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function #else function hipblasZsyrk_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrk_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex) :: beta complex(c_double_complex),target :: CP integer(c_int) :: ldc ! hipblasZsyrk_rank_0 = hipblasZsyrk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function function hipblasZsyrk_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrk_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasZsyrk_rank_1 = hipblasZsyrk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function function hipblasZsyrk_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrk_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasZsyrk_full_rank = hipblasZsyrk_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,beta, & c_loc(CP),ldc) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSsyrkStridedBatched_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSsyrkStridedBatched_assumed_rank = hipblasSsyrkStridedBatched_(handle,uplo,transA,n, & k,alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasSsyrkStridedBatched_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta, & CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float) :: beta real(c_float),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSsyrkStridedBatched_rank_0 = hipblasSsyrkStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasSsyrkStridedBatched_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta, & CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float) :: beta real(c_float),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSsyrkStridedBatched_rank_1 = hipblasSsyrkStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasSsyrkStridedBatched_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float) :: beta real(c_float),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSsyrkStridedBatched_full_rank = hipblasSsyrkStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDsyrkStridedBatched_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDsyrkStridedBatched_assumed_rank = hipblasDsyrkStridedBatched_(handle,uplo,transA,n, & k,alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasDsyrkStridedBatched_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta, & CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double) :: beta real(c_double),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDsyrkStridedBatched_rank_0 = hipblasDsyrkStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasDsyrkStridedBatched_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta, & CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double) :: beta real(c_double),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDsyrkStridedBatched_rank_1 = hipblasDsyrkStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasDsyrkStridedBatched_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double) :: beta real(c_double),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDsyrkStridedBatched_full_rank = hipblasDsyrkStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCsyrkStridedBatched_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCsyrkStridedBatched_assumed_rank = hipblasCsyrkStridedBatched_(handle,uplo,transA,n, & k,alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasCsyrkStridedBatched_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta, & CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex) :: beta complex(c_float_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCsyrkStridedBatched_rank_0 = hipblasCsyrkStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCsyrkStridedBatched_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta, & CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCsyrkStridedBatched_rank_1 = hipblasCsyrkStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCsyrkStridedBatched_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCsyrkStridedBatched_full_rank = hipblasCsyrkStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZsyrkStridedBatched_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZsyrkStridedBatched_assumed_rank = hipblasZsyrkStridedBatched_(handle,uplo,transA,n, & k,alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasZsyrkStridedBatched_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta, & CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex) :: beta complex(c_double_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZsyrkStridedBatched_rank_0 = hipblasZsyrkStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZsyrkStridedBatched_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,strideA,beta, & CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZsyrkStridedBatched_rank_1 = hipblasZsyrkStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZsyrkStridedBatched_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZsyrkStridedBatched_full_rank = hipblasZsyrkStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSsyr2k_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2k_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasSsyr2k_assumed_rank = hipblasSsyr2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasSsyr2k_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2k_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda real(c_float),target :: BP integer(c_int) :: ldb real(c_float) :: beta real(c_float),target :: CP integer(c_int) :: ldc ! hipblasSsyr2k_rank_0 = hipblasSsyr2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasSsyr2k_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2k_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: BP integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasSsyr2k_rank_1 = hipblasSsyr2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasSsyr2k_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2k_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:,:) :: BP integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasSsyr2k_full_rank = hipblasSsyr2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDsyr2k_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2k_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasDsyr2k_assumed_rank = hipblasDsyr2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasDsyr2k_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2k_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda real(c_double),target :: BP integer(c_int) :: ldb real(c_double) :: beta real(c_double),target :: CP integer(c_int) :: ldc ! hipblasDsyr2k_rank_0 = hipblasDsyr2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasDsyr2k_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2k_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: BP integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasDsyr2k_rank_1 = hipblasDsyr2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasDsyr2k_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2k_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:,:) :: BP integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasDsyr2k_full_rank = hipblasDsyr2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCsyr2k_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2k_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasCsyr2k_assumed_rank = hipblasCsyr2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasCsyr2k_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2k_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex),target :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target :: CP integer(c_int) :: ldc ! hipblasCsyr2k_rank_0 = hipblasCsyr2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasCsyr2k_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2k_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasCsyr2k_rank_1 = hipblasCsyr2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasCsyr2k_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2k_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasCsyr2k_full_rank = hipblasCsyr2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZsyr2k_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2k_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasZsyr2k_assumed_rank = hipblasZsyr2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasZsyr2k_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2k_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex),target :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target :: CP integer(c_int) :: ldc ! hipblasZsyr2k_rank_0 = hipblasZsyr2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasZsyr2k_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2k_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasZsyr2k_rank_1 = hipblasZsyr2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasZsyr2k_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2k_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasZsyr2k_full_rank = hipblasZsyr2k_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSsyr2kStridedBatched_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2kStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSsyr2kStridedBatched_assumed_rank = hipblasSsyr2kStridedBatched_(handle,uplo,transA, & n,k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasSsyr2kStridedBatched_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2kStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta real(c_float),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSsyr2kStridedBatched_rank_0 = hipblasSsyr2kStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasSsyr2kStridedBatched_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2kStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta real(c_float),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSsyr2kStridedBatched_rank_1 = hipblasSsyr2kStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasSsyr2kStridedBatched_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyr2kStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta real(c_float),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSsyr2kStridedBatched_full_rank = hipblasSsyr2kStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDsyr2kStridedBatched_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2kStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDsyr2kStridedBatched_assumed_rank = hipblasDsyr2kStridedBatched_(handle,uplo,transA, & n,k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasDsyr2kStridedBatched_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2kStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta real(c_double),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDsyr2kStridedBatched_rank_0 = hipblasDsyr2kStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasDsyr2kStridedBatched_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2kStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta real(c_double),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDsyr2kStridedBatched_rank_1 = hipblasDsyr2kStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasDsyr2kStridedBatched_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyr2kStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta real(c_double),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDsyr2kStridedBatched_full_rank = hipblasDsyr2kStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCsyr2kStridedBatched_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2kStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCsyr2kStridedBatched_assumed_rank = hipblasCsyr2kStridedBatched_(handle,uplo,transA, & n,k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasCsyr2kStridedBatched_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2kStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCsyr2kStridedBatched_rank_0 = hipblasCsyr2kStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCsyr2kStridedBatched_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2kStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCsyr2kStridedBatched_rank_1 = hipblasCsyr2kStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCsyr2kStridedBatched_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyr2kStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCsyr2kStridedBatched_full_rank = hipblasCsyr2kStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZsyr2kStridedBatched_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2kStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZsyr2kStridedBatched_assumed_rank = hipblasZsyr2kStridedBatched_(handle,uplo,transA, & n,k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasZsyr2kStridedBatched_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2kStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZsyr2kStridedBatched_rank_0 = hipblasZsyr2kStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZsyr2kStridedBatched_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2kStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZsyr2kStridedBatched_rank_1 = hipblasZsyr2kStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZsyr2kStridedBatched_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyr2kStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZsyr2kStridedBatched_full_rank = hipblasZsyr2kStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSsyrkx_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkx_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasSsyrkx_assumed_rank = hipblasSsyrkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasSsyrkx_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkx_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda real(c_float),target :: BP integer(c_int) :: ldb real(c_float) :: beta real(c_float),target :: CP integer(c_int) :: ldc ! hipblasSsyrkx_rank_0 = hipblasSsyrkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasSsyrkx_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkx_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: BP integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasSsyrkx_rank_1 = hipblasSsyrkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasSsyrkx_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkx_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:,:) :: BP integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasSsyrkx_full_rank = hipblasSsyrkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDsyrkx_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkx_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasDsyrkx_assumed_rank = hipblasDsyrkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasDsyrkx_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkx_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda real(c_double),target :: BP integer(c_int) :: ldb real(c_double) :: beta real(c_double),target :: CP integer(c_int) :: ldc ! hipblasDsyrkx_rank_0 = hipblasDsyrkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasDsyrkx_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkx_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: BP integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasDsyrkx_rank_1 = hipblasDsyrkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasDsyrkx_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkx_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:,:) :: BP integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasDsyrkx_full_rank = hipblasDsyrkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCsyrkx_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkx_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasCsyrkx_assumed_rank = hipblasCsyrkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasCsyrkx_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkx_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex),target :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target :: CP integer(c_int) :: ldc ! hipblasCsyrkx_rank_0 = hipblasCsyrkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasCsyrkx_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkx_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasCsyrkx_rank_1 = hipblasCsyrkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasCsyrkx_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkx_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasCsyrkx_full_rank = hipblasCsyrkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZsyrkx_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkx_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasZsyrkx_assumed_rank = hipblasZsyrkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasZsyrkx_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkx_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex),target :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target :: CP integer(c_int) :: ldc ! hipblasZsyrkx_rank_0 = hipblasZsyrkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasZsyrkx_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkx_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasZsyrkx_rank_1 = hipblasZsyrkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function function hipblasZsyrkx_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkx_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasZsyrkx_full_rank = hipblasZsyrkx_(handle,uplo,transA,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSsyrkxStridedBatched_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkxStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSsyrkxStridedBatched_assumed_rank = hipblasSsyrkxStridedBatched_(handle,uplo,transA, & n,k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasSsyrkxStridedBatched_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkxStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta real(c_float),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSsyrkxStridedBatched_rank_0 = hipblasSsyrkxStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasSsyrkxStridedBatched_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkxStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta real(c_float),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSsyrkxStridedBatched_rank_1 = hipblasSsyrkxStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasSsyrkxStridedBatched_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSsyrkxStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float) :: beta real(c_float),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSsyrkxStridedBatched_full_rank = hipblasSsyrkxStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDsyrkxStridedBatched_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkxStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDsyrkxStridedBatched_assumed_rank = hipblasDsyrkxStridedBatched_(handle,uplo,transA, & n,k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasDsyrkxStridedBatched_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkxStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta real(c_double),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDsyrkxStridedBatched_rank_0 = hipblasDsyrkxStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasDsyrkxStridedBatched_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkxStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta real(c_double),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDsyrkxStridedBatched_rank_1 = hipblasDsyrkxStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasDsyrkxStridedBatched_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDsyrkxStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double) :: beta real(c_double),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDsyrkxStridedBatched_full_rank = hipblasDsyrkxStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCsyrkxStridedBatched_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkxStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCsyrkxStridedBatched_assumed_rank = hipblasCsyrkxStridedBatched_(handle,uplo,transA, & n,k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasCsyrkxStridedBatched_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkxStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCsyrkxStridedBatched_rank_0 = hipblasCsyrkxStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCsyrkxStridedBatched_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkxStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCsyrkxStridedBatched_rank_1 = hipblasCsyrkxStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCsyrkxStridedBatched_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCsyrkxStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCsyrkxStridedBatched_full_rank = hipblasCsyrkxStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZsyrkxStridedBatched_assumed_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA, & BP,ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkxStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZsyrkxStridedBatched_assumed_rank = hipblasZsyrkxStridedBatched_(handle,uplo,transA, & n,k,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasZsyrkxStridedBatched_rank_0(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkxStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZsyrkxStridedBatched_rank_0 = hipblasZsyrkxStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZsyrkxStridedBatched_rank_1(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkxStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZsyrkxStridedBatched_rank_1 = hipblasZsyrkxStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZsyrkxStridedBatched_full_rank(handle,uplo,transA,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZsyrkxStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZsyrkxStridedBatched_full_rank = hipblasZsyrkxStridedBatched_(handle,uplo,transA,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSgeam_assumed_rank(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeam_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasSgeam_assumed_rank = hipblasSgeam_(handle,transA,transB,m,n,alpha,c_loc(AP),lda,beta, & c_loc(BP),ldb,c_loc(CP),ldc) end function #else function hipblasSgeam_rank_0(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeam_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda real(c_float) :: beta real(c_float),target :: BP integer(c_int) :: ldb real(c_float),target :: CP integer(c_int) :: ldc ! hipblasSgeam_rank_0 = hipblasSgeam_(handle,transA,transB,m,n,alpha,c_loc(AP),lda,beta, & c_loc(BP),ldb,c_loc(CP),ldc) end function function hipblasSgeam_rank_1(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeam_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda real(c_float) :: beta real(c_float),target,dimension(:) :: BP integer(c_int) :: ldb real(c_float),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasSgeam_rank_1 = hipblasSgeam_(handle,transA,transB,m,n,alpha,c_loc(AP),lda,beta, & c_loc(BP),ldb,c_loc(CP),ldc) end function function hipblasSgeam_full_rank(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeam_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_float) :: beta real(c_float),target,dimension(:,:) :: BP integer(c_int) :: ldb real(c_float),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasSgeam_full_rank = hipblasSgeam_(handle,transA,transB,m,n,alpha,c_loc(AP),lda,beta, & c_loc(BP),ldb,c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDgeam_assumed_rank(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeam_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasDgeam_assumed_rank = hipblasDgeam_(handle,transA,transB,m,n,alpha,c_loc(AP),lda,beta, & c_loc(BP),ldb,c_loc(CP),ldc) end function #else function hipblasDgeam_rank_0(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeam_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda real(c_double) :: beta real(c_double),target :: BP integer(c_int) :: ldb real(c_double),target :: CP integer(c_int) :: ldc ! hipblasDgeam_rank_0 = hipblasDgeam_(handle,transA,transB,m,n,alpha,c_loc(AP),lda,beta, & c_loc(BP),ldb,c_loc(CP),ldc) end function function hipblasDgeam_rank_1(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeam_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda real(c_double) :: beta real(c_double),target,dimension(:) :: BP integer(c_int) :: ldb real(c_double),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasDgeam_rank_1 = hipblasDgeam_(handle,transA,transB,m,n,alpha,c_loc(AP),lda,beta, & c_loc(BP),ldb,c_loc(CP),ldc) end function function hipblasDgeam_full_rank(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeam_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_double) :: beta real(c_double),target,dimension(:,:) :: BP integer(c_int) :: ldb real(c_double),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasDgeam_full_rank = hipblasDgeam_(handle,transA,transB,m,n,alpha,c_loc(AP),lda,beta, & c_loc(BP),ldb,c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCgeam_assumed_rank(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeam_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasCgeam_assumed_rank = hipblasCgeam_(handle,transA,transB,m,n,alpha,c_loc(AP),lda,beta, & c_loc(BP),ldb,c_loc(CP),ldc) end function #else function hipblasCgeam_rank_0(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeam_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex) :: beta complex(c_float_complex),target :: BP integer(c_int) :: ldb complex(c_float_complex),target :: CP integer(c_int) :: ldc ! hipblasCgeam_rank_0 = hipblasCgeam_(handle,transA,transB,m,n,alpha,c_loc(AP),lda,beta, & c_loc(BP),ldb,c_loc(CP),ldc) end function function hipblasCgeam_rank_1(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeam_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: BP integer(c_int) :: ldb complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasCgeam_rank_1 = hipblasCgeam_(handle,transA,transB,m,n,alpha,c_loc(AP),lda,beta, & c_loc(BP),ldb,c_loc(CP),ldc) end function function hipblasCgeam_full_rank(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeam_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasCgeam_full_rank = hipblasCgeam_(handle,transA,transB,m,n,alpha,c_loc(AP),lda,beta, & c_loc(BP),ldb,c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZgeam_assumed_rank(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeam_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasZgeam_assumed_rank = hipblasZgeam_(handle,transA,transB,m,n,alpha,c_loc(AP),lda,beta, & c_loc(BP),ldb,c_loc(CP),ldc) end function #else function hipblasZgeam_rank_0(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeam_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex) :: beta complex(c_double_complex),target :: BP integer(c_int) :: ldb complex(c_double_complex),target :: CP integer(c_int) :: ldc ! hipblasZgeam_rank_0 = hipblasZgeam_(handle,transA,transB,m,n,alpha,c_loc(AP),lda,beta, & c_loc(BP),ldb,c_loc(CP),ldc) end function function hipblasZgeam_rank_1(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeam_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: BP integer(c_int) :: ldb complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasZgeam_rank_1 = hipblasZgeam_(handle,transA,transB,m,n,alpha,c_loc(AP),lda,beta, & c_loc(BP),ldb,c_loc(CP),ldc) end function function hipblasZgeam_full_rank(handle,transA,transB,m,n,alpha,AP,lda,beta,BP,ldb,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeam_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasZgeam_full_rank = hipblasZgeam_(handle,transA,transB,m,n,alpha,c_loc(AP),lda,beta, & c_loc(BP),ldb,c_loc(CP),ldc) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSgeamStridedBatched_assumed_rank(handle,transA,transB,m,n,alpha,AP,lda, & strideA,beta,BP,ldb,strideB,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeamStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSgeamStridedBatched_assumed_rank = hipblasSgeamStridedBatched_(handle,transA,transB, & m,n,alpha,c_loc(AP),lda,strideA,beta,c_loc(BP),ldb,strideB,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasSgeamStridedBatched_rank_0(handle,transA,transB,m,n,alpha,AP,lda,strideA,beta, & BP,ldb,strideB,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeamStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float) :: beta real(c_float),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSgeamStridedBatched_rank_0 = hipblasSgeamStridedBatched_(handle,transA,transB,m,n, & alpha,c_loc(AP),lda,strideA,beta,c_loc(BP),ldb,strideB,c_loc(CP),ldc,strideC,batchCount) end function function hipblasSgeamStridedBatched_rank_1(handle,transA,transB,m,n,alpha,AP,lda,strideA,beta, & BP,ldb,strideB,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeamStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float) :: beta real(c_float),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSgeamStridedBatched_rank_1 = hipblasSgeamStridedBatched_(handle,transA,transB,m,n, & alpha,c_loc(AP),lda,strideA,beta,c_loc(BP),ldb,strideB,c_loc(CP),ldc,strideC,batchCount) end function function hipblasSgeamStridedBatched_full_rank(handle,transA,transB,m,n,alpha,AP,lda,strideA, & beta,BP,ldb,strideB,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeamStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float) :: beta real(c_float),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSgeamStridedBatched_full_rank = hipblasSgeamStridedBatched_(handle,transA,transB,m,n, & alpha,c_loc(AP),lda,strideA,beta,c_loc(BP),ldb,strideB,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDgeamStridedBatched_assumed_rank(handle,transA,transB,m,n,alpha,AP,lda, & strideA,beta,BP,ldb,strideB,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeamStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDgeamStridedBatched_assumed_rank = hipblasDgeamStridedBatched_(handle,transA,transB, & m,n,alpha,c_loc(AP),lda,strideA,beta,c_loc(BP),ldb,strideB,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasDgeamStridedBatched_rank_0(handle,transA,transB,m,n,alpha,AP,lda,strideA,beta, & BP,ldb,strideB,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeamStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double) :: beta real(c_double),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDgeamStridedBatched_rank_0 = hipblasDgeamStridedBatched_(handle,transA,transB,m,n, & alpha,c_loc(AP),lda,strideA,beta,c_loc(BP),ldb,strideB,c_loc(CP),ldc,strideC,batchCount) end function function hipblasDgeamStridedBatched_rank_1(handle,transA,transB,m,n,alpha,AP,lda,strideA,beta, & BP,ldb,strideB,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeamStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double) :: beta real(c_double),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDgeamStridedBatched_rank_1 = hipblasDgeamStridedBatched_(handle,transA,transB,m,n, & alpha,c_loc(AP),lda,strideA,beta,c_loc(BP),ldb,strideB,c_loc(CP),ldc,strideC,batchCount) end function function hipblasDgeamStridedBatched_full_rank(handle,transA,transB,m,n,alpha,AP,lda,strideA, & beta,BP,ldb,strideB,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeamStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double) :: beta real(c_double),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDgeamStridedBatched_full_rank = hipblasDgeamStridedBatched_(handle,transA,transB,m,n, & alpha,c_loc(AP),lda,strideA,beta,c_loc(BP),ldb,strideB,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCgeamStridedBatched_assumed_rank(handle,transA,transB,m,n,alpha,AP,lda, & strideA,beta,BP,ldb,strideB,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeamStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCgeamStridedBatched_assumed_rank = hipblasCgeamStridedBatched_(handle,transA,transB, & m,n,alpha,c_loc(AP),lda,strideA,beta,c_loc(BP),ldb,strideB,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasCgeamStridedBatched_rank_0(handle,transA,transB,m,n,alpha,AP,lda,strideA,beta, & BP,ldb,strideB,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeamStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex) :: beta complex(c_float_complex),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCgeamStridedBatched_rank_0 = hipblasCgeamStridedBatched_(handle,transA,transB,m,n, & alpha,c_loc(AP),lda,strideA,beta,c_loc(BP),ldb,strideB,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCgeamStridedBatched_rank_1(handle,transA,transB,m,n,alpha,AP,lda,strideA,beta, & BP,ldb,strideB,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeamStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCgeamStridedBatched_rank_1 = hipblasCgeamStridedBatched_(handle,transA,transB,m,n, & alpha,c_loc(AP),lda,strideA,beta,c_loc(BP),ldb,strideB,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCgeamStridedBatched_full_rank(handle,transA,transB,m,n,alpha,AP,lda,strideA, & beta,BP,ldb,strideB,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeamStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCgeamStridedBatched_full_rank = hipblasCgeamStridedBatched_(handle,transA,transB,m,n, & alpha,c_loc(AP),lda,strideA,beta,c_loc(BP),ldb,strideB,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZgeamStridedBatched_assumed_rank(handle,transA,transB,m,n,alpha,AP,lda, & strideA,beta,BP,ldb,strideB,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeamStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZgeamStridedBatched_assumed_rank = hipblasZgeamStridedBatched_(handle,transA,transB, & m,n,alpha,c_loc(AP),lda,strideA,beta,c_loc(BP),ldb,strideB,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasZgeamStridedBatched_rank_0(handle,transA,transB,m,n,alpha,AP,lda,strideA,beta, & BP,ldb,strideB,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeamStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex) :: beta complex(c_double_complex),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZgeamStridedBatched_rank_0 = hipblasZgeamStridedBatched_(handle,transA,transB,m,n, & alpha,c_loc(AP),lda,strideA,beta,c_loc(BP),ldb,strideB,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZgeamStridedBatched_rank_1(handle,transA,transB,m,n,alpha,AP,lda,strideA,beta, & BP,ldb,strideB,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeamStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZgeamStridedBatched_rank_1 = hipblasZgeamStridedBatched_(handle,transA,transB,m,n, & alpha,c_loc(AP),lda,strideA,beta,c_loc(BP),ldb,strideB,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZgeamStridedBatched_full_rank(handle,transA,transB,m,n,alpha,AP,lda,strideA, & beta,BP,ldb,strideB,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeamStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_OP_N)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZgeamStridedBatched_full_rank = hipblasZgeamStridedBatched_(handle,transA,transB,m,n, & alpha,c_loc(AP),lda,strideA,beta,c_loc(BP),ldb,strideB,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasChemm_assumed_rank(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasChemm_assumed_rank = hipblasChemm_(handle,side,uplo,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasChemm_rank_0(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex),target :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target :: CP integer(c_int) :: ldc ! hipblasChemm_rank_0 = hipblasChemm_(handle,side,uplo,n,k,alpha,c_loc(AP),lda,c_loc(BP),ldb, & beta,c_loc(CP),ldc) end function function hipblasChemm_rank_1(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasChemm_rank_1 = hipblasChemm_(handle,side,uplo,n,k,alpha,c_loc(AP),lda,c_loc(BP),ldb, & beta,c_loc(CP),ldc) end function function hipblasChemm_full_rank(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasChemm_full_rank = hipblasChemm_(handle,side,uplo,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZhemm_assumed_rank(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasZhemm_assumed_rank = hipblasZhemm_(handle,side,uplo,n,k,alpha,c_loc(AP),lda, & c_loc(BP),ldb,beta,c_loc(CP),ldc) end function #else function hipblasZhemm_rank_0(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex),target :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target :: CP integer(c_int) :: ldc ! hipblasZhemm_rank_0 = hipblasZhemm_(handle,side,uplo,n,k,alpha,c_loc(AP),lda,c_loc(BP),ldb, & beta,c_loc(CP),ldc) end function function hipblasZhemm_rank_1(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasZhemm_rank_1 = hipblasZhemm_(handle,side,uplo,n,k,alpha,c_loc(AP),lda,c_loc(BP),ldb, & beta,c_loc(CP),ldc) end function function hipblasZhemm_full_rank(handle,side,uplo,n,k,alpha,AP,lda,BP,ldb,beta,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasZhemm_full_rank = hipblasZhemm_(handle,side,uplo,n,k,alpha,c_loc(AP),lda,c_loc(BP), & ldb,beta,c_loc(CP),ldc) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasChemmStridedBatched_assumed_rank(handle,side,uplo,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasChemmStridedBatched_assumed_rank = hipblasChemmStridedBatched_(handle,side,uplo,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasChemmStridedBatched_rank_0(handle,side,uplo,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasChemmStridedBatched_rank_0 = hipblasChemmStridedBatched_(handle,side,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasChemmStridedBatched_rank_1(handle,side,uplo,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasChemmStridedBatched_rank_1 = hipblasChemmStridedBatched_(handle,side,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasChemmStridedBatched_full_rank(handle,side,uplo,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasChemmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasChemmStridedBatched_full_rank = hipblasChemmStridedBatched_(handle,side,uplo,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZhemmStridedBatched_assumed_rank(handle,side,uplo,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZhemmStridedBatched_assumed_rank = hipblasZhemmStridedBatched_(handle,side,uplo,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasZhemmStridedBatched_rank_0(handle,side,uplo,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZhemmStridedBatched_rank_0 = hipblasZhemmStridedBatched_(handle,side,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZhemmStridedBatched_rank_1(handle,side,uplo,n,k,alpha,AP,lda,strideA,BP,ldb, & strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZhemmStridedBatched_rank_1 = hipblasZhemmStridedBatched_(handle,side,uplo,n,k,alpha, & c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZhemmStridedBatched_full_rank(handle,side,uplo,n,k,alpha,AP,lda,strideA,BP, & ldb,strideB,beta,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZhemmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZhemmStridedBatched_full_rank = hipblasZhemmStridedBatched_(handle,side,uplo,n,k, & alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,beta,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasStrmm_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipblasStrmm_assumed_rank = hipblasStrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb,c_loc(C),ldc) end function #else function hipblasStrmm_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: B integer(c_int) :: ldb real(c_float),target :: C integer(c_int) :: ldc ! hipblasStrmm_rank_0 = hipblasStrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function function hipblasStrmm_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! hipblasStrmm_rank_1 = hipblasStrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function function hipblasStrmm_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipblasStrmm_full_rank = hipblasStrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDtrmm_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipblasDtrmm_assumed_rank = hipblasDtrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb,c_loc(C),ldc) end function #else function hipblasDtrmm_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: B integer(c_int) :: ldb real(c_double),target :: C integer(c_int) :: ldc ! hipblasDtrmm_rank_0 = hipblasDtrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function function hipblasDtrmm_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! hipblasDtrmm_rank_1 = hipblasDtrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function function hipblasDtrmm_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipblasDtrmm_full_rank = hipblasDtrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCtrmm_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipblasCtrmm_assumed_rank = hipblasCtrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb,c_loc(C),ldc) end function #else function hipblasCtrmm_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb complex(c_float_complex),target :: C integer(c_int) :: ldc ! hipblasCtrmm_rank_0 = hipblasCtrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function function hipblasCtrmm_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! hipblasCtrmm_rank_1 = hipblasCtrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function function hipblasCtrmm_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipblasCtrmm_full_rank = hipblasCtrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZtrmm_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipblasZtrmm_assumed_rank = hipblasZtrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb,c_loc(C),ldc) end function #else function hipblasZtrmm_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb complex(c_double_complex),target :: C integer(c_int) :: ldc ! hipblasZtrmm_rank_0 = hipblasZtrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function function hipblasZtrmm_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! hipblasZtrmm_rank_1 = hipblasZtrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function function hipblasZtrmm_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipblasZtrmm_full_rank = hipblasZtrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasStrmmStridedBatched_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & strideA,B,ldb,strideB,C,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasStrmmStridedBatched_assumed_rank = hipblasStrmmStridedBatched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(C),ldc,strideC, & batchCount) end function #else function hipblasStrmmStridedBatched_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & strideA,B,ldb,strideB,C,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasStrmmStridedBatched_rank_0 = hipblasStrmmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(C),ldc,strideC,batchCount) end function function hipblasStrmmStridedBatched_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & strideA,B,ldb,strideB,C,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasStrmmStridedBatched_rank_1 = hipblasStrmmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(C),ldc,strideC,batchCount) end function function hipblasStrmmStridedBatched_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & strideA,B,ldb,strideB,C,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrmmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasStrmmStridedBatched_full_rank = hipblasStrmmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(C),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDtrmmStridedBatched_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & strideA,B,ldb,strideB,C,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDtrmmStridedBatched_assumed_rank = hipblasDtrmmStridedBatched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(C),ldc,strideC, & batchCount) end function #else function hipblasDtrmmStridedBatched_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & strideA,B,ldb,strideB,C,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDtrmmStridedBatched_rank_0 = hipblasDtrmmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(C),ldc,strideC,batchCount) end function function hipblasDtrmmStridedBatched_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & strideA,B,ldb,strideB,C,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDtrmmStridedBatched_rank_1 = hipblasDtrmmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(C),ldc,strideC,batchCount) end function function hipblasDtrmmStridedBatched_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & strideA,B,ldb,strideB,C,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrmmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDtrmmStridedBatched_full_rank = hipblasDtrmmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(C),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCtrmmStridedBatched_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & strideA,B,ldb,strideB,C,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCtrmmStridedBatched_assumed_rank = hipblasCtrmmStridedBatched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(C),ldc,strideC, & batchCount) end function #else function hipblasCtrmmStridedBatched_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & strideA,B,ldb,strideB,C,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCtrmmStridedBatched_rank_0 = hipblasCtrmmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(C),ldc,strideC,batchCount) end function function hipblasCtrmmStridedBatched_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & strideA,B,ldb,strideB,C,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCtrmmStridedBatched_rank_1 = hipblasCtrmmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(C),ldc,strideC,batchCount) end function function hipblasCtrmmStridedBatched_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & strideA,B,ldb,strideB,C,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrmmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCtrmmStridedBatched_full_rank = hipblasCtrmmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(C),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZtrmmStridedBatched_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & strideA,B,ldb,strideB,C,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZtrmmStridedBatched_assumed_rank = hipblasZtrmmStridedBatched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(C),ldc,strideC, & batchCount) end function #else function hipblasZtrmmStridedBatched_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & strideA,B,ldb,strideB,C,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZtrmmStridedBatched_rank_0 = hipblasZtrmmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(C),ldc,strideC,batchCount) end function function hipblasZtrmmStridedBatched_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & strideA,B,ldb,strideB,C,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZtrmmStridedBatched_rank_1 = hipblasZtrmmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(C),ldc,strideC,batchCount) end function function hipblasZtrmmStridedBatched_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & strideA,B,ldb,strideB,C,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrmmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZtrmmStridedBatched_full_rank = hipblasZtrmmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(C),ldc,strideC,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasStrsm_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb ! hipblasStrsm_assumed_rank = hipblasStrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(AP), & lda,c_loc(BP),ldb) end function #else function hipblasStrsm_rank_0(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda real(c_float),target :: BP integer(c_int) :: ldb ! hipblasStrsm_rank_0 = hipblasStrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(AP),lda, & c_loc(BP),ldb) end function function hipblasStrsm_rank_1(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: BP integer(c_int) :: ldb ! hipblasStrsm_rank_1 = hipblasStrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(AP),lda, & c_loc(BP),ldb) end function function hipblasStrsm_full_rank(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:,:) :: BP integer(c_int) :: ldb ! hipblasStrsm_full_rank = hipblasStrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(AP),lda, & c_loc(BP),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDtrsm_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb ! hipblasDtrsm_assumed_rank = hipblasDtrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(AP), & lda,c_loc(BP),ldb) end function #else function hipblasDtrsm_rank_0(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda real(c_double),target :: BP integer(c_int) :: ldb ! hipblasDtrsm_rank_0 = hipblasDtrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(AP),lda, & c_loc(BP),ldb) end function function hipblasDtrsm_rank_1(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: BP integer(c_int) :: ldb ! hipblasDtrsm_rank_1 = hipblasDtrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(AP),lda, & c_loc(BP),ldb) end function function hipblasDtrsm_full_rank(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:,:) :: BP integer(c_int) :: ldb ! hipblasDtrsm_full_rank = hipblasDtrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(AP),lda, & c_loc(BP),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCtrsm_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb ! hipblasCtrsm_assumed_rank = hipblasCtrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(AP), & lda,c_loc(BP),ldb) end function #else function hipblasCtrsm_rank_0(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex),target :: BP integer(c_int) :: ldb ! hipblasCtrsm_rank_0 = hipblasCtrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(AP),lda, & c_loc(BP),ldb) end function function hipblasCtrsm_rank_1(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: BP integer(c_int) :: ldb ! hipblasCtrsm_rank_1 = hipblasCtrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(AP),lda, & c_loc(BP),ldb) end function function hipblasCtrsm_full_rank(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb ! hipblasCtrsm_full_rank = hipblasCtrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(AP),lda, & c_loc(BP),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZtrsm_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb ! hipblasZtrsm_assumed_rank = hipblasZtrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(AP), & lda,c_loc(BP),ldb) end function #else function hipblasZtrsm_rank_0(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex),target :: BP integer(c_int) :: ldb ! hipblasZtrsm_rank_0 = hipblasZtrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(AP),lda, & c_loc(BP),ldb) end function function hipblasZtrsm_rank_1(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: BP integer(c_int) :: ldb ! hipblasZtrsm_rank_1 = hipblasZtrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(AP),lda, & c_loc(BP),ldb) end function function hipblasZtrsm_full_rank(handle,side,uplo,transA,diag,m,n,alpha,AP,lda,BP,ldb) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb ! hipblasZtrsm_full_rank = hipblasZtrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(AP),lda, & c_loc(BP),ldb) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasStrsmStridedBatched_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,AP, & lda,strideA,BP,ldb,strideB,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batchCount ! hipblasStrsmStridedBatched_assumed_rank = hipblasStrsmStridedBatched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,batchCount) end function #else function hipblasStrsmStridedBatched_rank_0(handle,side,uplo,transA,diag,m,n,alpha,AP,lda, & strideA,BP,ldb,strideB,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batchCount ! hipblasStrsmStridedBatched_rank_0 = hipblasStrsmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,batchCount) end function function hipblasStrsmStridedBatched_rank_1(handle,side,uplo,transA,diag,m,n,alpha,AP,lda, & strideA,BP,ldb,strideB,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batchCount ! hipblasStrsmStridedBatched_rank_1 = hipblasStrsmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,batchCount) end function function hipblasStrsmStridedBatched_full_rank(handle,side,uplo,transA,diag,m,n,alpha,AP,lda, & strideA,BP,ldb,strideB,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrsmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batchCount ! hipblasStrsmStridedBatched_full_rank = hipblasStrsmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDtrsmStridedBatched_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,AP, & lda,strideA,BP,ldb,strideB,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batchCount ! hipblasDtrsmStridedBatched_assumed_rank = hipblasDtrsmStridedBatched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,batchCount) end function #else function hipblasDtrsmStridedBatched_rank_0(handle,side,uplo,transA,diag,m,n,alpha,AP,lda, & strideA,BP,ldb,strideB,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batchCount ! hipblasDtrsmStridedBatched_rank_0 = hipblasDtrsmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,batchCount) end function function hipblasDtrsmStridedBatched_rank_1(handle,side,uplo,transA,diag,m,n,alpha,AP,lda, & strideA,BP,ldb,strideB,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batchCount ! hipblasDtrsmStridedBatched_rank_1 = hipblasDtrsmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,batchCount) end function function hipblasDtrsmStridedBatched_full_rank(handle,side,uplo,transA,diag,m,n,alpha,AP,lda, & strideA,BP,ldb,strideB,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrsmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batchCount ! hipblasDtrsmStridedBatched_full_rank = hipblasDtrsmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCtrsmStridedBatched_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,AP, & lda,strideA,BP,ldb,strideB,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batchCount ! hipblasCtrsmStridedBatched_assumed_rank = hipblasCtrsmStridedBatched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,batchCount) end function #else function hipblasCtrsmStridedBatched_rank_0(handle,side,uplo,transA,diag,m,n,alpha,AP,lda, & strideA,BP,ldb,strideB,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batchCount ! hipblasCtrsmStridedBatched_rank_0 = hipblasCtrsmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,batchCount) end function function hipblasCtrsmStridedBatched_rank_1(handle,side,uplo,transA,diag,m,n,alpha,AP,lda, & strideA,BP,ldb,strideB,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batchCount ! hipblasCtrsmStridedBatched_rank_1 = hipblasCtrsmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,batchCount) end function function hipblasCtrsmStridedBatched_full_rank(handle,side,uplo,transA,diag,m,n,alpha,AP,lda, & strideA,BP,ldb,strideB,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrsmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batchCount ! hipblasCtrsmStridedBatched_full_rank = hipblasCtrsmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZtrsmStridedBatched_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,AP, & lda,strideA,BP,ldb,strideB,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batchCount ! hipblasZtrsmStridedBatched_assumed_rank = hipblasZtrsmStridedBatched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,batchCount) end function #else function hipblasZtrsmStridedBatched_rank_0(handle,side,uplo,transA,diag,m,n,alpha,AP,lda, & strideA,BP,ldb,strideB,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batchCount ! hipblasZtrsmStridedBatched_rank_0 = hipblasZtrsmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,batchCount) end function function hipblasZtrsmStridedBatched_rank_1(handle,side,uplo,transA,diag,m,n,alpha,AP,lda, & strideA,BP,ldb,strideB,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batchCount ! hipblasZtrsmStridedBatched_rank_1 = hipblasZtrsmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,batchCount) end function function hipblasZtrsmStridedBatched_full_rank(handle,side,uplo,transA,diag,m,n,alpha,AP,lda, & strideA,BP,ldb,strideB,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrsmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_OP_N)) :: transA integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:,:) :: BP integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batchCount ! hipblasZtrsmStridedBatched_full_rank = hipblasZtrsmStridedBatched_(handle,side,uplo,transA, & diag,m,n,alpha,c_loc(AP),lda,strideA,c_loc(BP),ldb,strideB,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasStrtri_assumed_rank(handle,uplo,diag,n,AP,lda,invA,ldinvA) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrtri_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: invA integer(c_int) :: ldinvA ! hipblasStrtri_assumed_rank = hipblasStrtri_(handle,uplo,diag,n,c_loc(AP),lda,c_loc(invA), & ldinvA) end function #else function hipblasStrtri_rank_0(handle,uplo,diag,n,AP,lda,invA,ldinvA) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrtri_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target :: AP integer(c_int) :: lda real(c_float),target :: invA integer(c_int) :: ldinvA ! hipblasStrtri_rank_0 = hipblasStrtri_(handle,uplo,diag,n,c_loc(AP),lda,c_loc(invA),ldinvA) end function function hipblasStrtri_rank_1(handle,uplo,diag,n,AP,lda,invA,ldinvA) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrtri_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: invA integer(c_int) :: ldinvA ! hipblasStrtri_rank_1 = hipblasStrtri_(handle,uplo,diag,n,c_loc(AP),lda,c_loc(invA),ldinvA) end function function hipblasStrtri_full_rank(handle,uplo,diag,n,AP,lda,invA,ldinvA) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrtri_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:,:) :: invA integer(c_int) :: ldinvA ! hipblasStrtri_full_rank = hipblasStrtri_(handle,uplo,diag,n,c_loc(AP),lda,c_loc(invA),ldinvA) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDtrtri_assumed_rank(handle,uplo,diag,n,AP,lda,invA,ldinvA) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrtri_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: invA integer(c_int) :: ldinvA ! hipblasDtrtri_assumed_rank = hipblasDtrtri_(handle,uplo,diag,n,c_loc(AP),lda,c_loc(invA), & ldinvA) end function #else function hipblasDtrtri_rank_0(handle,uplo,diag,n,AP,lda,invA,ldinvA) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrtri_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target :: AP integer(c_int) :: lda real(c_double),target :: invA integer(c_int) :: ldinvA ! hipblasDtrtri_rank_0 = hipblasDtrtri_(handle,uplo,diag,n,c_loc(AP),lda,c_loc(invA),ldinvA) end function function hipblasDtrtri_rank_1(handle,uplo,diag,n,AP,lda,invA,ldinvA) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrtri_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: invA integer(c_int) :: ldinvA ! hipblasDtrtri_rank_1 = hipblasDtrtri_(handle,uplo,diag,n,c_loc(AP),lda,c_loc(invA),ldinvA) end function function hipblasDtrtri_full_rank(handle,uplo,diag,n,AP,lda,invA,ldinvA) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrtri_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:,:) :: invA integer(c_int) :: ldinvA ! hipblasDtrtri_full_rank = hipblasDtrtri_(handle,uplo,diag,n,c_loc(AP),lda,c_loc(invA),ldinvA) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCtrtri_assumed_rank(handle,uplo,diag,n,AP,lda,invA,ldinvA) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrtri_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: invA integer(c_int) :: ldinvA ! hipblasCtrtri_assumed_rank = hipblasCtrtri_(handle,uplo,diag,n,c_loc(AP),lda,c_loc(invA), & ldinvA) end function #else function hipblasCtrtri_rank_0(handle,uplo,diag,n,AP,lda,invA,ldinvA) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrtri_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex),target :: invA integer(c_int) :: ldinvA ! hipblasCtrtri_rank_0 = hipblasCtrtri_(handle,uplo,diag,n,c_loc(AP),lda,c_loc(invA),ldinvA) end function function hipblasCtrtri_rank_1(handle,uplo,diag,n,AP,lda,invA,ldinvA) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrtri_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: invA integer(c_int) :: ldinvA ! hipblasCtrtri_rank_1 = hipblasCtrtri_(handle,uplo,diag,n,c_loc(AP),lda,c_loc(invA),ldinvA) end function function hipblasCtrtri_full_rank(handle,uplo,diag,n,AP,lda,invA,ldinvA) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrtri_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: invA integer(c_int) :: ldinvA ! hipblasCtrtri_full_rank = hipblasCtrtri_(handle,uplo,diag,n,c_loc(AP),lda,c_loc(invA),ldinvA) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZtrtri_assumed_rank(handle,uplo,diag,n,AP,lda,invA,ldinvA) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrtri_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: invA integer(c_int) :: ldinvA ! hipblasZtrtri_assumed_rank = hipblasZtrtri_(handle,uplo,diag,n,c_loc(AP),lda,c_loc(invA), & ldinvA) end function #else function hipblasZtrtri_rank_0(handle,uplo,diag,n,AP,lda,invA,ldinvA) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrtri_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex),target :: invA integer(c_int) :: ldinvA ! hipblasZtrtri_rank_0 = hipblasZtrtri_(handle,uplo,diag,n,c_loc(AP),lda,c_loc(invA),ldinvA) end function function hipblasZtrtri_rank_1(handle,uplo,diag,n,AP,lda,invA,ldinvA) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrtri_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: invA integer(c_int) :: ldinvA ! hipblasZtrtri_rank_1 = hipblasZtrtri_(handle,uplo,diag,n,c_loc(AP),lda,c_loc(invA),ldinvA) end function function hipblasZtrtri_full_rank(handle,uplo,diag,n,AP,lda,invA,ldinvA) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrtri_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: invA integer(c_int) :: ldinvA ! hipblasZtrtri_full_rank = hipblasZtrtri_(handle,uplo,diag,n,c_loc(AP),lda,c_loc(invA),ldinvA) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasStrtriStridedBatched_assumed_rank(handle,uplo,diag,n,AP,lda,strideA,invA, & ldinvA,stride_invA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrtriStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batchCount ! hipblasStrtriStridedBatched_assumed_rank = hipblasStrtriStridedBatched_(handle,uplo,diag,n, & c_loc(AP),lda,strideA,c_loc(invA),ldinvA,stride_invA,batchCount) end function #else function hipblasStrtriStridedBatched_rank_0(handle,uplo,diag,n,AP,lda,strideA,invA,ldinvA, & stride_invA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrtriStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batchCount ! hipblasStrtriStridedBatched_rank_0 = hipblasStrtriStridedBatched_(handle,uplo,diag,n, & c_loc(AP),lda,strideA,c_loc(invA),ldinvA,stride_invA,batchCount) end function function hipblasStrtriStridedBatched_rank_1(handle,uplo,diag,n,AP,lda,strideA,invA,ldinvA, & stride_invA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrtriStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batchCount ! hipblasStrtriStridedBatched_rank_1 = hipblasStrtriStridedBatched_(handle,uplo,diag,n, & c_loc(AP),lda,strideA,c_loc(invA),ldinvA,stride_invA,batchCount) end function function hipblasStrtriStridedBatched_full_rank(handle,uplo,diag,n,AP,lda,strideA,invA,ldinvA, & stride_invA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasStrtriStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:,:) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batchCount ! hipblasStrtriStridedBatched_full_rank = hipblasStrtriStridedBatched_(handle,uplo,diag,n, & c_loc(AP),lda,strideA,c_loc(invA),ldinvA,stride_invA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDtrtriStridedBatched_assumed_rank(handle,uplo,diag,n,AP,lda,strideA,invA, & ldinvA,stride_invA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrtriStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batchCount ! hipblasDtrtriStridedBatched_assumed_rank = hipblasDtrtriStridedBatched_(handle,uplo,diag,n, & c_loc(AP),lda,strideA,c_loc(invA),ldinvA,stride_invA,batchCount) end function #else function hipblasDtrtriStridedBatched_rank_0(handle,uplo,diag,n,AP,lda,strideA,invA,ldinvA, & stride_invA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrtriStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batchCount ! hipblasDtrtriStridedBatched_rank_0 = hipblasDtrtriStridedBatched_(handle,uplo,diag,n, & c_loc(AP),lda,strideA,c_loc(invA),ldinvA,stride_invA,batchCount) end function function hipblasDtrtriStridedBatched_rank_1(handle,uplo,diag,n,AP,lda,strideA,invA,ldinvA, & stride_invA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrtriStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batchCount ! hipblasDtrtriStridedBatched_rank_1 = hipblasDtrtriStridedBatched_(handle,uplo,diag,n, & c_loc(AP),lda,strideA,c_loc(invA),ldinvA,stride_invA,batchCount) end function function hipblasDtrtriStridedBatched_full_rank(handle,uplo,diag,n,AP,lda,strideA,invA,ldinvA, & stride_invA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDtrtriStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:,:) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batchCount ! hipblasDtrtriStridedBatched_full_rank = hipblasDtrtriStridedBatched_(handle,uplo,diag,n, & c_loc(AP),lda,strideA,c_loc(invA),ldinvA,stride_invA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCtrtriStridedBatched_assumed_rank(handle,uplo,diag,n,AP,lda,strideA,invA, & ldinvA,stride_invA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrtriStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batchCount ! hipblasCtrtriStridedBatched_assumed_rank = hipblasCtrtriStridedBatched_(handle,uplo,diag,n, & c_loc(AP),lda,strideA,c_loc(invA),ldinvA,stride_invA,batchCount) end function #else function hipblasCtrtriStridedBatched_rank_0(handle,uplo,diag,n,AP,lda,strideA,invA,ldinvA, & stride_invA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrtriStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batchCount ! hipblasCtrtriStridedBatched_rank_0 = hipblasCtrtriStridedBatched_(handle,uplo,diag,n, & c_loc(AP),lda,strideA,c_loc(invA),ldinvA,stride_invA,batchCount) end function function hipblasCtrtriStridedBatched_rank_1(handle,uplo,diag,n,AP,lda,strideA,invA,ldinvA, & stride_invA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrtriStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batchCount ! hipblasCtrtriStridedBatched_rank_1 = hipblasCtrtriStridedBatched_(handle,uplo,diag,n, & c_loc(AP),lda,strideA,c_loc(invA),ldinvA,stride_invA,batchCount) end function function hipblasCtrtriStridedBatched_full_rank(handle,uplo,diag,n,AP,lda,strideA,invA,ldinvA, & stride_invA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCtrtriStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:,:) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batchCount ! hipblasCtrtriStridedBatched_full_rank = hipblasCtrtriStridedBatched_(handle,uplo,diag,n, & c_loc(AP),lda,strideA,c_loc(invA),ldinvA,stride_invA,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZtrtriStridedBatched_assumed_rank(handle,uplo,diag,n,AP,lda,strideA,invA, & ldinvA,stride_invA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrtriStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batchCount ! hipblasZtrtriStridedBatched_assumed_rank = hipblasZtrtriStridedBatched_(handle,uplo,diag,n, & c_loc(AP),lda,strideA,c_loc(invA),ldinvA,stride_invA,batchCount) end function #else function hipblasZtrtriStridedBatched_rank_0(handle,uplo,diag,n,AP,lda,strideA,invA,ldinvA, & stride_invA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrtriStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batchCount ! hipblasZtrtriStridedBatched_rank_0 = hipblasZtrtriStridedBatched_(handle,uplo,diag,n, & c_loc(AP),lda,strideA,c_loc(invA),ldinvA,stride_invA,batchCount) end function function hipblasZtrtriStridedBatched_rank_1(handle,uplo,diag,n,AP,lda,strideA,invA,ldinvA, & stride_invA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrtriStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batchCount ! hipblasZtrtriStridedBatched_rank_1 = hipblasZtrtriStridedBatched_(handle,uplo,diag,n, & c_loc(AP),lda,strideA,c_loc(invA),ldinvA,stride_invA,batchCount) end function function hipblasZtrtriStridedBatched_full_rank(handle,uplo,diag,n,AP,lda,strideA,invA,ldinvA, & stride_invA,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZtrtriStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_FILL_MODE_UPPER)) :: uplo integer(kind(HIPBLAS_DIAG_NON_UNIT)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:,:) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batchCount ! hipblasZtrtriStridedBatched_full_rank = hipblasZtrtriStridedBatched_(handle,uplo,diag,n, & c_loc(AP),lda,strideA,c_loc(invA),ldinvA,stride_invA,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSdgmm_assumed_rank(handle,side,m,n,AP,lda,x,incx,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdgmm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasSdgmm_assumed_rank = hipblasSdgmm_(handle,side,m,n,c_loc(AP),lda,c_loc(x),incx, & c_loc(CP),ldc) end function #else function hipblasSdgmm_rank_0(handle,side,m,n,AP,lda,x,incx,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdgmm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target :: AP integer(c_int) :: lda real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: CP integer(c_int) :: ldc ! hipblasSdgmm_rank_0 = hipblasSdgmm_(handle,side,m,n,c_loc(AP),lda,c_loc(x),incx,c_loc(CP),ldc) end function function hipblasSdgmm_rank_1(handle,side,m,n,AP,lda,x,incx,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdgmm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasSdgmm_rank_1 = hipblasSdgmm_(handle,side,m,n,c_loc(AP),lda,c_loc(x),incx,c_loc(CP),ldc) end function function hipblasSdgmm_full_rank(handle,side,m,n,AP,lda,x,incx,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdgmm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasSdgmm_full_rank = hipblasSdgmm_(handle,side,m,n,c_loc(AP),lda,c_loc(x),incx, & c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDdgmm_assumed_rank(handle,side,m,n,AP,lda,x,incx,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdgmm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasDdgmm_assumed_rank = hipblasDdgmm_(handle,side,m,n,c_loc(AP),lda,c_loc(x),incx, & c_loc(CP),ldc) end function #else function hipblasDdgmm_rank_0(handle,side,m,n,AP,lda,x,incx,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdgmm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target :: AP integer(c_int) :: lda real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: CP integer(c_int) :: ldc ! hipblasDdgmm_rank_0 = hipblasDdgmm_(handle,side,m,n,c_loc(AP),lda,c_loc(x),incx,c_loc(CP),ldc) end function function hipblasDdgmm_rank_1(handle,side,m,n,AP,lda,x,incx,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdgmm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasDdgmm_rank_1 = hipblasDdgmm_(handle,side,m,n,c_loc(AP),lda,c_loc(x),incx,c_loc(CP),ldc) end function function hipblasDdgmm_full_rank(handle,side,m,n,AP,lda,x,incx,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdgmm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasDdgmm_full_rank = hipblasDdgmm_(handle,side,m,n,c_loc(AP),lda,c_loc(x),incx, & c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCdgmm_assumed_rank(handle,side,m,n,AP,lda,x,incx,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdgmm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasCdgmm_assumed_rank = hipblasCdgmm_(handle,side,m,n,c_loc(AP),lda,c_loc(x),incx, & c_loc(CP),ldc) end function #else function hipblasCdgmm_rank_0(handle,side,m,n,AP,lda,x,incx,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdgmm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: AP integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: CP integer(c_int) :: ldc ! hipblasCdgmm_rank_0 = hipblasCdgmm_(handle,side,m,n,c_loc(AP),lda,c_loc(x),incx,c_loc(CP),ldc) end function function hipblasCdgmm_rank_1(handle,side,m,n,AP,lda,x,incx,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdgmm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasCdgmm_rank_1 = hipblasCdgmm_(handle,side,m,n,c_loc(AP),lda,c_loc(x),incx,c_loc(CP),ldc) end function function hipblasCdgmm_full_rank(handle,side,m,n,AP,lda,x,incx,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdgmm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasCdgmm_full_rank = hipblasCdgmm_(handle,side,m,n,c_loc(AP),lda,c_loc(x),incx, & c_loc(CP),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZdgmm_assumed_rank(handle,side,m,n,AP,lda,x,incx,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdgmm_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc ! hipblasZdgmm_assumed_rank = hipblasZdgmm_(handle,side,m,n,c_loc(AP),lda,c_loc(x),incx, & c_loc(CP),ldc) end function #else function hipblasZdgmm_rank_0(handle,side,m,n,AP,lda,x,incx,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdgmm_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: AP integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: CP integer(c_int) :: ldc ! hipblasZdgmm_rank_0 = hipblasZdgmm_(handle,side,m,n,c_loc(AP),lda,c_loc(x),incx,c_loc(CP),ldc) end function function hipblasZdgmm_rank_1(handle,side,m,n,AP,lda,x,incx,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdgmm_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc ! hipblasZdgmm_rank_1 = hipblasZdgmm_(handle,side,m,n,c_loc(AP),lda,c_loc(x),incx,c_loc(CP),ldc) end function function hipblasZdgmm_full_rank(handle,side,m,n,AP,lda,x,incx,CP,ldc) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdgmm_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc ! hipblasZdgmm_full_rank = hipblasZdgmm_(handle,side,m,n,c_loc(AP),lda,c_loc(x),incx, & c_loc(CP),ldc) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSdgmmStridedBatched_assumed_rank(handle,side,m,n,AP,lda,strideA,x,incx, & stridex,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdgmmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSdgmmStridedBatched_assumed_rank = hipblasSdgmmStridedBatched_(handle,side,m,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasSdgmmStridedBatched_rank_0(handle,side,m,n,AP,lda,strideA,x,incx,stridex,CP, & ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdgmmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSdgmmStridedBatched_rank_0 = hipblasSdgmmStridedBatched_(handle,side,m,n,c_loc(AP), & lda,strideA,c_loc(x),incx,stridex,c_loc(CP),ldc,strideC,batchCount) end function function hipblasSdgmmStridedBatched_rank_1(handle,side,m,n,AP,lda,strideA,x,incx,stridex,CP, & ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdgmmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSdgmmStridedBatched_rank_1 = hipblasSdgmmStridedBatched_(handle,side,m,n,c_loc(AP), & lda,strideA,c_loc(x),incx,stridex,c_loc(CP),ldc,strideC,batchCount) end function function hipblasSdgmmStridedBatched_full_rank(handle,side,m,n,AP,lda,strideA,x,incx,stridex, & CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSdgmmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasSdgmmStridedBatched_full_rank = hipblasSdgmmStridedBatched_(handle,side,m,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDdgmmStridedBatched_assumed_rank(handle,side,m,n,AP,lda,strideA,x,incx, & stridex,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdgmmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDdgmmStridedBatched_assumed_rank = hipblasDdgmmStridedBatched_(handle,side,m,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasDdgmmStridedBatched_rank_0(handle,side,m,n,AP,lda,strideA,x,incx,stridex,CP, & ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdgmmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDdgmmStridedBatched_rank_0 = hipblasDdgmmStridedBatched_(handle,side,m,n,c_loc(AP), & lda,strideA,c_loc(x),incx,stridex,c_loc(CP),ldc,strideC,batchCount) end function function hipblasDdgmmStridedBatched_rank_1(handle,side,m,n,AP,lda,strideA,x,incx,stridex,CP, & ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdgmmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDdgmmStridedBatched_rank_1 = hipblasDdgmmStridedBatched_(handle,side,m,n,c_loc(AP), & lda,strideA,c_loc(x),incx,stridex,c_loc(CP),ldc,strideC,batchCount) end function function hipblasDdgmmStridedBatched_full_rank(handle,side,m,n,AP,lda,strideA,x,incx,stridex, & CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDdgmmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasDdgmmStridedBatched_full_rank = hipblasDdgmmStridedBatched_(handle,side,m,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCdgmmStridedBatched_assumed_rank(handle,side,m,n,AP,lda,strideA,x,incx, & stridex,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdgmmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCdgmmStridedBatched_assumed_rank = hipblasCdgmmStridedBatched_(handle,side,m,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasCdgmmStridedBatched_rank_0(handle,side,m,n,AP,lda,strideA,x,incx,stridex,CP, & ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdgmmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCdgmmStridedBatched_rank_0 = hipblasCdgmmStridedBatched_(handle,side,m,n,c_loc(AP), & lda,strideA,c_loc(x),incx,stridex,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCdgmmStridedBatched_rank_1(handle,side,m,n,AP,lda,strideA,x,incx,stridex,CP, & ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdgmmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCdgmmStridedBatched_rank_1 = hipblasCdgmmStridedBatched_(handle,side,m,n,c_loc(AP), & lda,strideA,c_loc(x),incx,stridex,c_loc(CP),ldc,strideC,batchCount) end function function hipblasCdgmmStridedBatched_full_rank(handle,side,m,n,AP,lda,strideA,x,incx,stridex, & CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCdgmmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasCdgmmStridedBatched_full_rank = hipblasCdgmmStridedBatched_(handle,side,m,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZdgmmStridedBatched_assumed_rank(handle,side,m,n,AP,lda,strideA,x,incx, & stridex,CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdgmmStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZdgmmStridedBatched_assumed_rank = hipblasZdgmmStridedBatched_(handle,side,m,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,c_loc(CP),ldc,strideC,batchCount) end function #else function hipblasZdgmmStridedBatched_rank_0(handle,side,m,n,AP,lda,strideA,x,incx,stridex,CP, & ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdgmmStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZdgmmStridedBatched_rank_0 = hipblasZdgmmStridedBatched_(handle,side,m,n,c_loc(AP), & lda,strideA,c_loc(x),incx,stridex,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZdgmmStridedBatched_rank_1(handle,side,m,n,AP,lda,strideA,x,incx,stridex,CP, & ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdgmmStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZdgmmStridedBatched_rank_1 = hipblasZdgmmStridedBatched_(handle,side,m,n,c_loc(AP), & lda,strideA,c_loc(x),incx,stridex,c_loc(CP),ldc,strideC,batchCount) end function function hipblasZdgmmStridedBatched_full_rank(handle,side,m,n,AP,lda,strideA,x,incx,stridex, & CP,ldc,strideC,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZdgmmStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: AP integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:,:) :: CP integer(c_int) :: ldc integer(c_int64_t) :: strideC integer(c_int) :: batchCount ! hipblasZdgmmStridedBatched_full_rank = hipblasZdgmmStridedBatched_(handle,side,m,n, & c_loc(AP),lda,strideA,c_loc(x),incx,stridex,c_loc(CP),ldc,strideC,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSgetrf_assumed_rank(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! hipblasSgetrf_assumed_rank = hipblasSgetrf_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function hipblasSgetrf_rank_0(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrf_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! hipblasSgetrf_rank_0 = hipblasSgetrf_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function hipblasSgetrf_rank_1(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrf_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! hipblasSgetrf_rank_1 = hipblasSgetrf_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function hipblasSgetrf_full_rank(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrf_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! hipblasSgetrf_full_rank = hipblasSgetrf_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDgetrf_assumed_rank(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! hipblasDgetrf_assumed_rank = hipblasDgetrf_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function hipblasDgetrf_rank_0(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrf_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! hipblasDgetrf_rank_0 = hipblasDgetrf_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function hipblasDgetrf_rank_1(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrf_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! hipblasDgetrf_rank_1 = hipblasDgetrf_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function hipblasDgetrf_full_rank(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrf_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! hipblasDgetrf_full_rank = hipblasDgetrf_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCgetrf_assumed_rank(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! hipblasCgetrf_assumed_rank = hipblasCgetrf_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function hipblasCgetrf_rank_0(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrf_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! hipblasCgetrf_rank_0 = hipblasCgetrf_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function hipblasCgetrf_rank_1(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrf_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! hipblasCgetrf_rank_1 = hipblasCgetrf_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function hipblasCgetrf_full_rank(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrf_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! hipblasCgetrf_full_rank = hipblasCgetrf_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZgetrf_assumed_rank(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! hipblasZgetrf_assumed_rank = hipblasZgetrf_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function hipblasZgetrf_rank_0(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrf_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! hipblasZgetrf_rank_0 = hipblasZgetrf_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function hipblasZgetrf_rank_1(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrf_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! hipblasZgetrf_rank_1 = hipblasZgetrf_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function hipblasZgetrf_full_rank(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrf_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! hipblasZgetrf_full_rank = hipblasZgetrf_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSgetrfStridedBatched_assumed_rank(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrfStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasSgetrfStridedBatched_assumed_rank = hipblasSgetrfStridedBatched_(handle,n,c_loc(A), & lda,strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function #else function hipblasSgetrfStridedBatched_rank_0(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrfStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasSgetrfStridedBatched_rank_0 = hipblasSgetrfStridedBatched_(handle,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function function hipblasSgetrfStridedBatched_rank_1(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrfStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasSgetrfStridedBatched_rank_1 = hipblasSgetrfStridedBatched_(handle,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function function hipblasSgetrfStridedBatched_full_rank(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrfStridedBatched_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasSgetrfStridedBatched_full_rank = hipblasSgetrfStridedBatched_(handle,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDgetrfStridedBatched_assumed_rank(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrfStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasDgetrfStridedBatched_assumed_rank = hipblasDgetrfStridedBatched_(handle,n,c_loc(A), & lda,strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function #else function hipblasDgetrfStridedBatched_rank_0(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrfStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasDgetrfStridedBatched_rank_0 = hipblasDgetrfStridedBatched_(handle,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function function hipblasDgetrfStridedBatched_rank_1(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrfStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasDgetrfStridedBatched_rank_1 = hipblasDgetrfStridedBatched_(handle,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function function hipblasDgetrfStridedBatched_full_rank(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrfStridedBatched_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasDgetrfStridedBatched_full_rank = hipblasDgetrfStridedBatched_(handle,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCgetrfStridedBatched_assumed_rank(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrfStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasCgetrfStridedBatched_assumed_rank = hipblasCgetrfStridedBatched_(handle,n,c_loc(A), & lda,strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function #else function hipblasCgetrfStridedBatched_rank_0(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrfStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasCgetrfStridedBatched_rank_0 = hipblasCgetrfStridedBatched_(handle,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function function hipblasCgetrfStridedBatched_rank_1(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrfStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasCgetrfStridedBatched_rank_1 = hipblasCgetrfStridedBatched_(handle,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function function hipblasCgetrfStridedBatched_full_rank(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrfStridedBatched_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasCgetrfStridedBatched_full_rank = hipblasCgetrfStridedBatched_(handle,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZgetrfStridedBatched_assumed_rank(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrfStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasZgetrfStridedBatched_assumed_rank = hipblasZgetrfStridedBatched_(handle,n,c_loc(A), & lda,strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function #else function hipblasZgetrfStridedBatched_rank_0(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrfStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasZgetrfStridedBatched_rank_0 = hipblasZgetrfStridedBatched_(handle,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function function hipblasZgetrfStridedBatched_rank_1(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrfStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasZgetrfStridedBatched_rank_1 = hipblasZgetrfStridedBatched_(handle,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function function hipblasZgetrfStridedBatched_full_rank(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrfStridedBatched_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasZgetrfStridedBatched_full_rank = hipblasZgetrfStridedBatched_(handle,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSgetrs_assumed_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrs_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! hipblasSgetrs_assumed_rank = hipblasSgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb,myInfo) end function #else function hipblasSgetrs_rank_0(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrs_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv real(c_float),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! hipblasSgetrs_rank_0 = hipblasSgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B), & ldb,myInfo) end function function hipblasSgetrs_rank_1(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrs_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv real(c_float),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! hipblasSgetrs_rank_1 = hipblasSgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B), & ldb,myInfo) end function function hipblasSgetrs_full_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrs_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! hipblasSgetrs_full_rank = hipblasSgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb,myInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDgetrs_assumed_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrs_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! hipblasDgetrs_assumed_rank = hipblasDgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb,myInfo) end function #else function hipblasDgetrs_rank_0(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrs_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv real(c_double),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! hipblasDgetrs_rank_0 = hipblasDgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B), & ldb,myInfo) end function function hipblasDgetrs_rank_1(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrs_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv real(c_double),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! hipblasDgetrs_rank_1 = hipblasDgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B), & ldb,myInfo) end function function hipblasDgetrs_full_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrs_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! hipblasDgetrs_full_rank = hipblasDgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb,myInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCgetrs_assumed_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrs_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! hipblasCgetrs_assumed_rank = hipblasCgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb,myInfo) end function #else function hipblasCgetrs_rank_0(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrs_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv complex(c_float_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! hipblasCgetrs_rank_0 = hipblasCgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B), & ldb,myInfo) end function function hipblasCgetrs_rank_1(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrs_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! hipblasCgetrs_rank_1 = hipblasCgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B), & ldb,myInfo) end function function hipblasCgetrs_full_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrs_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! hipblasCgetrs_full_rank = hipblasCgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb,myInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZgetrs_assumed_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrs_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! hipblasZgetrs_assumed_rank = hipblasZgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb,myInfo) end function #else function hipblasZgetrs_rank_0(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrs_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv complex(c_double_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! hipblasZgetrs_rank_0 = hipblasZgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B), & ldb,myInfo) end function function hipblasZgetrs_rank_1(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrs_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! hipblasZgetrs_rank_1 = hipblasZgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B), & ldb,myInfo) end function function hipblasZgetrs_full_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrs_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! hipblasZgetrs_full_rank = hipblasZgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb,myInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSgetrsStridedBatched_assumed_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrsStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasSgetrsStridedBatched_assumed_rank = hipblasSgetrsStridedBatched_(handle,trans,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batchCount) end function #else function hipblasSgetrsStridedBatched_rank_0(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrsStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP real(c_float),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasSgetrsStridedBatched_rank_0 = hipblasSgetrsStridedBatched_(handle,trans,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batchCount) end function function hipblasSgetrsStridedBatched_rank_1(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrsStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasSgetrsStridedBatched_rank_1 = hipblasSgetrsStridedBatched_(handle,trans,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batchCount) end function function hipblasSgetrsStridedBatched_full_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP, & B,ldb,strideB,myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgetrsStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasSgetrsStridedBatched_full_rank = hipblasSgetrsStridedBatched_(handle,trans,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDgetrsStridedBatched_assumed_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrsStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasDgetrsStridedBatched_assumed_rank = hipblasDgetrsStridedBatched_(handle,trans,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batchCount) end function #else function hipblasDgetrsStridedBatched_rank_0(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrsStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP real(c_double),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasDgetrsStridedBatched_rank_0 = hipblasDgetrsStridedBatched_(handle,trans,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batchCount) end function function hipblasDgetrsStridedBatched_rank_1(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrsStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasDgetrsStridedBatched_rank_1 = hipblasDgetrsStridedBatched_(handle,trans,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batchCount) end function function hipblasDgetrsStridedBatched_full_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP, & B,ldb,strideB,myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgetrsStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasDgetrsStridedBatched_full_rank = hipblasDgetrsStridedBatched_(handle,trans,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCgetrsStridedBatched_assumed_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrsStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasCgetrsStridedBatched_assumed_rank = hipblasCgetrsStridedBatched_(handle,trans,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batchCount) end function #else function hipblasCgetrsStridedBatched_rank_0(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrsStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasCgetrsStridedBatched_rank_0 = hipblasCgetrsStridedBatched_(handle,trans,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batchCount) end function function hipblasCgetrsStridedBatched_rank_1(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrsStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasCgetrsStridedBatched_rank_1 = hipblasCgetrsStridedBatched_(handle,trans,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batchCount) end function function hipblasCgetrsStridedBatched_full_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP, & B,ldb,strideB,myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgetrsStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasCgetrsStridedBatched_full_rank = hipblasCgetrsStridedBatched_(handle,trans,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZgetrsStridedBatched_assumed_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrsStridedBatched_assumed_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasZgetrsStridedBatched_assumed_rank = hipblasZgetrsStridedBatched_(handle,trans,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batchCount) end function #else function hipblasZgetrsStridedBatched_rank_0(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrsStridedBatched_rank_0 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasZgetrsStridedBatched_rank_0 = hipblasZgetrsStridedBatched_(handle,trans,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batchCount) end function function hipblasZgetrsStridedBatched_rank_1(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrsStridedBatched_rank_1 type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasZgetrsStridedBatched_rank_1 = hipblasZgetrsStridedBatched_(handle,trans,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batchCount) end function function hipblasZgetrsStridedBatched_full_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP, & B,ldb,strideB,myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgetrsStridedBatched_full_rank type(c_ptr) :: handle integer(kind(HIPBLAS_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasZgetrsStridedBatched_full_rank = hipblasZgetrsStridedBatched_(handle,trans,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSgeqrf_assumed_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeqrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! hipblasSgeqrf_assumed_rank = hipblasSgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function hipblasSgeqrf_rank_0(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeqrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv type(c_ptr) :: myInfo ! hipblasSgeqrf_rank_0 = hipblasSgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function hipblasSgeqrf_rank_1(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeqrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! hipblasSgeqrf_rank_1 = hipblasSgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function hipblasSgeqrf_full_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeqrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! hipblasSgeqrf_full_rank = hipblasSgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDgeqrf_assumed_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeqrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! hipblasDgeqrf_assumed_rank = hipblasDgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function hipblasDgeqrf_rank_0(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeqrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv type(c_ptr) :: myInfo ! hipblasDgeqrf_rank_0 = hipblasDgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function hipblasDgeqrf_rank_1(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeqrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! hipblasDgeqrf_rank_1 = hipblasDgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function hipblasDgeqrf_full_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeqrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! hipblasDgeqrf_full_rank = hipblasDgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCgeqrf_assumed_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeqrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! hipblasCgeqrf_assumed_rank = hipblasCgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function hipblasCgeqrf_rank_0(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeqrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv type(c_ptr) :: myInfo ! hipblasCgeqrf_rank_0 = hipblasCgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function hipblasCgeqrf_rank_1(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeqrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! hipblasCgeqrf_rank_1 = hipblasCgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function hipblasCgeqrf_full_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeqrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! hipblasCgeqrf_full_rank = hipblasCgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZgeqrf_assumed_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeqrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! hipblasZgeqrf_assumed_rank = hipblasZgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function hipblasZgeqrf_rank_0(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeqrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv type(c_ptr) :: myInfo ! hipblasZgeqrf_rank_0 = hipblasZgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function hipblasZgeqrf_rank_1(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeqrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! hipblasZgeqrf_rank_1 = hipblasZgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function hipblasZgeqrf_full_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeqrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! hipblasZgeqrf_full_rank = hipblasZgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSgeqrfStridedBatched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeqrfStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasSgeqrfStridedBatched_assumed_rank = hipblasSgeqrfStridedBatched_(handle,m,n,c_loc(A), & lda,strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function #else function hipblasSgeqrfStridedBatched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeqrfStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasSgeqrfStridedBatched_rank_0 = hipblasSgeqrfStridedBatched_(handle,m,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function function hipblasSgeqrfStridedBatched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeqrfStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasSgeqrfStridedBatched_rank_1 = hipblasSgeqrfStridedBatched_(handle,m,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function function hipblasSgeqrfStridedBatched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasSgeqrfStridedBatched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasSgeqrfStridedBatched_full_rank = hipblasSgeqrfStridedBatched_(handle,m,n,c_loc(A), & lda,strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasDgeqrfStridedBatched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeqrfStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasDgeqrfStridedBatched_assumed_rank = hipblasDgeqrfStridedBatched_(handle,m,n,c_loc(A), & lda,strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function #else function hipblasDgeqrfStridedBatched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeqrfStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasDgeqrfStridedBatched_rank_0 = hipblasDgeqrfStridedBatched_(handle,m,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function function hipblasDgeqrfStridedBatched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeqrfStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasDgeqrfStridedBatched_rank_1 = hipblasDgeqrfStridedBatched_(handle,m,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function function hipblasDgeqrfStridedBatched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasDgeqrfStridedBatched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasDgeqrfStridedBatched_full_rank = hipblasDgeqrfStridedBatched_(handle,m,n,c_loc(A), & lda,strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasCgeqrfStridedBatched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeqrfStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasCgeqrfStridedBatched_assumed_rank = hipblasCgeqrfStridedBatched_(handle,m,n,c_loc(A), & lda,strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function #else function hipblasCgeqrfStridedBatched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeqrfStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasCgeqrfStridedBatched_rank_0 = hipblasCgeqrfStridedBatched_(handle,m,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function function hipblasCgeqrfStridedBatched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeqrfStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasCgeqrfStridedBatched_rank_1 = hipblasCgeqrfStridedBatched_(handle,m,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function function hipblasCgeqrfStridedBatched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasCgeqrfStridedBatched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasCgeqrfStridedBatched_full_rank = hipblasCgeqrfStridedBatched_(handle,m,n,c_loc(A), & lda,strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasZgeqrfStridedBatched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeqrfStridedBatched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasZgeqrfStridedBatched_assumed_rank = hipblasZgeqrfStridedBatched_(handle,m,n,c_loc(A), & lda,strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function #else function hipblasZgeqrfStridedBatched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeqrfStridedBatched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasZgeqrfStridedBatched_rank_0 = hipblasZgeqrfStridedBatched_(handle,m,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function function hipblasZgeqrfStridedBatched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeqrfStridedBatched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasZgeqrfStridedBatched_rank_1 = hipblasZgeqrfStridedBatched_(handle,m,n,c_loc(A),lda, & strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function function hipblasZgeqrfStridedBatched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batchCount) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: hipblasZgeqrfStridedBatched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batchCount ! hipblasZgeqrfStridedBatched_full_rank = hipblasZgeqrfStridedBatched_(handle,m,n,c_loc(A), & lda,strideA,c_loc(ipiv),strideP,myInfo,batchCount) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipblasSetVector_l_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n logical(c_bool),target,contiguous,dimension(..) :: x integer(c_int),value :: incx logical(c_bool),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,1,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetVector_i4_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_int),target,contiguous,dimension(..) :: x integer(c_int),value :: incx integer(c_int),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetVector_i8_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_long),target,contiguous,dimension(..) :: x integer(c_int),value :: incx integer(c_long),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetVector_r4_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int),value :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetVector_r8_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int),value :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetVector_c4_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int),value :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,2*4,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetVector_c8_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int),value :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,2*8,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_l_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n logical(c_bool),target,contiguous,dimension(..) :: x integer(c_int),value :: incx logical(c_bool),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,1,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_i4_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_int),target,contiguous,dimension(..) :: x integer(c_int),value :: incx integer(c_int),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_i8_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_long),target,contiguous,dimension(..) :: x integer(c_int),value :: incx integer(c_long),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_r4_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int),value :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_r8_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int),value :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_c4_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int),value :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,2*4,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_c8_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int),value :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,2*8,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetMatrix_l_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,contiguous,dimension(..) :: A integer(c_int),value :: lda logical(c_bool),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetMatrix_i4_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,contiguous,dimension(..) :: A integer(c_int),value :: lda integer(c_int),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetMatrix_i8_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,contiguous,dimension(..) :: A integer(c_int),value :: lda integer(c_long),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetMatrix_r4_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,contiguous,dimension(..) :: A integer(c_int),value :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetMatrix_r8_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,contiguous,dimension(..) :: A integer(c_int),value :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetMatrix_c4_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int),value :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetMatrix_c8_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int),value :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_l_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,contiguous,dimension(..) :: A integer(c_int),value :: lda logical(c_bool),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_i4_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,contiguous,dimension(..) :: A integer(c_int),value :: lda integer(c_int),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_i8_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,contiguous,dimension(..) :: A integer(c_int),value :: lda integer(c_long),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_r4_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,contiguous,dimension(..) :: A integer(c_int),value :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_r8_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,contiguous,dimension(..) :: A integer(c_int),value :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_c4_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int),value :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_c8_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int),value :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetVectorAsync_l_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n logical(c_bool),target,contiguous,dimension(..) :: x integer(c_int),value :: incx logical(c_bool),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,1,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetVectorAsync_i4_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_int),target,contiguous,dimension(..) :: x integer(c_int),value :: incx integer(c_int),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetVectorAsync_i8_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_long),target,contiguous,dimension(..) :: x integer(c_int),value :: incx integer(c_long),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetVectorAsync_r4_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int),value :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetVectorAsync_r8_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int),value :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetVectorAsync_c4_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int),value :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,2*4,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetVectorAsync_c8_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int),value :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,2*8,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_l_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n logical(c_bool),target,contiguous,dimension(..) :: x integer(c_int),value :: incx logical(c_bool),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,1,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_i4_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_int),target,contiguous,dimension(..) :: x integer(c_int),value :: incx integer(c_int),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_i8_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_long),target,contiguous,dimension(..) :: x integer(c_int),value :: incx integer(c_long),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_r4_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int),value :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_r8_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int),value :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_c4_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int),value :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,2*4,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_c8_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int),value :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,2*8,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetMatrixAsync_l_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,contiguous,dimension(..) :: A integer(c_int),value :: lda logical(c_bool),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasSetMatrixAsync_i4_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,contiguous,dimension(..) :: A integer(c_int),value :: lda integer(c_int),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasSetMatrixAsync_i8_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,contiguous,dimension(..) :: A integer(c_int),value :: lda integer(c_long),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasSetMatrixAsync_r4_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,contiguous,dimension(..) :: A integer(c_int),value :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasSetMatrixAsync_r8_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,contiguous,dimension(..) :: A integer(c_int),value :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasSetMatrixAsync_c4_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int),value :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasSetMatrixAsync_c8_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int),value :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_l_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,contiguous,dimension(..) :: A integer(c_int),value :: lda logical(c_bool),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_i4_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,contiguous,dimension(..) :: A integer(c_int),value :: lda integer(c_int),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_i8_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,contiguous,dimension(..) :: A integer(c_int),value :: lda integer(c_long),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_r4_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,contiguous,dimension(..) :: A integer(c_int),value :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_r8_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,contiguous,dimension(..) :: A integer(c_int),value :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_c4_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int),value :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_c8_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int),value :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb,stream) end function #else function hipblasSetVector_l_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n logical(c_bool),target :: x integer(c_int),value :: incx logical(c_bool),target :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,1,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetVector_l_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n logical(c_bool),target,dimension(:) :: x integer(c_int),value :: incx logical(c_bool),target,dimension(:) :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,1,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetVector_i4_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_int),target :: x integer(c_int),value :: incx integer(c_int),target :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetVector_i4_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_int),target,dimension(:) :: x integer(c_int),value :: incx integer(c_int),target,dimension(:) :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetVector_i8_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_long),target :: x integer(c_int),value :: incx integer(c_long),target :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetVector_i8_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_long),target,dimension(:) :: x integer(c_int),value :: incx integer(c_long),target,dimension(:) :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetVector_r4_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_float),target :: x integer(c_int),value :: incx real(c_float),target :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetVector_r4_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_float),target,dimension(:) :: x integer(c_int),value :: incx real(c_float),target,dimension(:) :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetVector_r8_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_double),target :: x integer(c_int),value :: incx real(c_double),target :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetVector_r8_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_double),target,dimension(:) :: x integer(c_int),value :: incx real(c_double),target,dimension(:) :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetVector_c4_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_float_complex),target :: x integer(c_int),value :: incx complex(c_float_complex),target :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,2*4,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetVector_c4_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int),value :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,2*4,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetVector_c8_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_double_complex),target :: x integer(c_int),value :: incx complex(c_double_complex),target :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,2*8,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetVector_c8_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int),value :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int),value :: incy ! ret = hipblasSetVector_(n,2*8,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_l_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n logical(c_bool),target :: x integer(c_int),value :: incx logical(c_bool),target :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,1,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_l_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n logical(c_bool),target,dimension(:) :: x integer(c_int),value :: incx logical(c_bool),target,dimension(:) :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,1,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_i4_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_int),target :: x integer(c_int),value :: incx integer(c_int),target :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_i4_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_int),target,dimension(:) :: x integer(c_int),value :: incx integer(c_int),target,dimension(:) :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_i8_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_long),target :: x integer(c_int),value :: incx integer(c_long),target :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_i8_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_long),target,dimension(:) :: x integer(c_int),value :: incx integer(c_long),target,dimension(:) :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_r4_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_float),target :: x integer(c_int),value :: incx real(c_float),target :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_r4_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_float),target,dimension(:) :: x integer(c_int),value :: incx real(c_float),target,dimension(:) :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_r8_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_double),target :: x integer(c_int),value :: incx real(c_double),target :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_r8_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_double),target,dimension(:) :: x integer(c_int),value :: incx real(c_double),target,dimension(:) :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_c4_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_float_complex),target :: x integer(c_int),value :: incx complex(c_float_complex),target :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,2*4,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_c4_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int),value :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,2*4,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_c8_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_double_complex),target :: x integer(c_int),value :: incx complex(c_double_complex),target :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,2*8,c_loc(x),incx,c_loc(y),incy) end function function hipblasGetVector_c8_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int),value :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int),value :: incy ! ret = hipblasGetVector_(n,2*8,c_loc(x),incx,c_loc(y),incy) end function function hipblasSetMatrix_l_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,dimension(:,:) :: A logical(c_bool),target,dimension(:,:) :: B ! ret = hipblasSetMatrix_(rows,cols,1,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function hipblasSetMatrix_l_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target :: A integer(c_int),value :: lda logical(c_bool),target :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetMatrix_l_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,dimension(:) :: A integer(c_int),value :: lda logical(c_bool),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetMatrix_i4_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,dimension(:,:) :: A integer(c_int),target,dimension(:,:) :: B ! ret = hipblasSetMatrix_(rows,cols,4,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function hipblasSetMatrix_i4_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target :: A integer(c_int),value :: lda integer(c_int),target :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetMatrix_i4_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,dimension(:) :: A integer(c_int),value :: lda integer(c_int),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetMatrix_i8_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,dimension(:,:) :: A integer(c_long),target,dimension(:,:) :: B ! ret = hipblasSetMatrix_(rows,cols,8,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function hipblasSetMatrix_i8_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target :: A integer(c_int),value :: lda integer(c_long),target :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetMatrix_i8_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,dimension(:) :: A integer(c_int),value :: lda integer(c_long),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetMatrix_r4_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,dimension(:,:) :: A real(c_float),target,dimension(:,:) :: B ! ret = hipblasSetMatrix_(rows,cols,4,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function hipblasSetMatrix_r4_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target :: A integer(c_int),value :: lda real(c_float),target :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetMatrix_r4_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,dimension(:) :: A integer(c_int),value :: lda real(c_float),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetMatrix_r8_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,dimension(:,:) :: A real(c_double),target,dimension(:,:) :: B ! ret = hipblasSetMatrix_(rows,cols,8,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function hipblasSetMatrix_r8_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target :: A integer(c_int),value :: lda real(c_double),target :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetMatrix_r8_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,dimension(:) :: A integer(c_int),value :: lda real(c_double),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetMatrix_c4_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,dimension(:,:) :: A complex(c_float_complex),target,dimension(:,:) :: B ! ret = hipblasSetMatrix_(rows,cols,2*4,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function hipblasSetMatrix_c4_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target :: A integer(c_int),value :: lda complex(c_float_complex),target :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetMatrix_c4_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,dimension(:) :: A integer(c_int),value :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetMatrix_c8_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,dimension(:,:) :: A complex(c_double_complex),target,dimension(:,:) :: B ! ret = hipblasSetMatrix_(rows,cols,2*8,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function hipblasSetMatrix_c8_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target :: A integer(c_int),value :: lda complex(c_double_complex),target :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetMatrix_c8_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,dimension(:) :: A integer(c_int),value :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = hipblasSetMatrix_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_l_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,dimension(:,:) :: A logical(c_bool),target,dimension(:,:) :: B ! ret = hipblasGetMatrix_(rows,cols,1,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function hipblasGetMatrix_l_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target :: A integer(c_int),value :: lda logical(c_bool),target :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_l_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,dimension(:) :: A integer(c_int),value :: lda logical(c_bool),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_i4_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,dimension(:,:) :: A integer(c_int),target,dimension(:,:) :: B ! ret = hipblasGetMatrix_(rows,cols,4,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function hipblasGetMatrix_i4_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target :: A integer(c_int),value :: lda integer(c_int),target :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_i4_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,dimension(:) :: A integer(c_int),value :: lda integer(c_int),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_i8_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,dimension(:,:) :: A integer(c_long),target,dimension(:,:) :: B ! ret = hipblasGetMatrix_(rows,cols,8,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function hipblasGetMatrix_i8_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target :: A integer(c_int),value :: lda integer(c_long),target :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_i8_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,dimension(:) :: A integer(c_int),value :: lda integer(c_long),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_r4_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,dimension(:,:) :: A real(c_float),target,dimension(:,:) :: B ! ret = hipblasGetMatrix_(rows,cols,4,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function hipblasGetMatrix_r4_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target :: A integer(c_int),value :: lda real(c_float),target :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_r4_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,dimension(:) :: A integer(c_int),value :: lda real(c_float),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_r8_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,dimension(:,:) :: A real(c_double),target,dimension(:,:) :: B ! ret = hipblasGetMatrix_(rows,cols,8,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function hipblasGetMatrix_r8_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target :: A integer(c_int),value :: lda real(c_double),target :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_r8_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,dimension(:) :: A integer(c_int),value :: lda real(c_double),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_c4_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,dimension(:,:) :: A complex(c_float_complex),target,dimension(:,:) :: B ! ret = hipblasGetMatrix_(rows,cols,2*4,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function hipblasGetMatrix_c4_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target :: A integer(c_int),value :: lda complex(c_float_complex),target :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_c4_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,dimension(:) :: A integer(c_int),value :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_c8_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,dimension(:,:) :: A complex(c_double_complex),target,dimension(:,:) :: B ! ret = hipblasGetMatrix_(rows,cols,2*8,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function hipblasGetMatrix_c8_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target :: A integer(c_int),value :: lda complex(c_double_complex),target :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb) end function function hipblasGetMatrix_c8_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,dimension(:) :: A integer(c_int),value :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = hipblasGetMatrix_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb) end function function hipblasSetVectorAsync_l_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n logical(c_bool),target :: x integer(c_int),value :: incx logical(c_bool),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,1,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetVectorAsync_l_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n logical(c_bool),target,dimension(:) :: x integer(c_int),value :: incx logical(c_bool),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,1,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetVectorAsync_i4_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_int),target :: x integer(c_int),value :: incx integer(c_int),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetVectorAsync_i4_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_int),target,dimension(:) :: x integer(c_int),value :: incx integer(c_int),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetVectorAsync_i8_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_long),target :: x integer(c_int),value :: incx integer(c_long),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetVectorAsync_i8_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_long),target,dimension(:) :: x integer(c_int),value :: incx integer(c_long),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetVectorAsync_r4_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_float),target :: x integer(c_int),value :: incx real(c_float),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetVectorAsync_r4_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_float),target,dimension(:) :: x integer(c_int),value :: incx real(c_float),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetVectorAsync_r8_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_double),target :: x integer(c_int),value :: incx real(c_double),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetVectorAsync_r8_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_double),target,dimension(:) :: x integer(c_int),value :: incx real(c_double),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetVectorAsync_c4_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_float_complex),target :: x integer(c_int),value :: incx complex(c_float_complex),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,2*4,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetVectorAsync_c4_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int),value :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,2*4,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetVectorAsync_c8_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_double_complex),target :: x integer(c_int),value :: incx complex(c_double_complex),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,2*8,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetVectorAsync_c8_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int),value :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasSetVectorAsync_(n,2*8,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_l_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n logical(c_bool),target :: x integer(c_int),value :: incx logical(c_bool),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,1,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_l_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n logical(c_bool),target,dimension(:) :: x integer(c_int),value :: incx logical(c_bool),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,1,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_i4_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_int),target :: x integer(c_int),value :: incx integer(c_int),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_i4_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_int),target,dimension(:) :: x integer(c_int),value :: incx integer(c_int),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_i8_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_long),target :: x integer(c_int),value :: incx integer(c_long),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_i8_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n integer(c_long),target,dimension(:) :: x integer(c_int),value :: incx integer(c_long),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_r4_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_float),target :: x integer(c_int),value :: incx real(c_float),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_r4_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_float),target,dimension(:) :: x integer(c_int),value :: incx real(c_float),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_r8_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_double),target :: x integer(c_int),value :: incx real(c_double),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_r8_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n real(c_double),target,dimension(:) :: x integer(c_int),value :: incx real(c_double),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_c4_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_float_complex),target :: x integer(c_int),value :: incx complex(c_float_complex),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,2*4,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_c4_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int),value :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,2*4,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_c8_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_double_complex),target :: x integer(c_int),value :: incx complex(c_double_complex),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,2*8,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasGetVectorAsync_c8_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int),value :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = hipblasGetVectorAsync_(n,2*8,c_loc(x),incx,c_loc(y),incy,stream) end function function hipblasSetMatrixAsync_l_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,dimension(:,:) :: A logical(c_bool),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,1,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function hipblasSetMatrixAsync_l_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target :: A integer(c_int),value :: lda logical(c_bool),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasSetMatrixAsync_l_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,dimension(:) :: A integer(c_int),value :: lda logical(c_bool),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasSetMatrixAsync_i4_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,dimension(:,:) :: A integer(c_int),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,4,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function hipblasSetMatrixAsync_i4_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target :: A integer(c_int),value :: lda integer(c_int),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasSetMatrixAsync_i4_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,dimension(:) :: A integer(c_int),value :: lda integer(c_int),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasSetMatrixAsync_i8_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,dimension(:,:) :: A integer(c_long),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,8,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function hipblasSetMatrixAsync_i8_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target :: A integer(c_int),value :: lda integer(c_long),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasSetMatrixAsync_i8_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,dimension(:) :: A integer(c_int),value :: lda integer(c_long),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasSetMatrixAsync_r4_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,dimension(:,:) :: A real(c_float),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,4,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function hipblasSetMatrixAsync_r4_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target :: A integer(c_int),value :: lda real(c_float),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasSetMatrixAsync_r4_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,dimension(:) :: A integer(c_int),value :: lda real(c_float),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasSetMatrixAsync_r8_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,dimension(:,:) :: A real(c_double),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,8,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function hipblasSetMatrixAsync_r8_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target :: A integer(c_int),value :: lda real(c_double),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasSetMatrixAsync_r8_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,dimension(:) :: A integer(c_int),value :: lda real(c_double),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasSetMatrixAsync_c4_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,dimension(:,:) :: A complex(c_float_complex),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,2*4,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function hipblasSetMatrixAsync_c4_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target :: A integer(c_int),value :: lda complex(c_float_complex),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasSetMatrixAsync_c4_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,dimension(:) :: A integer(c_int),value :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasSetMatrixAsync_c8_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,dimension(:,:) :: A complex(c_double_complex),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,2*8,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function hipblasSetMatrixAsync_c8_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target :: A integer(c_int),value :: lda complex(c_double_complex),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasSetMatrixAsync_c8_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,dimension(:) :: A integer(c_int),value :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasSetMatrixAsync_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_l_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,dimension(:,:) :: A logical(c_bool),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,1,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function hipblasGetMatrixAsync_l_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target :: A integer(c_int),value :: lda logical(c_bool),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_l_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,dimension(:) :: A integer(c_int),value :: lda logical(c_bool),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_i4_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,dimension(:,:) :: A integer(c_int),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,4,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function hipblasGetMatrixAsync_i4_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target :: A integer(c_int),value :: lda integer(c_int),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_i4_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,dimension(:) :: A integer(c_int),value :: lda integer(c_int),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_i8_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,dimension(:,:) :: A integer(c_long),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,8,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function hipblasGetMatrixAsync_i8_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target :: A integer(c_int),value :: lda integer(c_long),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_i8_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,dimension(:) :: A integer(c_int),value :: lda integer(c_long),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_r4_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,dimension(:,:) :: A real(c_float),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,4,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function hipblasGetMatrixAsync_r4_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target :: A integer(c_int),value :: lda real(c_float),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_r4_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,dimension(:) :: A integer(c_int),value :: lda real(c_float),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_r8_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,dimension(:,:) :: A real(c_double),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,8,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function hipblasGetMatrixAsync_r8_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target :: A integer(c_int),value :: lda real(c_double),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_r8_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,dimension(:) :: A integer(c_int),value :: lda real(c_double),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_c4_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,dimension(:,:) :: A complex(c_float_complex),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,2*4,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function hipblasGetMatrixAsync_c4_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target :: A integer(c_int),value :: lda complex(c_float_complex),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_c4_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,dimension(:) :: A integer(c_int),value :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_c8_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,dimension(:,:) :: A complex(c_double_complex),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,2*8,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function hipblasGetMatrixAsync_c8_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target :: A integer(c_int),value :: lda complex(c_double_complex),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb,stream) end function function hipblasGetMatrixAsync_c8_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_hipblas_enums implicit none integer(kind(HIPBLAS_STATUS_SUCCESS)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,dimension(:) :: A integer(c_int),value :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = hipblasGetMatrixAsync_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb,stream) end function #endif #endif end module hipfort_hipblas hipfort-rocm-10.0.0/lib/hipfort/hipfort_hipblas_enums.F90000066400000000000000000000145231524740623400233020ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_hipblas_enums use, intrinsic :: iso_c_binding implicit none ! hipblasStatus_t 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_HANDLE_IS_NULLPTR = 9 enumerator :: HIPBLAS_STATUS_INVALID_ENUM = 10 enumerator :: HIPBLAS_STATUS_UNKNOWN = 11 end enum ! hipblasOperation_t enum, bind(c) #ifdef USE_CUDA_NAMES enumerator :: HIPBLAS_OP_N = 0 #else enumerator :: HIPBLAS_OP_N = 111 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPBLAS_OP_T = 1 #else enumerator :: HIPBLAS_OP_T = 112 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPBLAS_OP_C = 2 #else enumerator :: HIPBLAS_OP_C = 113 #endif end enum ! hipblasComputeType_t enum, bind(c) enumerator :: HIPBLAS_COMPUTE_16F = 0 enumerator :: HIPBLAS_COMPUTE_16F_PEDANTIC = 1 enumerator :: HIPBLAS_COMPUTE_32F = 2 enumerator :: HIPBLAS_COMPUTE_32F_PEDANTIC = 3 enumerator :: HIPBLAS_COMPUTE_32F_FAST_16F = 4 enumerator :: HIPBLAS_COMPUTE_32F_FAST_16BF = 5 enumerator :: HIPBLAS_COMPUTE_32F_FAST_TF32 = 6 enumerator :: HIPBLAS_COMPUTE_64F = 7 enumerator :: HIPBLAS_COMPUTE_64F_PEDANTIC = 8 enumerator :: HIPBLAS_COMPUTE_32I = 9 enumerator :: HIPBLAS_COMPUTE_32I_PEDANTIC = 10 enumerator :: HIPBLAS_COMPUTE_32F_FAST_8F_FNUZ = 100 enumerator :: HIPBLAS_COMPUTE_32F_FAST_8BF_FNUZ = 101 enumerator :: HIPBLAS_COMPUTE_32F_FAST_8F8BF_FNUZ = 102 enumerator :: HIPBLAS_COMPUTE_32F_FAST_8BF8F_FNUZ = 103 end enum ! hipblasPointerMode_t enum, bind(c) #ifdef USE_CUDA_NAMES enumerator :: HIPBLAS_POINTER_MODE_HOST = 0 #else enumerator :: HIPBLAS_POINTER_MODE_HOST = 0 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPBLAS_POINTER_MODE_DEVICE = 1 #else enumerator :: HIPBLAS_POINTER_MODE_DEVICE = 1 #endif end enum ! hipblasFillMode_t enum, bind(c) #ifdef USE_CUDA_NAMES enumerator :: HIPBLAS_FILL_MODE_UPPER = 1 #else enumerator :: HIPBLAS_FILL_MODE_UPPER = 121 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPBLAS_FILL_MODE_LOWER = 0 #else enumerator :: HIPBLAS_FILL_MODE_LOWER = 122 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPBLAS_FILL_MODE_FULL = 2 #else enumerator :: HIPBLAS_FILL_MODE_FULL = 123 #endif end enum ! hipblasDiagType_t enum, bind(c) #ifdef USE_CUDA_NAMES enumerator :: HIPBLAS_DIAG_NON_UNIT = 0 #else enumerator :: HIPBLAS_DIAG_NON_UNIT = 131 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPBLAS_DIAG_UNIT = 1 #else enumerator :: HIPBLAS_DIAG_UNIT = 132 #endif end enum ! hipblasSideMode_t enum, bind(c) #ifdef USE_CUDA_NAMES enumerator :: HIPBLAS_SIDE_LEFT = 0 #else enumerator :: HIPBLAS_SIDE_LEFT = 141 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPBLAS_SIDE_RIGHT = 1 #else enumerator :: HIPBLAS_SIDE_RIGHT = 142 #endif enumerator :: HIPBLAS_SIDE_BOTH = 143 end enum ! hipblasMath_t enum, bind(c) enumerator :: HIPBLAS_DEFAULT_MATH = 0 enumerator :: HIPBLAS_XF32_XDL_MATH = 1 enumerator :: HIPBLAS_PEDANTIC_MATH = 2 enumerator :: HIPBLAS_TF32_TENSOR_OP_MATH = 3 enumerator :: HIPBLAS_MATH_DISALLOW_REDUCED_PRECISION_REDUCTION = 4 enumerator :: HIPBLAS_TENSOR_OP_MATH = 5 end enum ! hipblasGemmAlgo_t enum, bind(c) #ifdef USE_CUDA_NAMES enumerator :: HIPBLAS_GEMM_DEFAULT = -1 #else enumerator :: HIPBLAS_GEMM_DEFAULT = 160 #endif end enum ! hipblasAtomicsMode_t enum, bind(c) #ifdef USE_CUDA_NAMES enumerator :: HIPBLAS_ATOMICS_NOT_ALLOWED = 0 #else enumerator :: HIPBLAS_ATOMICS_NOT_ALLOWED = 0 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPBLAS_ATOMICS_ALLOWED = 1 #else enumerator :: HIPBLAS_ATOMICS_ALLOWED = 1 #endif end enum ! hipblasGemmFlags_t enum, bind(c) enumerator :: HIPBLAS_GEMM_FLAGS_NONE = 0 enumerator :: HIPBLAS_GEMM_FLAGS_USE_CU_EFFICIENCY = 2 enumerator :: HIPBLAS_GEMM_FLAGS_FP16_ALT_IMPL = 4 enumerator :: HIPBLAS_GEMM_FLAGS_CHECK_SOLUTION_INDEX = 8 enumerator :: HIPBLAS_GEMM_FLAGS_FP16_ALT_IMPL_RNZ = 16 end enum ! hipblasLibraryProperty_t enum, bind(c) enumerator :: HIPBLAS_MAJOR_VERSION = 0 enumerator :: HIPBLAS_MINOR_VERSION = 1 enumerator :: HIPBLAS_PATCH_LEVEL = 2 end enum integer(c_int), parameter :: hipblasVersionMajor = 3 integer(c_int), parameter :: hipblaseVersionMinor = 6 integer(c_int), parameter :: hipblasVersionMinor = 6 integer(c_int), parameter :: hipblasVersionPatch = 0 integer(c_int), parameter :: hipblasVersionK = 100 end module hipfort_hipblas_enums hipfort-rocm-10.0.0/lib/hipfort/hipfort_hipfft.F90000066400000000000000000002130221524740623400217240ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_hipfft use hipfort_hipfft_enums implicit none !> @brief Create a new one-dimensional FFT plan. !> !> @details Allocate and initialize a new one-dimensional FFT plan. !> !> @param[out] plan - Pointer to the FFT plan handle. !> @param[in] nx - FFT length. !> @param[in] myType - FFT type. !> @param[in] batch - Number of batched transforms to compute. interface hipfftPlan1d #ifdef USE_CUDA_NAMES function hipfftPlan1d_(plan,nx,myType,batch) bind(c, name="cufftPlan1d") #else function hipfftPlan1d_(plan,nx,myType,batch) bind(c, name="hipfftPlan1d") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftPlan1d_ type(c_ptr) :: plan integer(c_int),value :: nx integer(kind(HIPFFT_R2C)),value :: myType integer(c_int),value :: batch end function end interface !> @brief Create a new two-dimensional FFT plan. !> !> @details Allocate and initialize a new two-dimensional FFT plan. !> Two-dimensional data should be stored in C ordering (row-major !> format), so that indexes in y-direction (j index) vary the !> fastest. !> !> @param[out] plan - Pointer to the FFT plan handle. !> @param[in] nx - Number of elements in the x-direction (slow index). !> @param[in] ny - Number of elements in the y-direction (fast index). !> @param[in] myType - FFT type. interface hipfftPlan2d #ifdef USE_CUDA_NAMES function hipfftPlan2d_(plan,nx,ny,myType) bind(c, name="cufftPlan2d") #else function hipfftPlan2d_(plan,nx,ny,myType) bind(c, name="hipfftPlan2d") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftPlan2d_ type(c_ptr) :: plan integer(c_int),value :: nx integer(c_int),value :: ny integer(kind(HIPFFT_R2C)),value :: myType end function end interface !> @brief Create a new three-dimensional FFT plan. !> !> @details Allocate and initialize a new three-dimensional FFT plan. !> Three-dimensional data should be stored in C ordering (row-major !> format), so that indexes in z-direction (k index) vary the !> fastest. !> !> @param[out] plan - Pointer to the FFT plan handle. !> @param[in] nx - Number of elements in the x-direction (slowest index). !> @param[in] ny - Number of elements in the y-direction. !> @param[in] nz - Number of elements in the z-direction (fastest index). !> @param[in] myType - FFT type. interface hipfftPlan3d #ifdef USE_CUDA_NAMES function hipfftPlan3d_(plan,nx,ny,nz,myType) bind(c, name="cufftPlan3d") #else function hipfftPlan3d_(plan,nx,ny,nz,myType) bind(c, name="hipfftPlan3d") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftPlan3d_ type(c_ptr) :: plan integer(c_int),value :: nx integer(c_int),value :: ny integer(c_int),value :: nz integer(kind(HIPFFT_R2C)),value :: myType end function end interface !> @brief Create a new batched rank-dimensional FFT plan with advanced data layout. !> !> @details Allocate and initialize a new batched rank-dimensional !> FFT plan. The number of elements to transform in each direction of !> the input data is specified in n. !> !> The batch parameter tells hipFFT how many transforms to perform. !> The distance between the first elements of two consecutive batches !> of the input and output data are specified with the idist and odist !> parameters. !> !> The inembed and onembed parameters define the input and output data !> layouts. The number of elements in the data is assumed to be larger !> than the number of elements in the transform. Strided data layouts !> are also supported. Strides along the fastest direction in the input !> and output data are specified via the istride and ostride parameters. !> !> If both inembed and onembed parameters are set to NULL, all the !> advanced data layout parameters are ignored and reverted to default !> values, i.e., the batched transform is performed with non-strided data !> access and the number of data/transform elements are assumed to be !> equivalent. !> !> @param[out] plan - Pointer to the FFT plan handle. !> @param[in] rank - Dimension of transform (1, 2, or 3). !> @param[in] n - Number of elements to transform in the x/y/z directions. !> @param[in] inembed - Number of elements in the input data in the x/y/z directions. !> @param[in] istride - Distance between two successive elements in the input data. !> @param[in] idist - Distance between input batches. !> @param[in] onembed - Number of elements in the output data in the x/y/z directions. !> @param[in] ostride - Distance between two successive elements in the output data. !> @param[in] odist - Distance between output batches. !> @param[in] myType - FFT type. !> @param[in] batch - Number of batched transforms to perform. interface hipfftPlanMany #ifdef USE_CUDA_NAMES function hipfftPlanMany_(plan,rank,n,inembed,istride,idist,onembed,ostride,odist,myType,batch) & bind(c, name="cufftPlanMany") #else function hipfftPlanMany_(plan,rank,n,inembed,istride,idist,onembed,ostride,odist,myType,batch) & bind(c, name="hipfftPlanMany") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftPlanMany_ type(c_ptr) :: plan integer(c_int),value :: rank type(c_ptr),value :: n type(c_ptr),value :: inembed integer(c_int),value :: istride integer(c_int),value :: idist type(c_ptr),value :: onembed integer(c_int),value :: ostride integer(c_int),value :: odist integer(kind(HIPFFT_R2C)),value :: myType integer(c_int),value :: batch end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipfftPlanMany_assumed_rank #else module procedure & hipfftPlanMany_rank_0,& hipfftPlanMany_rank_1 #endif #endif end interface !> @brief Allocate a new plan. !> !> @param[out] plan - Pointer to the FFT plan handle to be allocated. interface hipfftCreate #ifdef USE_CUDA_NAMES function hipfftCreate_(plan) bind(c, name="cufftCreate") #else function hipfftCreate_(plan) bind(c, name="hipfftCreate") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftCreate_ type(c_ptr) :: plan end function end interface !> @brief Set scaling factor. !> !> @details hipFFT multiplies each element of the result by the given factor at the end of the !> transform. !> !> The supplied factor must be a finite number. That is, it must neither be infinity nor NaN. !> !> This function must be called after the plan is allocated using !> `hipfftCreate`, but before the plan is initialized by any of the !> "MakePlan" functions. Therefore, API functions that combine !> creation and initialization (`hipfftPlan1d`, `hipfftPlan2d`, !> `hipfftPlan3d`, and `hipfftPlanMany`) cannot set a scale factor. !> !> Note that the scale factor applies to both forward and !> backward transforms executed with the specified plan handle. #ifndef USE_CUDA_NAMES interface hipfftExtPlanScaleFactor function hipfftExtPlanScaleFactor_(plan,scalefactor) bind(c, name="hipfftExtPlanScaleFactor") use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExtPlanScaleFactor_ type(c_ptr),value :: plan real(c_double),value :: scalefactor end function end interface #endif !> @brief Initialize a new one-dimensional FFT plan. !> !> @details Assumes that the plan has been created already, and !> modifies the plan associated with the plan handle. !> !> @param[in] plan - Handle of the FFT plan. !> @param[in] nx - FFT length. !> @param[in] myType - FFT type. !> @param[in] batch - Number of batched transforms to compute. !> @param[out] workSize - Pointer to work area size (returned value). interface hipfftMakePlan1d #ifdef USE_CUDA_NAMES function hipfftMakePlan1d_(plan,nx,myType,batch,workSize) bind(c, name="cufftMakePlan1d") #else function hipfftMakePlan1d_(plan,nx,myType,batch,workSize) bind(c, name="hipfftMakePlan1d") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftMakePlan1d_ type(c_ptr),value :: plan integer(c_int),value :: nx integer(kind(HIPFFT_R2C)),value :: myType integer(c_int),value :: batch integer(c_size_t) :: workSize end function end interface !> @brief Initialize a new two-dimensional FFT plan. !> !> @details Assumes that the plan has been created already, and !> modifies the plan associated with the plan handle. !> Two-dimensional data should be stored in C ordering (row-major !> format), so that indexes in y-direction (j index) vary the !> fastest. !> !> @param[in] plan - Handle of the FFT plan. !> @param[in] nx - Number of elements in the x-direction (slow index). !> @param[in] ny - Number of elements in the y-direction (fast index). !> @param[in] myType - FFT type. !> @param[out] workSize - Pointer to work area size (returned value). interface hipfftMakePlan2d #ifdef USE_CUDA_NAMES function hipfftMakePlan2d_(plan,nx,ny,myType,workSize) bind(c, name="cufftMakePlan2d") #else function hipfftMakePlan2d_(plan,nx,ny,myType,workSize) bind(c, name="hipfftMakePlan2d") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftMakePlan2d_ type(c_ptr),value :: plan integer(c_int),value :: nx integer(c_int),value :: ny integer(kind(HIPFFT_R2C)),value :: myType integer(c_size_t) :: workSize end function end interface !> @brief Initialize a new two-dimensional FFT plan. !> !> @details Assumes that the plan has been created already, and !> modifies the plan associated with the plan handle. !> Three-dimensional data should be stored in C ordering (row-major !> format), so that indexes in z-direction (k index) vary the !> fastest. !> !> @param[in] plan - Handle of the FFT plan. !> @param[in] nx - Number of elements in the x-direction (slowest index). !> @param[in] ny - Number of elements in the y-direction. !> @param[in] nz - Number of elements in the z-direction (fastest index). !> @param[in] myType - FFT type. !> @param[out] workSize - Pointer to work area size (returned value). interface hipfftMakePlan3d #ifdef USE_CUDA_NAMES function hipfftMakePlan3d_(plan,nx,ny,nz,myType,workSize) bind(c, name="cufftMakePlan3d") #else function hipfftMakePlan3d_(plan,nx,ny,nz,myType,workSize) bind(c, name="hipfftMakePlan3d") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftMakePlan3d_ type(c_ptr),value :: plan integer(c_int),value :: nx integer(c_int),value :: ny integer(c_int),value :: nz integer(kind(HIPFFT_R2C)),value :: myType integer(c_size_t) :: workSize end function end interface !> @brief Initialize a new batched rank-dimensional FFT plan with advanced data layout. !> !> @details Assumes that the plan has been created already, and !> modifies the plan associated with the plan handle. The number !> of elements to transform in each direction of the input data !> in the FFT plan is specified in n. !> !> The batch parameter tells hipFFT how many transforms to perform. !> The distance between the first elements of two consecutive batches !> of the input and output data are specified with the idist and odist !> parameters. !> !> The inembed and onembed parameters define the input and output data !> layouts. The number of elements in the data is assumed to be larger !> than the number of elements in the transform. Strided data layouts !> are also supported. Strides along the fastest direction in the input !> and output data are specified via the istride and ostride parameters. !> !> If both inembed and onembed parameters are set to NULL, all the !> advanced data layout parameters are ignored and reverted to default !> values, i.e., the batched transform is performed with non-strided data !> access and the number of data/transform elements are assumed to be !> equivalent. !> !> @param[out] plan - Pointer to the FFT plan handle. !> @param[in] rank - Dimension of transform (1, 2, or 3). !> @param[in] n - Number of elements to transform in the x/y/z directions. !> @param[in] inembed - Number of elements in the input data in the x/y/z directions. !> @param[in] istride - Distance between two successive elements in the input data. !> @param[in] idist - Distance between input batches. !> @param[in] onembed - Number of elements in the output data in the x/y/z directions. !> @param[in] ostride - Distance between two successive elements in the output data. !> @param[in] odist - Distance between output batches. !> @param[in] myType - FFT type. !> @param[in] batch - Number of batched transforms to perform. !> @param[out] workSize - Pointer to work area size (returned value). interface hipfftMakePlanMany #ifdef USE_CUDA_NAMES function hipfftMakePlanMany_(plan,rank,n,inembed,istride,idist,onembed,ostride,odist,myType, & batch,workSize) & bind(c, name="cufftMakePlanMany") #else function hipfftMakePlanMany_(plan,rank,n,inembed,istride,idist,onembed,ostride,odist,myType, & batch,workSize) & bind(c, name="hipfftMakePlanMany") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftMakePlanMany_ type(c_ptr),value :: plan integer(c_int),value :: rank type(c_ptr),value :: n type(c_ptr),value :: inembed integer(c_int),value :: istride integer(c_int),value :: idist type(c_ptr),value :: onembed integer(c_int),value :: ostride integer(c_int),value :: odist integer(kind(HIPFFT_R2C)),value :: myType integer(c_int),value :: batch integer(c_size_t) :: workSize end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipfftMakePlanMany_assumed_rank #else module procedure & hipfftMakePlanMany_rank_0,& hipfftMakePlanMany_rank_1 #endif #endif end interface interface hipfftMakePlanMany64 #ifdef USE_CUDA_NAMES function hipfftMakePlanMany64_(plan,rank,n,inembed,istride,idist,onembed,ostride,odist,myType, & batch,workSize) & bind(c, name="cufftMakePlanMany64") #else function hipfftMakePlanMany64_(plan,rank,n,inembed,istride,idist,onembed,ostride,odist,myType, & batch,workSize) & bind(c, name="hipfftMakePlanMany64") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftMakePlanMany64_ type(c_ptr),value :: plan integer(c_int),value :: rank type(c_ptr),value :: n type(c_ptr),value :: inembed integer(c_int64_t),value :: istride integer(c_int64_t),value :: idist type(c_ptr),value :: onembed integer(c_int64_t),value :: ostride integer(c_int64_t),value :: odist integer(kind(HIPFFT_R2C)),value :: myType integer(c_int64_t),value :: batch integer(c_size_t) :: workSize end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipfftMakePlanMany64_assumed_rank #else module procedure & hipfftMakePlanMany64_rank_0,& hipfftMakePlanMany64_rank_1 #endif #endif end interface !> @brief Return an estimate of the work area size required for a 1D plan. !> !> @param[in] nx - Number of elements in the x-direction. !> @param[in] myType - FFT type. !> @param[in] batch - Number of batched transforms to perform. !> @param[out] workSize - Pointer to work area size (returned value). interface hipfftEstimate1d #ifdef USE_CUDA_NAMES function hipfftEstimate1d_(nx,myType,batch,workSize) bind(c, name="cufftEstimate1d") #else function hipfftEstimate1d_(nx,myType,batch,workSize) bind(c, name="hipfftEstimate1d") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftEstimate1d_ integer(c_int),value :: nx integer(kind(HIPFFT_R2C)),value :: myType integer(c_int),value :: batch integer(c_size_t) :: workSize end function end interface !> @brief Return an estimate of the work area size required for a 2D plan. !> !> @param[in] nx - Number of elements in the x-direction. !> @param[in] ny - Number of elements in the y-direction. !> @param[in] myType - FFT type. !> @param[out] workSize - Pointer to work area size (returned value). interface hipfftEstimate2d #ifdef USE_CUDA_NAMES function hipfftEstimate2d_(nx,ny,myType,workSize) bind(c, name="cufftEstimate2d") #else function hipfftEstimate2d_(nx,ny,myType,workSize) bind(c, name="hipfftEstimate2d") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftEstimate2d_ integer(c_int),value :: nx integer(c_int),value :: ny integer(kind(HIPFFT_R2C)),value :: myType integer(c_size_t) :: workSize end function end interface !> @brief Return an estimate of the work area size required for a 3D plan. !> !> @param[in] nx - Number of elements in the x-direction. !> @param[in] ny - Number of elements in the y-direction. !> @param[in] nz - Number of elements in the z-direction. !> @param[in] myType - FFT type. !> @param[out] workSize - Pointer to work area size (returned value). interface hipfftEstimate3d #ifdef USE_CUDA_NAMES function hipfftEstimate3d_(nx,ny,nz,myType,workSize) bind(c, name="cufftEstimate3d") #else function hipfftEstimate3d_(nx,ny,nz,myType,workSize) bind(c, name="hipfftEstimate3d") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftEstimate3d_ integer(c_int),value :: nx integer(c_int),value :: ny integer(c_int),value :: nz integer(kind(HIPFFT_R2C)),value :: myType integer(c_size_t) :: workSize end function end interface !> @brief Return an estimate of the work area size required for a rank-dimensional plan. !> !> @param[in] rank - Dimension of FFT transform (1, 2, or 3). !> @param[in] n - Number of elements in the x/y/z directions. !> @param[in] inembed !> @param[in] istride !> @param[in] idist - Distance between input batches. !> @param[in] onembed !> @param[in] ostride !> @param[in] odist - Distance between output batches. !> @param[in] myType - FFT type. !> @param[in] batch - Number of batched transforms to perform. !> @param[out] workSize - Pointer to work area size (returned value). interface hipfftEstimateMany #ifdef USE_CUDA_NAMES function hipfftEstimateMany_(rank,n,inembed,istride,idist,onembed,ostride,odist,myType,batch, & workSize) & bind(c, name="cufftEstimateMany") #else function hipfftEstimateMany_(rank,n,inembed,istride,idist,onembed,ostride,odist,myType,batch, & workSize) & bind(c, name="hipfftEstimateMany") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftEstimateMany_ integer(c_int),value :: rank type(c_ptr),value :: n type(c_ptr),value :: inembed integer(c_int),value :: istride integer(c_int),value :: idist type(c_ptr),value :: onembed integer(c_int),value :: ostride integer(c_int),value :: odist integer(kind(HIPFFT_R2C)),value :: myType integer(c_int),value :: batch integer(c_size_t) :: workSize end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipfftEstimateMany_assumed_rank #else module procedure & hipfftEstimateMany_rank_0,& hipfftEstimateMany_rank_1 #endif #endif end interface !> @brief Return size of the work area size required for a 1D plan. !> !> @param[in] plan - Pointer to the FFT plan. !> @param[in] nx - Number of elements in the x-direction. !> @param[in] myType - FFT type. !> @param[in] batch - Number of batched transforms to perform. !> @param[out] workSize - Pointer to work area size (returned value). interface hipfftGetSize1d #ifdef USE_CUDA_NAMES function hipfftGetSize1d_(plan,nx,myType,batch,workSize) bind(c, name="cufftGetSize1d") #else function hipfftGetSize1d_(plan,nx,myType,batch,workSize) bind(c, name="hipfftGetSize1d") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftGetSize1d_ type(c_ptr),value :: plan integer(c_int),value :: nx integer(kind(HIPFFT_R2C)),value :: myType integer(c_int),value :: batch integer(c_size_t) :: workSize end function end interface !> @brief Return size of the work area size required for a 2D plan. !> !> @param[in] plan - Pointer to the FFT plan. !> @param[in] nx - Number of elements in the x-direction. !> @param[in] ny - Number of elements in the y-direction. !> @param[in] myType - FFT type. !> @param[out] workSize - Pointer to work area size (returned value). interface hipfftGetSize2d #ifdef USE_CUDA_NAMES function hipfftGetSize2d_(plan,nx,ny,myType,workSize) bind(c, name="cufftGetSize2d") #else function hipfftGetSize2d_(plan,nx,ny,myType,workSize) bind(c, name="hipfftGetSize2d") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftGetSize2d_ type(c_ptr),value :: plan integer(c_int),value :: nx integer(c_int),value :: ny integer(kind(HIPFFT_R2C)),value :: myType integer(c_size_t) :: workSize end function end interface !> @brief Return size of the work area size required for a 3D plan. !> !> @param[in] plan - Pointer to the FFT plan. !> @param[in] nx - Number of elements in the x-direction. !> @param[in] ny - Number of elements in the y-direction. !> @param[in] nz - Number of elements in the z-direction. !> @param[in] myType - FFT type. !> @param[out] workSize - Pointer to work area size (returned value). interface hipfftGetSize3d #ifdef USE_CUDA_NAMES function hipfftGetSize3d_(plan,nx,ny,nz,myType,workSize) bind(c, name="cufftGetSize3d") #else function hipfftGetSize3d_(plan,nx,ny,nz,myType,workSize) bind(c, name="hipfftGetSize3d") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftGetSize3d_ type(c_ptr),value :: plan integer(c_int),value :: nx integer(c_int),value :: ny integer(c_int),value :: nz integer(kind(HIPFFT_R2C)),value :: myType integer(c_size_t) :: workSize end function end interface !> @brief Return size of the work area size required for a rank-dimensional plan. !> !> @param[in] plan - Pointer to the FFT plan. !> @param[in] rank - Dimension of FFT transform (1, 2, or 3). !> @param[in] n - Number of elements in the x/y/z directions. !> @param[in] inembed !> @param[in] istride !> @param[in] idist - Distance between input batches. !> @param[in] onembed !> @param[in] ostride !> @param[in] odist - Distance between output batches. !> @param[in] myType - FFT type. !> @param[in] batch - Number of batched transforms to perform. !> @param[out] workSize - Pointer to work area size (returned value). interface hipfftGetSizeMany #ifdef USE_CUDA_NAMES function hipfftGetSizeMany_(plan,rank,n,inembed,istride,idist,onembed,ostride,odist,myType, & batch,workSize) & bind(c, name="cufftGetSizeMany") #else function hipfftGetSizeMany_(plan,rank,n,inembed,istride,idist,onembed,ostride,odist,myType, & batch,workSize) & bind(c, name="hipfftGetSizeMany") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftGetSizeMany_ type(c_ptr),value :: plan integer(c_int),value :: rank type(c_ptr),value :: n type(c_ptr),value :: inembed integer(c_int),value :: istride integer(c_int),value :: idist type(c_ptr),value :: onembed integer(c_int),value :: ostride integer(c_int),value :: odist integer(kind(HIPFFT_R2C)),value :: myType integer(c_int),value :: batch integer(c_size_t) :: workSize end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipfftGetSizeMany_assumed_rank #else module procedure & hipfftGetSizeMany_rank_0,& hipfftGetSizeMany_rank_1 #endif #endif end interface interface hipfftGetSizeMany64 #ifdef USE_CUDA_NAMES function hipfftGetSizeMany64_(plan,rank,n,inembed,istride,idist,onembed,ostride,odist,myType, & batch,workSize) & bind(c, name="cufftGetSizeMany64") #else function hipfftGetSizeMany64_(plan,rank,n,inembed,istride,idist,onembed,ostride,odist,myType, & batch,workSize) & bind(c, name="hipfftGetSizeMany64") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftGetSizeMany64_ type(c_ptr),value :: plan integer(c_int),value :: rank type(c_ptr),value :: n type(c_ptr),value :: inembed integer(c_int64_t),value :: istride integer(c_int64_t),value :: idist type(c_ptr),value :: onembed integer(c_int64_t),value :: ostride integer(c_int64_t),value :: odist integer(kind(HIPFFT_R2C)),value :: myType integer(c_int64_t),value :: batch integer(c_size_t) :: workSize end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipfftGetSizeMany64_assumed_rank #else module procedure & hipfftGetSizeMany64_rank_0,& hipfftGetSizeMany64_rank_1 #endif #endif end interface !> @brief Return size of the work area size required for a rank-dimensional plan. !> !> @param[in] plan - Pointer to the FFT plan. !> @param[out] workSize - Pointer to work area size (returned value). interface hipfftGetSize #ifdef USE_CUDA_NAMES function hipfftGetSize_(plan,workSize) bind(c, name="cufftGetSize") #else function hipfftGetSize_(plan,workSize) bind(c, name="hipfftGetSize") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftGetSize_ type(c_ptr),value :: plan integer(c_size_t) :: workSize end function end interface !> @brief Set the plan's auto-allocation flag. The plan will allocate its own workarea. !> !> @param[in] plan - Pointer to the FFT plan. !> @param[in] autoAllocate - 0 to disable auto-allocation, non-zero to enable. interface hipfftSetAutoAllocation #ifdef USE_CUDA_NAMES function hipfftSetAutoAllocation_(plan,autoAllocate) bind(c, name="cufftSetAutoAllocation") #else function hipfftSetAutoAllocation_(plan,autoAllocate) bind(c, name="hipfftSetAutoAllocation") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftSetAutoAllocation_ type(c_ptr),value :: plan integer(c_int),value :: autoAllocate end function end interface !> @brief Set the plan's work area. !> !> @param[in] plan - Pointer to the FFT plan. !> @param[in] workArea - Pointer to the work area (on device). interface hipfftSetWorkArea #ifdef USE_CUDA_NAMES function hipfftSetWorkArea_(plan,workArea) bind(c, name="cufftSetWorkArea") #else function hipfftSetWorkArea_(plan,workArea) bind(c, name="hipfftSetWorkArea") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftSetWorkArea_ type(c_ptr),value :: plan type(c_ptr),value :: workArea end function end interface !> @brief Execute a (float) complex-to-complex FFT. !> !> @details If the input and output buffers are equal, an in-place !> transform is performed. !> !> @param[in] plan - The FFT plan. !> @param[in] idata - Input data (on device). !> @param[out] odata - Output data (on device). !> @param[in] direction - Either `HIPFFT_FORWARD` or `HIPFFT_BACKWARD`. interface hipfftExecC2C #ifdef USE_CUDA_NAMES function hipfftExecC2C_(plan,idata,odata,direction) bind(c, name="cufftExecC2C") #else function hipfftExecC2C_(plan,idata,odata,direction) bind(c, name="hipfftExecC2C") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecC2C_ type(c_ptr),value :: plan type(c_ptr),value :: idata type(c_ptr),value :: odata integer(c_int),value :: direction end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipfftExecC2C_assumed_rank #else module procedure & hipfftExecC2C_rank_0,& hipfftExecC2C_rank_1,& hipfftExecC2C_rank_2,& hipfftExecC2C_rank_3 #endif #endif end interface !> @brief Execute a (float) real-to-complex FFT. !> !> @details If the input and output buffers are equal, an in-place !> transform is performed. !> !> @param[in] plan - The FFT plan. !> @param[in] idata - Input data (on device). !> @param[out] odata - Output data (on device). interface hipfftExecR2C #ifdef USE_CUDA_NAMES function hipfftExecR2C_(plan,idata,odata) bind(c, name="cufftExecR2C") #else function hipfftExecR2C_(plan,idata,odata) bind(c, name="hipfftExecR2C") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecR2C_ type(c_ptr),value :: plan type(c_ptr),value :: idata type(c_ptr),value :: odata end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipfftExecR2C_assumed_rank #else module procedure & hipfftExecR2C_rank_0,& hipfftExecR2C_rank_1,& hipfftExecR2C_rank_2,& hipfftExecR2C_rank_3 #endif #endif end interface !> @brief Execute a (float) complex-to-real FFT. !> !> @details If the input and output buffers are equal, an in-place !> transform is performed. !> !> @param[in] plan - The FFT plan. !> @param[in] idata - Input data (on device). !> @param[out] odata - Output data (on device). interface hipfftExecC2R #ifdef USE_CUDA_NAMES function hipfftExecC2R_(plan,idata,odata) bind(c, name="cufftExecC2R") #else function hipfftExecC2R_(plan,idata,odata) bind(c, name="hipfftExecC2R") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecC2R_ type(c_ptr),value :: plan type(c_ptr),value :: idata type(c_ptr),value :: odata end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipfftExecC2R_assumed_rank #else module procedure & hipfftExecC2R_rank_0,& hipfftExecC2R_rank_1,& hipfftExecC2R_rank_2,& hipfftExecC2R_rank_3 #endif #endif end interface !> @brief Execute a (double) complex-to-complex FFT. !> !> @details If the input and output buffers are equal, an in-place !> transform is performed. !> !> @param[in] plan - The FFT plan. !> @param[in] idata - Input data (on device). !> @param[out] odata - Output data (on device). !> @param[in] direction - Either `HIPFFT_FORWARD` or `HIPFFT_BACKWARD`. interface hipfftExecZ2Z #ifdef USE_CUDA_NAMES function hipfftExecZ2Z_(plan,idata,odata,direction) bind(c, name="cufftExecZ2Z") #else function hipfftExecZ2Z_(plan,idata,odata,direction) bind(c, name="hipfftExecZ2Z") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecZ2Z_ type(c_ptr),value :: plan type(c_ptr),value :: idata type(c_ptr),value :: odata integer(c_int),value :: direction end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipfftExecZ2Z_assumed_rank #else module procedure & hipfftExecZ2Z_rank_0,& hipfftExecZ2Z_rank_1,& hipfftExecZ2Z_rank_2,& hipfftExecZ2Z_rank_3 #endif #endif end interface !> @brief Execute a (double) real-to-complex FFT. !> !> @details If the input and output buffers are equal, an in-place !> transform is performed. !> !> @param[in] plan - The FFT plan. !> @param[in] idata - Input data (on device). !> @param[out] odata - Output data (on device). interface hipfftExecD2Z #ifdef USE_CUDA_NAMES function hipfftExecD2Z_(plan,idata,odata) bind(c, name="cufftExecD2Z") #else function hipfftExecD2Z_(plan,idata,odata) bind(c, name="hipfftExecD2Z") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecD2Z_ type(c_ptr),value :: plan type(c_ptr),value :: idata type(c_ptr),value :: odata end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipfftExecD2Z_assumed_rank #else module procedure & hipfftExecD2Z_rank_0,& hipfftExecD2Z_rank_1,& hipfftExecD2Z_rank_2,& hipfftExecD2Z_rank_3 #endif #endif end interface !> @brief Execute a (double) complex-to-real FFT. !> !> @details If the input and output buffers are equal, an in-place !> transform is performed. !> !> @param[in] plan - The FFT plan. !> @param[in] idata - Input data (on device). !> @param[out] odata - Output data (on device). interface hipfftExecZ2D #ifdef USE_CUDA_NAMES function hipfftExecZ2D_(plan,idata,odata) bind(c, name="cufftExecZ2D") #else function hipfftExecZ2D_(plan,idata,odata) bind(c, name="hipfftExecZ2D") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecZ2D_ type(c_ptr),value :: plan type(c_ptr),value :: idata type(c_ptr),value :: odata end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipfftExecZ2D_assumed_rank #else module procedure & hipfftExecZ2D_rank_0,& hipfftExecZ2D_rank_1,& hipfftExecZ2D_rank_2,& hipfftExecZ2D_rank_3 #endif #endif end interface !> @brief Set HIP stream to execute plan on. !> !> @details Associates a HIP stream with a hipFFT plan. All kernels !> launched by this plan are associated with the provided stream. !> !> @param[in] plan - The FFT plan. !> @param[in] stream - The HIP stream. interface hipfftSetStream #ifdef USE_CUDA_NAMES function hipfftSetStream_(plan,stream) bind(c, name="cufftSetStream") #else function hipfftSetStream_(plan,stream) bind(c, name="hipfftSetStream") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftSetStream_ type(c_ptr),value :: plan type(c_ptr),value :: stream end function end interface !> @brief Destroy and deallocate an existing plan. !> !> @param[in] plan - Handle of the FFT plan to be destroyed. interface hipfftDestroy #ifdef USE_CUDA_NAMES function hipfftDestroy_(plan) bind(c, name="cufftDestroy") #else function hipfftDestroy_(plan) bind(c, name="hipfftDestroy") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftDestroy_ type(c_ptr),value :: plan end function end interface !> @brief Get rocFFT/cuFFT version. !> !> @param[out] version - cuFFT/rocFFT version (returned value). interface hipfftGetVersion #ifdef USE_CUDA_NAMES function hipfftGetVersion_(version) bind(c, name="cufftGetVersion") #else function hipfftGetVersion_(version) bind(c, name="hipfftGetVersion") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftGetVersion_ integer(c_int) :: version end function end interface !> @brief Get library property. !> !> @param[in] myType - Property type. !> @param[out] myValue - Returned value. interface hipfftGetProperty #ifdef USE_CUDA_NAMES function hipfftGetProperty_(myType,myValue) bind(c, name="cufftGetProperty") #else function hipfftGetProperty_(myType,myValue) bind(c, name="hipfftGetProperty") #endif use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftGetProperty_ integer(kind(HIPFFT_MAJOR_VERSION)),value :: myType type(c_ptr),value :: myValue end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipfftGetProperty_assumed_rank #else module procedure & hipfftGetProperty_rank_0,& hipfftGetProperty_rank_1 #endif #endif end interface #ifdef USE_FPOINTER_INTERFACES contains #ifdef USE_ASSUMED_RANK_INTERFACES function hipfftPlanMany_assumed_rank(plan,rank,n,inembed,istride,idist,onembed,ostride,odist, & myType,batch) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftPlanMany_assumed_rank type(c_ptr) :: plan integer(c_int) :: rank integer(c_int),target,contiguous,dimension(..) :: n integer(c_int),target,contiguous,dimension(..) :: inembed integer(c_int) :: istride integer(c_int) :: idist integer(c_int),target,contiguous,dimension(..) :: onembed integer(c_int) :: ostride integer(c_int) :: odist integer(kind(HIPFFT_R2C)) :: myType integer(c_int) :: batch ! hipfftPlanMany_assumed_rank = hipfftPlanMany_(plan,rank,c_loc(n),c_loc(inembed),istride, & idist,c_loc(onembed),ostride,odist,myType,batch) end function #else function hipfftPlanMany_rank_0(plan,rank,n,inembed,istride,idist,onembed,ostride,odist,myType, & batch) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftPlanMany_rank_0 type(c_ptr) :: plan integer(c_int) :: rank integer(c_int),target :: n integer(c_int),target :: inembed integer(c_int) :: istride integer(c_int) :: idist integer(c_int),target :: onembed integer(c_int) :: ostride integer(c_int) :: odist integer(kind(HIPFFT_R2C)) :: myType integer(c_int) :: batch ! hipfftPlanMany_rank_0 = hipfftPlanMany_(plan,rank,c_loc(n),c_loc(inembed),istride,idist, & c_loc(onembed),ostride,odist,myType,batch) end function function hipfftPlanMany_rank_1(plan,rank,n,inembed,istride,idist,onembed,ostride,odist,myType, & batch) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftPlanMany_rank_1 type(c_ptr) :: plan integer(c_int) :: rank integer(c_int),target,dimension(:) :: n integer(c_int),target,dimension(:) :: inembed integer(c_int) :: istride integer(c_int) :: idist integer(c_int),target,dimension(:) :: onembed integer(c_int) :: ostride integer(c_int) :: odist integer(kind(HIPFFT_R2C)) :: myType integer(c_int) :: batch ! hipfftPlanMany_rank_1 = hipfftPlanMany_(plan,rank,c_loc(n),c_loc(inembed),istride,idist, & c_loc(onembed),ostride,odist,myType,batch) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipfftMakePlanMany_assumed_rank(plan,rank,n,inembed,istride,idist,onembed,ostride, & odist,myType,batch,workSize) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftMakePlanMany_assumed_rank type(c_ptr) :: plan integer(c_int) :: rank integer(c_int),target,contiguous,dimension(..) :: n integer(c_int),target,contiguous,dimension(..) :: inembed integer(c_int) :: istride integer(c_int) :: idist integer(c_int),target,contiguous,dimension(..) :: onembed integer(c_int) :: ostride integer(c_int) :: odist integer(kind(HIPFFT_R2C)) :: myType integer(c_int) :: batch integer(c_size_t) :: workSize ! hipfftMakePlanMany_assumed_rank = hipfftMakePlanMany_(plan,rank,c_loc(n),c_loc(inembed), & istride,idist,c_loc(onembed),ostride,odist,myType,batch,workSize) end function #else function hipfftMakePlanMany_rank_0(plan,rank,n,inembed,istride,idist,onembed,ostride,odist, & myType,batch,workSize) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftMakePlanMany_rank_0 type(c_ptr) :: plan integer(c_int) :: rank integer(c_int),target :: n integer(c_int),target :: inembed integer(c_int) :: istride integer(c_int) :: idist integer(c_int),target :: onembed integer(c_int) :: ostride integer(c_int) :: odist integer(kind(HIPFFT_R2C)) :: myType integer(c_int) :: batch integer(c_size_t) :: workSize ! hipfftMakePlanMany_rank_0 = hipfftMakePlanMany_(plan,rank,c_loc(n),c_loc(inembed),istride, & idist,c_loc(onembed),ostride,odist,myType,batch,workSize) end function function hipfftMakePlanMany_rank_1(plan,rank,n,inembed,istride,idist,onembed,ostride,odist, & myType,batch,workSize) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftMakePlanMany_rank_1 type(c_ptr) :: plan integer(c_int) :: rank integer(c_int),target,dimension(:) :: n integer(c_int),target,dimension(:) :: inembed integer(c_int) :: istride integer(c_int) :: idist integer(c_int),target,dimension(:) :: onembed integer(c_int) :: ostride integer(c_int) :: odist integer(kind(HIPFFT_R2C)) :: myType integer(c_int) :: batch integer(c_size_t) :: workSize ! hipfftMakePlanMany_rank_1 = hipfftMakePlanMany_(plan,rank,c_loc(n),c_loc(inembed),istride, & idist,c_loc(onembed),ostride,odist,myType,batch,workSize) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipfftMakePlanMany64_assumed_rank(plan,rank,n,inembed,istride,idist,onembed,ostride, & odist,myType,batch,workSize) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftMakePlanMany64_assumed_rank type(c_ptr) :: plan integer(c_int) :: rank integer(c_int64_t),target,contiguous,dimension(..) :: n integer(c_int64_t),target,contiguous,dimension(..) :: inembed integer(c_int64_t) :: istride integer(c_int64_t) :: idist integer(c_int64_t),target,contiguous,dimension(..) :: onembed integer(c_int64_t) :: ostride integer(c_int64_t) :: odist integer(kind(HIPFFT_R2C)) :: myType integer(c_int64_t) :: batch integer(c_size_t) :: workSize ! hipfftMakePlanMany64_assumed_rank = hipfftMakePlanMany64_(plan,rank,c_loc(n),c_loc(inembed), & istride,idist,c_loc(onembed),ostride,odist,myType,batch,workSize) end function #else function hipfftMakePlanMany64_rank_0(plan,rank,n,inembed,istride,idist,onembed,ostride,odist, & myType,batch,workSize) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftMakePlanMany64_rank_0 type(c_ptr) :: plan integer(c_int) :: rank integer(c_int64_t),target :: n integer(c_int64_t),target :: inembed integer(c_int64_t) :: istride integer(c_int64_t) :: idist integer(c_int64_t),target :: onembed integer(c_int64_t) :: ostride integer(c_int64_t) :: odist integer(kind(HIPFFT_R2C)) :: myType integer(c_int64_t) :: batch integer(c_size_t) :: workSize ! hipfftMakePlanMany64_rank_0 = hipfftMakePlanMany64_(plan,rank,c_loc(n),c_loc(inembed), & istride,idist,c_loc(onembed),ostride,odist,myType,batch,workSize) end function function hipfftMakePlanMany64_rank_1(plan,rank,n,inembed,istride,idist,onembed,ostride,odist, & myType,batch,workSize) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftMakePlanMany64_rank_1 type(c_ptr) :: plan integer(c_int) :: rank integer(c_int64_t),target,dimension(:) :: n integer(c_int64_t),target,dimension(:) :: inembed integer(c_int64_t) :: istride integer(c_int64_t) :: idist integer(c_int64_t),target,dimension(:) :: onembed integer(c_int64_t) :: ostride integer(c_int64_t) :: odist integer(kind(HIPFFT_R2C)) :: myType integer(c_int64_t) :: batch integer(c_size_t) :: workSize ! hipfftMakePlanMany64_rank_1 = hipfftMakePlanMany64_(plan,rank,c_loc(n),c_loc(inembed), & istride,idist,c_loc(onembed),ostride,odist,myType,batch,workSize) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipfftEstimateMany_assumed_rank(rank,n,inembed,istride,idist,onembed,ostride,odist, & myType,batch,workSize) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftEstimateMany_assumed_rank integer(c_int) :: rank integer(c_int),target,contiguous,dimension(..) :: n integer(c_int),target,contiguous,dimension(..) :: inembed integer(c_int) :: istride integer(c_int) :: idist integer(c_int),target,contiguous,dimension(..) :: onembed integer(c_int) :: ostride integer(c_int) :: odist integer(kind(HIPFFT_R2C)) :: myType integer(c_int) :: batch integer(c_size_t) :: workSize ! hipfftEstimateMany_assumed_rank = hipfftEstimateMany_(rank,c_loc(n),c_loc(inembed),istride, & idist,c_loc(onembed),ostride,odist,myType,batch,workSize) end function #else function hipfftEstimateMany_rank_0(rank,n,inembed,istride,idist,onembed,ostride,odist,myType, & batch,workSize) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftEstimateMany_rank_0 integer(c_int) :: rank integer(c_int),target :: n integer(c_int),target :: inembed integer(c_int) :: istride integer(c_int) :: idist integer(c_int),target :: onembed integer(c_int) :: ostride integer(c_int) :: odist integer(kind(HIPFFT_R2C)) :: myType integer(c_int) :: batch integer(c_size_t) :: workSize ! hipfftEstimateMany_rank_0 = hipfftEstimateMany_(rank,c_loc(n),c_loc(inembed),istride,idist, & c_loc(onembed),ostride,odist,myType,batch,workSize) end function function hipfftEstimateMany_rank_1(rank,n,inembed,istride,idist,onembed,ostride,odist,myType, & batch,workSize) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftEstimateMany_rank_1 integer(c_int) :: rank integer(c_int),target,dimension(:) :: n integer(c_int),target,dimension(:) :: inembed integer(c_int) :: istride integer(c_int) :: idist integer(c_int),target,dimension(:) :: onembed integer(c_int) :: ostride integer(c_int) :: odist integer(kind(HIPFFT_R2C)) :: myType integer(c_int) :: batch integer(c_size_t) :: workSize ! hipfftEstimateMany_rank_1 = hipfftEstimateMany_(rank,c_loc(n),c_loc(inembed),istride,idist, & c_loc(onembed),ostride,odist,myType,batch,workSize) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipfftGetSizeMany_assumed_rank(plan,rank,n,inembed,istride,idist,onembed,ostride, & odist,myType,batch,workSize) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftGetSizeMany_assumed_rank type(c_ptr) :: plan integer(c_int) :: rank integer(c_int),target,contiguous,dimension(..) :: n integer(c_int),target,contiguous,dimension(..) :: inembed integer(c_int) :: istride integer(c_int) :: idist integer(c_int),target,contiguous,dimension(..) :: onembed integer(c_int) :: ostride integer(c_int) :: odist integer(kind(HIPFFT_R2C)) :: myType integer(c_int) :: batch integer(c_size_t) :: workSize ! hipfftGetSizeMany_assumed_rank = hipfftGetSizeMany_(plan,rank,c_loc(n),c_loc(inembed), & istride,idist,c_loc(onembed),ostride,odist,myType,batch,workSize) end function #else function hipfftGetSizeMany_rank_0(plan,rank,n,inembed,istride,idist,onembed,ostride,odist, & myType,batch,workSize) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftGetSizeMany_rank_0 type(c_ptr) :: plan integer(c_int) :: rank integer(c_int),target :: n integer(c_int),target :: inembed integer(c_int) :: istride integer(c_int) :: idist integer(c_int),target :: onembed integer(c_int) :: ostride integer(c_int) :: odist integer(kind(HIPFFT_R2C)) :: myType integer(c_int) :: batch integer(c_size_t) :: workSize ! hipfftGetSizeMany_rank_0 = hipfftGetSizeMany_(plan,rank,c_loc(n),c_loc(inembed),istride, & idist,c_loc(onembed),ostride,odist,myType,batch,workSize) end function function hipfftGetSizeMany_rank_1(plan,rank,n,inembed,istride,idist,onembed,ostride,odist, & myType,batch,workSize) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftGetSizeMany_rank_1 type(c_ptr) :: plan integer(c_int) :: rank integer(c_int),target,dimension(:) :: n integer(c_int),target,dimension(:) :: inembed integer(c_int) :: istride integer(c_int) :: idist integer(c_int),target,dimension(:) :: onembed integer(c_int) :: ostride integer(c_int) :: odist integer(kind(HIPFFT_R2C)) :: myType integer(c_int) :: batch integer(c_size_t) :: workSize ! hipfftGetSizeMany_rank_1 = hipfftGetSizeMany_(plan,rank,c_loc(n),c_loc(inembed),istride, & idist,c_loc(onembed),ostride,odist,myType,batch,workSize) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipfftGetSizeMany64_assumed_rank(plan,rank,n,inembed,istride,idist,onembed,ostride, & odist,myType,batch,workSize) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftGetSizeMany64_assumed_rank type(c_ptr) :: plan integer(c_int) :: rank integer(c_int64_t),target,contiguous,dimension(..) :: n integer(c_int64_t),target,contiguous,dimension(..) :: inembed integer(c_int64_t) :: istride integer(c_int64_t) :: idist integer(c_int64_t),target,contiguous,dimension(..) :: onembed integer(c_int64_t) :: ostride integer(c_int64_t) :: odist integer(kind(HIPFFT_R2C)) :: myType integer(c_int64_t) :: batch integer(c_size_t) :: workSize ! hipfftGetSizeMany64_assumed_rank = hipfftGetSizeMany64_(plan,rank,c_loc(n),c_loc(inembed), & istride,idist,c_loc(onembed),ostride,odist,myType,batch,workSize) end function #else function hipfftGetSizeMany64_rank_0(plan,rank,n,inembed,istride,idist,onembed,ostride,odist, & myType,batch,workSize) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftGetSizeMany64_rank_0 type(c_ptr) :: plan integer(c_int) :: rank integer(c_int64_t),target :: n integer(c_int64_t),target :: inembed integer(c_int64_t) :: istride integer(c_int64_t) :: idist integer(c_int64_t),target :: onembed integer(c_int64_t) :: ostride integer(c_int64_t) :: odist integer(kind(HIPFFT_R2C)) :: myType integer(c_int64_t) :: batch integer(c_size_t) :: workSize ! hipfftGetSizeMany64_rank_0 = hipfftGetSizeMany64_(plan,rank,c_loc(n),c_loc(inembed),istride, & idist,c_loc(onembed),ostride,odist,myType,batch,workSize) end function function hipfftGetSizeMany64_rank_1(plan,rank,n,inembed,istride,idist,onembed,ostride,odist, & myType,batch,workSize) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftGetSizeMany64_rank_1 type(c_ptr) :: plan integer(c_int) :: rank integer(c_int64_t),target,dimension(:) :: n integer(c_int64_t),target,dimension(:) :: inembed integer(c_int64_t) :: istride integer(c_int64_t) :: idist integer(c_int64_t),target,dimension(:) :: onembed integer(c_int64_t) :: ostride integer(c_int64_t) :: odist integer(kind(HIPFFT_R2C)) :: myType integer(c_int64_t) :: batch integer(c_size_t) :: workSize ! hipfftGetSizeMany64_rank_1 = hipfftGetSizeMany64_(plan,rank,c_loc(n),c_loc(inembed),istride, & idist,c_loc(onembed),ostride,odist,myType,batch,workSize) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipfftExecC2C_assumed_rank(plan,idata,odata,direction) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecC2C_assumed_rank type(c_ptr) :: plan complex(c_float_complex),target,contiguous,dimension(..) :: idata complex(c_float_complex),target,contiguous,dimension(..) :: odata integer(c_int) :: direction ! hipfftExecC2C_assumed_rank = hipfftExecC2C_(plan,c_loc(idata),c_loc(odata),direction) end function #else function hipfftExecC2C_rank_0(plan,idata,odata,direction) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecC2C_rank_0 type(c_ptr) :: plan complex(c_float_complex),target :: idata complex(c_float_complex),target :: odata integer(c_int) :: direction ! hipfftExecC2C_rank_0 = hipfftExecC2C_(plan,c_loc(idata),c_loc(odata),direction) end function function hipfftExecC2C_rank_1(plan,idata,odata,direction) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecC2C_rank_1 type(c_ptr) :: plan complex(c_float_complex),target,dimension(:) :: idata complex(c_float_complex),target,dimension(:) :: odata integer(c_int) :: direction ! hipfftExecC2C_rank_1 = hipfftExecC2C_(plan,c_loc(idata),c_loc(odata),direction) end function function hipfftExecC2C_rank_2(plan,idata,odata,direction) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecC2C_rank_2 type(c_ptr) :: plan complex(c_float_complex),target,dimension(:,:) :: idata complex(c_float_complex),target,dimension(:,:) :: odata integer(c_int) :: direction ! hipfftExecC2C_rank_2 = hipfftExecC2C_(plan,c_loc(idata),c_loc(odata),direction) end function function hipfftExecC2C_rank_3(plan,idata,odata,direction) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecC2C_rank_3 type(c_ptr) :: plan complex(c_float_complex),target,dimension(:,:,:) :: idata complex(c_float_complex),target,dimension(:,:,:) :: odata integer(c_int) :: direction ! hipfftExecC2C_rank_3 = hipfftExecC2C_(plan,c_loc(idata),c_loc(odata),direction) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipfftExecR2C_assumed_rank(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecR2C_assumed_rank type(c_ptr) :: plan real(c_float),target,contiguous,dimension(..) :: idata complex(c_float_complex),target,contiguous,dimension(..) :: odata ! hipfftExecR2C_assumed_rank = hipfftExecR2C_(plan,c_loc(idata),c_loc(odata)) end function #else function hipfftExecR2C_rank_0(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecR2C_rank_0 type(c_ptr) :: plan real(c_float),target :: idata complex(c_float_complex),target :: odata ! hipfftExecR2C_rank_0 = hipfftExecR2C_(plan,c_loc(idata),c_loc(odata)) end function function hipfftExecR2C_rank_1(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecR2C_rank_1 type(c_ptr) :: plan real(c_float),target,dimension(:) :: idata complex(c_float_complex),target,dimension(:) :: odata ! hipfftExecR2C_rank_1 = hipfftExecR2C_(plan,c_loc(idata),c_loc(odata)) end function function hipfftExecR2C_rank_2(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecR2C_rank_2 type(c_ptr) :: plan real(c_float),target,dimension(:,:) :: idata complex(c_float_complex),target,dimension(:,:) :: odata ! hipfftExecR2C_rank_2 = hipfftExecR2C_(plan,c_loc(idata),c_loc(odata)) end function function hipfftExecR2C_rank_3(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecR2C_rank_3 type(c_ptr) :: plan real(c_float),target,dimension(:,:,:) :: idata complex(c_float_complex),target,dimension(:,:,:) :: odata ! hipfftExecR2C_rank_3 = hipfftExecR2C_(plan,c_loc(idata),c_loc(odata)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipfftExecC2R_assumed_rank(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecC2R_assumed_rank type(c_ptr) :: plan complex(c_float_complex),target,contiguous,dimension(..) :: idata real(c_float),target,contiguous,dimension(..) :: odata ! hipfftExecC2R_assumed_rank = hipfftExecC2R_(plan,c_loc(idata),c_loc(odata)) end function #else function hipfftExecC2R_rank_0(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecC2R_rank_0 type(c_ptr) :: plan complex(c_float_complex),target :: idata real(c_float),target :: odata ! hipfftExecC2R_rank_0 = hipfftExecC2R_(plan,c_loc(idata),c_loc(odata)) end function function hipfftExecC2R_rank_1(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecC2R_rank_1 type(c_ptr) :: plan complex(c_float_complex),target,dimension(:) :: idata real(c_float),target,dimension(:) :: odata ! hipfftExecC2R_rank_1 = hipfftExecC2R_(plan,c_loc(idata),c_loc(odata)) end function function hipfftExecC2R_rank_2(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecC2R_rank_2 type(c_ptr) :: plan complex(c_float_complex),target,dimension(:,:) :: idata real(c_float),target,dimension(:,:) :: odata ! hipfftExecC2R_rank_2 = hipfftExecC2R_(plan,c_loc(idata),c_loc(odata)) end function function hipfftExecC2R_rank_3(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecC2R_rank_3 type(c_ptr) :: plan complex(c_float_complex),target,dimension(:,:,:) :: idata real(c_float),target,dimension(:,:,:) :: odata ! hipfftExecC2R_rank_3 = hipfftExecC2R_(plan,c_loc(idata),c_loc(odata)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipfftExecZ2Z_assumed_rank(plan,idata,odata,direction) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecZ2Z_assumed_rank type(c_ptr) :: plan complex(c_double_complex),target,contiguous,dimension(..) :: idata complex(c_double_complex),target,contiguous,dimension(..) :: odata integer(c_int) :: direction ! hipfftExecZ2Z_assumed_rank = hipfftExecZ2Z_(plan,c_loc(idata),c_loc(odata),direction) end function #else function hipfftExecZ2Z_rank_0(plan,idata,odata,direction) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecZ2Z_rank_0 type(c_ptr) :: plan complex(c_double_complex),target :: idata complex(c_double_complex),target :: odata integer(c_int) :: direction ! hipfftExecZ2Z_rank_0 = hipfftExecZ2Z_(plan,c_loc(idata),c_loc(odata),direction) end function function hipfftExecZ2Z_rank_1(plan,idata,odata,direction) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecZ2Z_rank_1 type(c_ptr) :: plan complex(c_double_complex),target,dimension(:) :: idata complex(c_double_complex),target,dimension(:) :: odata integer(c_int) :: direction ! hipfftExecZ2Z_rank_1 = hipfftExecZ2Z_(plan,c_loc(idata),c_loc(odata),direction) end function function hipfftExecZ2Z_rank_2(plan,idata,odata,direction) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecZ2Z_rank_2 type(c_ptr) :: plan complex(c_double_complex),target,dimension(:,:) :: idata complex(c_double_complex),target,dimension(:,:) :: odata integer(c_int) :: direction ! hipfftExecZ2Z_rank_2 = hipfftExecZ2Z_(plan,c_loc(idata),c_loc(odata),direction) end function function hipfftExecZ2Z_rank_3(plan,idata,odata,direction) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecZ2Z_rank_3 type(c_ptr) :: plan complex(c_double_complex),target,dimension(:,:,:) :: idata complex(c_double_complex),target,dimension(:,:,:) :: odata integer(c_int) :: direction ! hipfftExecZ2Z_rank_3 = hipfftExecZ2Z_(plan,c_loc(idata),c_loc(odata),direction) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipfftExecD2Z_assumed_rank(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecD2Z_assumed_rank type(c_ptr) :: plan real(c_double),target,contiguous,dimension(..) :: idata complex(c_double_complex),target,contiguous,dimension(..) :: odata ! hipfftExecD2Z_assumed_rank = hipfftExecD2Z_(plan,c_loc(idata),c_loc(odata)) end function #else function hipfftExecD2Z_rank_0(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecD2Z_rank_0 type(c_ptr) :: plan real(c_double),target :: idata complex(c_double_complex),target :: odata ! hipfftExecD2Z_rank_0 = hipfftExecD2Z_(plan,c_loc(idata),c_loc(odata)) end function function hipfftExecD2Z_rank_1(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecD2Z_rank_1 type(c_ptr) :: plan real(c_double),target,dimension(:) :: idata complex(c_double_complex),target,dimension(:) :: odata ! hipfftExecD2Z_rank_1 = hipfftExecD2Z_(plan,c_loc(idata),c_loc(odata)) end function function hipfftExecD2Z_rank_2(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecD2Z_rank_2 type(c_ptr) :: plan real(c_double),target,dimension(:,:) :: idata complex(c_double_complex),target,dimension(:,:) :: odata ! hipfftExecD2Z_rank_2 = hipfftExecD2Z_(plan,c_loc(idata),c_loc(odata)) end function function hipfftExecD2Z_rank_3(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecD2Z_rank_3 type(c_ptr) :: plan real(c_double),target,dimension(:,:,:) :: idata complex(c_double_complex),target,dimension(:,:,:) :: odata ! hipfftExecD2Z_rank_3 = hipfftExecD2Z_(plan,c_loc(idata),c_loc(odata)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipfftExecZ2D_assumed_rank(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecZ2D_assumed_rank type(c_ptr) :: plan complex(c_double_complex),target,contiguous,dimension(..) :: idata real(c_double),target,contiguous,dimension(..) :: odata ! hipfftExecZ2D_assumed_rank = hipfftExecZ2D_(plan,c_loc(idata),c_loc(odata)) end function #else function hipfftExecZ2D_rank_0(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecZ2D_rank_0 type(c_ptr) :: plan complex(c_double_complex),target :: idata real(c_double),target :: odata ! hipfftExecZ2D_rank_0 = hipfftExecZ2D_(plan,c_loc(idata),c_loc(odata)) end function function hipfftExecZ2D_rank_1(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecZ2D_rank_1 type(c_ptr) :: plan complex(c_double_complex),target,dimension(:) :: idata real(c_double),target,dimension(:) :: odata ! hipfftExecZ2D_rank_1 = hipfftExecZ2D_(plan,c_loc(idata),c_loc(odata)) end function function hipfftExecZ2D_rank_2(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecZ2D_rank_2 type(c_ptr) :: plan complex(c_double_complex),target,dimension(:,:) :: idata real(c_double),target,dimension(:,:) :: odata ! hipfftExecZ2D_rank_2 = hipfftExecZ2D_(plan,c_loc(idata),c_loc(odata)) end function function hipfftExecZ2D_rank_3(plan,idata,odata) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftExecZ2D_rank_3 type(c_ptr) :: plan complex(c_double_complex),target,dimension(:,:,:) :: idata real(c_double),target,dimension(:,:,:) :: odata ! hipfftExecZ2D_rank_3 = hipfftExecZ2D_(plan,c_loc(idata),c_loc(odata)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipfftGetProperty_assumed_rank(myType,myValue) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftGetProperty_assumed_rank integer(kind(HIPFFT_MAJOR_VERSION)) :: myType integer(c_int),target,contiguous,dimension(..) :: myValue ! hipfftGetProperty_assumed_rank = hipfftGetProperty_(myType,c_loc(myValue)) end function #else function hipfftGetProperty_rank_0(myType,myValue) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftGetProperty_rank_0 integer(kind(HIPFFT_MAJOR_VERSION)) :: myType integer(c_int),target :: myValue ! hipfftGetProperty_rank_0 = hipfftGetProperty_(myType,c_loc(myValue)) end function function hipfftGetProperty_rank_1(myType,myValue) use iso_c_binding use hipfort_hipfft_enums implicit none integer(kind(HIPFFT_SUCCESS)) :: hipfftGetProperty_rank_1 integer(kind(HIPFFT_MAJOR_VERSION)) :: myType integer(c_int),target,dimension(:) :: myValue ! hipfftGetProperty_rank_1 = hipfftGetProperty_(myType,c_loc(myValue)) end function #endif #endif end module hipfort_hipfft hipfort-rocm-10.0.0/lib/hipfort/hipfort_hipfft_enums.F90000066400000000000000000000060101524740623400231300ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_hipfft_enums use, intrinsic :: iso_c_binding implicit none ! hipfftResult_t enum, bind(c) enumerator :: HIPFFT_SUCCESS = 0 enumerator :: HIPFFT_INVALID_PLAN = 1 enumerator :: HIPFFT_ALLOC_FAILED = 2 enumerator :: HIPFFT_INVALID_TYPE = 3 enumerator :: HIPFFT_INVALID_VALUE = 4 enumerator :: HIPFFT_INTERNAL_ERROR = 5 enumerator :: HIPFFT_EXEC_FAILED = 6 enumerator :: HIPFFT_SETUP_FAILED = 7 enumerator :: HIPFFT_INVALID_SIZE = 8 enumerator :: HIPFFT_UNALIGNED_DATA = 9 enumerator :: HIPFFT_INCOMPLETE_PARAMETER_LIST = 10 enumerator :: HIPFFT_INVALID_DEVICE = 11 enumerator :: HIPFFT_PARSE_ERROR = 12 enumerator :: HIPFFT_NO_WORKSPACE = 13 enumerator :: HIPFFT_NOT_IMPLEMENTED = 14 enumerator :: HIPFFT_NOT_SUPPORTED = 16 end enum ! hipfftType_t enum, bind(c) enumerator :: HIPFFT_R2C = 42 enumerator :: HIPFFT_C2R = 44 enumerator :: HIPFFT_C2C = 41 enumerator :: HIPFFT_D2Z = 106 enumerator :: HIPFFT_Z2D = 108 enumerator :: HIPFFT_Z2Z = 105 end enum ! hipfftLibraryPropertyType_t enum, bind(c) enumerator :: HIPFFT_MAJOR_VERSION = 0 enumerator :: HIPFFT_MINOR_VERSION = 1 enumerator :: HIPFFT_PATCH_LEVEL = 2 end enum integer(c_int), parameter :: hipfftVersionMajor = 1 integer(c_int), parameter :: hipfftVersionMinor = 0 integer(c_int), parameter :: hipfftVersionPatch = 25 integer(c_int), parameter :: HIPFFT_FORWARD = -1 integer(c_int), parameter :: HIPFFT_BACKWARD = 1 end module hipfort_hipfft_enums hipfort-rocm-10.0.0/lib/hipfort/hipfort_hipfftw.F90000066400000000000000000001466541524740623400221330ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_hipfftw use hipfort_hipfftw_enums use hipfort_hipfftw_types implicit none !> @brief Allocates a data buffer accessible by the host. !> @param[in] n - number of bytes desired for the buffer. !> @return a pointer to the base address of the allocated memory block upon success (``nullptr`` !> otherwise). !> !> @remark The returned base address is at least 64-bit aligned. interface fftw_malloc function fftw_malloc_(n) bind(c, name="fftw_malloc") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftw_malloc_ integer(c_size_t),value :: n end function end interface !> @brief This function is strictly equivalent to \ref fftw_malloc interface fftwf_malloc function fftwf_malloc_(n) bind(c, name="fftwf_malloc") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_malloc_ integer(c_size_t),value :: n end function end interface !> @brief This function is strictly equivalent to ``(double*) fftw_malloc(n * sizeof(double))`` interface fftw_alloc_real function fftw_alloc_real_(n) bind(c, name="fftw_alloc_real") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftw_alloc_real_ integer(c_size_t),value :: n end function end interface !> @brief This function is strictly equivalent to ``(float*) fftw_malloc(n * sizeof(float))`` interface fftwf_alloc_real function fftwf_alloc_real_(n) bind(c, name="fftwf_alloc_real") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_alloc_real_ integer(c_size_t),value :: n end function end interface !> @brief This function is strictly equivalent to !> ``(fftw_complex*) fftw_malloc(n * sizeof(fftw_complex))`` interface fftw_alloc_complex function fftw_alloc_complex_(n) bind(c, name="fftw_alloc_complex") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftw_alloc_complex_ integer(c_size_t),value :: n end function end interface !> @brief This function is strictly equivalent to !> ``(fftwf_complex*) fftw_malloc(n * sizeof(fftwf_complex))`` interface fftwf_alloc_complex function fftwf_alloc_complex_(n) bind(c, name="fftwf_alloc_complex") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_alloc_complex_ integer(c_size_t),value :: n end function end interface !> @brief Frees a buffer previously allocated by any of the allocation functions above. !> !> @param[in] p - pointer to the base address of the buffer to be freed. interface fftw_free subroutine fftw_free_(p) bind(c, name="fftw_free") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr),value :: p end subroutine end interface !> @brief This function is strictly equivalent to \ref fftw_free interface fftwf_free subroutine fftwf_free_(p) bind(c, name="fftwf_free") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr),value :: p end subroutine end interface !> @brief Creates a basic plan for a one-dimensional, double-precision, complex discrete Fourier !> transform of length ``n``. !> !> @param[in] n - strictly positive length of the transform; !> @param[in] in - pointer to the input buffer for the transform; !> @param[in] out - pointer to the output buffer for the transform; !> @param[in] sign - exponent sign defining the desired complex transform (``FFTW_FORWARD`` or !> ``FFTW_BACKWARD`` ); !> @param[in] flags - bitwise OR (|) combination of zero or more constant flag values. !> @return a valid double-precision hipFFTW plan ready for execution upon success (``nullptr`` !> otherwise). interface fftw_plan_dft_1d function fftw_plan_dft_1d_(n,in,out,sign,flags) bind(c, name="fftw_plan_dft_1d") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftw_plan_dft_1d_ integer(c_int),value :: n type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: sign integer(c_int),value :: flags end function end interface !> @brief Single-precision equivalent of \ref fftw_plan_dft_1d. interface fftwf_plan_dft_1d function fftwf_plan_dft_1d_(n,in,out,sign,flags) bind(c, name="fftwf_plan_dft_1d") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_dft_1d_ integer(c_int),value :: n type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: sign integer(c_int),value :: flags end function end interface !> @brief Creates a basic plan for a two-dimensional, double-precision, complex discrete Fourier !> transform of lengths ``n0 x n1``. !> !> @param[in] n0 - , n1 strictly positive lengths of the transform; !> @param[in] in - pointer to the input buffer for the transform; !> @param[in] out - pointer to the output buffer for the transform; !> @param[in] sign - exponent sign defining the desired complex transform (``FFTW_FORWARD`` or !> ``FFTW_BACKWARD`` ); !> @param[in] flags - bitwise OR (|) combination of zero or more constant flag values. !> @return a valid double-precision hipFFTW plan ready for execution upon success (``nullptr`` !> otherwise). interface fftw_plan_dft_2d function fftw_plan_dft_2d_(n0,n1,in,out,sign,flags) bind(c, name="fftw_plan_dft_2d") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftw_plan_dft_2d_ integer(c_int),value :: n0 integer(c_int),value :: n1 type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: sign integer(c_int),value :: flags end function end interface !> @brief Single-precision equivalent of \ref fftw_plan_dft_2d. interface fftwf_plan_dft_2d function fftwf_plan_dft_2d_(n0,n1,in,out,sign,flags) bind(c, name="fftwf_plan_dft_2d") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_dft_2d_ integer(c_int),value :: n0 integer(c_int),value :: n1 type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: sign integer(c_int),value :: flags end function end interface !> @brief Creates a basic plan for a three-dimensional, double-precision, complex discrete !> Fourier transform of lengths ``n0 x n1 x n2``. !> !> @param[in] n0 - , n1,n2 strictly positive lengths of the transform; !> @param[in] in - pointer to the input buffer for the transform; !> @param[in] out - pointer to the output buffer for the transform; !> @param[in] sign - exponent sign defining the desired complex transform (``FFTW_FORWARD`` or !> ``FFTW_BACKWARD`` ); !> @param[in] flags - bitwise OR (|) combination of zero or more constant flag values. !> @return a valid double-precision hipFFTW plan ready for execution upon success (``nullptr`` !> otherwise). interface fftw_plan_dft_3d function fftw_plan_dft_3d_(n0,n1,n2,in,out,sign,flags) bind(c, name="fftw_plan_dft_3d") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftw_plan_dft_3d_ integer(c_int),value :: n0 integer(c_int),value :: n1 integer(c_int),value :: n2 type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: sign integer(c_int),value :: flags end function end interface !> @brief Single-precision equivalent of \ref fftw_plan_dft_3d. interface fftwf_plan_dft_3d function fftwf_plan_dft_3d_(n0,n1,n2,in,out,sign,flags) bind(c, name="fftwf_plan_dft_3d") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_dft_3d_ integer(c_int),value :: n0 integer(c_int),value :: n1 integer(c_int),value :: n2 type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: sign integer(c_int),value :: flags end function end interface !> @brief Creates a basic plan for a multidimensional, double-precision, complex discrete Fourier !> transform of lengths n[0] x n[1] x ... x n[rank-1]. !> !> @param[in] rank - strictly positive rank of the transform; !> @param[in] n - array of strictly positive lengths of the transform (must be of size ``rank``); !> @param[in] in - pointer to the input buffer for the transform; !> @param[in] out - pointer to the output buffer for the transform; !> @param[in] sign - exponent sign defining the desired complex transform (``FFTW_FORWARD`` or !> ``FFTW_BACKWARD`` ); !> @param[in] flags - bitwise OR (|) combination of zero or more constant flag values. !> @return a valid double-precision hipFFTW plan ready for execution upon success (``nullptr`` !> otherwise). interface fftw_plan_dft function fftw_plan_dft_(rank,n,in,out,sign,flags) bind(c, name="fftw_plan_dft") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftw_plan_dft_ integer(c_int),value :: rank type(c_ptr),value :: n type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: sign integer(c_int),value :: flags end function end interface !> @brief Single-precision equivalent of \ref fftw_plan_dft. interface fftwf_plan_dft function fftwf_plan_dft_(rank,n,in,out,sign,flags) bind(c, name="fftwf_plan_dft") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_dft_ integer(c_int),value :: rank type(c_ptr),value :: n type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: sign integer(c_int),value :: flags end function end interface !> @brief Creates a basic plan for a one-dimensional, double-precision, real forward discrete !> Fourier transform of length ``n``. !> !> @param[in] n - strictly positive length of the transform; !> @param[in] in - pointer to the input buffer for the transform; !> @param[in] out - pointer to the output buffer for the transform; !> @param[in] flags - bitwise OR (|) combination of zero or more constant flag values. !> @return a valid double-precision hipFFTW plan ready for execution upon success (``nullptr`` !> otherwise). interface fftw_plan_dft_r2c_1d function fftw_plan_dft_r2c_1d_(n,in,out,flags) bind(c, name="fftw_plan_dft_r2c_1d") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftw_plan_dft_r2c_1d_ integer(c_int),value :: n type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Single-precision equivalent of \ref fftw_plan_dft_r2c_1d. interface fftwf_plan_dft_r2c_1d function fftwf_plan_dft_r2c_1d_(n,in,out,flags) bind(c, name="fftwf_plan_dft_r2c_1d") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_dft_r2c_1d_ integer(c_int),value :: n type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Creates a basic plan for a two-dimensional, double-precision, real forward discrete !> Fourier transform of lengths ``n0 x n1``. !> !> @param[in] n0 - , n1 strictly positive lengths of the transform; !> @param[in] in - pointer to the input buffer for the transform; !> @param[in] out - pointer to the output buffer for the transform; !> @param[in] flags - bitwise OR (|) combination of zero or more constant flag values. !> @return a valid double-precision hipFFTW plan ready for execution upon success (``nullptr`` !> otherwise). interface fftw_plan_dft_r2c_2d function fftw_plan_dft_r2c_2d_(n0,n1,in,out,flags) bind(c, name="fftw_plan_dft_r2c_2d") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftw_plan_dft_r2c_2d_ integer(c_int),value :: n0 integer(c_int),value :: n1 type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Single-precision equivalent of \ref fftw_plan_dft_r2c_2d. interface fftwf_plan_dft_r2c_2d function fftwf_plan_dft_r2c_2d_(n0,n1,in,out,flags) bind(c, name="fftwf_plan_dft_r2c_2d") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_dft_r2c_2d_ integer(c_int),value :: n0 integer(c_int),value :: n1 type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Creates a basic plan for a three-dimensional, double-precision, real forward discrete !> Fourier transform of lengths ``n0 x n1 x n2``. !> !> @param[in] n0 - , n1, n2 strictly positive lengths of the transform; !> @param[in] in - pointer to the input buffer for the transform; !> @param[in] out - pointer to the output buffer for the transform; !> @param[in] flags - bitwise OR (|) combination of zero or more constant flag values. !> @return a valid double-precision hipFFTW plan ready for execution upon success (``nullptr`` !> otherwise). interface fftw_plan_dft_r2c_3d function fftw_plan_dft_r2c_3d_(n0,n1,n2,in,out,flags) bind(c, name="fftw_plan_dft_r2c_3d") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftw_plan_dft_r2c_3d_ integer(c_int),value :: n0 integer(c_int),value :: n1 integer(c_int),value :: n2 type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Single-precision equivalent of \ref fftw_plan_dft_r2c_3d. interface fftwf_plan_dft_r2c_3d function fftwf_plan_dft_r2c_3d_(n0,n1,n2,in,out,flags) bind(c, name="fftwf_plan_dft_r2c_3d") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_dft_r2c_3d_ integer(c_int),value :: n0 integer(c_int),value :: n1 integer(c_int),value :: n2 type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Creates a basic plan for a multidimensional, double-precision, real forward discrete !> Fourier transform of lengths n[0] x n[1] x ... x n[rank-1]. !> !> @param[in] rank - strictly positive rank of the transform; !> @param[in] n - array of strictly positive lengths of the transform (must be of size ``rank``); !> @param[in] in - pointer to the input buffer for the transform; !> @param[in] out - pointer to the output buffer for the transform; !> @param[in] flags - bitwise OR (|) combination of zero or more constant flag values. !> @return a valid double-precision hipFFTW plan ready for execution upon success (``nullptr`` !> otherwise). interface fftw_plan_dft_r2c function fftw_plan_dft_r2c_(rank,n,in,out,flags) bind(c, name="fftw_plan_dft_r2c") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftw_plan_dft_r2c_ integer(c_int),value :: rank type(c_ptr),value :: n type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Single-precision equivalent of \ref fftw_plan_dft_r2c. interface fftwf_plan_dft_r2c function fftwf_plan_dft_r2c_(rank,n,in,out,flags) bind(c, name="fftwf_plan_dft_r2c") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_dft_r2c_ integer(c_int),value :: rank type(c_ptr),value :: n type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Creates a basic plan for a one-dimensional, double-precision, real backward (inverse) !> discrete Fourier transform of length ``n``. !> !> @param[in] n - strictly positive length of the transform; !> @param[in] in - pointer to the input buffer for the transform; !> @param[in] out - pointer to the output buffer for the transform; !> @param[in] flags - bitwise OR (|) combination of zero or more constant flag values. !> @return a valid double-precision hipFFTW plan ready for execution upon success (``nullptr`` !> otherwise). interface fftw_plan_dft_c2r_1d function fftw_plan_dft_c2r_1d_(n,in,out,flags) bind(c, name="fftw_plan_dft_c2r_1d") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftw_plan_dft_c2r_1d_ integer(c_int),value :: n type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Single-precision equivalent of \ref fftw_plan_dft_c2r_1d. interface fftwf_plan_dft_c2r_1d function fftwf_plan_dft_c2r_1d_(n,in,out,flags) bind(c, name="fftwf_plan_dft_c2r_1d") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_dft_c2r_1d_ integer(c_int),value :: n type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Creates a basic plan for a two-dimensional, double-precision, real backward (inverse) !> discrete Fourier transform of lengths ``n0 x n1``. !> !> @param[in] n0 - , n1 strictly positive lengths of the transform; !> @param[in] in - pointer to the input buffer for the transform; !> @param[in] out - pointer to the output buffer for the transform; !> @param[in] flags - bitwise OR (|) combination of zero or more constant flag values. !> @return a valid double-precision hipFFTW plan ready for execution upon success (``nullptr`` !> otherwise). interface fftw_plan_dft_c2r_2d function fftw_plan_dft_c2r_2d_(n0,n1,in,out,flags) bind(c, name="fftw_plan_dft_c2r_2d") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftw_plan_dft_c2r_2d_ integer(c_int),value :: n0 integer(c_int),value :: n1 type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Single-precision equivalent of \ref fftw_plan_dft_c2r_2d. interface fftwf_plan_dft_c2r_2d function fftwf_plan_dft_c2r_2d_(n0,n1,in,out,flags) bind(c, name="fftwf_plan_dft_c2r_2d") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_dft_c2r_2d_ integer(c_int),value :: n0 integer(c_int),value :: n1 type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Creates a basic plan for a three-dimensional, double-precision, real backward (inverse) !> discrete Fourier transform of lengths ``n0 x n1 x n2``. !> !> @param[in] n0 - , n1, n2 strictly positive lengths of the transform; !> @param[in] in - pointer to the input buffer for the transform; !> @param[in] out - pointer to the output buffer for the transform; !> @param[in] flags - bitwise OR (|) combination of zero or more constant flag values. !> @return a valid double-precision hipFFTW plan ready for execution upon success (``nullptr`` !> otherwise). interface fftw_plan_dft_c2r_3d function fftw_plan_dft_c2r_3d_(n0,n1,n2,in,out,flags) bind(c, name="fftw_plan_dft_c2r_3d") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftw_plan_dft_c2r_3d_ integer(c_int),value :: n0 integer(c_int),value :: n1 integer(c_int),value :: n2 type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Single-precision equivalent of \ref fftw_plan_dft_c2r_3d. interface fftwf_plan_dft_c2r_3d function fftwf_plan_dft_c2r_3d_(n0,n1,n2,in,out,flags) bind(c, name="fftwf_plan_dft_c2r_3d") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_dft_c2r_3d_ integer(c_int),value :: n0 integer(c_int),value :: n1 integer(c_int),value :: n2 type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Creates a basic plan for a multidimensional, double-precision, real backward (inverse) !> discrete Fourier transform of lengths n[0] x n[1] x ... x n[rank-1]. !> !> @param[in] rank - strictly positive rank of the transform; !> @param[in] n - array of strictly positive lengths of the transform (must be of size ``rank``); !> @param[in] in - pointer to the input buffer for the transform; !> @param[in] out - pointer to the output buffer for the transform; !> @param[in] flags - bitwise OR (|) combination of zero or more constant flag values. !> @return a valid double-precision hipFFTW plan ready for execution upon success (``nullptr`` !> otherwise). interface fftw_plan_dft_c2r function fftw_plan_dft_c2r_(rank,n,in,out,flags) bind(c, name="fftw_plan_dft_c2r") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftw_plan_dft_c2r_ integer(c_int),value :: rank type(c_ptr),value :: n type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Single-precision equivalent of \ref fftw_plan_dft_c2r. interface fftwf_plan_dft_c2r function fftwf_plan_dft_c2r_(rank,n,in,out,flags) bind(c, name="fftwf_plan_dft_c2r") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_dft_c2r_ integer(c_int),value :: rank type(c_ptr),value :: n type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Creates an advanced plan for a multidimensional, double-precision, complex discrete !> Fourier transform !> of lengths n[0] x n[1] x ... x n[rank-1] and batch size ``howmany``. !> !> @param[in] rank - strictly positive rank of the transform; !> @param[in] n - array of strictly positive lengths of the transform (must be of size ``rank``); !> @param[in] howmany - strictly positive batch size; !> @param[in] in - pointer to the input buffer for the transform; !> @param[in] inembed - array of strictly positive input-embedding lengths (must be of size !> ``rank`` ). Default input-embedding is considered if set to ``NULL``; !> @param[in] istride - strictly positive elementary stride in input data (along the last !> dimension); !> @param[in] idist - strictly positive distance between consecutive input data sequences in the !> batch; !> @param[in] out - pointer to the output buffer for the transform; !> @param[in] onembed - array of strictly positive output-embedding lengths (must be of size !> ``rank`` ). Default output-embedding is considered if set to ``NULL``; !> @param[in] ostride - strictly positive elementary stride in output data (along the last !> dimension); !> @param[in] odist - strictly positive distance between consecutive output data sequences in the !> batch; !> @param[in] sign - exponent sign defining the desired complex transform (``FFTW_FORWARD`` or !> ``FFTW_BACKWARD`` ); !> @param[in] flags - bitwise OR (|) combination of zero or more constant flag values. !> @return a valid double-precision hipFFTW plan ready for execution upon success (``nullptr`` !> otherwise). interface fftw_plan_many_dft function fftw_plan_many_dft_(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride, & odist,sign,flags) & bind(c, name="fftw_plan_many_dft") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftw_plan_many_dft_ integer(c_int),value :: rank type(c_ptr),value :: n integer(c_int),value :: howmany type(c_ptr),value :: in type(c_ptr),value :: inembed integer(c_int),value :: istride integer(c_int),value :: idist type(c_ptr),value :: out type(c_ptr),value :: onembed integer(c_int),value :: ostride integer(c_int),value :: odist integer(c_int),value :: sign integer(c_int),value :: flags end function end interface !> @brief Single-precision equivalent of \ref fftw_plan_many_dft. interface fftwf_plan_many_dft function fftwf_plan_many_dft_(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride, & odist,sign,flags) & bind(c, name="fftwf_plan_many_dft") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_many_dft_ integer(c_int),value :: rank type(c_ptr),value :: n integer(c_int),value :: howmany type(c_ptr),value :: in type(c_ptr),value :: inembed integer(c_int),value :: istride integer(c_int),value :: idist type(c_ptr),value :: out type(c_ptr),value :: onembed integer(c_int),value :: ostride integer(c_int),value :: odist integer(c_int),value :: sign integer(c_int),value :: flags end function end interface !> @brief Creates an advanced plan for a multidimensional, double-precision, real forward !> discrete Fourier !> transform of lengths n[0] x n[1] x ... x n[rank-1] and batch size ``howmany``. !> !> @param[in] rank - strictly positive rank of the transform; !> @param[in] n - array of strictly positive lengths of the transform (must be of size ``rank``); !> @param[in] howmany - strictly positive batch size; !> @param[in] in - pointer to the input buffer for the transform; !> @param[in] inembed - array of strictly positive input-embedding lengths (must be of size !> ``rank`` ). Default input-embedding is considered if set to ``NULL``; !> @param[in] istride - strictly positive elementary stride in input data (along the last !> dimension); !> @param[in] idist - strictly positive distance between consecutive input data sequences in the !> batch; !> @param[in] out - pointer to the output buffer for the transform; !> @param[in] onembed - array of strictly positive output-embedding lengths (must be of size !> ``rank`` ). Default output-embedding is considered if set to ``NULL``; !> @param[in] ostride - strictly positive elementary stride in output data (along the last !> dimension); !> @param[in] odist - strictly positive distance between consecutive output data sequences in the !> batch; !> @param[in] flags - bitwise OR (|) combination of zero or more constant flag values. !> @return a valid double-precision hipFFTW plan ready for execution upon success (``nullptr`` !> otherwise). interface fftw_plan_many_dft_r2c function fftw_plan_many_dft_r2c_(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride, & odist,flags) & bind(c, name="fftw_plan_many_dft_r2c") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftw_plan_many_dft_r2c_ integer(c_int),value :: rank type(c_ptr),value :: n integer(c_int),value :: howmany type(c_ptr),value :: in type(c_ptr),value :: inembed integer(c_int),value :: istride integer(c_int),value :: idist type(c_ptr),value :: out type(c_ptr),value :: onembed integer(c_int),value :: ostride integer(c_int),value :: odist integer(c_int),value :: flags end function end interface !> @brief Single-precision equivalent of \ref fftw_plan_many_dft_r2c. interface fftwf_plan_many_dft_r2c function fftwf_plan_many_dft_r2c_(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride, & odist,flags) & bind(c, name="fftwf_plan_many_dft_r2c") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_many_dft_r2c_ integer(c_int),value :: rank type(c_ptr),value :: n integer(c_int),value :: howmany type(c_ptr),value :: in type(c_ptr),value :: inembed integer(c_int),value :: istride integer(c_int),value :: idist type(c_ptr),value :: out type(c_ptr),value :: onembed integer(c_int),value :: ostride integer(c_int),value :: odist integer(c_int),value :: flags end function end interface !> @brief Creates an advanced plan for a multidimensional, double-precision, real backward !> (inverse) !> discrete Fourier transform of lengths n[0] x n[1] x ... x n[rank-1] and batch size !> ``howmany``. !> !> @param[in] rank - strictly positive rank of the transform; !> @param[in] n - array of strictly positive lengths of the transform (must be of size ``rank``); !> @param[in] howmany - strictly positive batch size; !> @param[in] in - pointer to the input buffer for the transform; !> @param[in] inembed - array of strictly positive input-embedding lengths (must be of size !> ``rank`` ). Default input-embedding is considered if set to ``NULL``; !> @param[in] istride - strictly positive elementary stride in input data (along the last !> dimension); !> @param[in] idist - strictly positive distance between consecutive input data sequences in the !> batch; !> @param[in] out - pointer to the output buffer for the transform; !> @param[in] onembed - array of strictly positive output-embedding lengths (must be of size !> ``rank`` ). Default output-embedding is considered if set to ``NULL``; !> @param[in] ostride - strictly positive elementary stride in output data (along the last !> dimension); !> @param[in] odist - strictly positive distance between consecutive output data sequences in the !> batch; !> @param[in] flags - bitwise OR (|) combination of zero or more constant flag values. !> @return a valid double-precision hipFFTW plan ready for execution upon success (``nullptr`` !> otherwise). interface fftw_plan_many_dft_c2r function fftw_plan_many_dft_c2r_(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride, & odist,flags) & bind(c, name="fftw_plan_many_dft_c2r") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftw_plan_many_dft_c2r_ integer(c_int),value :: rank type(c_ptr),value :: n integer(c_int),value :: howmany type(c_ptr),value :: in type(c_ptr),value :: inembed integer(c_int),value :: istride integer(c_int),value :: idist type(c_ptr),value :: out type(c_ptr),value :: onembed integer(c_int),value :: ostride integer(c_int),value :: odist integer(c_int),value :: flags end function end interface !> @brief Single-precision equivalent of \ref fftw_plan_many_dft_c2r. interface fftwf_plan_many_dft_c2r function fftwf_plan_many_dft_c2r_(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride, & odist,flags) & bind(c, name="fftwf_plan_many_dft_c2r") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_many_dft_c2r_ integer(c_int),value :: rank type(c_ptr),value :: n integer(c_int),value :: howmany type(c_ptr),value :: in type(c_ptr),value :: inembed integer(c_int),value :: istride integer(c_int),value :: idist type(c_ptr),value :: out type(c_ptr),value :: onembed integer(c_int),value :: ostride integer(c_int),value :: odist integer(c_int),value :: flags end function end interface !> @brief Creates an arbitrary plan for a multidimensional, double-precision, complex !> discrete Fourier transform of lengths dims[0].n x dims[1].n x ... x dims[rank-1].n !> and batch sizes howmany_dims[0].n x howmany_dims[1].n x ... x howmany_dims[howmany_rank-1].n. !> !> @param[in] rank - strictly positive rank of the transform; !> @param[in] dims - array of ``rank`` ``fftw_iodim`` values; !> @param[in] howmany_rank - strictly positive rank of the transform's batch sizes; !> @param[in] howmany_dims - array of ``howmany_rank`` ``fftw_iodim`` values; !> @param[in] in - pointer to the input buffer for the transform; !> @param[in] out - pointer to the output buffer for the transform; !> @param[in] sign - exponent sign defining the desired complex transform (``FFTW_FORWARD`` or !> ``FFTW_BACKWARD`` ); !> @param[in] flags - bitwise OR (|) combination of zero or more constant flag values. !> @return a valid double-precision hipFFTW plan ready for execution upon success (``nullptr`` !> otherwise). interface fftw_plan_guru_dft function fftw_plan_guru_dft_(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) & bind(c, name="fftw_plan_guru_dft") use iso_c_binding use hipfort_hipfftw_enums use hipfort_hipfftw_types implicit none type(c_ptr) :: fftw_plan_guru_dft_ integer(c_int),value :: rank type(fftw_iodim) :: dims integer(c_int),value :: howmany_rank type(fftw_iodim) :: howmany_dims type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: sign integer(c_int),value :: flags end function end interface !> @brief Single-precision equivalent of \ref fftw_plan_guru_dft. interface fftwf_plan_guru_dft function fftwf_plan_guru_dft_(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) & bind(c, name="fftwf_plan_guru_dft") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_guru_dft_ integer(c_int),value :: rank type(c_ptr),value :: dims integer(c_int),value :: howmany_rank type(c_ptr),value :: howmany_dims type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: sign integer(c_int),value :: flags end function end interface !> @brief Creates an arbitrary plan for a multidimensional, double-precision, real forward !> discrete Fourier transform of lengths dims[0].n x dims[1].n x ... x dims[rank-1].n !> and batch sizes howmany_dims[0].n x howmany_dims[1].n x ... x howmany_dims[howmany_rank-1].n. !> !> @param[in] rank - strictly positive rank of the transform; !> @param[in] dims - array of ``rank`` ``fftw_iodim`` values; !> @param[in] howmany_rank - strictly positive rank of the transform's batch sizes; !> @param[in] howmany_dims - array of ``howmany_rank`` ``fftw_iodim`` values; !> @param[in] in - pointer to the input buffer for the transform; !> @param[in] out - pointer to the output buffer for the transform; !> @param[in] flags - bitwise OR (|) combination of zero or more constant flag values. !> @return a valid double-precision hipFFTW plan ready for execution upon success (``nullptr`` !> otherwise). interface fftw_plan_guru_dft_r2c function fftw_plan_guru_dft_r2c_(rank,dims,howmany_rank,howmany_dims,in,out,flags) & bind(c, name="fftw_plan_guru_dft_r2c") use iso_c_binding use hipfort_hipfftw_enums use hipfort_hipfftw_types implicit none type(c_ptr) :: fftw_plan_guru_dft_r2c_ integer(c_int),value :: rank type(fftw_iodim) :: dims integer(c_int),value :: howmany_rank type(fftw_iodim) :: howmany_dims type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Single-precision equivalent of \ref fftw_plan_guru_dft_r2c. interface fftwf_plan_guru_dft_r2c function fftwf_plan_guru_dft_r2c_(rank,dims,howmany_rank,howmany_dims,in,out,flags) & bind(c, name="fftwf_plan_guru_dft_r2c") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_guru_dft_r2c_ integer(c_int),value :: rank type(c_ptr),value :: dims integer(c_int),value :: howmany_rank type(c_ptr),value :: howmany_dims type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Creates an arbitrary plan for a multidimensional, double-precision, real backward !> (inverse) discrete Fourier transform of lengths dims[0].n x dims[1].n x ... x dims[rank-1].n !> and batch sizes howmany_dims[0].n x howmany_dims[1].n x ... x howmany_dims[howmany_rank-1].n. !> !> @param[in] rank - strictly positive rank of the transform; !> @param[in] dims - array of ``rank`` ``fftw_iodim`` values; !> @param[in] howmany_rank - strictly positive rank of the transform's batch sizes; !> @param[in] howmany_dims - array of ``howmany_rank`` ``fftw_iodim`` values; !> @param[in] in - pointer to the input buffer for the transform; !> @param[in] out - pointer to the output buffer for the transform; !> @param[in] flags - bitwise OR (|) combination of zero or more constant flag values. !> @return a valid double-precision hipFFTW plan ready for execution upon success (``nullptr`` !> otherwise). interface fftw_plan_guru_dft_c2r function fftw_plan_guru_dft_c2r_(rank,dims,howmany_rank,howmany_dims,in,out,flags) & bind(c, name="fftw_plan_guru_dft_c2r") use iso_c_binding use hipfort_hipfftw_enums use hipfort_hipfftw_types implicit none type(c_ptr) :: fftw_plan_guru_dft_c2r_ integer(c_int),value :: rank type(fftw_iodim) :: dims integer(c_int),value :: howmany_rank type(fftw_iodim) :: howmany_dims type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Single-precision equivalent of \ref fftw_plan_guru_dft_c2r. interface fftwf_plan_guru_dft_c2r function fftwf_plan_guru_dft_c2r_(rank,dims,howmany_rank,howmany_dims,in,out,flags) & bind(c, name="fftwf_plan_guru_dft_c2r") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_guru_dft_c2r_ integer(c_int),value :: rank type(c_ptr),value :: dims integer(c_int),value :: howmany_rank type(c_ptr),value :: howmany_dims type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Equivalent of \ref fftw_plan_guru_dft using layout-describing values of type !> ``fftw_iodim64`` instead of ``fftw_iodim``. interface fftw_plan_guru64_dft function fftw_plan_guru64_dft_(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) & bind(c, name="fftw_plan_guru64_dft") use iso_c_binding use hipfort_hipfftw_enums use hipfort_hipfftw_types implicit none type(c_ptr) :: fftw_plan_guru64_dft_ integer(c_int),value :: rank type(fftw_iodim64) :: dims integer(c_int),value :: howmany_rank type(fftw_iodim64) :: howmany_dims type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: sign integer(c_int),value :: flags end function end interface !> @brief Equivalent of \ref fftwf_plan_guru_dft using layout-describing values of type !> ``fftwf_iodim64`` instead of ``fftwf_iodim``. interface fftwf_plan_guru64_dft function fftwf_plan_guru64_dft_(rank,dims,howmany_rank,howmany_dims,in,out,sign,flags) & bind(c, name="fftwf_plan_guru64_dft") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_guru64_dft_ integer(c_int),value :: rank type(c_ptr),value :: dims integer(c_int),value :: howmany_rank type(c_ptr),value :: howmany_dims type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: sign integer(c_int),value :: flags end function end interface !> @brief Equivalent of \ref fftw_plan_guru_dft_r2c using layout-describing values of type !> ``fftw_iodim64`` instead of ``fftw_iodim``. interface fftw_plan_guru64_dft_r2c function fftw_plan_guru64_dft_r2c_(rank,dims,howmany_rank,howmany_dims,in,out,flags) & bind(c, name="fftw_plan_guru64_dft_r2c") use iso_c_binding use hipfort_hipfftw_enums use hipfort_hipfftw_types implicit none type(c_ptr) :: fftw_plan_guru64_dft_r2c_ integer(c_int),value :: rank type(fftw_iodim64) :: dims integer(c_int),value :: howmany_rank type(fftw_iodim64) :: howmany_dims type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Equivalent of \ref fftwf_plan_guru_dft_r2c using layout-describing values of type !> ``fftwf_iodim64`` instead of ``fftwf_iodim``. interface fftwf_plan_guru64_dft_r2c function fftwf_plan_guru64_dft_r2c_(rank,dims,howmany_rank,howmany_dims,in,out,flags) & bind(c, name="fftwf_plan_guru64_dft_r2c") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_guru64_dft_r2c_ integer(c_int),value :: rank type(c_ptr),value :: dims integer(c_int),value :: howmany_rank type(c_ptr),value :: howmany_dims type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Equivalent of \ref fftw_plan_guru_dft_c2r using layout-describing values of type !> ``fftw_iodim64`` instead of ``fftw_iodim``. interface fftw_plan_guru64_dft_c2r function fftw_plan_guru64_dft_c2r_(rank,dims,howmany_rank,howmany_dims,in,out,flags) & bind(c, name="fftw_plan_guru64_dft_c2r") use iso_c_binding use hipfort_hipfftw_enums use hipfort_hipfftw_types implicit none type(c_ptr) :: fftw_plan_guru64_dft_c2r_ integer(c_int),value :: rank type(fftw_iodim64) :: dims integer(c_int),value :: howmany_rank type(fftw_iodim64) :: howmany_dims type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Equivalent of \ref fftwf_plan_guru_dft_c2r using layout-describing values of type !> ``fftwf_iodim64`` instead of ``fftwf_iodim``. interface fftwf_plan_guru64_dft_c2r function fftwf_plan_guru64_dft_c2r_(rank,dims,howmany_rank,howmany_dims,in,out,flags) & bind(c, name="fftwf_plan_guru64_dft_c2r") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr) :: fftwf_plan_guru64_dft_c2r_ integer(c_int),value :: rank type(c_ptr),value :: dims integer(c_int),value :: howmany_rank type(c_ptr),value :: howmany_dims type(c_ptr),value :: in type(c_ptr),value :: out integer(c_int),value :: flags end function end interface !> @brief Computes the discrete Fourier transform that a double-precision plan captures using !> the input and output data buffers that were communicated at plan's creation. !> !> @param[in] plan - the double-precision plan capturing the transform to compute. interface fftw_execute subroutine fftw_execute_(plan) bind(c, name="fftw_execute") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr),value :: plan end subroutine end interface !> @brief Single-precision equivalent of \ref fftw_execute interface fftwf_execute subroutine fftwf_execute_(plan) bind(c, name="fftwf_execute") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr),value :: plan end subroutine end interface !> @brief Computes the discrete Fourier transform that a double-precision plan captures using new !> input and output data buffers. !> The plan must have been created for a complex transform. !> !> @param[in] plan - the double-precision plan capturing the complex transform to compute; !> @param[in] in - pointer to a new input buffer for the transform; !> @param[out] out - pointer to a new output buffer for the transform. interface fftw_execute_dft subroutine fftw_execute_dft_(plan,in,out) bind(c, name="fftw_execute_dft") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr),value :: plan type(c_ptr),value :: in type(c_ptr),value :: out end subroutine end interface !> @brief Single-precision equivalent of \ref fftw_execute_dft. interface fftwf_execute_dft subroutine fftwf_execute_dft_(plan,in,out) bind(c, name="fftwf_execute_dft") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr),value :: plan type(c_ptr),value :: in type(c_ptr),value :: out end subroutine end interface !> @brief Computes the discrete Fourier transform that a double-precision plan captures using new !> input and output data buffers. !> The plan must have been created for a real forward transform. !> !> @param[in] plan - the double-precision plan capturing the real forward transform to compute; !> @param[in] in - pointer to a new input buffer for the transform; !> @param[out] out - pointer to a new output buffer for the transform. interface fftw_execute_dft_r2c subroutine fftw_execute_dft_r2c_(plan,in,out) bind(c, name="fftw_execute_dft_r2c") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr),value :: plan type(c_ptr),value :: in type(c_ptr),value :: out end subroutine end interface !> @brief Single-precision equivalent of \ref fftw_execute_dft_r2c. interface fftwf_execute_dft_r2c subroutine fftwf_execute_dft_r2c_(plan,in,out) bind(c, name="fftwf_execute_dft_r2c") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr),value :: plan type(c_ptr),value :: in type(c_ptr),value :: out end subroutine end interface !> @brief Computes the discrete Fourier transform that a double-precision plan captures using new !> input and output data buffers. !> The plan must have been created for a real backward (inverse) transform. !> !> @param[in] plan - the double-precision plan capturing the real backward (inverse) transform to !> compute; !> @param[in] in - pointer to a new input buffer for the transform; !> @param[out] out - pointer to a new output buffer for the transform. interface fftw_execute_dft_c2r subroutine fftw_execute_dft_c2r_(plan,in,out) bind(c, name="fftw_execute_dft_c2r") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr),value :: plan type(c_ptr),value :: in type(c_ptr),value :: out end subroutine end interface !> @brief Single-precision equivalent of \ref fftw_execute_dft_c2r. interface fftwf_execute_dft_c2r subroutine fftwf_execute_dft_c2r_(plan,in,out) bind(c, name="fftwf_execute_dft_c2r") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr),value :: plan type(c_ptr),value :: in type(c_ptr),value :: out end subroutine end interface !> @brief Deallocates a double-precision plan and frees all its resources. !> !> @param[in] plan - plan to be destroyed. interface fftw_destroy_plan subroutine fftw_destroy_plan_(plan) bind(c, name="fftw_destroy_plan") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr),value :: plan end subroutine end interface !> @brief Single-precision equivalent of \ref fftw_destroy_plan. interface fftwf_destroy_plan subroutine fftwf_destroy_plan_(plan) bind(c, name="fftwf_destroy_plan") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr),value :: plan end subroutine end interface interface fftw_print_plan subroutine fftw_print_plan_(arg1) bind(c, name="fftw_print_plan") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr),value :: arg1 end subroutine end interface interface fftwf_print_plan subroutine fftwf_print_plan_(arg1) bind(c, name="fftwf_print_plan") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr),value :: arg1 end subroutine end interface interface fftw_set_timelimit subroutine fftw_set_timelimit_(arg1) bind(c, name="fftw_set_timelimit") use iso_c_binding use hipfort_hipfftw_enums implicit none real(c_double),value :: arg1 end subroutine end interface interface fftwf_set_timelimit subroutine fftwf_set_timelimit_(arg1) bind(c, name="fftwf_set_timelimit") use iso_c_binding use hipfort_hipfftw_enums implicit none real(c_double),value :: arg1 end subroutine end interface interface fftw_cost function fftw_cost_(arg1) bind(c, name="fftw_cost") use iso_c_binding use hipfort_hipfftw_enums implicit none real(c_double) :: fftw_cost_ type(c_ptr),value :: arg1 end function end interface interface fftwf_cost function fftwf_cost_(arg1) bind(c, name="fftwf_cost") use iso_c_binding use hipfort_hipfftw_enums implicit none real(c_double) :: fftwf_cost_ type(c_ptr),value :: arg1 end function end interface interface fftw_flops subroutine fftw_flops_(arg1,arg2,arg3,arg4) bind(c, name="fftw_flops") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr),value :: arg1 type(c_ptr),value :: arg2 type(c_ptr),value :: arg3 type(c_ptr),value :: arg4 end subroutine end interface interface fftwf_flops subroutine fftwf_flops_(arg1,arg2,arg3,arg4) bind(c, name="fftwf_flops") use iso_c_binding use hipfort_hipfftw_enums implicit none type(c_ptr),value :: arg1 type(c_ptr),value :: arg2 type(c_ptr),value :: arg3 type(c_ptr),value :: arg4 end subroutine end interface interface fftw_cleanup subroutine fftw_cleanup_() bind(c, name="fftw_cleanup") use iso_c_binding use hipfort_hipfftw_enums implicit none end subroutine end interface interface fftwf_cleanup subroutine fftwf_cleanup_() bind(c, name="fftwf_cleanup") use iso_c_binding use hipfort_hipfftw_enums implicit none end subroutine end interface end module hipfort_hipfftw hipfort-rocm-10.0.0/lib/hipfort/hipfort_hipfftw_enums.F90000066400000000000000000000042311524740623400233220ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_hipfftw_enums use, intrinsic :: iso_c_binding implicit none integer(c_int), parameter :: FFTW_MEASURE = 0 integer(c_int), parameter :: FFTW_DESTROY_INPUT = 1 integer(c_int), parameter :: FFTW_UNALIGNED = 2 integer(c_int), parameter :: FFTW_CONSERVE_MEMORY = 4 integer(c_int), parameter :: FFTW_EXHAUSTIVE = 8 integer(c_int), parameter :: FFTW_PRESERVE_INPUT = 16 integer(c_int), parameter :: FFTW_PATIENT = 32 integer(c_int), parameter :: FFTW_ESTIMATE = 64 integer(c_int), parameter :: FFTW_WISDOM_ONLY = 2097152 integer(c_int), parameter :: FFTW_FORWARD = -1 integer(c_int), parameter :: FFTW_BACKWARD = 1 end module hipfort_hipfftw_enums hipfort-rocm-10.0.0/lib/hipfort/hipfort_hipfftw_types.F90000066400000000000000000000035621524740623400233450ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_hipfftw_types use, intrinsic :: iso_c_binding implicit none type, bind(c) :: fftw_iodim integer(c_int) :: n integer(c_int) :: is integer(c_int) :: os end type fftw_iodim type, bind(c) :: fftw_iodim64 integer(c_ptrdiff_t) :: n integer(c_ptrdiff_t) :: is integer(c_ptrdiff_t) :: os end type fftw_iodim64 end module hipfort_hipfftw_types hipfort-rocm-10.0.0/lib/hipfort/hipfort_hiphostregister.F90000066400000000000000000005074241524740623400237030ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_hiphostregister use, intrinsic :: iso_c_binding implicit none interface hipHostRegister !> @brief Register host memory so it can be accessed from the current device. !> !> @param[out] hostPtr Pointer to host memory to be registered. !> @param[in] sizeBytes Size of the host memory !> @param[in] flags See below. !> !> Flags: !> - `hipHostRegisterDefault` Memory is Mapped and Portable !> - `hipHostRegisterPortable` Memory is considered registered by all contexts. HIP only !> supports !> one context so this is always assumed true. !> - `hipHostRegisterMapped` Map the allocation into the address space for the current device. !> The device pointer can be obtained with `hipHostGetDevicePointer`. !> - `hipExtHostRegisterUncached` Map the host memory onto extended fine grained access system !> memory pool. !> !> After registering the memory, use `hipHostGetDevicePointer` to obtain the mapped device !> pointer. !> On many systems, the mapped device pointer will have a different value than the mapped host !> pointer. Applications must use the device pointer in device code, and the host pointer in host !> code. !> !> On some systems, registered memory is pinned. On some systems, registered memory may not be !> actually be pinned but uses OS or hardware facilities to all GPU access to the host memory. !> !> Developers are strongly encouraged to register memory blocks which are aligned to the host !> cache-line size. (typically 64-bytes but can be obtains from the CPUID instruction). !> !> If registering non-aligned pointers, the application must take care when register pointers !> from !> the same cache line on different devices. HIP's coarse-grained synchronization model does not !> guarantee correct results if different devices write to different parts of the same cache !> block - !> typically one of the writes will "win" and overwrite data from the other registered memory !> region. !> !> @returns `hipSuccess`, `hipErrorOutOfMemory` !> !> @see hipHostUnregister, hipHostGetFlags, hipHostGetDevicePointer #ifdef USE_CUDA_NAMES function hipHostRegister_(hostPtr, sizeBytes, flags) bind(c, name="cudaHostRegister") #else function hipHostRegister_(hostPtr, sizeBytes, flags) bind(c, name="hipHostRegister") #endif use iso_c_binding implicit none integer(c_int) :: hipHostRegister_ type(c_ptr), value :: hostPtr integer(c_size_t), value :: sizeBytes integer(c_int), value :: flags end function hipHostRegister_ module procedure hipHostRegister_i4_0_nosize module procedure hipHostRegister_i4_1_nosize module procedure hipHostRegister_i4_1 module procedure hipHostRegister_i4_1_c_size_t module procedure hipHostRegister_i4_2_nosize module procedure hipHostRegister_i4_2 module procedure hipHostRegister_i4_2_c_size_t module procedure hipHostRegister_i4_3_nosize module procedure hipHostRegister_i4_3 module procedure hipHostRegister_i4_3_c_size_t module procedure hipHostRegister_i4_4_nosize module procedure hipHostRegister_i4_4 module procedure hipHostRegister_i4_4_c_size_t module procedure hipHostRegister_i4_5_nosize module procedure hipHostRegister_i4_5 module procedure hipHostRegister_i4_5_c_size_t module procedure hipHostRegister_i4_6_nosize module procedure hipHostRegister_i4_6 module procedure hipHostRegister_i4_6_c_size_t module procedure hipHostRegister_i4_7_nosize module procedure hipHostRegister_i4_7 module procedure hipHostRegister_i4_7_c_size_t module procedure hipHostRegister_i8_0_nosize module procedure hipHostRegister_i8_1_nosize module procedure hipHostRegister_i8_1 module procedure hipHostRegister_i8_1_c_size_t module procedure hipHostRegister_i8_2_nosize module procedure hipHostRegister_i8_2 module procedure hipHostRegister_i8_2_c_size_t module procedure hipHostRegister_i8_3_nosize module procedure hipHostRegister_i8_3 module procedure hipHostRegister_i8_3_c_size_t module procedure hipHostRegister_i8_4_nosize module procedure hipHostRegister_i8_4 module procedure hipHostRegister_i8_4_c_size_t module procedure hipHostRegister_i8_5_nosize module procedure hipHostRegister_i8_5 module procedure hipHostRegister_i8_5_c_size_t module procedure hipHostRegister_i8_6_nosize module procedure hipHostRegister_i8_6 module procedure hipHostRegister_i8_6_c_size_t module procedure hipHostRegister_i8_7_nosize module procedure hipHostRegister_i8_7 module procedure hipHostRegister_i8_7_c_size_t module procedure hipHostRegister_r4_0_nosize module procedure hipHostRegister_r4_1_nosize module procedure hipHostRegister_r4_1 module procedure hipHostRegister_r4_1_c_size_t module procedure hipHostRegister_r4_2_nosize module procedure hipHostRegister_r4_2 module procedure hipHostRegister_r4_2_c_size_t module procedure hipHostRegister_r4_3_nosize module procedure hipHostRegister_r4_3 module procedure hipHostRegister_r4_3_c_size_t module procedure hipHostRegister_r4_4_nosize module procedure hipHostRegister_r4_4 module procedure hipHostRegister_r4_4_c_size_t module procedure hipHostRegister_r4_5_nosize module procedure hipHostRegister_r4_5 module procedure hipHostRegister_r4_5_c_size_t module procedure hipHostRegister_r4_6_nosize module procedure hipHostRegister_r4_6 module procedure hipHostRegister_r4_6_c_size_t module procedure hipHostRegister_r4_7_nosize module procedure hipHostRegister_r4_7 module procedure hipHostRegister_r4_7_c_size_t module procedure hipHostRegister_r8_0_nosize module procedure hipHostRegister_r8_1_nosize module procedure hipHostRegister_r8_1 module procedure hipHostRegister_r8_1_c_size_t module procedure hipHostRegister_r8_2_nosize module procedure hipHostRegister_r8_2 module procedure hipHostRegister_r8_2_c_size_t module procedure hipHostRegister_r8_3_nosize module procedure hipHostRegister_r8_3 module procedure hipHostRegister_r8_3_c_size_t module procedure hipHostRegister_r8_4_nosize module procedure hipHostRegister_r8_4 module procedure hipHostRegister_r8_4_c_size_t module procedure hipHostRegister_r8_5_nosize module procedure hipHostRegister_r8_5 module procedure hipHostRegister_r8_5_c_size_t module procedure hipHostRegister_r8_6_nosize module procedure hipHostRegister_r8_6 module procedure hipHostRegister_r8_6_c_size_t module procedure hipHostRegister_r8_7_nosize module procedure hipHostRegister_r8_7 module procedure hipHostRegister_r8_7_c_size_t module procedure hipHostRegister_c4_0_nosize module procedure hipHostRegister_c4_1_nosize module procedure hipHostRegister_c4_1 module procedure hipHostRegister_c4_1_c_size_t module procedure hipHostRegister_c4_2_nosize module procedure hipHostRegister_c4_2 module procedure hipHostRegister_c4_2_c_size_t module procedure hipHostRegister_c4_3_nosize module procedure hipHostRegister_c4_3 module procedure hipHostRegister_c4_3_c_size_t module procedure hipHostRegister_c4_4_nosize module procedure hipHostRegister_c4_4 module procedure hipHostRegister_c4_4_c_size_t module procedure hipHostRegister_c4_5_nosize module procedure hipHostRegister_c4_5 module procedure hipHostRegister_c4_5_c_size_t module procedure hipHostRegister_c4_6_nosize module procedure hipHostRegister_c4_6 module procedure hipHostRegister_c4_6_c_size_t module procedure hipHostRegister_c4_7_nosize module procedure hipHostRegister_c4_7 module procedure hipHostRegister_c4_7_c_size_t module procedure hipHostRegister_c8_0_nosize module procedure hipHostRegister_c8_1_nosize module procedure hipHostRegister_c8_1 module procedure hipHostRegister_c8_1_c_size_t module procedure hipHostRegister_c8_2_nosize module procedure hipHostRegister_c8_2 module procedure hipHostRegister_c8_2_c_size_t module procedure hipHostRegister_c8_3_nosize module procedure hipHostRegister_c8_3 module procedure hipHostRegister_c8_3_c_size_t module procedure hipHostRegister_c8_4_nosize module procedure hipHostRegister_c8_4 module procedure hipHostRegister_c8_4_c_size_t module procedure hipHostRegister_c8_5_nosize module procedure hipHostRegister_c8_5 module procedure hipHostRegister_c8_5_c_size_t module procedure hipHostRegister_c8_6_nosize module procedure hipHostRegister_c8_6 module procedure hipHostRegister_c8_6_c_size_t module procedure hipHostRegister_c8_7_nosize module procedure hipHostRegister_c8_7 module procedure hipHostRegister_c8_7_c_size_t module procedure hipHostRegister_l_0_nosize module procedure hipHostRegister_l_1_nosize module procedure hipHostRegister_l_1 module procedure hipHostRegister_l_1_c_size_t module procedure hipHostRegister_l_2_nosize module procedure hipHostRegister_l_2 module procedure hipHostRegister_l_2_c_size_t module procedure hipHostRegister_l_3_nosize module procedure hipHostRegister_l_3 module procedure hipHostRegister_l_3_c_size_t module procedure hipHostRegister_l_4_nosize module procedure hipHostRegister_l_4 module procedure hipHostRegister_l_4_c_size_t module procedure hipHostRegister_l_5_nosize module procedure hipHostRegister_l_5 module procedure hipHostRegister_l_5_c_size_t module procedure hipHostRegister_l_6_nosize module procedure hipHostRegister_l_6 module procedure hipHostRegister_l_6_c_size_t module procedure hipHostRegister_l_7_nosize module procedure hipHostRegister_l_7 module procedure hipHostRegister_l_7_c_size_t end interface hipHostRegister interface hipHostUnregister !> @brief Un-register host pointer !> !> @param[in] hostPtr Host pointer previously registered with `hipHostRegister` !> @returns Error code !> !> @see hipHostRegister #ifdef USE_CUDA_NAMES function hipHostUnregister_(hostPtr) bind(c, name="cudaHostUnregister") #else function hipHostUnregister_(hostPtr) bind(c, name="hipHostUnregister") #endif use iso_c_binding implicit none integer(c_int) :: hipHostUnregister_ type(c_ptr), value :: hostPtr end function hipHostUnregister_ module procedure hipHostUnregister_i4_0 module procedure hipHostUnregister_i4_1 module procedure hipHostUnregister_i4_2 module procedure hipHostUnregister_i4_3 module procedure hipHostUnregister_i4_4 module procedure hipHostUnregister_i4_5 module procedure hipHostUnregister_i4_6 module procedure hipHostUnregister_i4_7 module procedure hipHostUnregister_i8_0 module procedure hipHostUnregister_i8_1 module procedure hipHostUnregister_i8_2 module procedure hipHostUnregister_i8_3 module procedure hipHostUnregister_i8_4 module procedure hipHostUnregister_i8_5 module procedure hipHostUnregister_i8_6 module procedure hipHostUnregister_i8_7 module procedure hipHostUnregister_r4_0 module procedure hipHostUnregister_r4_1 module procedure hipHostUnregister_r4_2 module procedure hipHostUnregister_r4_3 module procedure hipHostUnregister_r4_4 module procedure hipHostUnregister_r4_5 module procedure hipHostUnregister_r4_6 module procedure hipHostUnregister_r4_7 module procedure hipHostUnregister_r8_0 module procedure hipHostUnregister_r8_1 module procedure hipHostUnregister_r8_2 module procedure hipHostUnregister_r8_3 module procedure hipHostUnregister_r8_4 module procedure hipHostUnregister_r8_5 module procedure hipHostUnregister_r8_6 module procedure hipHostUnregister_r8_7 module procedure hipHostUnregister_c4_0 module procedure hipHostUnregister_c4_1 module procedure hipHostUnregister_c4_2 module procedure hipHostUnregister_c4_3 module procedure hipHostUnregister_c4_4 module procedure hipHostUnregister_c4_5 module procedure hipHostUnregister_c4_6 module procedure hipHostUnregister_c4_7 module procedure hipHostUnregister_c8_0 module procedure hipHostUnregister_c8_1 module procedure hipHostUnregister_c8_2 module procedure hipHostUnregister_c8_3 module procedure hipHostUnregister_c8_4 module procedure hipHostUnregister_c8_5 module procedure hipHostUnregister_c8_6 module procedure hipHostUnregister_c8_7 module procedure hipHostUnregister_l_0 module procedure hipHostUnregister_l_1 module procedure hipHostUnregister_l_2 module procedure hipHostUnregister_l_3 module procedure hipHostUnregister_l_4 module procedure hipHostUnregister_l_5 module procedure hipHostUnregister_l_6 module procedure hipHostUnregister_l_7 end interface hipHostUnregister interface hipHostGetDevicePointer !> @brief Get Device pointer from Host Pointer allocated through hipHostMalloc !> !> @param[out] devPtr Device Pointer mapped to passed host pointer !> @param[in] hstPtr Host Pointer allocated through hipHostMalloc !> @param[in] flags Flags to be passed for extension !> !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorOutOfMemory` !> !> @see hipSetDeviceFlags, hipHostMalloc #ifdef USE_CUDA_NAMES function hipHostGetDevicePointer_(devPtr, hstPtr, flags) & bind(c, name="cudaHostGetDevicePointer") #else function hipHostGetDevicePointer_(devPtr, hstPtr, flags) bind(c, name="hipHostGetDevicePointer") #endif use iso_c_binding implicit none integer(c_int) :: hipHostGetDevicePointer_ type(c_ptr) :: devPtr type(c_ptr), value :: hstPtr integer(c_int), value :: flags end function hipHostGetDevicePointer_ module procedure hipHostGetDevicePointer_i4_0 module procedure hipHostGetDevicePointer_i4_1 module procedure hipHostGetDevicePointer_i4_2 module procedure hipHostGetDevicePointer_i4_3 module procedure hipHostGetDevicePointer_i4_4 module procedure hipHostGetDevicePointer_i4_5 module procedure hipHostGetDevicePointer_i4_6 module procedure hipHostGetDevicePointer_i4_7 module procedure hipHostGetDevicePointer_i8_0 module procedure hipHostGetDevicePointer_i8_1 module procedure hipHostGetDevicePointer_i8_2 module procedure hipHostGetDevicePointer_i8_3 module procedure hipHostGetDevicePointer_i8_4 module procedure hipHostGetDevicePointer_i8_5 module procedure hipHostGetDevicePointer_i8_6 module procedure hipHostGetDevicePointer_i8_7 module procedure hipHostGetDevicePointer_r4_0 module procedure hipHostGetDevicePointer_r4_1 module procedure hipHostGetDevicePointer_r4_2 module procedure hipHostGetDevicePointer_r4_3 module procedure hipHostGetDevicePointer_r4_4 module procedure hipHostGetDevicePointer_r4_5 module procedure hipHostGetDevicePointer_r4_6 module procedure hipHostGetDevicePointer_r4_7 module procedure hipHostGetDevicePointer_r8_0 module procedure hipHostGetDevicePointer_r8_1 module procedure hipHostGetDevicePointer_r8_2 module procedure hipHostGetDevicePointer_r8_3 module procedure hipHostGetDevicePointer_r8_4 module procedure hipHostGetDevicePointer_r8_5 module procedure hipHostGetDevicePointer_r8_6 module procedure hipHostGetDevicePointer_r8_7 module procedure hipHostGetDevicePointer_c4_0 module procedure hipHostGetDevicePointer_c4_1 module procedure hipHostGetDevicePointer_c4_2 module procedure hipHostGetDevicePointer_c4_3 module procedure hipHostGetDevicePointer_c4_4 module procedure hipHostGetDevicePointer_c4_5 module procedure hipHostGetDevicePointer_c4_6 module procedure hipHostGetDevicePointer_c4_7 module procedure hipHostGetDevicePointer_c8_0 module procedure hipHostGetDevicePointer_c8_1 module procedure hipHostGetDevicePointer_c8_2 module procedure hipHostGetDevicePointer_c8_3 module procedure hipHostGetDevicePointer_c8_4 module procedure hipHostGetDevicePointer_c8_5 module procedure hipHostGetDevicePointer_c8_6 module procedure hipHostGetDevicePointer_c8_7 module procedure hipHostGetDevicePointer_l_0 module procedure hipHostGetDevicePointer_l_1 module procedure hipHostGetDevicePointer_l_2 module procedure hipHostGetDevicePointer_l_3 module procedure hipHostGetDevicePointer_l_4 module procedure hipHostGetDevicePointer_l_5 module procedure hipHostGetDevicePointer_l_6 module procedure hipHostGetDevicePointer_l_7 end interface hipHostGetDevicePointer interface hipHostGetFlags !> @brief Return flags associated with host pointer !> !> @param[out] flagsPtr Memory location to store flags !> @param[in] hostPtr Host Pointer allocated through hipHostMalloc !> @returns `hipSuccess`, `hipErrorInvalidValue` !> !> @see hipHostMalloc #ifdef USE_CUDA_NAMES function hipHostGetFlags_(flagsPtr, hostPtr) bind(c, name="cudaHostGetFlags") #else function hipHostGetFlags_(flagsPtr, hostPtr) bind(c, name="hipHostGetFlags") #endif use iso_c_binding implicit none integer(c_int) :: hipHostGetFlags_ integer(c_int) :: flagsPtr type(c_ptr), value :: hostPtr end function hipHostGetFlags_ module procedure hipHostGetFlags_i4_0 module procedure hipHostGetFlags_i4_1 module procedure hipHostGetFlags_i4_2 module procedure hipHostGetFlags_i4_3 module procedure hipHostGetFlags_i4_4 module procedure hipHostGetFlags_i4_5 module procedure hipHostGetFlags_i4_6 module procedure hipHostGetFlags_i4_7 module procedure hipHostGetFlags_i8_0 module procedure hipHostGetFlags_i8_1 module procedure hipHostGetFlags_i8_2 module procedure hipHostGetFlags_i8_3 module procedure hipHostGetFlags_i8_4 module procedure hipHostGetFlags_i8_5 module procedure hipHostGetFlags_i8_6 module procedure hipHostGetFlags_i8_7 module procedure hipHostGetFlags_r4_0 module procedure hipHostGetFlags_r4_1 module procedure hipHostGetFlags_r4_2 module procedure hipHostGetFlags_r4_3 module procedure hipHostGetFlags_r4_4 module procedure hipHostGetFlags_r4_5 module procedure hipHostGetFlags_r4_6 module procedure hipHostGetFlags_r4_7 module procedure hipHostGetFlags_r8_0 module procedure hipHostGetFlags_r8_1 module procedure hipHostGetFlags_r8_2 module procedure hipHostGetFlags_r8_3 module procedure hipHostGetFlags_r8_4 module procedure hipHostGetFlags_r8_5 module procedure hipHostGetFlags_r8_6 module procedure hipHostGetFlags_r8_7 module procedure hipHostGetFlags_c4_0 module procedure hipHostGetFlags_c4_1 module procedure hipHostGetFlags_c4_2 module procedure hipHostGetFlags_c4_3 module procedure hipHostGetFlags_c4_4 module procedure hipHostGetFlags_c4_5 module procedure hipHostGetFlags_c4_6 module procedure hipHostGetFlags_c4_7 module procedure hipHostGetFlags_c8_0 module procedure hipHostGetFlags_c8_1 module procedure hipHostGetFlags_c8_2 module procedure hipHostGetFlags_c8_3 module procedure hipHostGetFlags_c8_4 module procedure hipHostGetFlags_c8_5 module procedure hipHostGetFlags_c8_6 module procedure hipHostGetFlags_c8_7 module procedure hipHostGetFlags_l_0 module procedure hipHostGetFlags_l_1 module procedure hipHostGetFlags_l_2 module procedure hipHostGetFlags_l_3 module procedure hipHostGetFlags_l_4 module procedure hipHostGetFlags_l_5 module procedure hipHostGetFlags_l_6 module procedure hipHostGetFlags_l_7 end interface hipHostGetFlags contains function hipHostRegister_i4_0_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none integer(c_int), target, intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr), int(1, c_size_t)*4_c_size_t, flags) end function hipHostRegister_i4_0_nosize function hipHostRegister_i4_1_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1)), int(size(hostPtr), c_size_t)*4_c_size_t, flags) end function hipHostRegister_i4_1_nosize function hipHostRegister_i4_1(hostPtr, length1, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1)), nbytes, flags) end function hipHostRegister_i4_1 function hipHostRegister_i4_1_c_size_t(hostPtr, length1, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1)), nbytes, flags) end function hipHostRegister_i4_1_c_size_t function hipHostRegister_i4_2_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1)), int(size(hostPtr), c_size_t)*4_c_size_t, flags) end function hipHostRegister_i4_2_nosize function hipHostRegister_i4_2(hostPtr, length1, length2, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1)), nbytes, flags) end function hipHostRegister_i4_2 function hipHostRegister_i4_2_c_size_t(hostPtr, length1, length2, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1)), nbytes, flags) end function hipHostRegister_i4_2_c_size_t function hipHostRegister_i4_3_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1)), int(size(hostPtr), c_size_t)*4_c_size_t, flags) end function hipHostRegister_i4_3_nosize function hipHostRegister_i4_3(hostPtr, length1, length2, length3, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1)), nbytes, flags) end function hipHostRegister_i4_3 function hipHostRegister_i4_3_c_size_t(hostPtr, length1, length2, length3, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1)), nbytes, flags) end function hipHostRegister_i4_3_c_size_t function hipHostRegister_i4_4_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), int(size(hostPtr), c_size_t)*4_c_size_t, flags) end function hipHostRegister_i4_4_nosize function hipHostRegister_i4_4(hostPtr, length1, length2, length3, length4, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), nbytes, flags) end function hipHostRegister_i4_4 function hipHostRegister_i4_4_c_size_t(hostPtr, length1, length2, length3, length4, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), nbytes, flags) end function hipHostRegister_i4_4_c_size_t function hipHostRegister_i4_5_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), int(size(hostPtr), c_size_t)*4_c_size_t, flags) end function hipHostRegister_i4_5_nosize function hipHostRegister_i4_5(hostPtr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), nbytes, flags) end function hipHostRegister_i4_5 function hipHostRegister_i4_5_c_size_t(hostPtr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), nbytes, flags) end function hipHostRegister_i4_5_c_size_t function hipHostRegister_i4_6_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), int(size(hostPtr), c_size_t)*4_c_size_t, flags) end function hipHostRegister_i4_6_nosize function hipHostRegister_i4_6(hostPtr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_i4_6 function hipHostRegister_i4_6_c_size_t(hostPtr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_i4_6_c_size_t function hipHostRegister_i4_7_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), int(size(hostPtr), c_size_t)*4_c_size_t, flags) end function hipHostRegister_i4_7_nosize function hipHostRegister_i4_7(hostPtr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_i4_7 function hipHostRegister_i4_7_c_size_t(hostPtr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_i4_7_c_size_t function hipHostRegister_i8_0_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr), int(1, c_size_t)*8_c_size_t, flags) end function hipHostRegister_i8_0_nosize function hipHostRegister_i8_1_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_i8_1_nosize function hipHostRegister_i8_1(hostPtr, length1, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1)), nbytes, flags) end function hipHostRegister_i8_1 function hipHostRegister_i8_1_c_size_t(hostPtr, length1, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1)), nbytes, flags) end function hipHostRegister_i8_1_c_size_t function hipHostRegister_i8_2_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_i8_2_nosize function hipHostRegister_i8_2(hostPtr, length1, length2, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1)), nbytes, flags) end function hipHostRegister_i8_2 function hipHostRegister_i8_2_c_size_t(hostPtr, length1, length2, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1)), nbytes, flags) end function hipHostRegister_i8_2_c_size_t function hipHostRegister_i8_3_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_i8_3_nosize function hipHostRegister_i8_3(hostPtr, length1, length2, length3, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1)), nbytes, flags) end function hipHostRegister_i8_3 function hipHostRegister_i8_3_c_size_t(hostPtr, length1, length2, length3, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1)), nbytes, flags) end function hipHostRegister_i8_3_c_size_t function hipHostRegister_i8_4_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_i8_4_nosize function hipHostRegister_i8_4(hostPtr, length1, length2, length3, length4, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), nbytes, flags) end function hipHostRegister_i8_4 function hipHostRegister_i8_4_c_size_t(hostPtr, length1, length2, length3, length4, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), nbytes, flags) end function hipHostRegister_i8_4_c_size_t function hipHostRegister_i8_5_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_i8_5_nosize function hipHostRegister_i8_5(hostPtr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), nbytes, flags) end function hipHostRegister_i8_5 function hipHostRegister_i8_5_c_size_t(hostPtr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), nbytes, flags) end function hipHostRegister_i8_5_c_size_t function hipHostRegister_i8_6_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_i8_6_nosize function hipHostRegister_i8_6(hostPtr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_i8_6 function hipHostRegister_i8_6_c_size_t(hostPtr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_i8_6_c_size_t function hipHostRegister_i8_7_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_i8_7_nosize function hipHostRegister_i8_7(hostPtr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_i8_7 function hipHostRegister_i8_7_c_size_t(hostPtr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_i8_7_c_size_t function hipHostRegister_r4_0_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none real(c_float), target, intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr), int(1, c_size_t)*4_c_size_t, flags) end function hipHostRegister_r4_0_nosize function hipHostRegister_r4_1_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1)), int(size(hostPtr), c_size_t)*4_c_size_t, flags) end function hipHostRegister_r4_1_nosize function hipHostRegister_r4_1(hostPtr, length1, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1)), nbytes, flags) end function hipHostRegister_r4_1 function hipHostRegister_r4_1_c_size_t(hostPtr, length1, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1)), nbytes, flags) end function hipHostRegister_r4_1_c_size_t function hipHostRegister_r4_2_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1)), int(size(hostPtr), c_size_t)*4_c_size_t, flags) end function hipHostRegister_r4_2_nosize function hipHostRegister_r4_2(hostPtr, length1, length2, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1)), nbytes, flags) end function hipHostRegister_r4_2 function hipHostRegister_r4_2_c_size_t(hostPtr, length1, length2, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1)), nbytes, flags) end function hipHostRegister_r4_2_c_size_t function hipHostRegister_r4_3_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1)), int(size(hostPtr), c_size_t)*4_c_size_t, flags) end function hipHostRegister_r4_3_nosize function hipHostRegister_r4_3(hostPtr, length1, length2, length3, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1)), nbytes, flags) end function hipHostRegister_r4_3 function hipHostRegister_r4_3_c_size_t(hostPtr, length1, length2, length3, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1)), nbytes, flags) end function hipHostRegister_r4_3_c_size_t function hipHostRegister_r4_4_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), int(size(hostPtr), c_size_t)*4_c_size_t, flags) end function hipHostRegister_r4_4_nosize function hipHostRegister_r4_4(hostPtr, length1, length2, length3, length4, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), nbytes, flags) end function hipHostRegister_r4_4 function hipHostRegister_r4_4_c_size_t(hostPtr, length1, length2, length3, length4, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), nbytes, flags) end function hipHostRegister_r4_4_c_size_t function hipHostRegister_r4_5_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), int(size(hostPtr), c_size_t)*4_c_size_t, flags) end function hipHostRegister_r4_5_nosize function hipHostRegister_r4_5(hostPtr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), nbytes, flags) end function hipHostRegister_r4_5 function hipHostRegister_r4_5_c_size_t(hostPtr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), nbytes, flags) end function hipHostRegister_r4_5_c_size_t function hipHostRegister_r4_6_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), int(size(hostPtr), c_size_t)*4_c_size_t, flags) end function hipHostRegister_r4_6_nosize function hipHostRegister_r4_6(hostPtr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_r4_6 function hipHostRegister_r4_6_c_size_t(hostPtr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_r4_6_c_size_t function hipHostRegister_r4_7_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), int(size(hostPtr), c_size_t)*4_c_size_t, flags) end function hipHostRegister_r4_7_nosize function hipHostRegister_r4_7(hostPtr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_r4_7 function hipHostRegister_r4_7_c_size_t(hostPtr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_r4_7_c_size_t function hipHostRegister_r8_0_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none real(c_double), target, intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr), int(1, c_size_t)*8_c_size_t, flags) end function hipHostRegister_r8_0_nosize function hipHostRegister_r8_1_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_r8_1_nosize function hipHostRegister_r8_1(hostPtr, length1, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1)), nbytes, flags) end function hipHostRegister_r8_1 function hipHostRegister_r8_1_c_size_t(hostPtr, length1, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1)), nbytes, flags) end function hipHostRegister_r8_1_c_size_t function hipHostRegister_r8_2_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_r8_2_nosize function hipHostRegister_r8_2(hostPtr, length1, length2, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1)), nbytes, flags) end function hipHostRegister_r8_2 function hipHostRegister_r8_2_c_size_t(hostPtr, length1, length2, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1)), nbytes, flags) end function hipHostRegister_r8_2_c_size_t function hipHostRegister_r8_3_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_r8_3_nosize function hipHostRegister_r8_3(hostPtr, length1, length2, length3, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1)), nbytes, flags) end function hipHostRegister_r8_3 function hipHostRegister_r8_3_c_size_t(hostPtr, length1, length2, length3, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1)), nbytes, flags) end function hipHostRegister_r8_3_c_size_t function hipHostRegister_r8_4_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_r8_4_nosize function hipHostRegister_r8_4(hostPtr, length1, length2, length3, length4, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), nbytes, flags) end function hipHostRegister_r8_4 function hipHostRegister_r8_4_c_size_t(hostPtr, length1, length2, length3, length4, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), nbytes, flags) end function hipHostRegister_r8_4_c_size_t function hipHostRegister_r8_5_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_r8_5_nosize function hipHostRegister_r8_5(hostPtr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), nbytes, flags) end function hipHostRegister_r8_5 function hipHostRegister_r8_5_c_size_t(hostPtr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), nbytes, flags) end function hipHostRegister_r8_5_c_size_t function hipHostRegister_r8_6_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_r8_6_nosize function hipHostRegister_r8_6(hostPtr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_r8_6 function hipHostRegister_r8_6_c_size_t(hostPtr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_r8_6_c_size_t function hipHostRegister_r8_7_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_r8_7_nosize function hipHostRegister_r8_7(hostPtr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_r8_7 function hipHostRegister_r8_7_c_size_t(hostPtr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_r8_7_c_size_t function hipHostRegister_c4_0_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr), int(1, c_size_t)*8_c_size_t, flags) end function hipHostRegister_c4_0_nosize function hipHostRegister_c4_1_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_c4_1_nosize function hipHostRegister_c4_1(hostPtr, length1, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1)), nbytes, flags) end function hipHostRegister_c4_1 function hipHostRegister_c4_1_c_size_t(hostPtr, length1, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1)), nbytes, flags) end function hipHostRegister_c4_1_c_size_t function hipHostRegister_c4_2_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_c4_2_nosize function hipHostRegister_c4_2(hostPtr, length1, length2, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1)), nbytes, flags) end function hipHostRegister_c4_2 function hipHostRegister_c4_2_c_size_t(hostPtr, length1, length2, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1)), nbytes, flags) end function hipHostRegister_c4_2_c_size_t function hipHostRegister_c4_3_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_c4_3_nosize function hipHostRegister_c4_3(hostPtr, length1, length2, length3, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1)), nbytes, flags) end function hipHostRegister_c4_3 function hipHostRegister_c4_3_c_size_t(hostPtr, length1, length2, length3, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1)), nbytes, flags) end function hipHostRegister_c4_3_c_size_t function hipHostRegister_c4_4_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_c4_4_nosize function hipHostRegister_c4_4(hostPtr, length1, length2, length3, length4, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), nbytes, flags) end function hipHostRegister_c4_4 function hipHostRegister_c4_4_c_size_t(hostPtr, length1, length2, length3, length4, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), nbytes, flags) end function hipHostRegister_c4_4_c_size_t function hipHostRegister_c4_5_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_c4_5_nosize function hipHostRegister_c4_5(hostPtr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), nbytes, flags) end function hipHostRegister_c4_5 function hipHostRegister_c4_5_c_size_t(hostPtr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), nbytes, flags) end function hipHostRegister_c4_5_c_size_t function hipHostRegister_c4_6_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_c4_6_nosize function hipHostRegister_c4_6(hostPtr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_c4_6 function hipHostRegister_c4_6_c_size_t(hostPtr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_c4_6_c_size_t function hipHostRegister_c4_7_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), int(size(hostPtr), c_size_t)*8_c_size_t, flags) end function hipHostRegister_c4_7_nosize function hipHostRegister_c4_7(hostPtr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_c4_7 function hipHostRegister_c4_7_c_size_t(hostPtr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_c4_7_c_size_t function hipHostRegister_c8_0_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr), int(1, c_size_t)*16_c_size_t, flags) end function hipHostRegister_c8_0_nosize function hipHostRegister_c8_1_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1)), int(size(hostPtr), c_size_t)*16_c_size_t, flags) end function hipHostRegister_c8_1_nosize function hipHostRegister_c8_1(hostPtr, length1, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1)), nbytes, flags) end function hipHostRegister_c8_1 function hipHostRegister_c8_1_c_size_t(hostPtr, length1, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1)), nbytes, flags) end function hipHostRegister_c8_1_c_size_t function hipHostRegister_c8_2_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1)), int(size(hostPtr), c_size_t)*16_c_size_t, flags) end function hipHostRegister_c8_2_nosize function hipHostRegister_c8_2(hostPtr, length1, length2, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1)), nbytes, flags) end function hipHostRegister_c8_2 function hipHostRegister_c8_2_c_size_t(hostPtr, length1, length2, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1)), nbytes, flags) end function hipHostRegister_c8_2_c_size_t function hipHostRegister_c8_3_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1)), int(size(hostPtr), c_size_t)*16_c_size_t, flags) end function hipHostRegister_c8_3_nosize function hipHostRegister_c8_3(hostPtr, length1, length2, length3, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1)), nbytes, flags) end function hipHostRegister_c8_3 function hipHostRegister_c8_3_c_size_t(hostPtr, length1, length2, length3, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1)), nbytes, flags) end function hipHostRegister_c8_3_c_size_t function hipHostRegister_c8_4_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), int(size(hostPtr), c_size_t)*16_c_size_t, flags) end function hipHostRegister_c8_4_nosize function hipHostRegister_c8_4(hostPtr, length1, length2, length3, length4, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), nbytes, flags) end function hipHostRegister_c8_4 function hipHostRegister_c8_4_c_size_t(hostPtr, length1, length2, length3, length4, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), nbytes, flags) end function hipHostRegister_c8_4_c_size_t function hipHostRegister_c8_5_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), int(size(hostPtr), c_size_t)*16_c_size_t, flags) end function hipHostRegister_c8_5_nosize function hipHostRegister_c8_5(hostPtr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), nbytes, flags) end function hipHostRegister_c8_5 function hipHostRegister_c8_5_c_size_t(hostPtr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), nbytes, flags) end function hipHostRegister_c8_5_c_size_t function hipHostRegister_c8_6_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), int(size(hostPtr), c_size_t)*16_c_size_t, flags) end function hipHostRegister_c8_6_nosize function hipHostRegister_c8_6(hostPtr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_c8_6 function hipHostRegister_c8_6_c_size_t(hostPtr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_c8_6_c_size_t function hipHostRegister_c8_7_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), int(size(hostPtr), c_size_t)*16_c_size_t, flags) end function hipHostRegister_c8_7_nosize function hipHostRegister_c8_7(hostPtr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_c8_7 function hipHostRegister_c8_7_c_size_t(hostPtr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_c8_7_c_size_t function hipHostRegister_l_0_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr), int(1, c_size_t)*1_c_size_t, flags) end function hipHostRegister_l_0_nosize function hipHostRegister_l_1_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1)), int(size(hostPtr), c_size_t)*1_c_size_t, flags) end function hipHostRegister_l_1_nosize function hipHostRegister_l_1(hostPtr, length1, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1)), nbytes, flags) end function hipHostRegister_l_1 function hipHostRegister_l_1_c_size_t(hostPtr, length1, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1)), nbytes, flags) end function hipHostRegister_l_1_c_size_t function hipHostRegister_l_2_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1)), int(size(hostPtr), c_size_t)*1_c_size_t, flags) end function hipHostRegister_l_2_nosize function hipHostRegister_l_2(hostPtr, length1, length2, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1)), nbytes, flags) end function hipHostRegister_l_2 function hipHostRegister_l_2_c_size_t(hostPtr, length1, length2, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1)), nbytes, flags) end function hipHostRegister_l_2_c_size_t function hipHostRegister_l_3_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1)), int(size(hostPtr), c_size_t)*1_c_size_t, flags) end function hipHostRegister_l_3_nosize function hipHostRegister_l_3(hostPtr, length1, length2, length3, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1)), nbytes, flags) end function hipHostRegister_l_3 function hipHostRegister_l_3_c_size_t(hostPtr, length1, length2, length3, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1)), nbytes, flags) end function hipHostRegister_l_3_c_size_t function hipHostRegister_l_4_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), int(size(hostPtr), c_size_t)*1_c_size_t, flags) end function hipHostRegister_l_4_nosize function hipHostRegister_l_4(hostPtr, length1, length2, length3, length4, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), nbytes, flags) end function hipHostRegister_l_4 function hipHostRegister_l_4_c_size_t(hostPtr, length1, length2, length3, length4, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1)), nbytes, flags) end function hipHostRegister_l_4_c_size_t function hipHostRegister_l_5_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), int(size(hostPtr), c_size_t)*1_c_size_t, flags) end function hipHostRegister_l_5_nosize function hipHostRegister_l_5(hostPtr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), nbytes, flags) end function hipHostRegister_l_5 function hipHostRegister_l_5_c_size_t(hostPtr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1)), nbytes, flags) end function hipHostRegister_l_5_c_size_t function hipHostRegister_l_6_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), int(size(hostPtr), c_size_t)*1_c_size_t, flags) end function hipHostRegister_l_6_nosize function hipHostRegister_l_6(hostPtr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_l_6 function hipHostRegister_l_6_c_size_t(hostPtr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_l_6_c_size_t function hipHostRegister_l_7_nosize(hostPtr, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: flags integer(c_int) :: res res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), int(size(hostPtr), c_size_t)*1_c_size_t, flags) end function hipHostRegister_l_7_nosize function hipHostRegister_l_7(hostPtr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_l_7 function hipHostRegister_l_7_c_size_t(hostPtr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(in) :: hostPtr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in) :: flags integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostRegister_(c_loc(hostPtr(1,1,1,1,1,1,1)), nbytes, flags) end function hipHostRegister_l_7_c_size_t function hipHostUnregister_i4_0(hostPtr) result(res) use iso_c_binding implicit none integer(c_int), target, intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr)) end function hipHostUnregister_i4_0 function hipHostUnregister_i4_1(hostPtr) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1))) end function hipHostUnregister_i4_1 function hipHostUnregister_i4_2(hostPtr) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1))) end function hipHostUnregister_i4_2 function hipHostUnregister_i4_3(hostPtr) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1))) end function hipHostUnregister_i4_3 function hipHostUnregister_i4_4(hostPtr) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1))) end function hipHostUnregister_i4_4 function hipHostUnregister_i4_5(hostPtr) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1))) end function hipHostUnregister_i4_5 function hipHostUnregister_i4_6(hostPtr) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1,1))) end function hipHostUnregister_i4_6 function hipHostUnregister_i4_7(hostPtr) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1,1,1))) end function hipHostUnregister_i4_7 function hipHostUnregister_i8_0(hostPtr) result(res) use iso_c_binding implicit none integer(c_int64_t), target, intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr)) end function hipHostUnregister_i8_0 function hipHostUnregister_i8_1(hostPtr) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1))) end function hipHostUnregister_i8_1 function hipHostUnregister_i8_2(hostPtr) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1))) end function hipHostUnregister_i8_2 function hipHostUnregister_i8_3(hostPtr) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1))) end function hipHostUnregister_i8_3 function hipHostUnregister_i8_4(hostPtr) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1))) end function hipHostUnregister_i8_4 function hipHostUnregister_i8_5(hostPtr) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1))) end function hipHostUnregister_i8_5 function hipHostUnregister_i8_6(hostPtr) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1,1))) end function hipHostUnregister_i8_6 function hipHostUnregister_i8_7(hostPtr) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1,1,1))) end function hipHostUnregister_i8_7 function hipHostUnregister_r4_0(hostPtr) result(res) use iso_c_binding implicit none real(c_float), target, intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr)) end function hipHostUnregister_r4_0 function hipHostUnregister_r4_1(hostPtr) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1))) end function hipHostUnregister_r4_1 function hipHostUnregister_r4_2(hostPtr) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1))) end function hipHostUnregister_r4_2 function hipHostUnregister_r4_3(hostPtr) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1))) end function hipHostUnregister_r4_3 function hipHostUnregister_r4_4(hostPtr) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1))) end function hipHostUnregister_r4_4 function hipHostUnregister_r4_5(hostPtr) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1))) end function hipHostUnregister_r4_5 function hipHostUnregister_r4_6(hostPtr) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1,1))) end function hipHostUnregister_r4_6 function hipHostUnregister_r4_7(hostPtr) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1,1,1))) end function hipHostUnregister_r4_7 function hipHostUnregister_r8_0(hostPtr) result(res) use iso_c_binding implicit none real(c_double), target, intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr)) end function hipHostUnregister_r8_0 function hipHostUnregister_r8_1(hostPtr) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1))) end function hipHostUnregister_r8_1 function hipHostUnregister_r8_2(hostPtr) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1))) end function hipHostUnregister_r8_2 function hipHostUnregister_r8_3(hostPtr) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1))) end function hipHostUnregister_r8_3 function hipHostUnregister_r8_4(hostPtr) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1))) end function hipHostUnregister_r8_4 function hipHostUnregister_r8_5(hostPtr) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1))) end function hipHostUnregister_r8_5 function hipHostUnregister_r8_6(hostPtr) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1,1))) end function hipHostUnregister_r8_6 function hipHostUnregister_r8_7(hostPtr) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1,1,1))) end function hipHostUnregister_r8_7 function hipHostUnregister_c4_0(hostPtr) result(res) use iso_c_binding implicit none complex(c_float_complex), target, intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr)) end function hipHostUnregister_c4_0 function hipHostUnregister_c4_1(hostPtr) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1))) end function hipHostUnregister_c4_1 function hipHostUnregister_c4_2(hostPtr) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1))) end function hipHostUnregister_c4_2 function hipHostUnregister_c4_3(hostPtr) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1))) end function hipHostUnregister_c4_3 function hipHostUnregister_c4_4(hostPtr) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1))) end function hipHostUnregister_c4_4 function hipHostUnregister_c4_5(hostPtr) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1))) end function hipHostUnregister_c4_5 function hipHostUnregister_c4_6(hostPtr) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1,1))) end function hipHostUnregister_c4_6 function hipHostUnregister_c4_7(hostPtr) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1,1,1))) end function hipHostUnregister_c4_7 function hipHostUnregister_c8_0(hostPtr) result(res) use iso_c_binding implicit none complex(c_double_complex), target, intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr)) end function hipHostUnregister_c8_0 function hipHostUnregister_c8_1(hostPtr) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1))) end function hipHostUnregister_c8_1 function hipHostUnregister_c8_2(hostPtr) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1))) end function hipHostUnregister_c8_2 function hipHostUnregister_c8_3(hostPtr) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1))) end function hipHostUnregister_c8_3 function hipHostUnregister_c8_4(hostPtr) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1))) end function hipHostUnregister_c8_4 function hipHostUnregister_c8_5(hostPtr) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1))) end function hipHostUnregister_c8_5 function hipHostUnregister_c8_6(hostPtr) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1,1))) end function hipHostUnregister_c8_6 function hipHostUnregister_c8_7(hostPtr) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1,1,1))) end function hipHostUnregister_c8_7 function hipHostUnregister_l_0(hostPtr) result(res) use iso_c_binding implicit none logical(c_bool), target, intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr)) end function hipHostUnregister_l_0 function hipHostUnregister_l_1(hostPtr) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1))) end function hipHostUnregister_l_1 function hipHostUnregister_l_2(hostPtr) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1))) end function hipHostUnregister_l_2 function hipHostUnregister_l_3(hostPtr) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1))) end function hipHostUnregister_l_3 function hipHostUnregister_l_4(hostPtr) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1))) end function hipHostUnregister_l_4 function hipHostUnregister_l_5(hostPtr) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1))) end function hipHostUnregister_l_5 function hipHostUnregister_l_6(hostPtr) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1,1))) end function hipHostUnregister_l_6 function hipHostUnregister_l_7(hostPtr) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostUnregister_(c_loc(hostPtr(1,1,1,1,1,1,1))) end function hipHostUnregister_l_7 function hipHostGetDevicePointer_i4_0(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr integer(c_int), target, intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr), flags) end function hipHostGetDevicePointer_i4_0 function hipHostGetDevicePointer_i4_1(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr integer(c_int), target, dimension(:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1)), flags) end function hipHostGetDevicePointer_i4_1 function hipHostGetDevicePointer_i4_2(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr integer(c_int), target, dimension(:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1)), flags) end function hipHostGetDevicePointer_i4_2 function hipHostGetDevicePointer_i4_3(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr integer(c_int), target, dimension(:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1)), flags) end function hipHostGetDevicePointer_i4_3 function hipHostGetDevicePointer_i4_4(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr integer(c_int), target, dimension(:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1)), flags) end function hipHostGetDevicePointer_i4_4 function hipHostGetDevicePointer_i4_5(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr integer(c_int), target, dimension(:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1)), flags) end function hipHostGetDevicePointer_i4_5 function hipHostGetDevicePointer_i4_6(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr integer(c_int), target, dimension(:,:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1,1)), flags) end function hipHostGetDevicePointer_i4_6 function hipHostGetDevicePointer_i4_7(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1,1,1)), flags) end function hipHostGetDevicePointer_i4_7 function hipHostGetDevicePointer_i8_0(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr integer(c_int64_t), target, intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr), flags) end function hipHostGetDevicePointer_i8_0 function hipHostGetDevicePointer_i8_1(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr integer(c_int64_t), target, dimension(:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1)), flags) end function hipHostGetDevicePointer_i8_1 function hipHostGetDevicePointer_i8_2(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr integer(c_int64_t), target, dimension(:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1)), flags) end function hipHostGetDevicePointer_i8_2 function hipHostGetDevicePointer_i8_3(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr integer(c_int64_t), target, dimension(:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1)), flags) end function hipHostGetDevicePointer_i8_3 function hipHostGetDevicePointer_i8_4(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr integer(c_int64_t), target, dimension(:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1)), flags) end function hipHostGetDevicePointer_i8_4 function hipHostGetDevicePointer_i8_5(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr integer(c_int64_t), target, dimension(:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1)), flags) end function hipHostGetDevicePointer_i8_5 function hipHostGetDevicePointer_i8_6(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1,1)), flags) end function hipHostGetDevicePointer_i8_6 function hipHostGetDevicePointer_i8_7(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1,1,1)), flags) end function hipHostGetDevicePointer_i8_7 function hipHostGetDevicePointer_r4_0(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr real(c_float), target, intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr), flags) end function hipHostGetDevicePointer_r4_0 function hipHostGetDevicePointer_r4_1(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr real(c_float), target, dimension(:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1)), flags) end function hipHostGetDevicePointer_r4_1 function hipHostGetDevicePointer_r4_2(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr real(c_float), target, dimension(:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1)), flags) end function hipHostGetDevicePointer_r4_2 function hipHostGetDevicePointer_r4_3(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr real(c_float), target, dimension(:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1)), flags) end function hipHostGetDevicePointer_r4_3 function hipHostGetDevicePointer_r4_4(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr real(c_float), target, dimension(:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1)), flags) end function hipHostGetDevicePointer_r4_4 function hipHostGetDevicePointer_r4_5(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr real(c_float), target, dimension(:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1)), flags) end function hipHostGetDevicePointer_r4_5 function hipHostGetDevicePointer_r4_6(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr real(c_float), target, dimension(:,:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1,1)), flags) end function hipHostGetDevicePointer_r4_6 function hipHostGetDevicePointer_r4_7(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr real(c_float), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1,1,1)), flags) end function hipHostGetDevicePointer_r4_7 function hipHostGetDevicePointer_r8_0(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr real(c_double), target, intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr), flags) end function hipHostGetDevicePointer_r8_0 function hipHostGetDevicePointer_r8_1(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr real(c_double), target, dimension(:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1)), flags) end function hipHostGetDevicePointer_r8_1 function hipHostGetDevicePointer_r8_2(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr real(c_double), target, dimension(:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1)), flags) end function hipHostGetDevicePointer_r8_2 function hipHostGetDevicePointer_r8_3(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr real(c_double), target, dimension(:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1)), flags) end function hipHostGetDevicePointer_r8_3 function hipHostGetDevicePointer_r8_4(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr real(c_double), target, dimension(:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1)), flags) end function hipHostGetDevicePointer_r8_4 function hipHostGetDevicePointer_r8_5(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr real(c_double), target, dimension(:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1)), flags) end function hipHostGetDevicePointer_r8_5 function hipHostGetDevicePointer_r8_6(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr real(c_double), target, dimension(:,:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1,1)), flags) end function hipHostGetDevicePointer_r8_6 function hipHostGetDevicePointer_r8_7(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr real(c_double), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1,1,1)), flags) end function hipHostGetDevicePointer_r8_7 function hipHostGetDevicePointer_c4_0(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr complex(c_float_complex), target, intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr), flags) end function hipHostGetDevicePointer_c4_0 function hipHostGetDevicePointer_c4_1(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr complex(c_float_complex), target, dimension(:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1)), flags) end function hipHostGetDevicePointer_c4_1 function hipHostGetDevicePointer_c4_2(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr complex(c_float_complex), target, dimension(:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1)), flags) end function hipHostGetDevicePointer_c4_2 function hipHostGetDevicePointer_c4_3(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr complex(c_float_complex), target, dimension(:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1)), flags) end function hipHostGetDevicePointer_c4_3 function hipHostGetDevicePointer_c4_4(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr complex(c_float_complex), target, dimension(:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1)), flags) end function hipHostGetDevicePointer_c4_4 function hipHostGetDevicePointer_c4_5(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr complex(c_float_complex), target, dimension(:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1)), flags) end function hipHostGetDevicePointer_c4_5 function hipHostGetDevicePointer_c4_6(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1,1)), flags) end function hipHostGetDevicePointer_c4_6 function hipHostGetDevicePointer_c4_7(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1,1,1)), flags) end function hipHostGetDevicePointer_c4_7 function hipHostGetDevicePointer_c8_0(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr complex(c_double_complex), target, intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr), flags) end function hipHostGetDevicePointer_c8_0 function hipHostGetDevicePointer_c8_1(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr complex(c_double_complex), target, dimension(:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1)), flags) end function hipHostGetDevicePointer_c8_1 function hipHostGetDevicePointer_c8_2(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr complex(c_double_complex), target, dimension(:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1)), flags) end function hipHostGetDevicePointer_c8_2 function hipHostGetDevicePointer_c8_3(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr complex(c_double_complex), target, dimension(:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1)), flags) end function hipHostGetDevicePointer_c8_3 function hipHostGetDevicePointer_c8_4(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr complex(c_double_complex), target, dimension(:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1)), flags) end function hipHostGetDevicePointer_c8_4 function hipHostGetDevicePointer_c8_5(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr complex(c_double_complex), target, dimension(:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1)), flags) end function hipHostGetDevicePointer_c8_5 function hipHostGetDevicePointer_c8_6(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1,1)), flags) end function hipHostGetDevicePointer_c8_6 function hipHostGetDevicePointer_c8_7(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1,1,1)), flags) end function hipHostGetDevicePointer_c8_7 function hipHostGetDevicePointer_l_0(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr logical(c_bool), target, intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr), flags) end function hipHostGetDevicePointer_l_0 function hipHostGetDevicePointer_l_1(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr logical(c_bool), target, dimension(:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1)), flags) end function hipHostGetDevicePointer_l_1 function hipHostGetDevicePointer_l_2(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr logical(c_bool), target, dimension(:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1)), flags) end function hipHostGetDevicePointer_l_2 function hipHostGetDevicePointer_l_3(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr logical(c_bool), target, dimension(:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1)), flags) end function hipHostGetDevicePointer_l_3 function hipHostGetDevicePointer_l_4(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr logical(c_bool), target, dimension(:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1)), flags) end function hipHostGetDevicePointer_l_4 function hipHostGetDevicePointer_l_5(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr logical(c_bool), target, dimension(:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1)), flags) end function hipHostGetDevicePointer_l_5 function hipHostGetDevicePointer_l_6(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr logical(c_bool), target, dimension(:,:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1,1)), flags) end function hipHostGetDevicePointer_l_6 function hipHostGetDevicePointer_l_7(devPtr, hstPtr, flags) result(res) use iso_c_binding implicit none type(c_ptr) :: devPtr logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hstPtr integer(c_int), value :: flags integer(c_int) :: res res = hipHostGetDevicePointer_(devPtr, c_loc(hstPtr(1,1,1,1,1,1,1)), flags) end function hipHostGetDevicePointer_l_7 function hipHostGetFlags_i4_0(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr integer(c_int), target, intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr)) end function hipHostGetFlags_i4_0 function hipHostGetFlags_i4_1(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr integer(c_int), target, dimension(:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1))) end function hipHostGetFlags_i4_1 function hipHostGetFlags_i4_2(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr integer(c_int), target, dimension(:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1))) end function hipHostGetFlags_i4_2 function hipHostGetFlags_i4_3(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr integer(c_int), target, dimension(:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1))) end function hipHostGetFlags_i4_3 function hipHostGetFlags_i4_4(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr integer(c_int), target, dimension(:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1))) end function hipHostGetFlags_i4_4 function hipHostGetFlags_i4_5(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr integer(c_int), target, dimension(:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1))) end function hipHostGetFlags_i4_5 function hipHostGetFlags_i4_6(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr integer(c_int), target, dimension(:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1,1))) end function hipHostGetFlags_i4_6 function hipHostGetFlags_i4_7(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1,1,1))) end function hipHostGetFlags_i4_7 function hipHostGetFlags_i8_0(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr integer(c_int64_t), target, intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr)) end function hipHostGetFlags_i8_0 function hipHostGetFlags_i8_1(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr integer(c_int64_t), target, dimension(:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1))) end function hipHostGetFlags_i8_1 function hipHostGetFlags_i8_2(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr integer(c_int64_t), target, dimension(:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1))) end function hipHostGetFlags_i8_2 function hipHostGetFlags_i8_3(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr integer(c_int64_t), target, dimension(:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1))) end function hipHostGetFlags_i8_3 function hipHostGetFlags_i8_4(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr integer(c_int64_t), target, dimension(:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1))) end function hipHostGetFlags_i8_4 function hipHostGetFlags_i8_5(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr integer(c_int64_t), target, dimension(:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1))) end function hipHostGetFlags_i8_5 function hipHostGetFlags_i8_6(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1,1))) end function hipHostGetFlags_i8_6 function hipHostGetFlags_i8_7(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1,1,1))) end function hipHostGetFlags_i8_7 function hipHostGetFlags_r4_0(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr real(c_float), target, intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr)) end function hipHostGetFlags_r4_0 function hipHostGetFlags_r4_1(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr real(c_float), target, dimension(:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1))) end function hipHostGetFlags_r4_1 function hipHostGetFlags_r4_2(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr real(c_float), target, dimension(:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1))) end function hipHostGetFlags_r4_2 function hipHostGetFlags_r4_3(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr real(c_float), target, dimension(:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1))) end function hipHostGetFlags_r4_3 function hipHostGetFlags_r4_4(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr real(c_float), target, dimension(:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1))) end function hipHostGetFlags_r4_4 function hipHostGetFlags_r4_5(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr real(c_float), target, dimension(:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1))) end function hipHostGetFlags_r4_5 function hipHostGetFlags_r4_6(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr real(c_float), target, dimension(:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1,1))) end function hipHostGetFlags_r4_6 function hipHostGetFlags_r4_7(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr real(c_float), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1,1,1))) end function hipHostGetFlags_r4_7 function hipHostGetFlags_r8_0(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr real(c_double), target, intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr)) end function hipHostGetFlags_r8_0 function hipHostGetFlags_r8_1(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr real(c_double), target, dimension(:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1))) end function hipHostGetFlags_r8_1 function hipHostGetFlags_r8_2(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr real(c_double), target, dimension(:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1))) end function hipHostGetFlags_r8_2 function hipHostGetFlags_r8_3(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr real(c_double), target, dimension(:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1))) end function hipHostGetFlags_r8_3 function hipHostGetFlags_r8_4(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr real(c_double), target, dimension(:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1))) end function hipHostGetFlags_r8_4 function hipHostGetFlags_r8_5(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr real(c_double), target, dimension(:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1))) end function hipHostGetFlags_r8_5 function hipHostGetFlags_r8_6(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr real(c_double), target, dimension(:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1,1))) end function hipHostGetFlags_r8_6 function hipHostGetFlags_r8_7(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr real(c_double), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1,1,1))) end function hipHostGetFlags_r8_7 function hipHostGetFlags_c4_0(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr complex(c_float_complex), target, intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr)) end function hipHostGetFlags_c4_0 function hipHostGetFlags_c4_1(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr complex(c_float_complex), target, dimension(:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1))) end function hipHostGetFlags_c4_1 function hipHostGetFlags_c4_2(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr complex(c_float_complex), target, dimension(:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1))) end function hipHostGetFlags_c4_2 function hipHostGetFlags_c4_3(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr complex(c_float_complex), target, dimension(:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1))) end function hipHostGetFlags_c4_3 function hipHostGetFlags_c4_4(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr complex(c_float_complex), target, dimension(:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1))) end function hipHostGetFlags_c4_4 function hipHostGetFlags_c4_5(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr complex(c_float_complex), target, dimension(:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1))) end function hipHostGetFlags_c4_5 function hipHostGetFlags_c4_6(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1,1))) end function hipHostGetFlags_c4_6 function hipHostGetFlags_c4_7(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1,1,1))) end function hipHostGetFlags_c4_7 function hipHostGetFlags_c8_0(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr complex(c_double_complex), target, intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr)) end function hipHostGetFlags_c8_0 function hipHostGetFlags_c8_1(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr complex(c_double_complex), target, dimension(:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1))) end function hipHostGetFlags_c8_1 function hipHostGetFlags_c8_2(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr complex(c_double_complex), target, dimension(:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1))) end function hipHostGetFlags_c8_2 function hipHostGetFlags_c8_3(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr complex(c_double_complex), target, dimension(:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1))) end function hipHostGetFlags_c8_3 function hipHostGetFlags_c8_4(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr complex(c_double_complex), target, dimension(:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1))) end function hipHostGetFlags_c8_4 function hipHostGetFlags_c8_5(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr complex(c_double_complex), target, dimension(:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1))) end function hipHostGetFlags_c8_5 function hipHostGetFlags_c8_6(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1,1))) end function hipHostGetFlags_c8_6 function hipHostGetFlags_c8_7(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1,1,1))) end function hipHostGetFlags_c8_7 function hipHostGetFlags_l_0(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr logical(c_bool), target, intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr)) end function hipHostGetFlags_l_0 function hipHostGetFlags_l_1(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr logical(c_bool), target, dimension(:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1))) end function hipHostGetFlags_l_1 function hipHostGetFlags_l_2(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr logical(c_bool), target, dimension(:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1))) end function hipHostGetFlags_l_2 function hipHostGetFlags_l_3(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr logical(c_bool), target, dimension(:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1))) end function hipHostGetFlags_l_3 function hipHostGetFlags_l_4(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr logical(c_bool), target, dimension(:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1))) end function hipHostGetFlags_l_4 function hipHostGetFlags_l_5(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr logical(c_bool), target, dimension(:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1))) end function hipHostGetFlags_l_5 function hipHostGetFlags_l_6(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr logical(c_bool), target, dimension(:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1,1))) end function hipHostGetFlags_l_6 function hipHostGetFlags_l_7(flagsPtr, hostPtr) result(res) use iso_c_binding implicit none integer(c_int) :: flagsPtr logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(inout) :: hostPtr integer(c_int) :: res res = hipHostGetFlags_(flagsPtr, c_loc(hostPtr(1,1,1,1,1,1,1))) end function hipHostGetFlags_l_7 end module hipfort_hiphostregister hipfort-rocm-10.0.0/lib/hipfort/hipfort_hipmalloc.F90000066400000000000000000030633721524740623400224320ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_hipmalloc use, intrinsic :: iso_c_binding use hipfort_hipmemcpy ! hipMemcpy_ for the source=/dsource= hipMalloc forms implicit none interface hipMalloc !> @brief Allocate memory on the default accelerator !> !> @param[out] ptr Pointer to the allocated memory !> @param[in] sizeBytes Requested memory size !> !> If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned. !> !> @returns `hipSuccess`, `hipErrorOutOfMemory`, `hipErrorInvalidValue` (bad context, null *ptr) !> !> @see hipMallocPitch, hipFree, hipMallocArray, hipFreeArray, hipMalloc3D, hipMalloc3DArray, !> hipHostFree, hipHostMalloc #ifdef USE_CUDA_NAMES function hipMalloc_(ptr, sizeBytes) bind(c, name="cudaMalloc") #else function hipMalloc_(ptr, sizeBytes) bind(c, name="hipMalloc") #endif use iso_c_binding implicit none integer(c_int) :: hipMalloc_ type(c_ptr) :: ptr integer(c_size_t), value :: sizeBytes end function hipMalloc_ module procedure hipMalloc_i4_0_source module procedure hipMalloc_i4_1 module procedure hipMalloc_i4_1_c_size_t module procedure hipMalloc_i4_1_source module procedure hipMalloc_i4_2 module procedure hipMalloc_i4_2_c_size_t module procedure hipMalloc_i4_2_source module procedure hipMalloc_i4_3 module procedure hipMalloc_i4_3_c_size_t module procedure hipMalloc_i4_3_source module procedure hipMalloc_i4_4 module procedure hipMalloc_i4_4_c_size_t module procedure hipMalloc_i4_4_source module procedure hipMalloc_i4_5 module procedure hipMalloc_i4_5_c_size_t module procedure hipMalloc_i4_5_source module procedure hipMalloc_i4_6 module procedure hipMalloc_i4_6_c_size_t module procedure hipMalloc_i4_6_source module procedure hipMalloc_i4_7 module procedure hipMalloc_i4_7_c_size_t module procedure hipMalloc_i4_7_source module procedure hipMalloc_i8_0_source module procedure hipMalloc_i8_1 module procedure hipMalloc_i8_1_c_size_t module procedure hipMalloc_i8_1_source module procedure hipMalloc_i8_2 module procedure hipMalloc_i8_2_c_size_t module procedure hipMalloc_i8_2_source module procedure hipMalloc_i8_3 module procedure hipMalloc_i8_3_c_size_t module procedure hipMalloc_i8_3_source module procedure hipMalloc_i8_4 module procedure hipMalloc_i8_4_c_size_t module procedure hipMalloc_i8_4_source module procedure hipMalloc_i8_5 module procedure hipMalloc_i8_5_c_size_t module procedure hipMalloc_i8_5_source module procedure hipMalloc_i8_6 module procedure hipMalloc_i8_6_c_size_t module procedure hipMalloc_i8_6_source module procedure hipMalloc_i8_7 module procedure hipMalloc_i8_7_c_size_t module procedure hipMalloc_i8_7_source module procedure hipMalloc_r4_0_source module procedure hipMalloc_r4_1 module procedure hipMalloc_r4_1_c_size_t module procedure hipMalloc_r4_1_source module procedure hipMalloc_r4_2 module procedure hipMalloc_r4_2_c_size_t module procedure hipMalloc_r4_2_source module procedure hipMalloc_r4_3 module procedure hipMalloc_r4_3_c_size_t module procedure hipMalloc_r4_3_source module procedure hipMalloc_r4_4 module procedure hipMalloc_r4_4_c_size_t module procedure hipMalloc_r4_4_source module procedure hipMalloc_r4_5 module procedure hipMalloc_r4_5_c_size_t module procedure hipMalloc_r4_5_source module procedure hipMalloc_r4_6 module procedure hipMalloc_r4_6_c_size_t module procedure hipMalloc_r4_6_source module procedure hipMalloc_r4_7 module procedure hipMalloc_r4_7_c_size_t module procedure hipMalloc_r4_7_source module procedure hipMalloc_r8_0_source module procedure hipMalloc_r8_1 module procedure hipMalloc_r8_1_c_size_t module procedure hipMalloc_r8_1_source module procedure hipMalloc_r8_2 module procedure hipMalloc_r8_2_c_size_t module procedure hipMalloc_r8_2_source module procedure hipMalloc_r8_3 module procedure hipMalloc_r8_3_c_size_t module procedure hipMalloc_r8_3_source module procedure hipMalloc_r8_4 module procedure hipMalloc_r8_4_c_size_t module procedure hipMalloc_r8_4_source module procedure hipMalloc_r8_5 module procedure hipMalloc_r8_5_c_size_t module procedure hipMalloc_r8_5_source module procedure hipMalloc_r8_6 module procedure hipMalloc_r8_6_c_size_t module procedure hipMalloc_r8_6_source module procedure hipMalloc_r8_7 module procedure hipMalloc_r8_7_c_size_t module procedure hipMalloc_r8_7_source module procedure hipMalloc_c4_0_source module procedure hipMalloc_c4_1 module procedure hipMalloc_c4_1_c_size_t module procedure hipMalloc_c4_1_source module procedure hipMalloc_c4_2 module procedure hipMalloc_c4_2_c_size_t module procedure hipMalloc_c4_2_source module procedure hipMalloc_c4_3 module procedure hipMalloc_c4_3_c_size_t module procedure hipMalloc_c4_3_source module procedure hipMalloc_c4_4 module procedure hipMalloc_c4_4_c_size_t module procedure hipMalloc_c4_4_source module procedure hipMalloc_c4_5 module procedure hipMalloc_c4_5_c_size_t module procedure hipMalloc_c4_5_source module procedure hipMalloc_c4_6 module procedure hipMalloc_c4_6_c_size_t module procedure hipMalloc_c4_6_source module procedure hipMalloc_c4_7 module procedure hipMalloc_c4_7_c_size_t module procedure hipMalloc_c4_7_source module procedure hipMalloc_c8_0_source module procedure hipMalloc_c8_1 module procedure hipMalloc_c8_1_c_size_t module procedure hipMalloc_c8_1_source module procedure hipMalloc_c8_2 module procedure hipMalloc_c8_2_c_size_t module procedure hipMalloc_c8_2_source module procedure hipMalloc_c8_3 module procedure hipMalloc_c8_3_c_size_t module procedure hipMalloc_c8_3_source module procedure hipMalloc_c8_4 module procedure hipMalloc_c8_4_c_size_t module procedure hipMalloc_c8_4_source module procedure hipMalloc_c8_5 module procedure hipMalloc_c8_5_c_size_t module procedure hipMalloc_c8_5_source module procedure hipMalloc_c8_6 module procedure hipMalloc_c8_6_c_size_t module procedure hipMalloc_c8_6_source module procedure hipMalloc_c8_7 module procedure hipMalloc_c8_7_c_size_t module procedure hipMalloc_c8_7_source module procedure hipMalloc_l_0_source module procedure hipMalloc_l_1 module procedure hipMalloc_l_1_c_size_t module procedure hipMalloc_l_1_source module procedure hipMalloc_l_2 module procedure hipMalloc_l_2_c_size_t module procedure hipMalloc_l_2_source module procedure hipMalloc_l_3 module procedure hipMalloc_l_3_c_size_t module procedure hipMalloc_l_3_source module procedure hipMalloc_l_4 module procedure hipMalloc_l_4_c_size_t module procedure hipMalloc_l_4_source module procedure hipMalloc_l_5 module procedure hipMalloc_l_5_c_size_t module procedure hipMalloc_l_5_source module procedure hipMalloc_l_6 module procedure hipMalloc_l_6_c_size_t module procedure hipMalloc_l_6_source module procedure hipMalloc_l_7 module procedure hipMalloc_l_7_c_size_t module procedure hipMalloc_l_7_source end interface hipMalloc interface hipMallocManaged !> ------------------------------------------------------------------------------------------------- !> ------------------------------------------------------------------------------------------------- !> @defgroup MemoryM Managed Memory !> !> @ingroup Memory !> !> This section describes the managed memory management functions of HIP runtime API. !> !> @note The managed memory management APIs are implemented on Linux, under developement !> on Windows. !> !> !> !> @brief Allocates memory that will be automatically managed by HIP. !> !> This API is used for managed memory, allows data be shared and accessible to both CPU and !> GPU using a single pointer. !> !> The API returns the allocation pointer, managed by HMM, can be used further to execute kernels !> on device and fetch data between the host and device as needed. !> !> If HMM is not supported, the function behaves the same as @p hipMallocHost . !> !> @note It is recommend to do the capability check before call this API. !> !> @param [out] ptr - pointer to allocated device memory !> @param [in] sizeBytes - requested allocation size in bytes, it should be granularity of 4KB !> @param [in] flags - must be either hipMemAttachGlobal or hipMemAttachHost !> (defaults to hipMemAttachGlobal) !> !> @returns `hipSuccess`, `hipErrorMemoryAllocation`, `hipErrorNotSupported`, !> `hipErrorInvalidValue` #ifdef USE_CUDA_NAMES function hipMallocManaged_(ptr, sizeBytes, flags) bind(c, name="cudaMallocManaged") #else function hipMallocManaged_(ptr, sizeBytes, flags) bind(c, name="hipMallocManaged") #endif use iso_c_binding implicit none integer(c_int) :: hipMallocManaged_ type(c_ptr) :: ptr integer(c_size_t), value :: sizeBytes integer(c_int), value :: flags end function hipMallocManaged_ module procedure hipMallocManaged_i4_0_source module procedure hipMallocManaged_i4_1 module procedure hipMallocManaged_i4_1_c_size_t module procedure hipMallocManaged_i4_1_source module procedure hipMallocManaged_i4_2 module procedure hipMallocManaged_i4_2_c_size_t module procedure hipMallocManaged_i4_2_source module procedure hipMallocManaged_i4_3 module procedure hipMallocManaged_i4_3_c_size_t module procedure hipMallocManaged_i4_3_source module procedure hipMallocManaged_i4_4 module procedure hipMallocManaged_i4_4_c_size_t module procedure hipMallocManaged_i4_4_source module procedure hipMallocManaged_i4_5 module procedure hipMallocManaged_i4_5_c_size_t module procedure hipMallocManaged_i4_5_source module procedure hipMallocManaged_i4_6 module procedure hipMallocManaged_i4_6_c_size_t module procedure hipMallocManaged_i4_6_source module procedure hipMallocManaged_i4_7 module procedure hipMallocManaged_i4_7_c_size_t module procedure hipMallocManaged_i4_7_source module procedure hipMallocManaged_i8_0_source module procedure hipMallocManaged_i8_1 module procedure hipMallocManaged_i8_1_c_size_t module procedure hipMallocManaged_i8_1_source module procedure hipMallocManaged_i8_2 module procedure hipMallocManaged_i8_2_c_size_t module procedure hipMallocManaged_i8_2_source module procedure hipMallocManaged_i8_3 module procedure hipMallocManaged_i8_3_c_size_t module procedure hipMallocManaged_i8_3_source module procedure hipMallocManaged_i8_4 module procedure hipMallocManaged_i8_4_c_size_t module procedure hipMallocManaged_i8_4_source module procedure hipMallocManaged_i8_5 module procedure hipMallocManaged_i8_5_c_size_t module procedure hipMallocManaged_i8_5_source module procedure hipMallocManaged_i8_6 module procedure hipMallocManaged_i8_6_c_size_t module procedure hipMallocManaged_i8_6_source module procedure hipMallocManaged_i8_7 module procedure hipMallocManaged_i8_7_c_size_t module procedure hipMallocManaged_i8_7_source module procedure hipMallocManaged_r4_0_source module procedure hipMallocManaged_r4_1 module procedure hipMallocManaged_r4_1_c_size_t module procedure hipMallocManaged_r4_1_source module procedure hipMallocManaged_r4_2 module procedure hipMallocManaged_r4_2_c_size_t module procedure hipMallocManaged_r4_2_source module procedure hipMallocManaged_r4_3 module procedure hipMallocManaged_r4_3_c_size_t module procedure hipMallocManaged_r4_3_source module procedure hipMallocManaged_r4_4 module procedure hipMallocManaged_r4_4_c_size_t module procedure hipMallocManaged_r4_4_source module procedure hipMallocManaged_r4_5 module procedure hipMallocManaged_r4_5_c_size_t module procedure hipMallocManaged_r4_5_source module procedure hipMallocManaged_r4_6 module procedure hipMallocManaged_r4_6_c_size_t module procedure hipMallocManaged_r4_6_source module procedure hipMallocManaged_r4_7 module procedure hipMallocManaged_r4_7_c_size_t module procedure hipMallocManaged_r4_7_source module procedure hipMallocManaged_r8_0_source module procedure hipMallocManaged_r8_1 module procedure hipMallocManaged_r8_1_c_size_t module procedure hipMallocManaged_r8_1_source module procedure hipMallocManaged_r8_2 module procedure hipMallocManaged_r8_2_c_size_t module procedure hipMallocManaged_r8_2_source module procedure hipMallocManaged_r8_3 module procedure hipMallocManaged_r8_3_c_size_t module procedure hipMallocManaged_r8_3_source module procedure hipMallocManaged_r8_4 module procedure hipMallocManaged_r8_4_c_size_t module procedure hipMallocManaged_r8_4_source module procedure hipMallocManaged_r8_5 module procedure hipMallocManaged_r8_5_c_size_t module procedure hipMallocManaged_r8_5_source module procedure hipMallocManaged_r8_6 module procedure hipMallocManaged_r8_6_c_size_t module procedure hipMallocManaged_r8_6_source module procedure hipMallocManaged_r8_7 module procedure hipMallocManaged_r8_7_c_size_t module procedure hipMallocManaged_r8_7_source module procedure hipMallocManaged_c4_0_source module procedure hipMallocManaged_c4_1 module procedure hipMallocManaged_c4_1_c_size_t module procedure hipMallocManaged_c4_1_source module procedure hipMallocManaged_c4_2 module procedure hipMallocManaged_c4_2_c_size_t module procedure hipMallocManaged_c4_2_source module procedure hipMallocManaged_c4_3 module procedure hipMallocManaged_c4_3_c_size_t module procedure hipMallocManaged_c4_3_source module procedure hipMallocManaged_c4_4 module procedure hipMallocManaged_c4_4_c_size_t module procedure hipMallocManaged_c4_4_source module procedure hipMallocManaged_c4_5 module procedure hipMallocManaged_c4_5_c_size_t module procedure hipMallocManaged_c4_5_source module procedure hipMallocManaged_c4_6 module procedure hipMallocManaged_c4_6_c_size_t module procedure hipMallocManaged_c4_6_source module procedure hipMallocManaged_c4_7 module procedure hipMallocManaged_c4_7_c_size_t module procedure hipMallocManaged_c4_7_source module procedure hipMallocManaged_c8_0_source module procedure hipMallocManaged_c8_1 module procedure hipMallocManaged_c8_1_c_size_t module procedure hipMallocManaged_c8_1_source module procedure hipMallocManaged_c8_2 module procedure hipMallocManaged_c8_2_c_size_t module procedure hipMallocManaged_c8_2_source module procedure hipMallocManaged_c8_3 module procedure hipMallocManaged_c8_3_c_size_t module procedure hipMallocManaged_c8_3_source module procedure hipMallocManaged_c8_4 module procedure hipMallocManaged_c8_4_c_size_t module procedure hipMallocManaged_c8_4_source module procedure hipMallocManaged_c8_5 module procedure hipMallocManaged_c8_5_c_size_t module procedure hipMallocManaged_c8_5_source module procedure hipMallocManaged_c8_6 module procedure hipMallocManaged_c8_6_c_size_t module procedure hipMallocManaged_c8_6_source module procedure hipMallocManaged_c8_7 module procedure hipMallocManaged_c8_7_c_size_t module procedure hipMallocManaged_c8_7_source module procedure hipMallocManaged_l_0_source module procedure hipMallocManaged_l_1 module procedure hipMallocManaged_l_1_c_size_t module procedure hipMallocManaged_l_1_source module procedure hipMallocManaged_l_2 module procedure hipMallocManaged_l_2_c_size_t module procedure hipMallocManaged_l_2_source module procedure hipMallocManaged_l_3 module procedure hipMallocManaged_l_3_c_size_t module procedure hipMallocManaged_l_3_source module procedure hipMallocManaged_l_4 module procedure hipMallocManaged_l_4_c_size_t module procedure hipMallocManaged_l_4_source module procedure hipMallocManaged_l_5 module procedure hipMallocManaged_l_5_c_size_t module procedure hipMallocManaged_l_5_source module procedure hipMallocManaged_l_6 module procedure hipMallocManaged_l_6_c_size_t module procedure hipMallocManaged_l_6_source module procedure hipMallocManaged_l_7 module procedure hipMallocManaged_l_7_c_size_t module procedure hipMallocManaged_l_7_source end interface hipMallocManaged interface hipHostMalloc !> @brief Allocates device accessible page locked (pinned) host memory !> !> This API allocates pinned host memory which is mapped into the address space of all GPUs !> in the system, the memory can be accessed directly by the GPU device, and can be read or !> written with much higher bandwidth than pageable memory obtained with functions such as !> malloc(). !> !> Using the pinned host memory, applications can implement faster data transfers for !> HostToDevice !> and DeviceToHost. The runtime tracks the hipHostMalloc allocations and can avoid some of the !> setup required for regular unpinned memory. !> !> When the memory accesses are infrequent, zero-copy memory can be a good choice, for coherent !> allocation. GPU can directly access the host memory over the CPU/GPU interconnect, without !> need !> to copy the data. !> !> Currently the allocation granularity is 4KB for the API. !> !> Developers need to choose proper allocation flag with consideration of synchronization. !> !> @param[out] ptr Pointer to the allocated host pinned memory !> @param[in] sizeBytes Requested memory size in bytes !> If size is 0, no memory is allocated, *ptr returns nullptr, and hipSuccess is returned. !> @param[in] flags Type of host memory allocation. See the description of flags in !> hipSetDeviceFlags. !> !> If no input for flags, it will be the default pinned memory allocation on the host. !> !> @returns `hipSuccess`, `hipErrorOutOfMemory` !> !> !> @see hipSetDeviceFlags, hiptHostFree #ifdef USE_CUDA_NAMES function hipHostMalloc_(ptr, sizeBytes, flags) bind(c, name="cudaHostAlloc") #else function hipHostMalloc_(ptr, sizeBytes, flags) bind(c, name="hipHostMalloc") #endif use iso_c_binding implicit none integer(c_int) :: hipHostMalloc_ type(c_ptr) :: ptr integer(c_size_t), value :: sizeBytes integer(c_int), value :: flags end function hipHostMalloc_ module procedure hipHostMalloc_i4_0_source module procedure hipHostMalloc_i4_1 module procedure hipHostMalloc_i4_1_c_size_t module procedure hipHostMalloc_i4_1_source module procedure hipHostMalloc_i4_2 module procedure hipHostMalloc_i4_2_c_size_t module procedure hipHostMalloc_i4_2_source module procedure hipHostMalloc_i4_3 module procedure hipHostMalloc_i4_3_c_size_t module procedure hipHostMalloc_i4_3_source module procedure hipHostMalloc_i4_4 module procedure hipHostMalloc_i4_4_c_size_t module procedure hipHostMalloc_i4_4_source module procedure hipHostMalloc_i4_5 module procedure hipHostMalloc_i4_5_c_size_t module procedure hipHostMalloc_i4_5_source module procedure hipHostMalloc_i4_6 module procedure hipHostMalloc_i4_6_c_size_t module procedure hipHostMalloc_i4_6_source module procedure hipHostMalloc_i4_7 module procedure hipHostMalloc_i4_7_c_size_t module procedure hipHostMalloc_i4_7_source module procedure hipHostMalloc_i8_0_source module procedure hipHostMalloc_i8_1 module procedure hipHostMalloc_i8_1_c_size_t module procedure hipHostMalloc_i8_1_source module procedure hipHostMalloc_i8_2 module procedure hipHostMalloc_i8_2_c_size_t module procedure hipHostMalloc_i8_2_source module procedure hipHostMalloc_i8_3 module procedure hipHostMalloc_i8_3_c_size_t module procedure hipHostMalloc_i8_3_source module procedure hipHostMalloc_i8_4 module procedure hipHostMalloc_i8_4_c_size_t module procedure hipHostMalloc_i8_4_source module procedure hipHostMalloc_i8_5 module procedure hipHostMalloc_i8_5_c_size_t module procedure hipHostMalloc_i8_5_source module procedure hipHostMalloc_i8_6 module procedure hipHostMalloc_i8_6_c_size_t module procedure hipHostMalloc_i8_6_source module procedure hipHostMalloc_i8_7 module procedure hipHostMalloc_i8_7_c_size_t module procedure hipHostMalloc_i8_7_source module procedure hipHostMalloc_r4_0_source module procedure hipHostMalloc_r4_1 module procedure hipHostMalloc_r4_1_c_size_t module procedure hipHostMalloc_r4_1_source module procedure hipHostMalloc_r4_2 module procedure hipHostMalloc_r4_2_c_size_t module procedure hipHostMalloc_r4_2_source module procedure hipHostMalloc_r4_3 module procedure hipHostMalloc_r4_3_c_size_t module procedure hipHostMalloc_r4_3_source module procedure hipHostMalloc_r4_4 module procedure hipHostMalloc_r4_4_c_size_t module procedure hipHostMalloc_r4_4_source module procedure hipHostMalloc_r4_5 module procedure hipHostMalloc_r4_5_c_size_t module procedure hipHostMalloc_r4_5_source module procedure hipHostMalloc_r4_6 module procedure hipHostMalloc_r4_6_c_size_t module procedure hipHostMalloc_r4_6_source module procedure hipHostMalloc_r4_7 module procedure hipHostMalloc_r4_7_c_size_t module procedure hipHostMalloc_r4_7_source module procedure hipHostMalloc_r8_0_source module procedure hipHostMalloc_r8_1 module procedure hipHostMalloc_r8_1_c_size_t module procedure hipHostMalloc_r8_1_source module procedure hipHostMalloc_r8_2 module procedure hipHostMalloc_r8_2_c_size_t module procedure hipHostMalloc_r8_2_source module procedure hipHostMalloc_r8_3 module procedure hipHostMalloc_r8_3_c_size_t module procedure hipHostMalloc_r8_3_source module procedure hipHostMalloc_r8_4 module procedure hipHostMalloc_r8_4_c_size_t module procedure hipHostMalloc_r8_4_source module procedure hipHostMalloc_r8_5 module procedure hipHostMalloc_r8_5_c_size_t module procedure hipHostMalloc_r8_5_source module procedure hipHostMalloc_r8_6 module procedure hipHostMalloc_r8_6_c_size_t module procedure hipHostMalloc_r8_6_source module procedure hipHostMalloc_r8_7 module procedure hipHostMalloc_r8_7_c_size_t module procedure hipHostMalloc_r8_7_source module procedure hipHostMalloc_c4_0_source module procedure hipHostMalloc_c4_1 module procedure hipHostMalloc_c4_1_c_size_t module procedure hipHostMalloc_c4_1_source module procedure hipHostMalloc_c4_2 module procedure hipHostMalloc_c4_2_c_size_t module procedure hipHostMalloc_c4_2_source module procedure hipHostMalloc_c4_3 module procedure hipHostMalloc_c4_3_c_size_t module procedure hipHostMalloc_c4_3_source module procedure hipHostMalloc_c4_4 module procedure hipHostMalloc_c4_4_c_size_t module procedure hipHostMalloc_c4_4_source module procedure hipHostMalloc_c4_5 module procedure hipHostMalloc_c4_5_c_size_t module procedure hipHostMalloc_c4_5_source module procedure hipHostMalloc_c4_6 module procedure hipHostMalloc_c4_6_c_size_t module procedure hipHostMalloc_c4_6_source module procedure hipHostMalloc_c4_7 module procedure hipHostMalloc_c4_7_c_size_t module procedure hipHostMalloc_c4_7_source module procedure hipHostMalloc_c8_0_source module procedure hipHostMalloc_c8_1 module procedure hipHostMalloc_c8_1_c_size_t module procedure hipHostMalloc_c8_1_source module procedure hipHostMalloc_c8_2 module procedure hipHostMalloc_c8_2_c_size_t module procedure hipHostMalloc_c8_2_source module procedure hipHostMalloc_c8_3 module procedure hipHostMalloc_c8_3_c_size_t module procedure hipHostMalloc_c8_3_source module procedure hipHostMalloc_c8_4 module procedure hipHostMalloc_c8_4_c_size_t module procedure hipHostMalloc_c8_4_source module procedure hipHostMalloc_c8_5 module procedure hipHostMalloc_c8_5_c_size_t module procedure hipHostMalloc_c8_5_source module procedure hipHostMalloc_c8_6 module procedure hipHostMalloc_c8_6_c_size_t module procedure hipHostMalloc_c8_6_source module procedure hipHostMalloc_c8_7 module procedure hipHostMalloc_c8_7_c_size_t module procedure hipHostMalloc_c8_7_source module procedure hipHostMalloc_l_0_source module procedure hipHostMalloc_l_1 module procedure hipHostMalloc_l_1_c_size_t module procedure hipHostMalloc_l_1_source module procedure hipHostMalloc_l_2 module procedure hipHostMalloc_l_2_c_size_t module procedure hipHostMalloc_l_2_source module procedure hipHostMalloc_l_3 module procedure hipHostMalloc_l_3_c_size_t module procedure hipHostMalloc_l_3_source module procedure hipHostMalloc_l_4 module procedure hipHostMalloc_l_4_c_size_t module procedure hipHostMalloc_l_4_source module procedure hipHostMalloc_l_5 module procedure hipHostMalloc_l_5_c_size_t module procedure hipHostMalloc_l_5_source module procedure hipHostMalloc_l_6 module procedure hipHostMalloc_l_6_c_size_t module procedure hipHostMalloc_l_6_source module procedure hipHostMalloc_l_7 module procedure hipHostMalloc_l_7_c_size_t module procedure hipHostMalloc_l_7_source end interface hipHostMalloc interface hipFree !> @brief Free memory allocated by the HIP-Clang hip memory allocation API. !> This API performs an implicit hipDeviceSynchronize() call. !> If pointer is NULL, the hip runtime is initialized and hipSuccess is returned. !> !> @param[in] ptr Pointer to memory to be freed !> @returns `hipSuccess` !> @returns `hipErrorInvalidDevicePointer` (if pointer is invalid, including host pointers !> allocated !> with hipHostMalloc) !> !> @see hipMalloc, hipMallocPitch, hipMallocArray, hipFreeArray, hipHostFree, hipMalloc3D, !> hipMalloc3DArray, hipHostMalloc #ifdef USE_CUDA_NAMES function hipFree_(ptr) bind(c, name="cudaFree") #else function hipFree_(ptr) bind(c, name="hipFree") #endif use iso_c_binding implicit none integer(c_int) :: hipFree_ type(c_ptr), value :: ptr end function hipFree_ module procedure hipFree_i4_0 module procedure hipFree_i4_1 module procedure hipFree_i4_2 module procedure hipFree_i4_3 module procedure hipFree_i4_4 module procedure hipFree_i4_5 module procedure hipFree_i4_6 module procedure hipFree_i4_7 module procedure hipFree_i8_0 module procedure hipFree_i8_1 module procedure hipFree_i8_2 module procedure hipFree_i8_3 module procedure hipFree_i8_4 module procedure hipFree_i8_5 module procedure hipFree_i8_6 module procedure hipFree_i8_7 module procedure hipFree_r4_0 module procedure hipFree_r4_1 module procedure hipFree_r4_2 module procedure hipFree_r4_3 module procedure hipFree_r4_4 module procedure hipFree_r4_5 module procedure hipFree_r4_6 module procedure hipFree_r4_7 module procedure hipFree_r8_0 module procedure hipFree_r8_1 module procedure hipFree_r8_2 module procedure hipFree_r8_3 module procedure hipFree_r8_4 module procedure hipFree_r8_5 module procedure hipFree_r8_6 module procedure hipFree_r8_7 module procedure hipFree_c4_0 module procedure hipFree_c4_1 module procedure hipFree_c4_2 module procedure hipFree_c4_3 module procedure hipFree_c4_4 module procedure hipFree_c4_5 module procedure hipFree_c4_6 module procedure hipFree_c4_7 module procedure hipFree_c8_0 module procedure hipFree_c8_1 module procedure hipFree_c8_2 module procedure hipFree_c8_3 module procedure hipFree_c8_4 module procedure hipFree_c8_5 module procedure hipFree_c8_6 module procedure hipFree_c8_7 module procedure hipFree_l_0 module procedure hipFree_l_1 module procedure hipFree_l_2 module procedure hipFree_l_3 module procedure hipFree_l_4 module procedure hipFree_l_5 module procedure hipFree_l_6 module procedure hipFree_l_7 end interface hipFree interface hipHostFree !> @brief Free memory allocated by the HIP-Clang hip host memory allocation API !> This API performs an implicit hipDeviceSynchronize() call. !> If pointer is NULL, the hip runtime is initialized and hipSuccess is returned. !> !> @ingroup MemoryD !> !> @param[in] ptr Pointer to memory to be freed !> @returns `hipSuccess`, !> `hipErrorInvalidValue` (if pointer is invalid, including device pointers allocated !> with !> hipMalloc) !> !> @see hipMalloc, hipMallocPitch, hipFree, hipMallocArray, hipFreeArray, hipMalloc3D, !> hipMalloc3DArray, hipHostMalloc #ifdef USE_CUDA_NAMES function hipHostFree_(ptr) bind(c, name="cudaFreeHost") #else function hipHostFree_(ptr) bind(c, name="hipHostFree") #endif use iso_c_binding implicit none integer(c_int) :: hipHostFree_ type(c_ptr), value :: ptr end function hipHostFree_ module procedure hipHostFree_i4_0 module procedure hipHostFree_i4_1 module procedure hipHostFree_i4_2 module procedure hipHostFree_i4_3 module procedure hipHostFree_i4_4 module procedure hipHostFree_i4_5 module procedure hipHostFree_i4_6 module procedure hipHostFree_i4_7 module procedure hipHostFree_i8_0 module procedure hipHostFree_i8_1 module procedure hipHostFree_i8_2 module procedure hipHostFree_i8_3 module procedure hipHostFree_i8_4 module procedure hipHostFree_i8_5 module procedure hipHostFree_i8_6 module procedure hipHostFree_i8_7 module procedure hipHostFree_r4_0 module procedure hipHostFree_r4_1 module procedure hipHostFree_r4_2 module procedure hipHostFree_r4_3 module procedure hipHostFree_r4_4 module procedure hipHostFree_r4_5 module procedure hipHostFree_r4_6 module procedure hipHostFree_r4_7 module procedure hipHostFree_r8_0 module procedure hipHostFree_r8_1 module procedure hipHostFree_r8_2 module procedure hipHostFree_r8_3 module procedure hipHostFree_r8_4 module procedure hipHostFree_r8_5 module procedure hipHostFree_r8_6 module procedure hipHostFree_r8_7 module procedure hipHostFree_c4_0 module procedure hipHostFree_c4_1 module procedure hipHostFree_c4_2 module procedure hipHostFree_c4_3 module procedure hipHostFree_c4_4 module procedure hipHostFree_c4_5 module procedure hipHostFree_c4_6 module procedure hipHostFree_c4_7 module procedure hipHostFree_c8_0 module procedure hipHostFree_c8_1 module procedure hipHostFree_c8_2 module procedure hipHostFree_c8_3 module procedure hipHostFree_c8_4 module procedure hipHostFree_c8_5 module procedure hipHostFree_c8_6 module procedure hipHostFree_c8_7 module procedure hipHostFree_l_0 module procedure hipHostFree_l_1 module procedure hipHostFree_l_2 module procedure hipHostFree_l_3 module procedure hipHostFree_l_4 module procedure hipHostFree_l_5 module procedure hipHostFree_l_6 module procedure hipHostFree_l_7 end interface hipHostFree contains function hipMalloc_i4_1(ptr, length1) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMalloc_i4_1 function hipMalloc_i4_1_c_size_t(ptr, length1) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMalloc_i4_1_c_size_t function hipMalloc_i4_2(ptr, length1, length2) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMalloc_i4_2 function hipMalloc_i4_2_c_size_t(ptr, length1, length2) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMalloc_i4_2_c_size_t function hipMalloc_i4_3(ptr, length1, length2, length3) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMalloc_i4_3 function hipMalloc_i4_3_c_size_t(ptr, length1, length2, length3) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMalloc_i4_3_c_size_t function hipMalloc_i4_4(ptr, length1, length2, length3, length4) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMalloc_i4_4 function hipMalloc_i4_4_c_size_t(ptr, length1, length2, length3, length4) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMalloc_i4_4_c_size_t function hipMalloc_i4_5(ptr, length1, length2, length3, length4, length5) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMalloc_i4_5 function hipMalloc_i4_5_c_size_t(ptr, length1, length2, length3, length4, length5) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMalloc_i4_5_c_size_t function hipMalloc_i4_6(ptr, length1, length2, length3, length4, length5, length6) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMalloc_i4_6 function hipMalloc_i4_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMalloc_i4_6_c_size_t function hipMalloc_i4_7(ptr, length1, length2, length3, length4, length5, length6, length7) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMalloc_i4_7 function hipMalloc_i4_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMalloc_i4_7_c_size_t function hipMalloc_i8_1(ptr, length1) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMalloc_i8_1 function hipMalloc_i8_1_c_size_t(ptr, length1) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMalloc_i8_1_c_size_t function hipMalloc_i8_2(ptr, length1, length2) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMalloc_i8_2 function hipMalloc_i8_2_c_size_t(ptr, length1, length2) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMalloc_i8_2_c_size_t function hipMalloc_i8_3(ptr, length1, length2, length3) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMalloc_i8_3 function hipMalloc_i8_3_c_size_t(ptr, length1, length2, length3) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMalloc_i8_3_c_size_t function hipMalloc_i8_4(ptr, length1, length2, length3, length4) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMalloc_i8_4 function hipMalloc_i8_4_c_size_t(ptr, length1, length2, length3, length4) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMalloc_i8_4_c_size_t function hipMalloc_i8_5(ptr, length1, length2, length3, length4, length5) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMalloc_i8_5 function hipMalloc_i8_5_c_size_t(ptr, length1, length2, length3, length4, length5) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMalloc_i8_5_c_size_t function hipMalloc_i8_6(ptr, length1, length2, length3, length4, length5, length6) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMalloc_i8_6 function hipMalloc_i8_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMalloc_i8_6_c_size_t function hipMalloc_i8_7(ptr, length1, length2, length3, length4, length5, length6, length7) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMalloc_i8_7 function hipMalloc_i8_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMalloc_i8_7_c_size_t function hipMalloc_r4_1(ptr, length1) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMalloc_r4_1 function hipMalloc_r4_1_c_size_t(ptr, length1) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMalloc_r4_1_c_size_t function hipMalloc_r4_2(ptr, length1, length2) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMalloc_r4_2 function hipMalloc_r4_2_c_size_t(ptr, length1, length2) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMalloc_r4_2_c_size_t function hipMalloc_r4_3(ptr, length1, length2, length3) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMalloc_r4_3 function hipMalloc_r4_3_c_size_t(ptr, length1, length2, length3) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMalloc_r4_3_c_size_t function hipMalloc_r4_4(ptr, length1, length2, length3, length4) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMalloc_r4_4 function hipMalloc_r4_4_c_size_t(ptr, length1, length2, length3, length4) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMalloc_r4_4_c_size_t function hipMalloc_r4_5(ptr, length1, length2, length3, length4, length5) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMalloc_r4_5 function hipMalloc_r4_5_c_size_t(ptr, length1, length2, length3, length4, length5) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMalloc_r4_5_c_size_t function hipMalloc_r4_6(ptr, length1, length2, length3, length4, length5, length6) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMalloc_r4_6 function hipMalloc_r4_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMalloc_r4_6_c_size_t function hipMalloc_r4_7(ptr, length1, length2, length3, length4, length5, length6, length7) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMalloc_r4_7 function hipMalloc_r4_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMalloc_r4_7_c_size_t function hipMalloc_r8_1(ptr, length1) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMalloc_r8_1 function hipMalloc_r8_1_c_size_t(ptr, length1) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMalloc_r8_1_c_size_t function hipMalloc_r8_2(ptr, length1, length2) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMalloc_r8_2 function hipMalloc_r8_2_c_size_t(ptr, length1, length2) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMalloc_r8_2_c_size_t function hipMalloc_r8_3(ptr, length1, length2, length3) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMalloc_r8_3 function hipMalloc_r8_3_c_size_t(ptr, length1, length2, length3) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMalloc_r8_3_c_size_t function hipMalloc_r8_4(ptr, length1, length2, length3, length4) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMalloc_r8_4 function hipMalloc_r8_4_c_size_t(ptr, length1, length2, length3, length4) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMalloc_r8_4_c_size_t function hipMalloc_r8_5(ptr, length1, length2, length3, length4, length5) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMalloc_r8_5 function hipMalloc_r8_5_c_size_t(ptr, length1, length2, length3, length4, length5) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMalloc_r8_5_c_size_t function hipMalloc_r8_6(ptr, length1, length2, length3, length4, length5, length6) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMalloc_r8_6 function hipMalloc_r8_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMalloc_r8_6_c_size_t function hipMalloc_r8_7(ptr, length1, length2, length3, length4, length5, length6, length7) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMalloc_r8_7 function hipMalloc_r8_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMalloc_r8_7_c_size_t function hipMalloc_c4_1(ptr, length1) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMalloc_c4_1 function hipMalloc_c4_1_c_size_t(ptr, length1) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMalloc_c4_1_c_size_t function hipMalloc_c4_2(ptr, length1, length2) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMalloc_c4_2 function hipMalloc_c4_2_c_size_t(ptr, length1, length2) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMalloc_c4_2_c_size_t function hipMalloc_c4_3(ptr, length1, length2, length3) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMalloc_c4_3 function hipMalloc_c4_3_c_size_t(ptr, length1, length2, length3) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMalloc_c4_3_c_size_t function hipMalloc_c4_4(ptr, length1, length2, length3, length4) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMalloc_c4_4 function hipMalloc_c4_4_c_size_t(ptr, length1, length2, length3, length4) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMalloc_c4_4_c_size_t function hipMalloc_c4_5(ptr, length1, length2, length3, length4, length5) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMalloc_c4_5 function hipMalloc_c4_5_c_size_t(ptr, length1, length2, length3, length4, length5) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMalloc_c4_5_c_size_t function hipMalloc_c4_6(ptr, length1, length2, length3, length4, length5, length6) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMalloc_c4_6 function hipMalloc_c4_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMalloc_c4_6_c_size_t function hipMalloc_c4_7(ptr, length1, length2, length3, length4, length5, length6, length7) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMalloc_c4_7 function hipMalloc_c4_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMalloc_c4_7_c_size_t function hipMalloc_c8_1(ptr, length1) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMalloc_c8_1 function hipMalloc_c8_1_c_size_t(ptr, length1) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMalloc_c8_1_c_size_t function hipMalloc_c8_2(ptr, length1, length2) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMalloc_c8_2 function hipMalloc_c8_2_c_size_t(ptr, length1, length2) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMalloc_c8_2_c_size_t function hipMalloc_c8_3(ptr, length1, length2, length3) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMalloc_c8_3 function hipMalloc_c8_3_c_size_t(ptr, length1, length2, length3) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMalloc_c8_3_c_size_t function hipMalloc_c8_4(ptr, length1, length2, length3, length4) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMalloc_c8_4 function hipMalloc_c8_4_c_size_t(ptr, length1, length2, length3, length4) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMalloc_c8_4_c_size_t function hipMalloc_c8_5(ptr, length1, length2, length3, length4, length5) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMalloc_c8_5 function hipMalloc_c8_5_c_size_t(ptr, length1, length2, length3, length4, length5) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMalloc_c8_5_c_size_t function hipMalloc_c8_6(ptr, length1, length2, length3, length4, length5, length6) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMalloc_c8_6 function hipMalloc_c8_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMalloc_c8_6_c_size_t function hipMalloc_c8_7(ptr, length1, length2, length3, length4, length5, length6, length7) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMalloc_c8_7 function hipMalloc_c8_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMalloc_c8_7_c_size_t function hipMalloc_l_1(ptr, length1) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMalloc_l_1 function hipMalloc_l_1_c_size_t(ptr, length1) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMalloc_l_1_c_size_t function hipMalloc_l_2(ptr, length1, length2) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMalloc_l_2 function hipMalloc_l_2_c_size_t(ptr, length1, length2) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMalloc_l_2_c_size_t function hipMalloc_l_3(ptr, length1, length2, length3) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMalloc_l_3 function hipMalloc_l_3_c_size_t(ptr, length1, length2, length3) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMalloc_l_3_c_size_t function hipMalloc_l_4(ptr, length1, length2, length3, length4) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMalloc_l_4 function hipMalloc_l_4_c_size_t(ptr, length1, length2, length3, length4) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMalloc_l_4_c_size_t function hipMalloc_l_5(ptr, length1, length2, length3, length4, length5) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMalloc_l_5 function hipMalloc_l_5_c_size_t(ptr, length1, length2, length3, length4, length5) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMalloc_l_5_c_size_t function hipMalloc_l_6(ptr, length1, length2, length3, length4, length5, length6) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMalloc_l_6 function hipMalloc_l_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMalloc_l_6_c_size_t function hipMalloc_l_7(ptr, length1, length2, length3, length4, length5, length6, length7) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMalloc_l_7 function hipMalloc_l_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int) :: res integer(c_size_t) :: nbytes type(c_ptr) :: cptr nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMalloc_(cptr, nbytes) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMalloc_l_7_c_size_t function hipMalloc_i4_0_source(ptr, dsource, source) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, intent(inout) :: ptr integer(c_int), target, intent(in), optional :: dsource, source integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dsource/source" if (present(dsource)) then res = hipMalloc_(cptr, 4_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), 4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipMalloc_(cptr, 4_c_size_t) res = hipMemcpy(cptr, c_loc(source), 4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, ptr) else res = hipMalloc_(cptr, 4_c_size_t) call c_f_pointer(cptr, ptr) end if end function hipMalloc_i4_0_source function hipMalloc_i4_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) integer(c_int), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipMalloc_i4_1_source function hipMalloc_i4_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) integer(c_int), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipMalloc_i4_2_source function hipMalloc_i4_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) integer(c_int), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipMalloc_i4_3_source function hipMalloc_i4_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) integer(c_int), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipMalloc_i4_4_source function hipMalloc_i4_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) integer(c_int), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipMalloc_i4_5_source function hipMalloc_i4_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) integer(c_int), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipMalloc_i4_6_source function hipMalloc_i4_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipMalloc_i4_7_source function hipMalloc_i8_0_source(ptr, dsource, source) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, intent(inout) :: ptr integer(c_int64_t), target, intent(in), optional :: dsource, source integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dsource/source" if (present(dsource)) then res = hipMalloc_(cptr, 8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), 8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipMalloc_(cptr, 8_c_size_t) res = hipMemcpy(cptr, c_loc(source), 8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, ptr) else res = hipMalloc_(cptr, 8_c_size_t) call c_f_pointer(cptr, ptr) end if end function hipMalloc_i8_0_source function hipMalloc_i8_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) integer(c_int64_t), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipMalloc_i8_1_source function hipMalloc_i8_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) integer(c_int64_t), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipMalloc_i8_2_source function hipMalloc_i8_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) integer(c_int64_t), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipMalloc_i8_3_source function hipMalloc_i8_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) integer(c_int64_t), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipMalloc_i8_4_source function hipMalloc_i8_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) integer(c_int64_t), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipMalloc_i8_5_source function hipMalloc_i8_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipMalloc_i8_6_source function hipMalloc_i8_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipMalloc_i8_7_source function hipMalloc_r4_0_source(ptr, dsource, source) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, intent(inout) :: ptr real(c_float), target, intent(in), optional :: dsource, source integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dsource/source" if (present(dsource)) then res = hipMalloc_(cptr, 4_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), 4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipMalloc_(cptr, 4_c_size_t) res = hipMemcpy(cptr, c_loc(source), 4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, ptr) else res = hipMalloc_(cptr, 4_c_size_t) call c_f_pointer(cptr, ptr) end if end function hipMalloc_r4_0_source function hipMalloc_r4_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) real(c_float), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipMalloc_r4_1_source function hipMalloc_r4_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) real(c_float), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipMalloc_r4_2_source function hipMalloc_r4_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) real(c_float), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipMalloc_r4_3_source function hipMalloc_r4_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) real(c_float), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipMalloc_r4_4_source function hipMalloc_r4_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) real(c_float), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipMalloc_r4_5_source function hipMalloc_r4_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) real(c_float), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipMalloc_r4_6_source function hipMalloc_r4_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) real(c_float), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipMalloc_r4_7_source function hipMalloc_r8_0_source(ptr, dsource, source) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, intent(inout) :: ptr real(c_double), target, intent(in), optional :: dsource, source integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dsource/source" if (present(dsource)) then res = hipMalloc_(cptr, 8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), 8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipMalloc_(cptr, 8_c_size_t) res = hipMemcpy(cptr, c_loc(source), 8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, ptr) else res = hipMalloc_(cptr, 8_c_size_t) call c_f_pointer(cptr, ptr) end if end function hipMalloc_r8_0_source function hipMalloc_r8_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) real(c_double), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipMalloc_r8_1_source function hipMalloc_r8_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) real(c_double), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipMalloc_r8_2_source function hipMalloc_r8_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) real(c_double), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipMalloc_r8_3_source function hipMalloc_r8_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) real(c_double), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipMalloc_r8_4_source function hipMalloc_r8_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) real(c_double), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipMalloc_r8_5_source function hipMalloc_r8_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) real(c_double), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipMalloc_r8_6_source function hipMalloc_r8_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) real(c_double), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipMalloc_r8_7_source function hipMalloc_c4_0_source(ptr, dsource, source) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, intent(inout) :: ptr complex(c_float_complex), target, intent(in), optional :: dsource, source integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dsource/source" if (present(dsource)) then res = hipMalloc_(cptr, 8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), 8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipMalloc_(cptr, 8_c_size_t) res = hipMemcpy(cptr, c_loc(source), 8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, ptr) else res = hipMalloc_(cptr, 8_c_size_t) call c_f_pointer(cptr, ptr) end if end function hipMalloc_c4_0_source function hipMalloc_c4_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) complex(c_float_complex), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipMalloc_c4_1_source function hipMalloc_c4_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) complex(c_float_complex), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipMalloc_c4_2_source function hipMalloc_c4_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) complex(c_float_complex), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipMalloc_c4_3_source function hipMalloc_c4_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) complex(c_float_complex), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipMalloc_c4_4_source function hipMalloc_c4_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) complex(c_float_complex), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipMalloc_c4_5_source function hipMalloc_c4_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipMalloc_c4_6_source function hipMalloc_c4_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipMalloc_c4_7_source function hipMalloc_c8_0_source(ptr, dsource, source) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, intent(inout) :: ptr complex(c_double_complex), target, intent(in), optional :: dsource, source integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dsource/source" if (present(dsource)) then res = hipMalloc_(cptr, 16_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), 16_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipMalloc_(cptr, 16_c_size_t) res = hipMemcpy(cptr, c_loc(source), 16_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, ptr) else res = hipMalloc_(cptr, 16_c_size_t) call c_f_pointer(cptr, ptr) end if end function hipMalloc_c8_0_source function hipMalloc_c8_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) complex(c_double_complex), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*16_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*16_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*16_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*16_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*16_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipMalloc_c8_1_source function hipMalloc_c8_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) complex(c_double_complex), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*16_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*16_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*16_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*16_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*16_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipMalloc_c8_2_source function hipMalloc_c8_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) complex(c_double_complex), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*16_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*16_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*16_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*16_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*16_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipMalloc_c8_3_source function hipMalloc_c8_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) complex(c_double_complex), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*16_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*16_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*16_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*16_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*16_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipMalloc_c8_4_source function hipMalloc_c8_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) complex(c_double_complex), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*16_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*16_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*16_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*16_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*16_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipMalloc_c8_5_source function hipMalloc_c8_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*16_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*16_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*16_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*16_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*16_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipMalloc_c8_6_source function hipMalloc_c8_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*16_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*16_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*16_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*16_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*16_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipMalloc_c8_7_source function hipMalloc_l_0_source(ptr, dsource, source) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, intent(inout) :: ptr logical(c_bool), target, intent(in), optional :: dsource, source integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dsource/source" if (present(dsource)) then res = hipMalloc_(cptr, 1_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), 1_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipMalloc_(cptr, 1_c_size_t) res = hipMemcpy(cptr, c_loc(source), 1_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, ptr) else res = hipMalloc_(cptr, 1_c_size_t) call c_f_pointer(cptr, ptr) end if end function hipMalloc_l_0_source function hipMalloc_l_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) logical(c_bool), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*1_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*1_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*1_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*1_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*1_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipMalloc_l_1_source function hipMalloc_l_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) logical(c_bool), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*1_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*1_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*1_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*1_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*1_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipMalloc_l_2_source function hipMalloc_l_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) logical(c_bool), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*1_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*1_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*1_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*1_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*1_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipMalloc_l_3_source function hipMalloc_l_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) logical(c_bool), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*1_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*1_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*1_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*1_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*1_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipMalloc_l_4_source function hipMalloc_l_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) logical(c_bool), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*1_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*1_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*1_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*1_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*1_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipMalloc_l_5_source function hipMalloc_l_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) logical(c_bool), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*1_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*1_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*1_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*1_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*1_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipMalloc_l_6_source function hipMalloc_l_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMalloc: lbounds requires dims" if (present(dsource)) then res = hipMalloc_(cptr, int(size(dsource), c_size_t)*1_c_size_t) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipMalloc_(cptr, int(size(source), c_size_t)*1_c_size_t) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipMalloc_(cptr, int(size(mold), c_size_t)*1_c_size_t) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipMalloc_(cptr, product(dims8)*1_c_size_t) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMalloc_(cptr, product(int(dims, c_size_t))*1_c_size_t) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipMalloc_l_7_source function hipMallocManaged_i4_1(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMallocManaged_i4_1 function hipMallocManaged_i4_1_c_size_t(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMallocManaged_i4_1_c_size_t function hipMallocManaged_i4_2(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMallocManaged_i4_2 function hipMallocManaged_i4_2_c_size_t(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMallocManaged_i4_2_c_size_t function hipMallocManaged_i4_3(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMallocManaged_i4_3 function hipMallocManaged_i4_3_c_size_t(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMallocManaged_i4_3_c_size_t function hipMallocManaged_i4_4(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMallocManaged_i4_4 function hipMallocManaged_i4_4_c_size_t(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMallocManaged_i4_4_c_size_t function hipMallocManaged_i4_5(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMallocManaged_i4_5 function hipMallocManaged_i4_5_c_size_t(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMallocManaged_i4_5_c_size_t function hipMallocManaged_i4_6(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMallocManaged_i4_6 function hipMallocManaged_i4_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMallocManaged_i4_6_c_size_t function hipMallocManaged_i4_7(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMallocManaged_i4_7 function hipMallocManaged_i4_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMallocManaged_i4_7_c_size_t function hipMallocManaged_i8_1(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int64_t), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMallocManaged_i8_1 function hipMallocManaged_i8_1_c_size_t(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int64_t), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMallocManaged_i8_1_c_size_t function hipMallocManaged_i8_2(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int64_t), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMallocManaged_i8_2 function hipMallocManaged_i8_2_c_size_t(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int64_t), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMallocManaged_i8_2_c_size_t function hipMallocManaged_i8_3(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int64_t), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMallocManaged_i8_3 function hipMallocManaged_i8_3_c_size_t(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int64_t), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMallocManaged_i8_3_c_size_t function hipMallocManaged_i8_4(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int64_t), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMallocManaged_i8_4 function hipMallocManaged_i8_4_c_size_t(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int64_t), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMallocManaged_i8_4_c_size_t function hipMallocManaged_i8_5(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMallocManaged_i8_5 function hipMallocManaged_i8_5_c_size_t(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMallocManaged_i8_5_c_size_t function hipMallocManaged_i8_6(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMallocManaged_i8_6 function hipMallocManaged_i8_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMallocManaged_i8_6_c_size_t function hipMallocManaged_i8_7(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMallocManaged_i8_7 function hipMallocManaged_i8_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMallocManaged_i8_7_c_size_t function hipMallocManaged_r4_1(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_float), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMallocManaged_r4_1 function hipMallocManaged_r4_1_c_size_t(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_float), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMallocManaged_r4_1_c_size_t function hipMallocManaged_r4_2(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_float), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMallocManaged_r4_2 function hipMallocManaged_r4_2_c_size_t(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_float), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMallocManaged_r4_2_c_size_t function hipMallocManaged_r4_3(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_float), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMallocManaged_r4_3 function hipMallocManaged_r4_3_c_size_t(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_float), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMallocManaged_r4_3_c_size_t function hipMallocManaged_r4_4(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_float), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMallocManaged_r4_4 function hipMallocManaged_r4_4_c_size_t(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_float), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMallocManaged_r4_4_c_size_t function hipMallocManaged_r4_5(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_float), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMallocManaged_r4_5 function hipMallocManaged_r4_5_c_size_t(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_float), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMallocManaged_r4_5_c_size_t function hipMallocManaged_r4_6(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_float), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMallocManaged_r4_6 function hipMallocManaged_r4_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_float), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMallocManaged_r4_6_c_size_t function hipMallocManaged_r4_7(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_float), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMallocManaged_r4_7 function hipMallocManaged_r4_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_float), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMallocManaged_r4_7_c_size_t function hipMallocManaged_r8_1(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_double), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMallocManaged_r8_1 function hipMallocManaged_r8_1_c_size_t(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_double), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMallocManaged_r8_1_c_size_t function hipMallocManaged_r8_2(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_double), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMallocManaged_r8_2 function hipMallocManaged_r8_2_c_size_t(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_double), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMallocManaged_r8_2_c_size_t function hipMallocManaged_r8_3(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_double), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMallocManaged_r8_3 function hipMallocManaged_r8_3_c_size_t(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_double), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMallocManaged_r8_3_c_size_t function hipMallocManaged_r8_4(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_double), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMallocManaged_r8_4 function hipMallocManaged_r8_4_c_size_t(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_double), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMallocManaged_r8_4_c_size_t function hipMallocManaged_r8_5(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_double), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMallocManaged_r8_5 function hipMallocManaged_r8_5_c_size_t(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_double), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMallocManaged_r8_5_c_size_t function hipMallocManaged_r8_6(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_double), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMallocManaged_r8_6 function hipMallocManaged_r8_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_double), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMallocManaged_r8_6_c_size_t function hipMallocManaged_r8_7(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_double), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMallocManaged_r8_7 function hipMallocManaged_r8_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none real(c_double), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMallocManaged_r8_7_c_size_t function hipMallocManaged_c4_1(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_float_complex), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMallocManaged_c4_1 function hipMallocManaged_c4_1_c_size_t(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_float_complex), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMallocManaged_c4_1_c_size_t function hipMallocManaged_c4_2(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_float_complex), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMallocManaged_c4_2 function hipMallocManaged_c4_2_c_size_t(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_float_complex), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMallocManaged_c4_2_c_size_t function hipMallocManaged_c4_3(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_float_complex), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMallocManaged_c4_3 function hipMallocManaged_c4_3_c_size_t(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_float_complex), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMallocManaged_c4_3_c_size_t function hipMallocManaged_c4_4(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_float_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMallocManaged_c4_4 function hipMallocManaged_c4_4_c_size_t(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_float_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMallocManaged_c4_4_c_size_t function hipMallocManaged_c4_5(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMallocManaged_c4_5 function hipMallocManaged_c4_5_c_size_t(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMallocManaged_c4_5_c_size_t function hipMallocManaged_c4_6(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMallocManaged_c4_6 function hipMallocManaged_c4_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMallocManaged_c4_6_c_size_t function hipMallocManaged_c4_7(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMallocManaged_c4_7 function hipMallocManaged_c4_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMallocManaged_c4_7_c_size_t function hipMallocManaged_c8_1(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_double_complex), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMallocManaged_c8_1 function hipMallocManaged_c8_1_c_size_t(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_double_complex), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMallocManaged_c8_1_c_size_t function hipMallocManaged_c8_2(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_double_complex), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMallocManaged_c8_2 function hipMallocManaged_c8_2_c_size_t(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_double_complex), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMallocManaged_c8_2_c_size_t function hipMallocManaged_c8_3(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_double_complex), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMallocManaged_c8_3 function hipMallocManaged_c8_3_c_size_t(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_double_complex), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMallocManaged_c8_3_c_size_t function hipMallocManaged_c8_4(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_double_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMallocManaged_c8_4 function hipMallocManaged_c8_4_c_size_t(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_double_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMallocManaged_c8_4_c_size_t function hipMallocManaged_c8_5(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMallocManaged_c8_5 function hipMallocManaged_c8_5_c_size_t(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMallocManaged_c8_5_c_size_t function hipMallocManaged_c8_6(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMallocManaged_c8_6 function hipMallocManaged_c8_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMallocManaged_c8_6_c_size_t function hipMallocManaged_c8_7(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMallocManaged_c8_7 function hipMallocManaged_c8_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMallocManaged_c8_7_c_size_t function hipMallocManaged_l_1(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none logical(c_bool), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMallocManaged_l_1 function hipMallocManaged_l_1_c_size_t(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none logical(c_bool), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipMallocManaged_l_1_c_size_t function hipMallocManaged_l_2(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none logical(c_bool), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMallocManaged_l_2 function hipMallocManaged_l_2_c_size_t(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none logical(c_bool), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipMallocManaged_l_2_c_size_t function hipMallocManaged_l_3(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none logical(c_bool), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMallocManaged_l_3 function hipMallocManaged_l_3_c_size_t(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none logical(c_bool), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipMallocManaged_l_3_c_size_t function hipMallocManaged_l_4(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none logical(c_bool), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMallocManaged_l_4 function hipMallocManaged_l_4_c_size_t(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none logical(c_bool), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipMallocManaged_l_4_c_size_t function hipMallocManaged_l_5(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none logical(c_bool), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMallocManaged_l_5 function hipMallocManaged_l_5_c_size_t(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none logical(c_bool), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipMallocManaged_l_5_c_size_t function hipMallocManaged_l_6(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMallocManaged_l_6 function hipMallocManaged_l_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipMallocManaged_l_6_c_size_t function hipMallocManaged_l_7(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMallocManaged_l_7 function hipMallocManaged_l_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemAttachGlobal implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipMemAttachGlobal if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipMallocManaged_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipMallocManaged_l_7_c_size_t function hipMallocManaged_i4_0_source(ptr, dsource, source, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, intent(inout) :: ptr integer(c_int), target, intent(in), optional :: dsource, source integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dsource/source" if (present(dsource)) then res = hipMallocManaged_(cptr, 4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), 4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipMallocManaged_(cptr, 4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), 4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, ptr) else res = hipMallocManaged_(cptr, 4_c_size_t, flags) call c_f_pointer(cptr, ptr) end if end function hipMallocManaged_i4_0_source function hipMallocManaged_i4_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) integer(c_int), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipMallocManaged_i4_1_source function hipMallocManaged_i4_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) integer(c_int), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipMallocManaged_i4_2_source function hipMallocManaged_i4_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) integer(c_int), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipMallocManaged_i4_3_source function hipMallocManaged_i4_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) integer(c_int), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipMallocManaged_i4_4_source function hipMallocManaged_i4_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) integer(c_int), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipMallocManaged_i4_5_source function hipMallocManaged_i4_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) integer(c_int), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipMallocManaged_i4_6_source function hipMallocManaged_i4_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipMallocManaged_i4_7_source function hipMallocManaged_i8_0_source(ptr, dsource, source, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, intent(inout) :: ptr integer(c_int64_t), target, intent(in), optional :: dsource, source integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dsource/source" if (present(dsource)) then res = hipMallocManaged_(cptr, 8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), 8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipMallocManaged_(cptr, 8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), 8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, ptr) else res = hipMallocManaged_(cptr, 8_c_size_t, flags) call c_f_pointer(cptr, ptr) end if end function hipMallocManaged_i8_0_source function hipMallocManaged_i8_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) integer(c_int64_t), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipMallocManaged_i8_1_source function hipMallocManaged_i8_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) integer(c_int64_t), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipMallocManaged_i8_2_source function hipMallocManaged_i8_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) integer(c_int64_t), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipMallocManaged_i8_3_source function hipMallocManaged_i8_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) integer(c_int64_t), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipMallocManaged_i8_4_source function hipMallocManaged_i8_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) integer(c_int64_t), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipMallocManaged_i8_5_source function hipMallocManaged_i8_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipMallocManaged_i8_6_source function hipMallocManaged_i8_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipMallocManaged_i8_7_source function hipMallocManaged_r4_0_source(ptr, dsource, source, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, intent(inout) :: ptr real(c_float), target, intent(in), optional :: dsource, source integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dsource/source" if (present(dsource)) then res = hipMallocManaged_(cptr, 4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), 4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipMallocManaged_(cptr, 4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), 4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, ptr) else res = hipMallocManaged_(cptr, 4_c_size_t, flags) call c_f_pointer(cptr, ptr) end if end function hipMallocManaged_r4_0_source function hipMallocManaged_r4_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) real(c_float), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipMallocManaged_r4_1_source function hipMallocManaged_r4_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) real(c_float), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipMallocManaged_r4_2_source function hipMallocManaged_r4_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) real(c_float), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipMallocManaged_r4_3_source function hipMallocManaged_r4_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) real(c_float), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipMallocManaged_r4_4_source function hipMallocManaged_r4_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) real(c_float), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipMallocManaged_r4_5_source function hipMallocManaged_r4_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) real(c_float), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipMallocManaged_r4_6_source function hipMallocManaged_r4_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) real(c_float), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipMallocManaged_r4_7_source function hipMallocManaged_r8_0_source(ptr, dsource, source, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, intent(inout) :: ptr real(c_double), target, intent(in), optional :: dsource, source integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dsource/source" if (present(dsource)) then res = hipMallocManaged_(cptr, 8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), 8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipMallocManaged_(cptr, 8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), 8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, ptr) else res = hipMallocManaged_(cptr, 8_c_size_t, flags) call c_f_pointer(cptr, ptr) end if end function hipMallocManaged_r8_0_source function hipMallocManaged_r8_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) real(c_double), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipMallocManaged_r8_1_source function hipMallocManaged_r8_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) real(c_double), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipMallocManaged_r8_2_source function hipMallocManaged_r8_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) real(c_double), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipMallocManaged_r8_3_source function hipMallocManaged_r8_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) real(c_double), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipMallocManaged_r8_4_source function hipMallocManaged_r8_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) real(c_double), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipMallocManaged_r8_5_source function hipMallocManaged_r8_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) real(c_double), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipMallocManaged_r8_6_source function hipMallocManaged_r8_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) real(c_double), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipMallocManaged_r8_7_source function hipMallocManaged_c4_0_source(ptr, dsource, source, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, intent(inout) :: ptr complex(c_float_complex), target, intent(in), optional :: dsource, source integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dsource/source" if (present(dsource)) then res = hipMallocManaged_(cptr, 8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), 8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipMallocManaged_(cptr, 8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), 8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, ptr) else res = hipMallocManaged_(cptr, 8_c_size_t, flags) call c_f_pointer(cptr, ptr) end if end function hipMallocManaged_c4_0_source function hipMallocManaged_c4_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) complex(c_float_complex), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipMallocManaged_c4_1_source function hipMallocManaged_c4_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) complex(c_float_complex), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipMallocManaged_c4_2_source function hipMallocManaged_c4_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) complex(c_float_complex), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipMallocManaged_c4_3_source function hipMallocManaged_c4_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) complex(c_float_complex), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipMallocManaged_c4_4_source function hipMallocManaged_c4_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) complex(c_float_complex), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipMallocManaged_c4_5_source function hipMallocManaged_c4_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipMallocManaged_c4_6_source function hipMallocManaged_c4_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipMallocManaged_c4_7_source function hipMallocManaged_c8_0_source(ptr, dsource, source, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, intent(inout) :: ptr complex(c_double_complex), target, intent(in), optional :: dsource, source integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dsource/source" if (present(dsource)) then res = hipMallocManaged_(cptr, 16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), 16_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipMallocManaged_(cptr, 16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), 16_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, ptr) else res = hipMallocManaged_(cptr, 16_c_size_t, flags) call c_f_pointer(cptr, ptr) end if end function hipMallocManaged_c8_0_source function hipMallocManaged_c8_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) complex(c_double_complex), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipMallocManaged_c8_1_source function hipMallocManaged_c8_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) complex(c_double_complex), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipMallocManaged_c8_2_source function hipMallocManaged_c8_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) complex(c_double_complex), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipMallocManaged_c8_3_source function hipMallocManaged_c8_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) complex(c_double_complex), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipMallocManaged_c8_4_source function hipMallocManaged_c8_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) complex(c_double_complex), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipMallocManaged_c8_5_source function hipMallocManaged_c8_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipMallocManaged_c8_6_source function hipMallocManaged_c8_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipMallocManaged_c8_7_source function hipMallocManaged_l_0_source(ptr, dsource, source, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, intent(inout) :: ptr logical(c_bool), target, intent(in), optional :: dsource, source integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dsource/source" if (present(dsource)) then res = hipMallocManaged_(cptr, 1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), 1_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipMallocManaged_(cptr, 1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), 1_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, ptr) else res = hipMallocManaged_(cptr, 1_c_size_t, flags) call c_f_pointer(cptr, ptr) end if end function hipMallocManaged_l_0_source function hipMallocManaged_l_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) logical(c_bool), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipMallocManaged_l_1_source function hipMallocManaged_l_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) logical(c_bool), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipMallocManaged_l_2_source function hipMallocManaged_l_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) logical(c_bool), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipMallocManaged_l_3_source function hipMallocManaged_l_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) logical(c_bool), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipMallocManaged_l_4_source function hipMallocManaged_l_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) logical(c_bool), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipMallocManaged_l_5_source function hipMallocManaged_l_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) logical(c_bool), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipMallocManaged_l_6_source function hipMallocManaged_l_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToDevice, hipMemcpyDeviceToDevice use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipMallocManaged: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipMallocManaged: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipMallocManaged: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipMallocManaged: lbounds requires dims" if (present(dsource)) then res = hipMallocManaged_(cptr, int(size(dsource), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToDevice) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipMallocManaged_(cptr, int(size(source), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToDevice) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipMallocManaged_(cptr, int(size(mold), c_size_t)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipMallocManaged_(cptr, product(dims8)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipMallocManaged_(cptr, product(int(dims, c_size_t))*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipMallocManaged_l_7_source function hipHostMalloc_i4_1(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipHostMalloc_i4_1 function hipHostMalloc_i4_1_c_size_t(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipHostMalloc_i4_1_c_size_t function hipHostMalloc_i4_2(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipHostMalloc_i4_2 function hipHostMalloc_i4_2_c_size_t(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipHostMalloc_i4_2_c_size_t function hipHostMalloc_i4_3(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipHostMalloc_i4_3 function hipHostMalloc_i4_3_c_size_t(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipHostMalloc_i4_3_c_size_t function hipHostMalloc_i4_4(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipHostMalloc_i4_4 function hipHostMalloc_i4_4_c_size_t(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipHostMalloc_i4_4_c_size_t function hipHostMalloc_i4_5(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipHostMalloc_i4_5 function hipHostMalloc_i4_5_c_size_t(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipHostMalloc_i4_5_c_size_t function hipHostMalloc_i4_6(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipHostMalloc_i4_6 function hipHostMalloc_i4_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipHostMalloc_i4_6_c_size_t function hipHostMalloc_i4_7(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipHostMalloc_i4_7 function hipHostMalloc_i4_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipHostMalloc_i4_7_c_size_t function hipHostMalloc_i8_1(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int64_t), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipHostMalloc_i8_1 function hipHostMalloc_i8_1_c_size_t(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int64_t), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipHostMalloc_i8_1_c_size_t function hipHostMalloc_i8_2(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int64_t), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipHostMalloc_i8_2 function hipHostMalloc_i8_2_c_size_t(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int64_t), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipHostMalloc_i8_2_c_size_t function hipHostMalloc_i8_3(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int64_t), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipHostMalloc_i8_3 function hipHostMalloc_i8_3_c_size_t(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int64_t), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipHostMalloc_i8_3_c_size_t function hipHostMalloc_i8_4(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int64_t), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipHostMalloc_i8_4 function hipHostMalloc_i8_4_c_size_t(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int64_t), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipHostMalloc_i8_4_c_size_t function hipHostMalloc_i8_5(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipHostMalloc_i8_5 function hipHostMalloc_i8_5_c_size_t(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipHostMalloc_i8_5_c_size_t function hipHostMalloc_i8_6(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipHostMalloc_i8_6 function hipHostMalloc_i8_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipHostMalloc_i8_6_c_size_t function hipHostMalloc_i8_7(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipHostMalloc_i8_7 function hipHostMalloc_i8_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipHostMalloc_i8_7_c_size_t function hipHostMalloc_r4_1(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_float), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipHostMalloc_r4_1 function hipHostMalloc_r4_1_c_size_t(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_float), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipHostMalloc_r4_1_c_size_t function hipHostMalloc_r4_2(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_float), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipHostMalloc_r4_2 function hipHostMalloc_r4_2_c_size_t(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_float), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipHostMalloc_r4_2_c_size_t function hipHostMalloc_r4_3(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_float), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipHostMalloc_r4_3 function hipHostMalloc_r4_3_c_size_t(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_float), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipHostMalloc_r4_3_c_size_t function hipHostMalloc_r4_4(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_float), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipHostMalloc_r4_4 function hipHostMalloc_r4_4_c_size_t(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_float), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipHostMalloc_r4_4_c_size_t function hipHostMalloc_r4_5(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_float), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipHostMalloc_r4_5 function hipHostMalloc_r4_5_c_size_t(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_float), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipHostMalloc_r4_5_c_size_t function hipHostMalloc_r4_6(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_float), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipHostMalloc_r4_6 function hipHostMalloc_r4_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_float), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipHostMalloc_r4_6_c_size_t function hipHostMalloc_r4_7(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_float), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipHostMalloc_r4_7 function hipHostMalloc_r4_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_float), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 4_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipHostMalloc_r4_7_c_size_t function hipHostMalloc_r8_1(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_double), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipHostMalloc_r8_1 function hipHostMalloc_r8_1_c_size_t(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_double), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipHostMalloc_r8_1_c_size_t function hipHostMalloc_r8_2(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_double), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipHostMalloc_r8_2 function hipHostMalloc_r8_2_c_size_t(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_double), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipHostMalloc_r8_2_c_size_t function hipHostMalloc_r8_3(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_double), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipHostMalloc_r8_3 function hipHostMalloc_r8_3_c_size_t(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_double), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipHostMalloc_r8_3_c_size_t function hipHostMalloc_r8_4(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_double), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipHostMalloc_r8_4 function hipHostMalloc_r8_4_c_size_t(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_double), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipHostMalloc_r8_4_c_size_t function hipHostMalloc_r8_5(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_double), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipHostMalloc_r8_5 function hipHostMalloc_r8_5_c_size_t(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_double), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipHostMalloc_r8_5_c_size_t function hipHostMalloc_r8_6(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_double), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipHostMalloc_r8_6 function hipHostMalloc_r8_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_double), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipHostMalloc_r8_6_c_size_t function hipHostMalloc_r8_7(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_double), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipHostMalloc_r8_7 function hipHostMalloc_r8_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none real(c_double), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipHostMalloc_r8_7_c_size_t function hipHostMalloc_c4_1(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_float_complex), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipHostMalloc_c4_1 function hipHostMalloc_c4_1_c_size_t(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_float_complex), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipHostMalloc_c4_1_c_size_t function hipHostMalloc_c4_2(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_float_complex), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipHostMalloc_c4_2 function hipHostMalloc_c4_2_c_size_t(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_float_complex), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipHostMalloc_c4_2_c_size_t function hipHostMalloc_c4_3(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_float_complex), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipHostMalloc_c4_3 function hipHostMalloc_c4_3_c_size_t(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_float_complex), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipHostMalloc_c4_3_c_size_t function hipHostMalloc_c4_4(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_float_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipHostMalloc_c4_4 function hipHostMalloc_c4_4_c_size_t(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_float_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipHostMalloc_c4_4_c_size_t function hipHostMalloc_c4_5(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipHostMalloc_c4_5 function hipHostMalloc_c4_5_c_size_t(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipHostMalloc_c4_5_c_size_t function hipHostMalloc_c4_6(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipHostMalloc_c4_6 function hipHostMalloc_c4_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipHostMalloc_c4_6_c_size_t function hipHostMalloc_c4_7(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipHostMalloc_c4_7 function hipHostMalloc_c4_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 8_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipHostMalloc_c4_7_c_size_t function hipHostMalloc_c8_1(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_double_complex), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipHostMalloc_c8_1 function hipHostMalloc_c8_1_c_size_t(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_double_complex), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipHostMalloc_c8_1_c_size_t function hipHostMalloc_c8_2(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_double_complex), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipHostMalloc_c8_2 function hipHostMalloc_c8_2_c_size_t(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_double_complex), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipHostMalloc_c8_2_c_size_t function hipHostMalloc_c8_3(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_double_complex), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipHostMalloc_c8_3 function hipHostMalloc_c8_3_c_size_t(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_double_complex), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipHostMalloc_c8_3_c_size_t function hipHostMalloc_c8_4(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_double_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipHostMalloc_c8_4 function hipHostMalloc_c8_4_c_size_t(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_double_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipHostMalloc_c8_4_c_size_t function hipHostMalloc_c8_5(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipHostMalloc_c8_5 function hipHostMalloc_c8_5_c_size_t(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipHostMalloc_c8_5_c_size_t function hipHostMalloc_c8_6(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipHostMalloc_c8_6 function hipHostMalloc_c8_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipHostMalloc_c8_6_c_size_t function hipHostMalloc_c8_7(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipHostMalloc_c8_7 function hipHostMalloc_c8_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 16_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipHostMalloc_c8_7_c_size_t function hipHostMalloc_l_1(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none logical(c_bool), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipHostMalloc_l_1 function hipHostMalloc_l_1_c_size_t(ptr, length1, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none logical(c_bool), pointer, dimension(:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1]) end function hipHostMalloc_l_1_c_size_t function hipHostMalloc_l_2(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none logical(c_bool), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipHostMalloc_l_2 function hipHostMalloc_l_2_c_size_t(ptr, length1, length2, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none logical(c_bool), pointer, dimension(:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2]) end function hipHostMalloc_l_2_c_size_t function hipHostMalloc_l_3(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none logical(c_bool), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipHostMalloc_l_3 function hipHostMalloc_l_3_c_size_t(ptr, length1, length2, length3, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none logical(c_bool), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3]) end function hipHostMalloc_l_3_c_size_t function hipHostMalloc_l_4(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none logical(c_bool), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipHostMalloc_l_4 function hipHostMalloc_l_4_c_size_t(ptr, length1, length2, length3, length4, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none logical(c_bool), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4]) end function hipHostMalloc_l_4_c_size_t function hipHostMalloc_l_5(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none logical(c_bool), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipHostMalloc_l_5 function hipHostMalloc_l_5_c_size_t(ptr, length1, length2, length3, length4, length5, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none logical(c_bool), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5]) end function hipHostMalloc_l_5_c_size_t function hipHostMalloc_l_6(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipHostMalloc_l_6 function hipHostMalloc_l_6_c_size_t(ptr, length1, length2, length3, length4, length5, length6, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6]) end function hipHostMalloc_l_6_c_size_t function hipHostMalloc_l_7(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipHostMalloc_l_7 function hipHostMalloc_l_7_c_size_t(ptr, length1, length2, length3, length4, length5, length6, length7, flags) result(res) use iso_c_binding use hipfort_enums, only: hipHostMallocDefault implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_size_t), intent(in) :: length1, length2, length3, length4, length5, length6, length7 integer(c_int), intent(in), optional :: flags integer(c_int) :: res integer(c_int) :: fl integer(c_size_t) :: nbytes type(c_ptr) :: cptr fl = hipHostMallocDefault if (present(flags)) fl = flags nbytes = 1_c_size_t nbytes = nbytes * int(length1, c_size_t) nbytes = nbytes * int(length2, c_size_t) nbytes = nbytes * int(length3, c_size_t) nbytes = nbytes * int(length4, c_size_t) nbytes = nbytes * int(length5, c_size_t) nbytes = nbytes * int(length6, c_size_t) nbytes = nbytes * int(length7, c_size_t) res = hipHostMalloc_(cptr, nbytes, fl) call c_f_pointer(cptr, ptr, shape=[length1,length2,length3,length4,length5,length6,length7]) end function hipHostMalloc_l_7_c_size_t function hipHostMalloc_i4_0_source(ptr, dsource, source, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, intent(inout) :: ptr integer(c_int), target, intent(in), optional :: dsource, source integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dsource/source" if (present(dsource)) then res = hipHostMalloc_(cptr, 4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), 4_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipHostMalloc_(cptr, 4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), 4_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, ptr) else res = hipHostMalloc_(cptr, 4_c_size_t, flags) call c_f_pointer(cptr, ptr) end if end function hipHostMalloc_i4_0_source function hipHostMalloc_i4_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) integer(c_int), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipHostMalloc_i4_1_source function hipHostMalloc_i4_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) integer(c_int), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipHostMalloc_i4_2_source function hipHostMalloc_i4_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) integer(c_int), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipHostMalloc_i4_3_source function hipHostMalloc_i4_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) integer(c_int), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipHostMalloc_i4_4_source function hipHostMalloc_i4_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) integer(c_int), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipHostMalloc_i4_5_source function hipHostMalloc_i4_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) integer(c_int), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipHostMalloc_i4_6_source function hipHostMalloc_i4_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipHostMalloc_i4_7_source function hipHostMalloc_i8_0_source(ptr, dsource, source, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, intent(inout) :: ptr integer(c_int64_t), target, intent(in), optional :: dsource, source integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dsource/source" if (present(dsource)) then res = hipHostMalloc_(cptr, 8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), 8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipHostMalloc_(cptr, 8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), 8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, ptr) else res = hipHostMalloc_(cptr, 8_c_size_t, flags) call c_f_pointer(cptr, ptr) end if end function hipHostMalloc_i8_0_source function hipHostMalloc_i8_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) integer(c_int64_t), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipHostMalloc_i8_1_source function hipHostMalloc_i8_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) integer(c_int64_t), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipHostMalloc_i8_2_source function hipHostMalloc_i8_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) integer(c_int64_t), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipHostMalloc_i8_3_source function hipHostMalloc_i8_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) integer(c_int64_t), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipHostMalloc_i8_4_source function hipHostMalloc_i8_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) integer(c_int64_t), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipHostMalloc_i8_5_source function hipHostMalloc_i8_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipHostMalloc_i8_6_source function hipHostMalloc_i8_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr integer(c_int64_t), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipHostMalloc_i8_7_source function hipHostMalloc_r4_0_source(ptr, dsource, source, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, intent(inout) :: ptr real(c_float), target, intent(in), optional :: dsource, source integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dsource/source" if (present(dsource)) then res = hipHostMalloc_(cptr, 4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), 4_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipHostMalloc_(cptr, 4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), 4_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, ptr) else res = hipHostMalloc_(cptr, 4_c_size_t, flags) call c_f_pointer(cptr, ptr) end if end function hipHostMalloc_r4_0_source function hipHostMalloc_r4_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) real(c_float), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipHostMalloc_r4_1_source function hipHostMalloc_r4_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) real(c_float), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipHostMalloc_r4_2_source function hipHostMalloc_r4_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) real(c_float), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipHostMalloc_r4_3_source function hipHostMalloc_r4_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) real(c_float), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipHostMalloc_r4_4_source function hipHostMalloc_r4_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) real(c_float), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipHostMalloc_r4_5_source function hipHostMalloc_r4_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) real(c_float), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipHostMalloc_r4_6_source function hipHostMalloc_r4_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_float), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) real(c_float), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_float), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*4_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*4_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*4_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*4_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipHostMalloc_r4_7_source function hipHostMalloc_r8_0_source(ptr, dsource, source, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, intent(inout) :: ptr real(c_double), target, intent(in), optional :: dsource, source integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dsource/source" if (present(dsource)) then res = hipHostMalloc_(cptr, 8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), 8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipHostMalloc_(cptr, 8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), 8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, ptr) else res = hipHostMalloc_(cptr, 8_c_size_t, flags) call c_f_pointer(cptr, ptr) end if end function hipHostMalloc_r8_0_source function hipHostMalloc_r8_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) real(c_double), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipHostMalloc_r8_1_source function hipHostMalloc_r8_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) real(c_double), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipHostMalloc_r8_2_source function hipHostMalloc_r8_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) real(c_double), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipHostMalloc_r8_3_source function hipHostMalloc_r8_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) real(c_double), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipHostMalloc_r8_4_source function hipHostMalloc_r8_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) real(c_double), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipHostMalloc_r8_5_source function hipHostMalloc_r8_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) real(c_double), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipHostMalloc_r8_6_source function hipHostMalloc_r8_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none real(c_double), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) real(c_double), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr real(c_double), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipHostMalloc_r8_7_source function hipHostMalloc_c4_0_source(ptr, dsource, source, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, intent(inout) :: ptr complex(c_float_complex), target, intent(in), optional :: dsource, source integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dsource/source" if (present(dsource)) then res = hipHostMalloc_(cptr, 8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), 8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipHostMalloc_(cptr, 8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), 8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, ptr) else res = hipHostMalloc_(cptr, 8_c_size_t, flags) call c_f_pointer(cptr, ptr) end if end function hipHostMalloc_c4_0_source function hipHostMalloc_c4_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) complex(c_float_complex), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipHostMalloc_c4_1_source function hipHostMalloc_c4_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) complex(c_float_complex), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipHostMalloc_c4_2_source function hipHostMalloc_c4_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) complex(c_float_complex), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipHostMalloc_c4_3_source function hipHostMalloc_c4_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) complex(c_float_complex), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipHostMalloc_c4_4_source function hipHostMalloc_c4_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) complex(c_float_complex), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipHostMalloc_c4_5_source function hipHostMalloc_c4_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipHostMalloc_c4_6_source function hipHostMalloc_c4_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_float_complex), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*8_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*8_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*8_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*8_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipHostMalloc_c4_7_source function hipHostMalloc_c8_0_source(ptr, dsource, source, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, intent(inout) :: ptr complex(c_double_complex), target, intent(in), optional :: dsource, source integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dsource/source" if (present(dsource)) then res = hipHostMalloc_(cptr, 16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), 16_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipHostMalloc_(cptr, 16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), 16_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, ptr) else res = hipHostMalloc_(cptr, 16_c_size_t, flags) call c_f_pointer(cptr, ptr) end if end function hipHostMalloc_c8_0_source function hipHostMalloc_c8_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) complex(c_double_complex), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipHostMalloc_c8_1_source function hipHostMalloc_c8_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) complex(c_double_complex), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipHostMalloc_c8_2_source function hipHostMalloc_c8_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) complex(c_double_complex), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipHostMalloc_c8_3_source function hipHostMalloc_c8_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) complex(c_double_complex), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipHostMalloc_c8_4_source function hipHostMalloc_c8_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) complex(c_double_complex), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipHostMalloc_c8_5_source function hipHostMalloc_c8_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipHostMalloc_c8_6_source function hipHostMalloc_c8_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr complex(c_double_complex), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*16_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*16_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*16_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*16_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipHostMalloc_c8_7_source function hipHostMalloc_l_0_source(ptr, dsource, source, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, intent(inout) :: ptr logical(c_bool), target, intent(in), optional :: dsource, source integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr nOptArgs = 0 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dsource/source" if (present(dsource)) then res = hipHostMalloc_(cptr, 1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), 1_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, ptr) else if (present(source)) then res = hipHostMalloc_(cptr, 1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), 1_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, ptr) else res = hipHostMalloc_(cptr, 1_c_size_t, flags) call c_f_pointer(cptr, ptr) end if end function hipHostMalloc_l_0_source function hipHostMalloc_l_1_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(1), lbounds(1) integer(c_int64_t), intent(in), optional :: dims8(1), lbounds8(1) logical(c_bool), target, dimension(:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):) => tmp else ptr => tmp end if end if end function hipHostMalloc_l_1_source function hipHostMalloc_l_2_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(2), lbounds(2) integer(c_int64_t), intent(in), optional :: dims8(2), lbounds8(2) logical(c_bool), target, dimension(:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):) => tmp else ptr => tmp end if end if end function hipHostMalloc_l_2_source function hipHostMalloc_l_3_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(3), lbounds(3) integer(c_int64_t), intent(in), optional :: dims8(3), lbounds8(3) logical(c_bool), target, dimension(:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):) => tmp else ptr => tmp end if end if end function hipHostMalloc_l_3_source function hipHostMalloc_l_4_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(4), lbounds(4) integer(c_int64_t), intent(in), optional :: dims8(4), lbounds8(4) logical(c_bool), target, dimension(:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):) => tmp else ptr => tmp end if end if end function hipHostMalloc_l_4_source function hipHostMalloc_l_5_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(5), lbounds(5) integer(c_int64_t), intent(in), optional :: dims8(5), lbounds8(5) logical(c_bool), target, dimension(:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,LBOUND(dsource,2):,LBOUND(dsource,3):,LBOUND(dsource,4):,LBOUND(dsource,5):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):) => tmp else ptr => tmp end if end if end function hipHostMalloc_l_5_source function hipHostMalloc_l_6_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(6), lbounds(6) integer(c_int64_t), intent(in), optional :: dims8(6), lbounds8(6) logical(c_bool), target, dimension(:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,LBOUND(source,2):,LBOUND(source,3):,LBOUND(source,4):,LBOUND(source,5):,LBOUND(source,6):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,LBOUND(mold,2):,LBOUND(mold,3):,LBOUND(mold,4):,LBOUND(mold,5):,LBOUND(mold,6):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):) => tmp else ptr => tmp end if end if end function hipHostMalloc_l_6_source function hipHostMalloc_l_7_source(ptr, dims, dims8, lbounds, lbounds8, dsource, source, mold, flags) result(res) use iso_c_binding use hipfort_enums, only: hipMemcpyHostToHost, hipMemcpyDeviceToHost use hipfort_hipmemcpy, only: hipMemcpy implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr integer(c_int), intent(in), optional :: dims(7), lbounds(7) integer(c_int64_t), intent(in), optional :: dims8(7), lbounds8(7) logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(in), optional :: dsource, source, mold integer(c_int), intent(in) :: flags integer(c_int) :: res integer :: nOptArgs type(c_ptr) :: cptr logical(c_bool), pointer, dimension(:,:,:,:,:,:,:) :: tmp nOptArgs = 0 if (present(dims)) nOptArgs = nOptArgs + 1 if (present(dims8)) nOptArgs = nOptArgs + 1 if (present(dsource)) nOptArgs = nOptArgs + 1 if (present(source)) nOptArgs = nOptArgs + 1 if (present(mold)) nOptArgs = nOptArgs + 1 if (nOptArgs == 0) ERROR STOP "hipHostMalloc: specify one of dims/dims8/dsource/source/mold" if (nOptArgs > 1) ERROR STOP "hipHostMalloc: specify only one of dims/dims8/dsource/source/mold" if (present(lbounds8) .and. .not. present(dims8)) ERROR STOP "hipHostMalloc: lbounds8 requires dims8" if (present(lbounds) .and. .not. present(dims)) ERROR STOP "hipHostMalloc: lbounds requires dims" if (present(dsource)) then res = hipHostMalloc_(cptr, int(size(dsource), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(dsource), int(size(dsource), c_size_t)*1_c_size_t, hipMemcpyDeviceToHost) call c_f_pointer(cptr, tmp, shape=shape(dsource)) ptr(LBOUND(dsource,1):,& LBOUND(dsource,2):,& LBOUND(dsource,3):,& LBOUND(dsource,4):,& LBOUND(dsource,5):,& LBOUND(dsource,6):,& LBOUND(dsource,7):) => tmp else if (present(source)) then res = hipHostMalloc_(cptr, int(size(source), c_size_t)*1_c_size_t, flags) res = hipMemcpy(cptr, c_loc(source), int(size(source), c_size_t)*1_c_size_t, hipMemcpyHostToHost) call c_f_pointer(cptr, tmp, shape=shape(source)) ptr(LBOUND(source,1):,& LBOUND(source,2):,& LBOUND(source,3):,& LBOUND(source,4):,& LBOUND(source,5):,& LBOUND(source,6):,& LBOUND(source,7):) => tmp else if (present(mold)) then res = hipHostMalloc_(cptr, int(size(mold), c_size_t)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=shape(mold)) ptr(LBOUND(mold,1):,& LBOUND(mold,2):,& LBOUND(mold,3):,& LBOUND(mold,4):,& LBOUND(mold,5):,& LBOUND(mold,6):,& LBOUND(mold,7):) => tmp else if (present(dims8)) then res = hipHostMalloc_(cptr, product(dims8)*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims8) if (present(lbounds8)) then ptr(lbounds8(1):,lbounds8(2):,lbounds8(3):,lbounds8(4):,lbounds8(5):,lbounds8(6):,lbounds8(7):) => tmp else ptr => tmp end if else if (present(dims)) then res = hipHostMalloc_(cptr, product(int(dims, c_size_t))*1_c_size_t, flags) call c_f_pointer(cptr, tmp, shape=dims) if (present(lbounds)) then ptr(lbounds(1):,lbounds(2):,lbounds(3):,lbounds(4):,lbounds(5):,lbounds(6):,lbounds(7):) => tmp else ptr => tmp end if end if end function hipHostMalloc_l_7_source function hipFree_i4_0(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int), pointer, intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr)) ptr => null() end if end function hipFree_i4_0 function hipFree_i4_1(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1))) ptr => null() end if end function hipFree_i4_1 function hipFree_i4_2(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1))) ptr => null() end if end function hipFree_i4_2 function hipFree_i4_3(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1))) ptr => null() end if end function hipFree_i4_3 function hipFree_i4_4(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1))) ptr => null() end if end function hipFree_i4_4 function hipFree_i4_5(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1))) ptr => null() end if end function hipFree_i4_5 function hipFree_i4_6(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1,1))) ptr => null() end if end function hipFree_i4_6 function hipFree_i4_7(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1,1,1))) ptr => null() end if end function hipFree_i4_7 function hipFree_i8_0(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr)) ptr => null() end if end function hipFree_i8_0 function hipFree_i8_1(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1))) ptr => null() end if end function hipFree_i8_1 function hipFree_i8_2(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1))) ptr => null() end if end function hipFree_i8_2 function hipFree_i8_3(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1))) ptr => null() end if end function hipFree_i8_3 function hipFree_i8_4(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1))) ptr => null() end if end function hipFree_i8_4 function hipFree_i8_5(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1))) ptr => null() end if end function hipFree_i8_5 function hipFree_i8_6(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1,1))) ptr => null() end if end function hipFree_i8_6 function hipFree_i8_7(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1,1,1))) ptr => null() end if end function hipFree_i8_7 function hipFree_r4_0(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_float), pointer, intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr)) ptr => null() end if end function hipFree_r4_0 function hipFree_r4_1(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1))) ptr => null() end if end function hipFree_r4_1 function hipFree_r4_2(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1))) ptr => null() end if end function hipFree_r4_2 function hipFree_r4_3(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1))) ptr => null() end if end function hipFree_r4_3 function hipFree_r4_4(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1))) ptr => null() end if end function hipFree_r4_4 function hipFree_r4_5(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1))) ptr => null() end if end function hipFree_r4_5 function hipFree_r4_6(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1,1))) ptr => null() end if end function hipFree_r4_6 function hipFree_r4_7(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1,1,1))) ptr => null() end if end function hipFree_r4_7 function hipFree_r8_0(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_double), pointer, intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr)) ptr => null() end if end function hipFree_r8_0 function hipFree_r8_1(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1))) ptr => null() end if end function hipFree_r8_1 function hipFree_r8_2(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1))) ptr => null() end if end function hipFree_r8_2 function hipFree_r8_3(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1))) ptr => null() end if end function hipFree_r8_3 function hipFree_r8_4(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1))) ptr => null() end if end function hipFree_r8_4 function hipFree_r8_5(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1))) ptr => null() end if end function hipFree_r8_5 function hipFree_r8_6(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1,1))) ptr => null() end if end function hipFree_r8_6 function hipFree_r8_7(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1,1,1))) ptr => null() end if end function hipFree_r8_7 function hipFree_c4_0(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr)) ptr => null() end if end function hipFree_c4_0 function hipFree_c4_1(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1))) ptr => null() end if end function hipFree_c4_1 function hipFree_c4_2(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1))) ptr => null() end if end function hipFree_c4_2 function hipFree_c4_3(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1))) ptr => null() end if end function hipFree_c4_3 function hipFree_c4_4(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1))) ptr => null() end if end function hipFree_c4_4 function hipFree_c4_5(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1))) ptr => null() end if end function hipFree_c4_5 function hipFree_c4_6(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1,1))) ptr => null() end if end function hipFree_c4_6 function hipFree_c4_7(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1,1,1))) ptr => null() end if end function hipFree_c4_7 function hipFree_c8_0(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr)) ptr => null() end if end function hipFree_c8_0 function hipFree_c8_1(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1))) ptr => null() end if end function hipFree_c8_1 function hipFree_c8_2(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1))) ptr => null() end if end function hipFree_c8_2 function hipFree_c8_3(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1))) ptr => null() end if end function hipFree_c8_3 function hipFree_c8_4(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1))) ptr => null() end if end function hipFree_c8_4 function hipFree_c8_5(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1))) ptr => null() end if end function hipFree_c8_5 function hipFree_c8_6(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1,1))) ptr => null() end if end function hipFree_c8_6 function hipFree_c8_7(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1,1,1))) ptr => null() end if end function hipFree_c8_7 function hipFree_l_0(ptr, only_if_allocated) result(res) use iso_c_binding implicit none logical(c_bool), pointer, intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr)) ptr => null() end if end function hipFree_l_0 function hipFree_l_1(ptr, only_if_allocated) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1))) ptr => null() end if end function hipFree_l_1 function hipFree_l_2(ptr, only_if_allocated) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1))) ptr => null() end if end function hipFree_l_2 function hipFree_l_3(ptr, only_if_allocated) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1))) ptr => null() end if end function hipFree_l_3 function hipFree_l_4(ptr, only_if_allocated) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1))) ptr => null() end if end function hipFree_l_4 function hipFree_l_5(ptr, only_if_allocated) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1))) ptr => null() end if end function hipFree_l_5 function hipFree_l_6(ptr, only_if_allocated) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1,1))) ptr => null() end if end function hipFree_l_6 function hipFree_l_7(ptr, only_if_allocated) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipFree_(c_loc(ptr(1,1,1,1,1,1,1))) ptr => null() end if end function hipFree_l_7 function hipHostFree_i4_0(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int), pointer, intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr)) ptr => null() end if end function hipHostFree_i4_0 function hipHostFree_i4_1(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1))) ptr => null() end if end function hipHostFree_i4_1 function hipHostFree_i4_2(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1))) ptr => null() end if end function hipHostFree_i4_2 function hipHostFree_i4_3(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1))) ptr => null() end if end function hipHostFree_i4_3 function hipHostFree_i4_4(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1))) ptr => null() end if end function hipHostFree_i4_4 function hipHostFree_i4_5(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1))) ptr => null() end if end function hipHostFree_i4_5 function hipHostFree_i4_6(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1,1))) ptr => null() end if end function hipHostFree_i4_6 function hipHostFree_i4_7(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1,1,1))) ptr => null() end if end function hipHostFree_i4_7 function hipHostFree_i8_0(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr)) ptr => null() end if end function hipHostFree_i8_0 function hipHostFree_i8_1(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1))) ptr => null() end if end function hipHostFree_i8_1 function hipHostFree_i8_2(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1))) ptr => null() end if end function hipHostFree_i8_2 function hipHostFree_i8_3(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1))) ptr => null() end if end function hipHostFree_i8_3 function hipHostFree_i8_4(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1))) ptr => null() end if end function hipHostFree_i8_4 function hipHostFree_i8_5(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1))) ptr => null() end if end function hipHostFree_i8_5 function hipHostFree_i8_6(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1,1))) ptr => null() end if end function hipHostFree_i8_6 function hipHostFree_i8_7(ptr, only_if_allocated) result(res) use iso_c_binding implicit none integer(c_int64_t), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1,1,1))) ptr => null() end if end function hipHostFree_i8_7 function hipHostFree_r4_0(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_float), pointer, intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr)) ptr => null() end if end function hipHostFree_r4_0 function hipHostFree_r4_1(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1))) ptr => null() end if end function hipHostFree_r4_1 function hipHostFree_r4_2(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1))) ptr => null() end if end function hipHostFree_r4_2 function hipHostFree_r4_3(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1))) ptr => null() end if end function hipHostFree_r4_3 function hipHostFree_r4_4(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1))) ptr => null() end if end function hipHostFree_r4_4 function hipHostFree_r4_5(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1))) ptr => null() end if end function hipHostFree_r4_5 function hipHostFree_r4_6(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1,1))) ptr => null() end if end function hipHostFree_r4_6 function hipHostFree_r4_7(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_float), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1,1,1))) ptr => null() end if end function hipHostFree_r4_7 function hipHostFree_r8_0(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_double), pointer, intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr)) ptr => null() end if end function hipHostFree_r8_0 function hipHostFree_r8_1(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1))) ptr => null() end if end function hipHostFree_r8_1 function hipHostFree_r8_2(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1))) ptr => null() end if end function hipHostFree_r8_2 function hipHostFree_r8_3(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1))) ptr => null() end if end function hipHostFree_r8_3 function hipHostFree_r8_4(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1))) ptr => null() end if end function hipHostFree_r8_4 function hipHostFree_r8_5(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1))) ptr => null() end if end function hipHostFree_r8_5 function hipHostFree_r8_6(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1,1))) ptr => null() end if end function hipHostFree_r8_6 function hipHostFree_r8_7(ptr, only_if_allocated) result(res) use iso_c_binding implicit none real(c_double), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1,1,1))) ptr => null() end if end function hipHostFree_r8_7 function hipHostFree_c4_0(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr)) ptr => null() end if end function hipHostFree_c4_0 function hipHostFree_c4_1(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1))) ptr => null() end if end function hipHostFree_c4_1 function hipHostFree_c4_2(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1))) ptr => null() end if end function hipHostFree_c4_2 function hipHostFree_c4_3(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1))) ptr => null() end if end function hipHostFree_c4_3 function hipHostFree_c4_4(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1))) ptr => null() end if end function hipHostFree_c4_4 function hipHostFree_c4_5(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1))) ptr => null() end if end function hipHostFree_c4_5 function hipHostFree_c4_6(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1,1))) ptr => null() end if end function hipHostFree_c4_6 function hipHostFree_c4_7(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_float_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1,1,1))) ptr => null() end if end function hipHostFree_c4_7 function hipHostFree_c8_0(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr)) ptr => null() end if end function hipHostFree_c8_0 function hipHostFree_c8_1(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1))) ptr => null() end if end function hipHostFree_c8_1 function hipHostFree_c8_2(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1))) ptr => null() end if end function hipHostFree_c8_2 function hipHostFree_c8_3(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1))) ptr => null() end if end function hipHostFree_c8_3 function hipHostFree_c8_4(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1))) ptr => null() end if end function hipHostFree_c8_4 function hipHostFree_c8_5(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1))) ptr => null() end if end function hipHostFree_c8_5 function hipHostFree_c8_6(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1,1))) ptr => null() end if end function hipHostFree_c8_6 function hipHostFree_c8_7(ptr, only_if_allocated) result(res) use iso_c_binding implicit none complex(c_double_complex), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1,1,1))) ptr => null() end if end function hipHostFree_c8_7 function hipHostFree_l_0(ptr, only_if_allocated) result(res) use iso_c_binding implicit none logical(c_bool), pointer, intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr)) ptr => null() end if end function hipHostFree_l_0 function hipHostFree_l_1(ptr, only_if_allocated) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1))) ptr => null() end if end function hipHostFree_l_1 function hipHostFree_l_2(ptr, only_if_allocated) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1))) ptr => null() end if end function hipHostFree_l_2 function hipHostFree_l_3(ptr, only_if_allocated) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1))) ptr => null() end if end function hipHostFree_l_3 function hipHostFree_l_4(ptr, only_if_allocated) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1))) ptr => null() end if end function hipHostFree_l_4 function hipHostFree_l_5(ptr, only_if_allocated) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1))) ptr => null() end if end function hipHostFree_l_5 function hipHostFree_l_6(ptr, only_if_allocated) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1,1))) ptr => null() end if end function hipHostFree_l_6 function hipHostFree_l_7(ptr, only_if_allocated) result(res) use iso_c_binding implicit none logical(c_bool), pointer, dimension(:,:,:,:,:,:,:), intent(inout) :: ptr logical, intent(in), optional :: only_if_allocated integer(c_int) :: res logical :: guard guard = .false. if (present(only_if_allocated)) guard = only_if_allocated res = 0 if (.not. guard .or. associated(ptr)) then res = hipHostFree_(c_loc(ptr(1,1,1,1,1,1,1))) ptr => null() end if end function hipHostFree_l_7 end module hipfort_hipmalloc hipfort-rocm-10.0.0/lib/hipfort/hipfort_hipmemcpy.F90000066400000000000000000015141601524740623400224470ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_hipmemcpy use, intrinsic :: iso_c_binding implicit none interface hipMemcpy !> @brief Copy data from src to dst. !> !> It supports memory from host to device, !> device to host, device to device and host to host !> The src and dst must not overlap. !> !> For hipMemcpy, the copy is always performed by the current device (set by hipSetDevice). !> For multi-gpu or peer-to-peer configurations, it is recommended to set the current device to !> the !> device where the src data is physically located. For optimal peer-to-peer copies, the copy !> device must be able to access the src and dst pointers (by calling hipDeviceEnablePeerAccess !> with !> copy agent as the current device and src/dst as the peerDevice argument. if this is not done, !> the hipMemcpy will still work, but will perform the copy using a staging buffer on the host. !> Calling hipMemcpy with dst and src pointers that do not match the hipMemcpyKind results in !> undefined behavior. !> !> @param[out] dest Data being copy to !> @param[in] src Data being copy from !> @param[in] sizeBytes Data size in bytes !> @param[in] myKind Kind of transfer !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorUnknown` !> !> @see hipArrayCreate, hipArrayDestroy, hipArrayGetDescriptor, hipMemAlloc, hipMemAllocHost, !> hipMemAllocPitch, hipMemcpy2D, hipMemcpy2DAsync, hipMemcpy2DUnaligned, hipMemcpyAtoA, !> hipMemcpyAtoD, hipMemcpyAtoH, hipMemcpyAtoHAsync, hipMemcpyDtoA, hipMemcpyDtoD, !> hipMemcpyDtoDAsync, hipMemcpyDtoH, hipMemcpyDtoHAsync, hipMemcpyHtoA, hipMemcpyHtoAAsync, !> hipMemcpyHtoDAsync, hipMemFree, hipMemFreeHost, hipMemGetAddressRange, hipMemGetInfo, !> hipMemHostAlloc, hipMemHostGetDevicePointer #ifdef USE_CUDA_NAMES function hipMemcpy_(dest, src, sizeBytes, myKind) bind(c, name="cudaMemcpy") #else function hipMemcpy_(dest, src, sizeBytes, myKind) bind(c, name="hipMemcpy") #endif use iso_c_binding implicit none integer(c_int) :: hipMemcpy_ type(c_ptr), value :: dest type(c_ptr), value :: src integer(c_size_t), value :: sizeBytes integer(c_int), value :: myKind end function hipMemcpy_ #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipMemcpy_i4_assumed_rank module procedure hipMemcpy_i4_assumed_rank_c_size_t module procedure hipMemcpy_i4_assumed_rank_c_int module procedure hipMemcpy_i8_assumed_rank module procedure hipMemcpy_i8_assumed_rank_c_size_t module procedure hipMemcpy_i8_assumed_rank_c_int module procedure hipMemcpy_r4_assumed_rank module procedure hipMemcpy_r4_assumed_rank_c_size_t module procedure hipMemcpy_r4_assumed_rank_c_int module procedure hipMemcpy_r8_assumed_rank module procedure hipMemcpy_r8_assumed_rank_c_size_t module procedure hipMemcpy_r8_assumed_rank_c_int module procedure hipMemcpy_c4_assumed_rank module procedure hipMemcpy_c4_assumed_rank_c_size_t module procedure hipMemcpy_c4_assumed_rank_c_int module procedure hipMemcpy_c8_assumed_rank module procedure hipMemcpy_c8_assumed_rank_c_size_t module procedure hipMemcpy_c8_assumed_rank_c_int module procedure hipMemcpy_l_assumed_rank module procedure hipMemcpy_l_assumed_rank_c_size_t module procedure hipMemcpy_l_assumed_rank_c_int #else module procedure hipMemcpy_i4_0 module procedure hipMemcpy_i4_0_c_size_t module procedure hipMemcpy_i4_0_c_int module procedure hipMemcpy_i4_1 module procedure hipMemcpy_i4_1_c_size_t module procedure hipMemcpy_i4_1_c_int module procedure hipMemcpy_i4_2 module procedure hipMemcpy_i4_2_c_size_t module procedure hipMemcpy_i4_2_c_int module procedure hipMemcpy_i4_3 module procedure hipMemcpy_i4_3_c_size_t module procedure hipMemcpy_i4_3_c_int module procedure hipMemcpy_i4_4 module procedure hipMemcpy_i4_4_c_size_t module procedure hipMemcpy_i4_4_c_int module procedure hipMemcpy_i4_5 module procedure hipMemcpy_i4_5_c_size_t module procedure hipMemcpy_i4_5_c_int module procedure hipMemcpy_i4_6 module procedure hipMemcpy_i4_6_c_size_t module procedure hipMemcpy_i4_6_c_int module procedure hipMemcpy_i4_7 module procedure hipMemcpy_i4_7_c_size_t module procedure hipMemcpy_i4_7_c_int module procedure hipMemcpy_i8_0 module procedure hipMemcpy_i8_0_c_size_t module procedure hipMemcpy_i8_0_c_int module procedure hipMemcpy_i8_1 module procedure hipMemcpy_i8_1_c_size_t module procedure hipMemcpy_i8_1_c_int module procedure hipMemcpy_i8_2 module procedure hipMemcpy_i8_2_c_size_t module procedure hipMemcpy_i8_2_c_int module procedure hipMemcpy_i8_3 module procedure hipMemcpy_i8_3_c_size_t module procedure hipMemcpy_i8_3_c_int module procedure hipMemcpy_i8_4 module procedure hipMemcpy_i8_4_c_size_t module procedure hipMemcpy_i8_4_c_int module procedure hipMemcpy_i8_5 module procedure hipMemcpy_i8_5_c_size_t module procedure hipMemcpy_i8_5_c_int module procedure hipMemcpy_i8_6 module procedure hipMemcpy_i8_6_c_size_t module procedure hipMemcpy_i8_6_c_int module procedure hipMemcpy_i8_7 module procedure hipMemcpy_i8_7_c_size_t module procedure hipMemcpy_i8_7_c_int module procedure hipMemcpy_r4_0 module procedure hipMemcpy_r4_0_c_size_t module procedure hipMemcpy_r4_0_c_int module procedure hipMemcpy_r4_1 module procedure hipMemcpy_r4_1_c_size_t module procedure hipMemcpy_r4_1_c_int module procedure hipMemcpy_r4_2 module procedure hipMemcpy_r4_2_c_size_t module procedure hipMemcpy_r4_2_c_int module procedure hipMemcpy_r4_3 module procedure hipMemcpy_r4_3_c_size_t module procedure hipMemcpy_r4_3_c_int module procedure hipMemcpy_r4_4 module procedure hipMemcpy_r4_4_c_size_t module procedure hipMemcpy_r4_4_c_int module procedure hipMemcpy_r4_5 module procedure hipMemcpy_r4_5_c_size_t module procedure hipMemcpy_r4_5_c_int module procedure hipMemcpy_r4_6 module procedure hipMemcpy_r4_6_c_size_t module procedure hipMemcpy_r4_6_c_int module procedure hipMemcpy_r4_7 module procedure hipMemcpy_r4_7_c_size_t module procedure hipMemcpy_r4_7_c_int module procedure hipMemcpy_r8_0 module procedure hipMemcpy_r8_0_c_size_t module procedure hipMemcpy_r8_0_c_int module procedure hipMemcpy_r8_1 module procedure hipMemcpy_r8_1_c_size_t module procedure hipMemcpy_r8_1_c_int module procedure hipMemcpy_r8_2 module procedure hipMemcpy_r8_2_c_size_t module procedure hipMemcpy_r8_2_c_int module procedure hipMemcpy_r8_3 module procedure hipMemcpy_r8_3_c_size_t module procedure hipMemcpy_r8_3_c_int module procedure hipMemcpy_r8_4 module procedure hipMemcpy_r8_4_c_size_t module procedure hipMemcpy_r8_4_c_int module procedure hipMemcpy_r8_5 module procedure hipMemcpy_r8_5_c_size_t module procedure hipMemcpy_r8_5_c_int module procedure hipMemcpy_r8_6 module procedure hipMemcpy_r8_6_c_size_t module procedure hipMemcpy_r8_6_c_int module procedure hipMemcpy_r8_7 module procedure hipMemcpy_r8_7_c_size_t module procedure hipMemcpy_r8_7_c_int module procedure hipMemcpy_c4_0 module procedure hipMemcpy_c4_0_c_size_t module procedure hipMemcpy_c4_0_c_int module procedure hipMemcpy_c4_1 module procedure hipMemcpy_c4_1_c_size_t module procedure hipMemcpy_c4_1_c_int module procedure hipMemcpy_c4_2 module procedure hipMemcpy_c4_2_c_size_t module procedure hipMemcpy_c4_2_c_int module procedure hipMemcpy_c4_3 module procedure hipMemcpy_c4_3_c_size_t module procedure hipMemcpy_c4_3_c_int module procedure hipMemcpy_c4_4 module procedure hipMemcpy_c4_4_c_size_t module procedure hipMemcpy_c4_4_c_int module procedure hipMemcpy_c4_5 module procedure hipMemcpy_c4_5_c_size_t module procedure hipMemcpy_c4_5_c_int module procedure hipMemcpy_c4_6 module procedure hipMemcpy_c4_6_c_size_t module procedure hipMemcpy_c4_6_c_int module procedure hipMemcpy_c4_7 module procedure hipMemcpy_c4_7_c_size_t module procedure hipMemcpy_c4_7_c_int module procedure hipMemcpy_c8_0 module procedure hipMemcpy_c8_0_c_size_t module procedure hipMemcpy_c8_0_c_int module procedure hipMemcpy_c8_1 module procedure hipMemcpy_c8_1_c_size_t module procedure hipMemcpy_c8_1_c_int module procedure hipMemcpy_c8_2 module procedure hipMemcpy_c8_2_c_size_t module procedure hipMemcpy_c8_2_c_int module procedure hipMemcpy_c8_3 module procedure hipMemcpy_c8_3_c_size_t module procedure hipMemcpy_c8_3_c_int module procedure hipMemcpy_c8_4 module procedure hipMemcpy_c8_4_c_size_t module procedure hipMemcpy_c8_4_c_int module procedure hipMemcpy_c8_5 module procedure hipMemcpy_c8_5_c_size_t module procedure hipMemcpy_c8_5_c_int module procedure hipMemcpy_c8_6 module procedure hipMemcpy_c8_6_c_size_t module procedure hipMemcpy_c8_6_c_int module procedure hipMemcpy_c8_7 module procedure hipMemcpy_c8_7_c_size_t module procedure hipMemcpy_c8_7_c_int module procedure hipMemcpy_l_0 module procedure hipMemcpy_l_0_c_size_t module procedure hipMemcpy_l_0_c_int module procedure hipMemcpy_l_1 module procedure hipMemcpy_l_1_c_size_t module procedure hipMemcpy_l_1_c_int module procedure hipMemcpy_l_2 module procedure hipMemcpy_l_2_c_size_t module procedure hipMemcpy_l_2_c_int module procedure hipMemcpy_l_3 module procedure hipMemcpy_l_3_c_size_t module procedure hipMemcpy_l_3_c_int module procedure hipMemcpy_l_4 module procedure hipMemcpy_l_4_c_size_t module procedure hipMemcpy_l_4_c_int module procedure hipMemcpy_l_5 module procedure hipMemcpy_l_5_c_size_t module procedure hipMemcpy_l_5_c_int module procedure hipMemcpy_l_6 module procedure hipMemcpy_l_6_c_size_t module procedure hipMemcpy_l_6_c_int module procedure hipMemcpy_l_7 module procedure hipMemcpy_l_7_c_size_t module procedure hipMemcpy_l_7_c_int #endif end interface hipMemcpy interface hipMemcpyAsync !> @brief Copies data from src to dst asynchronously. !> !> The copy is always performed by the device associated with the specified stream. !> !> For multi-gpu or peer-to-peer configurations, it is recommended to use a stream which is !> attached to the device where the src data is physically located. !> For optimal peer-to-peer copies, the copy device must be able to access the src and dst !> pointers (by calling hipDeviceEnablePeerAccess) with copy agent as the current device and !> src/dest as the peerDevice argument. If enabling device peer access is not done, the memory !> copy !> will still work, but will perform the copy using a staging buffer on the host. !> !> @note If host or dst are not pinned, the memory copy will be performed synchronously. For !> best performance, use hipHostMalloc to allocate host memory that is transferred !> asynchronously. !> !> @param[out] dest Data being copy to !> @param[in] src Data being copy from !> @param[in] sizeBytes Data size in bytes !> @param[in] myKind Type of memory transfer !> @param[in] stream Stream identifier !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorUnknown` !> !> @see hipMemcpy, hipMemcpy2D, hipMemcpyToArray, hipMemcpy2DToArray, hipMemcpyFromArray, !> hipMemcpy2DFromArray, hipMemcpyArrayToArray, hipMemcpy2DArrayToArray, hipMemcpyToSymbol, !> hipMemcpyFromSymbol, hipMemcpy2DAsync, hipMemcpyToArrayAsync, hipMemcpy2DToArrayAsync, !> hipMemcpyFromArrayAsync, hipMemcpy2DFromArrayAsync, hipMemcpyToSymbolAsync, !> hipMemcpyFromSymbolAsync #ifdef USE_CUDA_NAMES function hipMemcpyAsync_(dest, src, sizeBytes, myKind, stream) bind(c, name="cudaMemcpyAsync") #else function hipMemcpyAsync_(dest, src, sizeBytes, myKind, stream) bind(c, name="hipMemcpyAsync") #endif use iso_c_binding implicit none integer(c_int) :: hipMemcpyAsync_ type(c_ptr), value :: dest type(c_ptr), value :: src integer(c_size_t), value :: sizeBytes integer(c_int), value :: myKind type(c_ptr), value :: stream end function hipMemcpyAsync_ #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipMemcpyAsync_i4_assumed_rank module procedure hipMemcpyAsync_i4_assumed_rank_c_size_t module procedure hipMemcpyAsync_i4_assumed_rank_c_int module procedure hipMemcpyAsync_i8_assumed_rank module procedure hipMemcpyAsync_i8_assumed_rank_c_size_t module procedure hipMemcpyAsync_i8_assumed_rank_c_int module procedure hipMemcpyAsync_r4_assumed_rank module procedure hipMemcpyAsync_r4_assumed_rank_c_size_t module procedure hipMemcpyAsync_r4_assumed_rank_c_int module procedure hipMemcpyAsync_r8_assumed_rank module procedure hipMemcpyAsync_r8_assumed_rank_c_size_t module procedure hipMemcpyAsync_r8_assumed_rank_c_int module procedure hipMemcpyAsync_c4_assumed_rank module procedure hipMemcpyAsync_c4_assumed_rank_c_size_t module procedure hipMemcpyAsync_c4_assumed_rank_c_int module procedure hipMemcpyAsync_c8_assumed_rank module procedure hipMemcpyAsync_c8_assumed_rank_c_size_t module procedure hipMemcpyAsync_c8_assumed_rank_c_int module procedure hipMemcpyAsync_l_assumed_rank module procedure hipMemcpyAsync_l_assumed_rank_c_size_t module procedure hipMemcpyAsync_l_assumed_rank_c_int #else module procedure hipMemcpyAsync_i4_0 module procedure hipMemcpyAsync_i4_0_c_size_t module procedure hipMemcpyAsync_i4_0_c_int module procedure hipMemcpyAsync_i4_1 module procedure hipMemcpyAsync_i4_1_c_size_t module procedure hipMemcpyAsync_i4_1_c_int module procedure hipMemcpyAsync_i4_2 module procedure hipMemcpyAsync_i4_2_c_size_t module procedure hipMemcpyAsync_i4_2_c_int module procedure hipMemcpyAsync_i4_3 module procedure hipMemcpyAsync_i4_3_c_size_t module procedure hipMemcpyAsync_i4_3_c_int module procedure hipMemcpyAsync_i4_4 module procedure hipMemcpyAsync_i4_4_c_size_t module procedure hipMemcpyAsync_i4_4_c_int module procedure hipMemcpyAsync_i4_5 module procedure hipMemcpyAsync_i4_5_c_size_t module procedure hipMemcpyAsync_i4_5_c_int module procedure hipMemcpyAsync_i4_6 module procedure hipMemcpyAsync_i4_6_c_size_t module procedure hipMemcpyAsync_i4_6_c_int module procedure hipMemcpyAsync_i4_7 module procedure hipMemcpyAsync_i4_7_c_size_t module procedure hipMemcpyAsync_i4_7_c_int module procedure hipMemcpyAsync_i8_0 module procedure hipMemcpyAsync_i8_0_c_size_t module procedure hipMemcpyAsync_i8_0_c_int module procedure hipMemcpyAsync_i8_1 module procedure hipMemcpyAsync_i8_1_c_size_t module procedure hipMemcpyAsync_i8_1_c_int module procedure hipMemcpyAsync_i8_2 module procedure hipMemcpyAsync_i8_2_c_size_t module procedure hipMemcpyAsync_i8_2_c_int module procedure hipMemcpyAsync_i8_3 module procedure hipMemcpyAsync_i8_3_c_size_t module procedure hipMemcpyAsync_i8_3_c_int module procedure hipMemcpyAsync_i8_4 module procedure hipMemcpyAsync_i8_4_c_size_t module procedure hipMemcpyAsync_i8_4_c_int module procedure hipMemcpyAsync_i8_5 module procedure hipMemcpyAsync_i8_5_c_size_t module procedure hipMemcpyAsync_i8_5_c_int module procedure hipMemcpyAsync_i8_6 module procedure hipMemcpyAsync_i8_6_c_size_t module procedure hipMemcpyAsync_i8_6_c_int module procedure hipMemcpyAsync_i8_7 module procedure hipMemcpyAsync_i8_7_c_size_t module procedure hipMemcpyAsync_i8_7_c_int module procedure hipMemcpyAsync_r4_0 module procedure hipMemcpyAsync_r4_0_c_size_t module procedure hipMemcpyAsync_r4_0_c_int module procedure hipMemcpyAsync_r4_1 module procedure hipMemcpyAsync_r4_1_c_size_t module procedure hipMemcpyAsync_r4_1_c_int module procedure hipMemcpyAsync_r4_2 module procedure hipMemcpyAsync_r4_2_c_size_t module procedure hipMemcpyAsync_r4_2_c_int module procedure hipMemcpyAsync_r4_3 module procedure hipMemcpyAsync_r4_3_c_size_t module procedure hipMemcpyAsync_r4_3_c_int module procedure hipMemcpyAsync_r4_4 module procedure hipMemcpyAsync_r4_4_c_size_t module procedure hipMemcpyAsync_r4_4_c_int module procedure hipMemcpyAsync_r4_5 module procedure hipMemcpyAsync_r4_5_c_size_t module procedure hipMemcpyAsync_r4_5_c_int module procedure hipMemcpyAsync_r4_6 module procedure hipMemcpyAsync_r4_6_c_size_t module procedure hipMemcpyAsync_r4_6_c_int module procedure hipMemcpyAsync_r4_7 module procedure hipMemcpyAsync_r4_7_c_size_t module procedure hipMemcpyAsync_r4_7_c_int module procedure hipMemcpyAsync_r8_0 module procedure hipMemcpyAsync_r8_0_c_size_t module procedure hipMemcpyAsync_r8_0_c_int module procedure hipMemcpyAsync_r8_1 module procedure hipMemcpyAsync_r8_1_c_size_t module procedure hipMemcpyAsync_r8_1_c_int module procedure hipMemcpyAsync_r8_2 module procedure hipMemcpyAsync_r8_2_c_size_t module procedure hipMemcpyAsync_r8_2_c_int module procedure hipMemcpyAsync_r8_3 module procedure hipMemcpyAsync_r8_3_c_size_t module procedure hipMemcpyAsync_r8_3_c_int module procedure hipMemcpyAsync_r8_4 module procedure hipMemcpyAsync_r8_4_c_size_t module procedure hipMemcpyAsync_r8_4_c_int module procedure hipMemcpyAsync_r8_5 module procedure hipMemcpyAsync_r8_5_c_size_t module procedure hipMemcpyAsync_r8_5_c_int module procedure hipMemcpyAsync_r8_6 module procedure hipMemcpyAsync_r8_6_c_size_t module procedure hipMemcpyAsync_r8_6_c_int module procedure hipMemcpyAsync_r8_7 module procedure hipMemcpyAsync_r8_7_c_size_t module procedure hipMemcpyAsync_r8_7_c_int module procedure hipMemcpyAsync_c4_0 module procedure hipMemcpyAsync_c4_0_c_size_t module procedure hipMemcpyAsync_c4_0_c_int module procedure hipMemcpyAsync_c4_1 module procedure hipMemcpyAsync_c4_1_c_size_t module procedure hipMemcpyAsync_c4_1_c_int module procedure hipMemcpyAsync_c4_2 module procedure hipMemcpyAsync_c4_2_c_size_t module procedure hipMemcpyAsync_c4_2_c_int module procedure hipMemcpyAsync_c4_3 module procedure hipMemcpyAsync_c4_3_c_size_t module procedure hipMemcpyAsync_c4_3_c_int module procedure hipMemcpyAsync_c4_4 module procedure hipMemcpyAsync_c4_4_c_size_t module procedure hipMemcpyAsync_c4_4_c_int module procedure hipMemcpyAsync_c4_5 module procedure hipMemcpyAsync_c4_5_c_size_t module procedure hipMemcpyAsync_c4_5_c_int module procedure hipMemcpyAsync_c4_6 module procedure hipMemcpyAsync_c4_6_c_size_t module procedure hipMemcpyAsync_c4_6_c_int module procedure hipMemcpyAsync_c4_7 module procedure hipMemcpyAsync_c4_7_c_size_t module procedure hipMemcpyAsync_c4_7_c_int module procedure hipMemcpyAsync_c8_0 module procedure hipMemcpyAsync_c8_0_c_size_t module procedure hipMemcpyAsync_c8_0_c_int module procedure hipMemcpyAsync_c8_1 module procedure hipMemcpyAsync_c8_1_c_size_t module procedure hipMemcpyAsync_c8_1_c_int module procedure hipMemcpyAsync_c8_2 module procedure hipMemcpyAsync_c8_2_c_size_t module procedure hipMemcpyAsync_c8_2_c_int module procedure hipMemcpyAsync_c8_3 module procedure hipMemcpyAsync_c8_3_c_size_t module procedure hipMemcpyAsync_c8_3_c_int module procedure hipMemcpyAsync_c8_4 module procedure hipMemcpyAsync_c8_4_c_size_t module procedure hipMemcpyAsync_c8_4_c_int module procedure hipMemcpyAsync_c8_5 module procedure hipMemcpyAsync_c8_5_c_size_t module procedure hipMemcpyAsync_c8_5_c_int module procedure hipMemcpyAsync_c8_6 module procedure hipMemcpyAsync_c8_6_c_size_t module procedure hipMemcpyAsync_c8_6_c_int module procedure hipMemcpyAsync_c8_7 module procedure hipMemcpyAsync_c8_7_c_size_t module procedure hipMemcpyAsync_c8_7_c_int module procedure hipMemcpyAsync_l_0 module procedure hipMemcpyAsync_l_0_c_size_t module procedure hipMemcpyAsync_l_0_c_int module procedure hipMemcpyAsync_l_1 module procedure hipMemcpyAsync_l_1_c_size_t module procedure hipMemcpyAsync_l_1_c_int module procedure hipMemcpyAsync_l_2 module procedure hipMemcpyAsync_l_2_c_size_t module procedure hipMemcpyAsync_l_2_c_int module procedure hipMemcpyAsync_l_3 module procedure hipMemcpyAsync_l_3_c_size_t module procedure hipMemcpyAsync_l_3_c_int module procedure hipMemcpyAsync_l_4 module procedure hipMemcpyAsync_l_4_c_size_t module procedure hipMemcpyAsync_l_4_c_int module procedure hipMemcpyAsync_l_5 module procedure hipMemcpyAsync_l_5_c_size_t module procedure hipMemcpyAsync_l_5_c_int module procedure hipMemcpyAsync_l_6 module procedure hipMemcpyAsync_l_6_c_size_t module procedure hipMemcpyAsync_l_6_c_int module procedure hipMemcpyAsync_l_7 module procedure hipMemcpyAsync_l_7_c_size_t module procedure hipMemcpyAsync_l_7_c_int #endif end interface hipMemcpyAsync interface hipMemcpy2D !> @brief Copies data between host and device. !> !> hipMemcpy2D supports memory matrix copy from the pointed area src to the pointed area dst. !> The copy direction is defined by kind which must be one of `hipMemcpyHostToDevice`, !> `hipMemcpyHostToDevice`, `hipMemcpyDeviceToHost` `hipMemcpyDeviceToDevice` or !> `hipMemcpyDefault`. !> Device to Device copies don't need to wait for host synchronization. !> The copy is executed on the default null tream. The src and dst must not overlap. !> dpitch and spitch are the widths in bytes in memory matrix, width cannot exceed dpitch or !> spitch. !> !> For hipMemcpy2D, the copy is always performed by the current device (set by hipSetDevice). !> For multi-gpu or peer-to-peer configurations, it is recommended to set the current device to !> the !> device where the src data is physically located. For optimal peer-to-peer copies, the copy !> device !> must be able to access the src and dst pointers (by calling hipDeviceEnablePeerAccess with !> copy !> agent as the current device and src/dst as the peerDevice argument. if this is not done, the !> hipMemcpy2D will still work, but will perform the copy using a staging buffer on the host. !> !> @warning Calling hipMemcpy2D with dst and src pointers that do not match the hipMemcpyKind !> results in undefined behavior. !> !> @param[out] dest Destination memory address !> @param[in] dpitch Pitch size in bytes of destination memory !> @param[in] src Source memory address !> @param[in] spitch Pitch size in bytes of source memory !> @param[in] width Width size in bytes of matrix transfer (columns) !> @param[in] height Height size in bytes of matrix transfer (rows) !> @param[in] myKind Type of transfer !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidPitchValue`, !> `hipErrorInvalidDevicePointer`, `hipErrorInvalidMemcpyDirection` !> !> @see hipMemcpy, hipMemcpyToArray, hipMemcpy2DToArray, hipMemcpyFromArray, hipMemcpyToSymbol, !> hipMemcpyAsync #ifdef USE_CUDA_NAMES function hipMemcpy2D_(dest, dpitch, src, spitch, width, height, myKind) & bind(c, name="cudaMemcpy2D") #else function hipMemcpy2D_(dest, dpitch, src, spitch, width, height, myKind) & bind(c, name="hipMemcpy2D") #endif use iso_c_binding implicit none integer(c_int) :: hipMemcpy2D_ type(c_ptr), value :: dest integer(c_size_t), value :: dpitch type(c_ptr), value :: src integer(c_size_t), value :: spitch integer(c_size_t), value :: width integer(c_size_t), value :: height integer(c_int), value :: myKind end function hipMemcpy2D_ #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipMemcpy2D_i4_assumed_rank_c_size_t module procedure hipMemcpy2D_i4_assumed_rank_c_int module procedure hipMemcpy2D_i8_assumed_rank_c_size_t module procedure hipMemcpy2D_i8_assumed_rank_c_int module procedure hipMemcpy2D_r4_assumed_rank_c_size_t module procedure hipMemcpy2D_r4_assumed_rank_c_int module procedure hipMemcpy2D_r8_assumed_rank_c_size_t module procedure hipMemcpy2D_r8_assumed_rank_c_int module procedure hipMemcpy2D_c4_assumed_rank_c_size_t module procedure hipMemcpy2D_c4_assumed_rank_c_int module procedure hipMemcpy2D_c8_assumed_rank_c_size_t module procedure hipMemcpy2D_c8_assumed_rank_c_int module procedure hipMemcpy2D_l_assumed_rank_c_size_t module procedure hipMemcpy2D_l_assumed_rank_c_int #else module procedure hipMemcpy2D_i4_0_c_size_t module procedure hipMemcpy2D_i4_0_c_int module procedure hipMemcpy2D_i4_1_c_size_t module procedure hipMemcpy2D_i4_1_c_int module procedure hipMemcpy2D_i4_2_c_size_t module procedure hipMemcpy2D_i4_2_c_int module procedure hipMemcpy2D_i4_3_c_size_t module procedure hipMemcpy2D_i4_3_c_int module procedure hipMemcpy2D_i4_4_c_size_t module procedure hipMemcpy2D_i4_4_c_int module procedure hipMemcpy2D_i4_5_c_size_t module procedure hipMemcpy2D_i4_5_c_int module procedure hipMemcpy2D_i4_6_c_size_t module procedure hipMemcpy2D_i4_6_c_int module procedure hipMemcpy2D_i4_7_c_size_t module procedure hipMemcpy2D_i4_7_c_int module procedure hipMemcpy2D_i8_0_c_size_t module procedure hipMemcpy2D_i8_0_c_int module procedure hipMemcpy2D_i8_1_c_size_t module procedure hipMemcpy2D_i8_1_c_int module procedure hipMemcpy2D_i8_2_c_size_t module procedure hipMemcpy2D_i8_2_c_int module procedure hipMemcpy2D_i8_3_c_size_t module procedure hipMemcpy2D_i8_3_c_int module procedure hipMemcpy2D_i8_4_c_size_t module procedure hipMemcpy2D_i8_4_c_int module procedure hipMemcpy2D_i8_5_c_size_t module procedure hipMemcpy2D_i8_5_c_int module procedure hipMemcpy2D_i8_6_c_size_t module procedure hipMemcpy2D_i8_6_c_int module procedure hipMemcpy2D_i8_7_c_size_t module procedure hipMemcpy2D_i8_7_c_int module procedure hipMemcpy2D_r4_0_c_size_t module procedure hipMemcpy2D_r4_0_c_int module procedure hipMemcpy2D_r4_1_c_size_t module procedure hipMemcpy2D_r4_1_c_int module procedure hipMemcpy2D_r4_2_c_size_t module procedure hipMemcpy2D_r4_2_c_int module procedure hipMemcpy2D_r4_3_c_size_t module procedure hipMemcpy2D_r4_3_c_int module procedure hipMemcpy2D_r4_4_c_size_t module procedure hipMemcpy2D_r4_4_c_int module procedure hipMemcpy2D_r4_5_c_size_t module procedure hipMemcpy2D_r4_5_c_int module procedure hipMemcpy2D_r4_6_c_size_t module procedure hipMemcpy2D_r4_6_c_int module procedure hipMemcpy2D_r4_7_c_size_t module procedure hipMemcpy2D_r4_7_c_int module procedure hipMemcpy2D_r8_0_c_size_t module procedure hipMemcpy2D_r8_0_c_int module procedure hipMemcpy2D_r8_1_c_size_t module procedure hipMemcpy2D_r8_1_c_int module procedure hipMemcpy2D_r8_2_c_size_t module procedure hipMemcpy2D_r8_2_c_int module procedure hipMemcpy2D_r8_3_c_size_t module procedure hipMemcpy2D_r8_3_c_int module procedure hipMemcpy2D_r8_4_c_size_t module procedure hipMemcpy2D_r8_4_c_int module procedure hipMemcpy2D_r8_5_c_size_t module procedure hipMemcpy2D_r8_5_c_int module procedure hipMemcpy2D_r8_6_c_size_t module procedure hipMemcpy2D_r8_6_c_int module procedure hipMemcpy2D_r8_7_c_size_t module procedure hipMemcpy2D_r8_7_c_int module procedure hipMemcpy2D_c4_0_c_size_t module procedure hipMemcpy2D_c4_0_c_int module procedure hipMemcpy2D_c4_1_c_size_t module procedure hipMemcpy2D_c4_1_c_int module procedure hipMemcpy2D_c4_2_c_size_t module procedure hipMemcpy2D_c4_2_c_int module procedure hipMemcpy2D_c4_3_c_size_t module procedure hipMemcpy2D_c4_3_c_int module procedure hipMemcpy2D_c4_4_c_size_t module procedure hipMemcpy2D_c4_4_c_int module procedure hipMemcpy2D_c4_5_c_size_t module procedure hipMemcpy2D_c4_5_c_int module procedure hipMemcpy2D_c4_6_c_size_t module procedure hipMemcpy2D_c4_6_c_int module procedure hipMemcpy2D_c4_7_c_size_t module procedure hipMemcpy2D_c4_7_c_int module procedure hipMemcpy2D_c8_0_c_size_t module procedure hipMemcpy2D_c8_0_c_int module procedure hipMemcpy2D_c8_1_c_size_t module procedure hipMemcpy2D_c8_1_c_int module procedure hipMemcpy2D_c8_2_c_size_t module procedure hipMemcpy2D_c8_2_c_int module procedure hipMemcpy2D_c8_3_c_size_t module procedure hipMemcpy2D_c8_3_c_int module procedure hipMemcpy2D_c8_4_c_size_t module procedure hipMemcpy2D_c8_4_c_int module procedure hipMemcpy2D_c8_5_c_size_t module procedure hipMemcpy2D_c8_5_c_int module procedure hipMemcpy2D_c8_6_c_size_t module procedure hipMemcpy2D_c8_6_c_int module procedure hipMemcpy2D_c8_7_c_size_t module procedure hipMemcpy2D_c8_7_c_int module procedure hipMemcpy2D_l_0_c_size_t module procedure hipMemcpy2D_l_0_c_int module procedure hipMemcpy2D_l_1_c_size_t module procedure hipMemcpy2D_l_1_c_int module procedure hipMemcpy2D_l_2_c_size_t module procedure hipMemcpy2D_l_2_c_int module procedure hipMemcpy2D_l_3_c_size_t module procedure hipMemcpy2D_l_3_c_int module procedure hipMemcpy2D_l_4_c_size_t module procedure hipMemcpy2D_l_4_c_int module procedure hipMemcpy2D_l_5_c_size_t module procedure hipMemcpy2D_l_5_c_int module procedure hipMemcpy2D_l_6_c_size_t module procedure hipMemcpy2D_l_6_c_int module procedure hipMemcpy2D_l_7_c_size_t module procedure hipMemcpy2D_l_7_c_int #endif end interface hipMemcpy2D interface hipMemcpy2DAsync !> @brief Copies data between host and device asynchronously. !> !> hipMemcpy2DAsync supports memory matrix copy from the pointed area src to the pointed area !> dst. !> The copy direction is defined by kind which must be one of `hipMemcpyHostToDevice`, !> `hipMemcpyDeviceToHost`, `hipMemcpyDeviceToDevice` or `hipMemcpyDefault`. !> dpitch and spitch are the widths in bytes for memory matrix corresponds to dst and src. !> width cannot exceed dpitch or spitch. !> !> The copy is always performed by the device associated with the specified stream. !> The API is asynchronous with respect to the host, so the call may return before the copy is !> complete. The copy can optionally be excuted in a specific stream by passing a non-zero stream !> argument, for HostToDevice or DeviceToHost copies, the copy can overlap with operations !> in other streams. !> !> For multi-gpu or peer-to-peer configurations, it is recommended to use a stream which is !> attached to the device where the src data is physically located. !> !> For optimal peer-to-peer copies, the copy device must be able to access the src and dst !> pointers !> (by calling hipDeviceEnablePeerAccess) with copy agent as the current device and src/dst as !> the !> peerDevice argument. If enabling device peer access is not done, the API will still work, but !> will perform the copy using a staging buffer on the host. !> !> @note If host or dst are not pinned, the memory copy will be performed synchronously. For !> best performance, use hipHostMalloc to allocate host memory that is transferred !> asynchronously. !> !> @param[out] dest Pointer to destination memory address !> @param[in] dpitch Pitch size in bytes of destination memory !> @param[in] src Pointer to source memory address !> @param[in] spitch Pitch size in bytes of source memory !> @param[in] width Width of matrix transfer (columns in bytes) !> @param[in] height Height of matrix transfer (rows) !> @param[in] myKind Type of transfer !> @param[in] stream Stream to use !> @returns `hipSuccess`, `hipErrorInvalidValue`, `hipErrorInvalidPitchValue`, !> `hipErrorInvalidDevicePointer`, `hipErrorInvalidMemcpyDirection` !> !> @see hipMemcpy, hipMemcpyToArray, hipMemcpy2DToArray, hipMemcpyFromArray, hipMemcpyToSymbol, !> hipMemcpyAsync #ifdef USE_CUDA_NAMES function hipMemcpy2DAsync_(dest, dpitch, src, spitch, width, height, myKind, stream) & bind(c, name="cudaMemcpy2DAsync") #else function hipMemcpy2DAsync_(dest, dpitch, src, spitch, width, height, myKind, stream) & bind(c, name="hipMemcpy2DAsync") #endif use iso_c_binding implicit none integer(c_int) :: hipMemcpy2DAsync_ type(c_ptr), value :: dest integer(c_size_t), value :: dpitch type(c_ptr), value :: src integer(c_size_t), value :: spitch integer(c_size_t), value :: width integer(c_size_t), value :: height integer(c_int), value :: myKind type(c_ptr), value :: stream end function hipMemcpy2DAsync_ #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipMemcpy2DAsync_i4_assumed_rank_c_size_t module procedure hipMemcpy2DAsync_i4_assumed_rank_c_int module procedure hipMemcpy2DAsync_i8_assumed_rank_c_size_t module procedure hipMemcpy2DAsync_i8_assumed_rank_c_int module procedure hipMemcpy2DAsync_r4_assumed_rank_c_size_t module procedure hipMemcpy2DAsync_r4_assumed_rank_c_int module procedure hipMemcpy2DAsync_r8_assumed_rank_c_size_t module procedure hipMemcpy2DAsync_r8_assumed_rank_c_int module procedure hipMemcpy2DAsync_c4_assumed_rank_c_size_t module procedure hipMemcpy2DAsync_c4_assumed_rank_c_int module procedure hipMemcpy2DAsync_c8_assumed_rank_c_size_t module procedure hipMemcpy2DAsync_c8_assumed_rank_c_int module procedure hipMemcpy2DAsync_l_assumed_rank_c_size_t module procedure hipMemcpy2DAsync_l_assumed_rank_c_int #else module procedure hipMemcpy2DAsync_i4_0_c_size_t module procedure hipMemcpy2DAsync_i4_0_c_int module procedure hipMemcpy2DAsync_i4_1_c_size_t module procedure hipMemcpy2DAsync_i4_1_c_int module procedure hipMemcpy2DAsync_i4_2_c_size_t module procedure hipMemcpy2DAsync_i4_2_c_int module procedure hipMemcpy2DAsync_i4_3_c_size_t module procedure hipMemcpy2DAsync_i4_3_c_int module procedure hipMemcpy2DAsync_i4_4_c_size_t module procedure hipMemcpy2DAsync_i4_4_c_int module procedure hipMemcpy2DAsync_i4_5_c_size_t module procedure hipMemcpy2DAsync_i4_5_c_int module procedure hipMemcpy2DAsync_i4_6_c_size_t module procedure hipMemcpy2DAsync_i4_6_c_int module procedure hipMemcpy2DAsync_i4_7_c_size_t module procedure hipMemcpy2DAsync_i4_7_c_int module procedure hipMemcpy2DAsync_i8_0_c_size_t module procedure hipMemcpy2DAsync_i8_0_c_int module procedure hipMemcpy2DAsync_i8_1_c_size_t module procedure hipMemcpy2DAsync_i8_1_c_int module procedure hipMemcpy2DAsync_i8_2_c_size_t module procedure hipMemcpy2DAsync_i8_2_c_int module procedure hipMemcpy2DAsync_i8_3_c_size_t module procedure hipMemcpy2DAsync_i8_3_c_int module procedure hipMemcpy2DAsync_i8_4_c_size_t module procedure hipMemcpy2DAsync_i8_4_c_int module procedure hipMemcpy2DAsync_i8_5_c_size_t module procedure hipMemcpy2DAsync_i8_5_c_int module procedure hipMemcpy2DAsync_i8_6_c_size_t module procedure hipMemcpy2DAsync_i8_6_c_int module procedure hipMemcpy2DAsync_i8_7_c_size_t module procedure hipMemcpy2DAsync_i8_7_c_int module procedure hipMemcpy2DAsync_r4_0_c_size_t module procedure hipMemcpy2DAsync_r4_0_c_int module procedure hipMemcpy2DAsync_r4_1_c_size_t module procedure hipMemcpy2DAsync_r4_1_c_int module procedure hipMemcpy2DAsync_r4_2_c_size_t module procedure hipMemcpy2DAsync_r4_2_c_int module procedure hipMemcpy2DAsync_r4_3_c_size_t module procedure hipMemcpy2DAsync_r4_3_c_int module procedure hipMemcpy2DAsync_r4_4_c_size_t module procedure hipMemcpy2DAsync_r4_4_c_int module procedure hipMemcpy2DAsync_r4_5_c_size_t module procedure hipMemcpy2DAsync_r4_5_c_int module procedure hipMemcpy2DAsync_r4_6_c_size_t module procedure hipMemcpy2DAsync_r4_6_c_int module procedure hipMemcpy2DAsync_r4_7_c_size_t module procedure hipMemcpy2DAsync_r4_7_c_int module procedure hipMemcpy2DAsync_r8_0_c_size_t module procedure hipMemcpy2DAsync_r8_0_c_int module procedure hipMemcpy2DAsync_r8_1_c_size_t module procedure hipMemcpy2DAsync_r8_1_c_int module procedure hipMemcpy2DAsync_r8_2_c_size_t module procedure hipMemcpy2DAsync_r8_2_c_int module procedure hipMemcpy2DAsync_r8_3_c_size_t module procedure hipMemcpy2DAsync_r8_3_c_int module procedure hipMemcpy2DAsync_r8_4_c_size_t module procedure hipMemcpy2DAsync_r8_4_c_int module procedure hipMemcpy2DAsync_r8_5_c_size_t module procedure hipMemcpy2DAsync_r8_5_c_int module procedure hipMemcpy2DAsync_r8_6_c_size_t module procedure hipMemcpy2DAsync_r8_6_c_int module procedure hipMemcpy2DAsync_r8_7_c_size_t module procedure hipMemcpy2DAsync_r8_7_c_int module procedure hipMemcpy2DAsync_c4_0_c_size_t module procedure hipMemcpy2DAsync_c4_0_c_int module procedure hipMemcpy2DAsync_c4_1_c_size_t module procedure hipMemcpy2DAsync_c4_1_c_int module procedure hipMemcpy2DAsync_c4_2_c_size_t module procedure hipMemcpy2DAsync_c4_2_c_int module procedure hipMemcpy2DAsync_c4_3_c_size_t module procedure hipMemcpy2DAsync_c4_3_c_int module procedure hipMemcpy2DAsync_c4_4_c_size_t module procedure hipMemcpy2DAsync_c4_4_c_int module procedure hipMemcpy2DAsync_c4_5_c_size_t module procedure hipMemcpy2DAsync_c4_5_c_int module procedure hipMemcpy2DAsync_c4_6_c_size_t module procedure hipMemcpy2DAsync_c4_6_c_int module procedure hipMemcpy2DAsync_c4_7_c_size_t module procedure hipMemcpy2DAsync_c4_7_c_int module procedure hipMemcpy2DAsync_c8_0_c_size_t module procedure hipMemcpy2DAsync_c8_0_c_int module procedure hipMemcpy2DAsync_c8_1_c_size_t module procedure hipMemcpy2DAsync_c8_1_c_int module procedure hipMemcpy2DAsync_c8_2_c_size_t module procedure hipMemcpy2DAsync_c8_2_c_int module procedure hipMemcpy2DAsync_c8_3_c_size_t module procedure hipMemcpy2DAsync_c8_3_c_int module procedure hipMemcpy2DAsync_c8_4_c_size_t module procedure hipMemcpy2DAsync_c8_4_c_int module procedure hipMemcpy2DAsync_c8_5_c_size_t module procedure hipMemcpy2DAsync_c8_5_c_int module procedure hipMemcpy2DAsync_c8_6_c_size_t module procedure hipMemcpy2DAsync_c8_6_c_int module procedure hipMemcpy2DAsync_c8_7_c_size_t module procedure hipMemcpy2DAsync_c8_7_c_int module procedure hipMemcpy2DAsync_l_0_c_size_t module procedure hipMemcpy2DAsync_l_0_c_int module procedure hipMemcpy2DAsync_l_1_c_size_t module procedure hipMemcpy2DAsync_l_1_c_int module procedure hipMemcpy2DAsync_l_2_c_size_t module procedure hipMemcpy2DAsync_l_2_c_int module procedure hipMemcpy2DAsync_l_3_c_size_t module procedure hipMemcpy2DAsync_l_3_c_int module procedure hipMemcpy2DAsync_l_4_c_size_t module procedure hipMemcpy2DAsync_l_4_c_int module procedure hipMemcpy2DAsync_l_5_c_size_t module procedure hipMemcpy2DAsync_l_5_c_int module procedure hipMemcpy2DAsync_l_6_c_size_t module procedure hipMemcpy2DAsync_l_6_c_int module procedure hipMemcpy2DAsync_l_7_c_size_t module procedure hipMemcpy2DAsync_l_7_c_int #endif end interface hipMemcpy2DAsync contains #ifdef USE_ASSUMED_RANK_INTERFACES function hipMemcpy_i4_assumed_rank_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), target, contiguous, dimension(..), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_i4_assumed_rank_c_size_t function hipMemcpy_i4_assumed_rank_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_i4_assumed_rank_c_int function hipMemcpy_i4_assumed_rank(dest, src, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_i4_assumed_rank function hipMemcpy_i8_assumed_rank_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int64_t), target, contiguous, dimension(..), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_i8_assumed_rank_c_size_t function hipMemcpy_i8_assumed_rank_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int64_t), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_i8_assumed_rank_c_int function hipMemcpy_i8_assumed_rank(dest, src, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int64_t), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_i8_assumed_rank function hipMemcpy_r4_assumed_rank_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_float), target, contiguous, dimension(..), intent(inout) :: dest real(c_float), target, contiguous, dimension(..), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_r4_assumed_rank_c_size_t function hipMemcpy_r4_assumed_rank_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_float), target, contiguous, dimension(..), intent(inout) :: dest real(c_float), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_r4_assumed_rank_c_int function hipMemcpy_r4_assumed_rank(dest, src, myKind) result(res) use iso_c_binding implicit none real(c_float), target, contiguous, dimension(..), intent(inout) :: dest real(c_float), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_r4_assumed_rank function hipMemcpy_r8_assumed_rank_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_double), target, contiguous, dimension(..), intent(inout) :: dest real(c_double), target, contiguous, dimension(..), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_r8_assumed_rank_c_size_t function hipMemcpy_r8_assumed_rank_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_double), target, contiguous, dimension(..), intent(inout) :: dest real(c_double), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_r8_assumed_rank_c_int function hipMemcpy_r8_assumed_rank(dest, src, myKind) result(res) use iso_c_binding implicit none real(c_double), target, contiguous, dimension(..), intent(inout) :: dest real(c_double), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_r8_assumed_rank function hipMemcpy_c4_assumed_rank_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, contiguous, dimension(..), intent(inout) :: dest complex(c_float_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_c4_assumed_rank_c_size_t function hipMemcpy_c4_assumed_rank_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, contiguous, dimension(..), intent(inout) :: dest complex(c_float_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_c4_assumed_rank_c_int function hipMemcpy_c4_assumed_rank(dest, src, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, contiguous, dimension(..), intent(inout) :: dest complex(c_float_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_c4_assumed_rank function hipMemcpy_c8_assumed_rank_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, contiguous, dimension(..), intent(inout) :: dest complex(c_double_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_c8_assumed_rank_c_size_t function hipMemcpy_c8_assumed_rank_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, contiguous, dimension(..), intent(inout) :: dest complex(c_double_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_c8_assumed_rank_c_int function hipMemcpy_c8_assumed_rank(dest, src, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, contiguous, dimension(..), intent(inout) :: dest complex(c_double_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_c8_assumed_rank function hipMemcpy_l_assumed_rank_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, contiguous, dimension(..), intent(inout) :: dest logical(c_bool), target, contiguous, dimension(..), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_l_assumed_rank_c_size_t function hipMemcpy_l_assumed_rank_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, contiguous, dimension(..), intent(inout) :: dest logical(c_bool), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_l_assumed_rank_c_int function hipMemcpy_l_assumed_rank(dest, src, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, contiguous, dimension(..), intent(inout) :: dest logical(c_bool), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_l_assumed_rank function hipMemcpyAsync_i4_assumed_rank_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), target, contiguous, dimension(..), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_i4_assumed_rank_c_size_t function hipMemcpyAsync_i4_assumed_rank_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_i4_assumed_rank_c_int function hipMemcpyAsync_i4_assumed_rank(dest, src, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_i4_assumed_rank function hipMemcpyAsync_i8_assumed_rank_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int64_t), target, contiguous, dimension(..), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_i8_assumed_rank_c_size_t function hipMemcpyAsync_i8_assumed_rank_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int64_t), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_i8_assumed_rank_c_int function hipMemcpyAsync_i8_assumed_rank(dest, src, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int64_t), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_i8_assumed_rank function hipMemcpyAsync_r4_assumed_rank_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, contiguous, dimension(..), intent(inout) :: dest real(c_float), target, contiguous, dimension(..), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_r4_assumed_rank_c_size_t function hipMemcpyAsync_r4_assumed_rank_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, contiguous, dimension(..), intent(inout) :: dest real(c_float), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_r4_assumed_rank_c_int function hipMemcpyAsync_r4_assumed_rank(dest, src, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, contiguous, dimension(..), intent(inout) :: dest real(c_float), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_r4_assumed_rank function hipMemcpyAsync_r8_assumed_rank_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, contiguous, dimension(..), intent(inout) :: dest real(c_double), target, contiguous, dimension(..), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_r8_assumed_rank_c_size_t function hipMemcpyAsync_r8_assumed_rank_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, contiguous, dimension(..), intent(inout) :: dest real(c_double), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_r8_assumed_rank_c_int function hipMemcpyAsync_r8_assumed_rank(dest, src, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, contiguous, dimension(..), intent(inout) :: dest real(c_double), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_r8_assumed_rank function hipMemcpyAsync_c4_assumed_rank_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, contiguous, dimension(..), intent(inout) :: dest complex(c_float_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_c4_assumed_rank_c_size_t function hipMemcpyAsync_c4_assumed_rank_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, contiguous, dimension(..), intent(inout) :: dest complex(c_float_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_c4_assumed_rank_c_int function hipMemcpyAsync_c4_assumed_rank(dest, src, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, contiguous, dimension(..), intent(inout) :: dest complex(c_float_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_c4_assumed_rank function hipMemcpyAsync_c8_assumed_rank_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, contiguous, dimension(..), intent(inout) :: dest complex(c_double_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_c8_assumed_rank_c_size_t function hipMemcpyAsync_c8_assumed_rank_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, contiguous, dimension(..), intent(inout) :: dest complex(c_double_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_c8_assumed_rank_c_int function hipMemcpyAsync_c8_assumed_rank(dest, src, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, contiguous, dimension(..), intent(inout) :: dest complex(c_double_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_c8_assumed_rank function hipMemcpyAsync_l_assumed_rank_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, contiguous, dimension(..), intent(inout) :: dest logical(c_bool), target, contiguous, dimension(..), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_l_assumed_rank_c_size_t function hipMemcpyAsync_l_assumed_rank_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, contiguous, dimension(..), intent(inout) :: dest logical(c_bool), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_l_assumed_rank_c_int function hipMemcpyAsync_l_assumed_rank(dest, src, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, contiguous, dimension(..), intent(inout) :: dest logical(c_bool), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_l_assumed_rank function hipMemcpy2D_i4_assumed_rank_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, contiguous, dimension(..), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i4_assumed_rank_c_size_t function hipMemcpy2D_i4_assumed_rank_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i4_assumed_rank_c_int function hipMemcpy2D_i8_assumed_rank_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, contiguous, dimension(..), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int64_t), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i8_assumed_rank_c_size_t function hipMemcpy2D_i8_assumed_rank_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int64_t), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i8_assumed_rank_c_int function hipMemcpy2D_r4_assumed_rank_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_float), target, contiguous, dimension(..), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_float), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r4_assumed_rank_c_size_t function hipMemcpy2D_r4_assumed_rank_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_float), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_float), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r4_assumed_rank_c_int function hipMemcpy2D_r8_assumed_rank_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_double), target, contiguous, dimension(..), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_double), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r8_assumed_rank_c_size_t function hipMemcpy2D_r8_assumed_rank_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_double), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_double), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r8_assumed_rank_c_int function hipMemcpy2D_c4_assumed_rank_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, contiguous, dimension(..), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_float_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c4_assumed_rank_c_size_t function hipMemcpy2D_c4_assumed_rank_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_float_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c4_assumed_rank_c_int function hipMemcpy2D_c8_assumed_rank_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, contiguous, dimension(..), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_double_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c8_assumed_rank_c_size_t function hipMemcpy2D_c8_assumed_rank_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_double_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c8_assumed_rank_c_int function hipMemcpy2D_l_assumed_rank_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, contiguous, dimension(..), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height logical(c_bool), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_l_assumed_rank_c_size_t function hipMemcpy2D_l_assumed_rank_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height logical(c_bool), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_l_assumed_rank_c_int function hipMemcpy2DAsync_i4_assumed_rank_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, contiguous, dimension(..), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i4_assumed_rank_c_size_t function hipMemcpy2DAsync_i4_assumed_rank_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i4_assumed_rank_c_int function hipMemcpy2DAsync_i8_assumed_rank_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, contiguous, dimension(..), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int64_t), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i8_assumed_rank_c_size_t function hipMemcpy2DAsync_i8_assumed_rank_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int64_t), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i8_assumed_rank_c_int function hipMemcpy2DAsync_r4_assumed_rank_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, contiguous, dimension(..), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_float), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r4_assumed_rank_c_size_t function hipMemcpy2DAsync_r4_assumed_rank_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_float), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r4_assumed_rank_c_int function hipMemcpy2DAsync_r8_assumed_rank_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, contiguous, dimension(..), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_double), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r8_assumed_rank_c_size_t function hipMemcpy2DAsync_r8_assumed_rank_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_double), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r8_assumed_rank_c_int function hipMemcpy2DAsync_c4_assumed_rank_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, contiguous, dimension(..), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_float_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c4_assumed_rank_c_size_t function hipMemcpy2DAsync_c4_assumed_rank_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_float_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c4_assumed_rank_c_int function hipMemcpy2DAsync_c8_assumed_rank_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, contiguous, dimension(..), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_double_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c8_assumed_rank_c_size_t function hipMemcpy2DAsync_c8_assumed_rank_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_double_complex), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c8_assumed_rank_c_int function hipMemcpy2DAsync_l_assumed_rank_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, contiguous, dimension(..), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height logical(c_bool), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_l_assumed_rank_c_size_t function hipMemcpy2DAsync_l_assumed_rank_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, contiguous, dimension(..), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height logical(c_bool), target, contiguous, dimension(..), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_l_assumed_rank_c_int #else function hipMemcpy_i4_0_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, intent(inout) :: dest integer(c_int), target, intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_i4_0_c_size_t function hipMemcpy_i4_0_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, intent(inout) :: dest integer(c_int), target, intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_i4_0_c_int function hipMemcpy_i4_0(dest, src, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, intent(inout) :: dest integer(c_int), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(1, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_i4_0 function hipMemcpy_i4_1_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:), intent(inout) :: dest integer(c_int), target, dimension(:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_i4_1_c_size_t function hipMemcpy_i4_1_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:), intent(inout) :: dest integer(c_int), target, dimension(:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_i4_1_c_int function hipMemcpy_i4_1(dest, src, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:), intent(inout) :: dest integer(c_int), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_i4_1 function hipMemcpy_i4_2_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_i4_2_c_size_t function hipMemcpy_i4_2_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_i4_2_c_int function hipMemcpy_i4_2(dest, src, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_i4_2 function hipMemcpy_i4_3_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_i4_3_c_size_t function hipMemcpy_i4_3_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_i4_3_c_int function hipMemcpy_i4_3(dest, src, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_i4_3 function hipMemcpy_i4_4_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_i4_4_c_size_t function hipMemcpy_i4_4_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_i4_4_c_int function hipMemcpy_i4_4(dest, src, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_i4_4 function hipMemcpy_i4_5_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_i4_5_c_size_t function hipMemcpy_i4_5_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_i4_5_c_int function hipMemcpy_i4_5(dest, src, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_i4_5 function hipMemcpy_i4_6_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_i4_6_c_size_t function hipMemcpy_i4_6_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_i4_6_c_int function hipMemcpy_i4_6(dest, src, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_i4_6 function hipMemcpy_i4_7_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_i4_7_c_size_t function hipMemcpy_i4_7_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_i4_7_c_int function hipMemcpy_i4_7(dest, src, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_i4_7 function hipMemcpy_i8_0_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, intent(inout) :: dest integer(c_int64_t), target, intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_i8_0_c_size_t function hipMemcpy_i8_0_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, intent(inout) :: dest integer(c_int64_t), target, intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_i8_0_c_int function hipMemcpy_i8_0(dest, src, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, intent(inout) :: dest integer(c_int64_t), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(1, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_i8_0 function hipMemcpy_i8_1_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:), intent(inout) :: dest integer(c_int64_t), target, dimension(:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_i8_1_c_size_t function hipMemcpy_i8_1_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:), intent(inout) :: dest integer(c_int64_t), target, dimension(:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_i8_1_c_int function hipMemcpy_i8_1(dest, src, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:), intent(inout) :: dest integer(c_int64_t), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_i8_1 function hipMemcpy_i8_2_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_i8_2_c_size_t function hipMemcpy_i8_2_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_i8_2_c_int function hipMemcpy_i8_2(dest, src, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_i8_2 function hipMemcpy_i8_3_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_i8_3_c_size_t function hipMemcpy_i8_3_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_i8_3_c_int function hipMemcpy_i8_3(dest, src, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_i8_3 function hipMemcpy_i8_4_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_i8_4_c_size_t function hipMemcpy_i8_4_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_i8_4_c_int function hipMemcpy_i8_4(dest, src, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_i8_4 function hipMemcpy_i8_5_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_i8_5_c_size_t function hipMemcpy_i8_5_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_i8_5_c_int function hipMemcpy_i8_5(dest, src, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_i8_5 function hipMemcpy_i8_6_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_i8_6_c_size_t function hipMemcpy_i8_6_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_i8_6_c_int function hipMemcpy_i8_6(dest, src, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_i8_6 function hipMemcpy_i8_7_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_i8_7_c_size_t function hipMemcpy_i8_7_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_i8_7_c_int function hipMemcpy_i8_7(dest, src, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_i8_7 function hipMemcpy_r4_0_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_float), target, intent(inout) :: dest real(c_float), target, intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_r4_0_c_size_t function hipMemcpy_r4_0_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_float), target, intent(inout) :: dest real(c_float), target, intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_r4_0_c_int function hipMemcpy_r4_0(dest, src, myKind) result(res) use iso_c_binding implicit none real(c_float), target, intent(inout) :: dest real(c_float), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(1, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_r4_0 function hipMemcpy_r4_1_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:), intent(inout) :: dest real(c_float), target, dimension(:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_r4_1_c_size_t function hipMemcpy_r4_1_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:), intent(inout) :: dest real(c_float), target, dimension(:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_r4_1_c_int function hipMemcpy_r4_1(dest, src, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:), intent(inout) :: dest real(c_float), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_r4_1 function hipMemcpy_r4_2_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:), intent(inout) :: dest real(c_float), target, dimension(:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_r4_2_c_size_t function hipMemcpy_r4_2_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:), intent(inout) :: dest real(c_float), target, dimension(:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_r4_2_c_int function hipMemcpy_r4_2(dest, src, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:), intent(inout) :: dest real(c_float), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_r4_2 function hipMemcpy_r4_3_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_r4_3_c_size_t function hipMemcpy_r4_3_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_r4_3_c_int function hipMemcpy_r4_3(dest, src, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_r4_3 function hipMemcpy_r4_4_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_r4_4_c_size_t function hipMemcpy_r4_4_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_r4_4_c_int function hipMemcpy_r4_4(dest, src, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_r4_4 function hipMemcpy_r4_5_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_r4_5_c_size_t function hipMemcpy_r4_5_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_r4_5_c_int function hipMemcpy_r4_5(dest, src, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_r4_5 function hipMemcpy_r4_6_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_r4_6_c_size_t function hipMemcpy_r4_6_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_r4_6_c_int function hipMemcpy_r4_6(dest, src, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_r4_6 function hipMemcpy_r4_7_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_r4_7_c_size_t function hipMemcpy_r4_7_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_r4_7_c_int function hipMemcpy_r4_7(dest, src, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_r4_7 function hipMemcpy_r8_0_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_double), target, intent(inout) :: dest real(c_double), target, intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_r8_0_c_size_t function hipMemcpy_r8_0_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_double), target, intent(inout) :: dest real(c_double), target, intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_r8_0_c_int function hipMemcpy_r8_0(dest, src, myKind) result(res) use iso_c_binding implicit none real(c_double), target, intent(inout) :: dest real(c_double), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(1, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_r8_0 function hipMemcpy_r8_1_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:), intent(inout) :: dest real(c_double), target, dimension(:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_r8_1_c_size_t function hipMemcpy_r8_1_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:), intent(inout) :: dest real(c_double), target, dimension(:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_r8_1_c_int function hipMemcpy_r8_1(dest, src, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:), intent(inout) :: dest real(c_double), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_r8_1 function hipMemcpy_r8_2_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:), intent(inout) :: dest real(c_double), target, dimension(:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_r8_2_c_size_t function hipMemcpy_r8_2_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:), intent(inout) :: dest real(c_double), target, dimension(:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_r8_2_c_int function hipMemcpy_r8_2(dest, src, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:), intent(inout) :: dest real(c_double), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_r8_2 function hipMemcpy_r8_3_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_r8_3_c_size_t function hipMemcpy_r8_3_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_r8_3_c_int function hipMemcpy_r8_3(dest, src, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_r8_3 function hipMemcpy_r8_4_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_r8_4_c_size_t function hipMemcpy_r8_4_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_r8_4_c_int function hipMemcpy_r8_4(dest, src, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_r8_4 function hipMemcpy_r8_5_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_r8_5_c_size_t function hipMemcpy_r8_5_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_r8_5_c_int function hipMemcpy_r8_5(dest, src, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_r8_5 function hipMemcpy_r8_6_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_r8_6_c_size_t function hipMemcpy_r8_6_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_r8_6_c_int function hipMemcpy_r8_6(dest, src, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_r8_6 function hipMemcpy_r8_7_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_r8_7_c_size_t function hipMemcpy_r8_7_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_r8_7_c_int function hipMemcpy_r8_7(dest, src, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_r8_7 function hipMemcpy_c4_0_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, intent(inout) :: dest complex(c_float_complex), target, intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_c4_0_c_size_t function hipMemcpy_c4_0_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, intent(inout) :: dest complex(c_float_complex), target, intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_c4_0_c_int function hipMemcpy_c4_0(dest, src, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, intent(inout) :: dest complex(c_float_complex), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(1, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_c4_0 function hipMemcpy_c4_1_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:), intent(inout) :: dest complex(c_float_complex), target, dimension(:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_c4_1_c_size_t function hipMemcpy_c4_1_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:), intent(inout) :: dest complex(c_float_complex), target, dimension(:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_c4_1_c_int function hipMemcpy_c4_1(dest, src, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:), intent(inout) :: dest complex(c_float_complex), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_c4_1 function hipMemcpy_c4_2_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_c4_2_c_size_t function hipMemcpy_c4_2_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_c4_2_c_int function hipMemcpy_c4_2(dest, src, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_c4_2 function hipMemcpy_c4_3_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_c4_3_c_size_t function hipMemcpy_c4_3_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_c4_3_c_int function hipMemcpy_c4_3(dest, src, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_c4_3 function hipMemcpy_c4_4_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_c4_4_c_size_t function hipMemcpy_c4_4_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_c4_4_c_int function hipMemcpy_c4_4(dest, src, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_c4_4 function hipMemcpy_c4_5_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_c4_5_c_size_t function hipMemcpy_c4_5_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_c4_5_c_int function hipMemcpy_c4_5(dest, src, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_c4_5 function hipMemcpy_c4_6_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_c4_6_c_size_t function hipMemcpy_c4_6_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_c4_6_c_int function hipMemcpy_c4_6(dest, src, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_c4_6 function hipMemcpy_c4_7_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_c4_7_c_size_t function hipMemcpy_c4_7_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_c4_7_c_int function hipMemcpy_c4_7(dest, src, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_c4_7 function hipMemcpy_c8_0_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, intent(inout) :: dest complex(c_double_complex), target, intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_c8_0_c_size_t function hipMemcpy_c8_0_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, intent(inout) :: dest complex(c_double_complex), target, intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_c8_0_c_int function hipMemcpy_c8_0(dest, src, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, intent(inout) :: dest complex(c_double_complex), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(1, c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_c8_0 function hipMemcpy_c8_1_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:), intent(inout) :: dest complex(c_double_complex), target, dimension(:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_c8_1_c_size_t function hipMemcpy_c8_1_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:), intent(inout) :: dest complex(c_double_complex), target, dimension(:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_c8_1_c_int function hipMemcpy_c8_1(dest, src, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:), intent(inout) :: dest complex(c_double_complex), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_c8_1 function hipMemcpy_c8_2_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_c8_2_c_size_t function hipMemcpy_c8_2_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_c8_2_c_int function hipMemcpy_c8_2(dest, src, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_c8_2 function hipMemcpy_c8_3_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_c8_3_c_size_t function hipMemcpy_c8_3_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_c8_3_c_int function hipMemcpy_c8_3(dest, src, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_c8_3 function hipMemcpy_c8_4_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_c8_4_c_size_t function hipMemcpy_c8_4_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_c8_4_c_int function hipMemcpy_c8_4(dest, src, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_c8_4 function hipMemcpy_c8_5_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_c8_5_c_size_t function hipMemcpy_c8_5_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_c8_5_c_int function hipMemcpy_c8_5(dest, src, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_c8_5 function hipMemcpy_c8_6_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_c8_6_c_size_t function hipMemcpy_c8_6_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_c8_6_c_int function hipMemcpy_c8_6(dest, src, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_c8_6 function hipMemcpy_c8_7_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_c8_7_c_size_t function hipMemcpy_c8_7_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_c8_7_c_int function hipMemcpy_c8_7(dest, src, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 16_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_c8_7 function hipMemcpy_l_0_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, intent(inout) :: dest logical(c_bool), target, intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_l_0_c_size_t function hipMemcpy_l_0_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, intent(inout) :: dest logical(c_bool), target, intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_l_0_c_int function hipMemcpy_l_0(dest, src, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, intent(inout) :: dest logical(c_bool), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(1, c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest), c_loc(src), nbytes, myKind) end function hipMemcpy_l_0 function hipMemcpy_l_1_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:), intent(inout) :: dest logical(c_bool), target, dimension(:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_l_1_c_size_t function hipMemcpy_l_1_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:), intent(inout) :: dest logical(c_bool), target, dimension(:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_l_1_c_int function hipMemcpy_l_1(dest, src, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:), intent(inout) :: dest logical(c_bool), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind) end function hipMemcpy_l_1 function hipMemcpy_l_2_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_l_2_c_size_t function hipMemcpy_l_2_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_l_2_c_int function hipMemcpy_l_2(dest, src, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind) end function hipMemcpy_l_2 function hipMemcpy_l_3_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_l_3_c_size_t function hipMemcpy_l_3_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_l_3_c_int function hipMemcpy_l_3(dest, src, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind) end function hipMemcpy_l_3 function hipMemcpy_l_4_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_l_4_c_size_t function hipMemcpy_l_4_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_l_4_c_int function hipMemcpy_l_4(dest, src, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind) end function hipMemcpy_l_4 function hipMemcpy_l_5_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_l_5_c_size_t function hipMemcpy_l_5_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_l_5_c_int function hipMemcpy_l_5(dest, src, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_l_5 function hipMemcpy_l_6_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_l_6_c_size_t function hipMemcpy_l_6_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_l_6_c_int function hipMemcpy_l_6(dest, src, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_l_6 function hipMemcpy_l_7_c_size_t(dest, src, length, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_l_7_c_size_t function hipMemcpy_l_7_c_int(dest, src, length, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_l_7_c_int function hipMemcpy_l_7(dest, src, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 1_c_size_t res = hipMemcpy_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind) end function hipMemcpy_l_7 function hipMemcpyAsync_i4_0_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, intent(inout) :: dest integer(c_int), target, intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_i4_0_c_size_t function hipMemcpyAsync_i4_0_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, intent(inout) :: dest integer(c_int), target, intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_i4_0_c_int function hipMemcpyAsync_i4_0(dest, src, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, intent(inout) :: dest integer(c_int), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(1, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_i4_0 function hipMemcpyAsync_i4_1_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:), intent(inout) :: dest integer(c_int), target, dimension(:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_1_c_size_t function hipMemcpyAsync_i4_1_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:), intent(inout) :: dest integer(c_int), target, dimension(:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_1_c_int function hipMemcpyAsync_i4_1(dest, src, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:), intent(inout) :: dest integer(c_int), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_1 function hipMemcpyAsync_i4_2_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_2_c_size_t function hipMemcpyAsync_i4_2_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_2_c_int function hipMemcpyAsync_i4_2(dest, src, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_2 function hipMemcpyAsync_i4_3_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_3_c_size_t function hipMemcpyAsync_i4_3_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_3_c_int function hipMemcpyAsync_i4_3(dest, src, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_3 function hipMemcpyAsync_i4_4_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_4_c_size_t function hipMemcpyAsync_i4_4_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_4_c_int function hipMemcpyAsync_i4_4(dest, src, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_4 function hipMemcpyAsync_i4_5_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_5_c_size_t function hipMemcpyAsync_i4_5_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_5_c_int function hipMemcpyAsync_i4_5(dest, src, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_5 function hipMemcpyAsync_i4_6_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_6_c_size_t function hipMemcpyAsync_i4_6_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_6_c_int function hipMemcpyAsync_i4_6(dest, src, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_6 function hipMemcpyAsync_i4_7_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_7_c_size_t function hipMemcpyAsync_i4_7_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_7_c_int function hipMemcpyAsync_i4_7(dest, src, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i4_7 function hipMemcpyAsync_i8_0_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, intent(inout) :: dest integer(c_int64_t), target, intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_i8_0_c_size_t function hipMemcpyAsync_i8_0_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, intent(inout) :: dest integer(c_int64_t), target, intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_i8_0_c_int function hipMemcpyAsync_i8_0(dest, src, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, intent(inout) :: dest integer(c_int64_t), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(1, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_i8_0 function hipMemcpyAsync_i8_1_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:), intent(inout) :: dest integer(c_int64_t), target, dimension(:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_1_c_size_t function hipMemcpyAsync_i8_1_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:), intent(inout) :: dest integer(c_int64_t), target, dimension(:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_1_c_int function hipMemcpyAsync_i8_1(dest, src, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:), intent(inout) :: dest integer(c_int64_t), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_1 function hipMemcpyAsync_i8_2_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_2_c_size_t function hipMemcpyAsync_i8_2_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_2_c_int function hipMemcpyAsync_i8_2(dest, src, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_2 function hipMemcpyAsync_i8_3_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_3_c_size_t function hipMemcpyAsync_i8_3_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_3_c_int function hipMemcpyAsync_i8_3(dest, src, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_3 function hipMemcpyAsync_i8_4_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_4_c_size_t function hipMemcpyAsync_i8_4_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_4_c_int function hipMemcpyAsync_i8_4(dest, src, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_4 function hipMemcpyAsync_i8_5_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_5_c_size_t function hipMemcpyAsync_i8_5_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_5_c_int function hipMemcpyAsync_i8_5(dest, src, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_5 function hipMemcpyAsync_i8_6_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_6_c_size_t function hipMemcpyAsync_i8_6_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_6_c_int function hipMemcpyAsync_i8_6(dest, src, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_6 function hipMemcpyAsync_i8_7_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_7_c_size_t function hipMemcpyAsync_i8_7_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_7_c_int function hipMemcpyAsync_i8_7(dest, src, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_i8_7 function hipMemcpyAsync_r4_0_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, intent(inout) :: dest real(c_float), target, intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_r4_0_c_size_t function hipMemcpyAsync_r4_0_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, intent(inout) :: dest real(c_float), target, intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_r4_0_c_int function hipMemcpyAsync_r4_0(dest, src, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, intent(inout) :: dest real(c_float), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(1, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_r4_0 function hipMemcpyAsync_r4_1_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:), intent(inout) :: dest real(c_float), target, dimension(:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_1_c_size_t function hipMemcpyAsync_r4_1_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:), intent(inout) :: dest real(c_float), target, dimension(:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_1_c_int function hipMemcpyAsync_r4_1(dest, src, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:), intent(inout) :: dest real(c_float), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_1 function hipMemcpyAsync_r4_2_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:), intent(inout) :: dest real(c_float), target, dimension(:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_2_c_size_t function hipMemcpyAsync_r4_2_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:), intent(inout) :: dest real(c_float), target, dimension(:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_2_c_int function hipMemcpyAsync_r4_2(dest, src, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:), intent(inout) :: dest real(c_float), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_2 function hipMemcpyAsync_r4_3_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_3_c_size_t function hipMemcpyAsync_r4_3_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_3_c_int function hipMemcpyAsync_r4_3(dest, src, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_3 function hipMemcpyAsync_r4_4_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_4_c_size_t function hipMemcpyAsync_r4_4_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_4_c_int function hipMemcpyAsync_r4_4(dest, src, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_4 function hipMemcpyAsync_r4_5_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_5_c_size_t function hipMemcpyAsync_r4_5_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_5_c_int function hipMemcpyAsync_r4_5(dest, src, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_5 function hipMemcpyAsync_r4_6_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_6_c_size_t function hipMemcpyAsync_r4_6_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_6_c_int function hipMemcpyAsync_r4_6(dest, src, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_6 function hipMemcpyAsync_r4_7_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_7_c_size_t function hipMemcpyAsync_r4_7_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_7_c_int function hipMemcpyAsync_r4_7(dest, src, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest real(c_float), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 4_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r4_7 function hipMemcpyAsync_r8_0_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, intent(inout) :: dest real(c_double), target, intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_r8_0_c_size_t function hipMemcpyAsync_r8_0_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, intent(inout) :: dest real(c_double), target, intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_r8_0_c_int function hipMemcpyAsync_r8_0(dest, src, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, intent(inout) :: dest real(c_double), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(1, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_r8_0 function hipMemcpyAsync_r8_1_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:), intent(inout) :: dest real(c_double), target, dimension(:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_1_c_size_t function hipMemcpyAsync_r8_1_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:), intent(inout) :: dest real(c_double), target, dimension(:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_1_c_int function hipMemcpyAsync_r8_1(dest, src, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:), intent(inout) :: dest real(c_double), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_1 function hipMemcpyAsync_r8_2_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:), intent(inout) :: dest real(c_double), target, dimension(:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_2_c_size_t function hipMemcpyAsync_r8_2_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:), intent(inout) :: dest real(c_double), target, dimension(:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_2_c_int function hipMemcpyAsync_r8_2(dest, src, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:), intent(inout) :: dest real(c_double), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_2 function hipMemcpyAsync_r8_3_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_3_c_size_t function hipMemcpyAsync_r8_3_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_3_c_int function hipMemcpyAsync_r8_3(dest, src, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_3 function hipMemcpyAsync_r8_4_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_4_c_size_t function hipMemcpyAsync_r8_4_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_4_c_int function hipMemcpyAsync_r8_4(dest, src, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_4 function hipMemcpyAsync_r8_5_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_5_c_size_t function hipMemcpyAsync_r8_5_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_5_c_int function hipMemcpyAsync_r8_5(dest, src, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_5 function hipMemcpyAsync_r8_6_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_6_c_size_t function hipMemcpyAsync_r8_6_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_6_c_int function hipMemcpyAsync_r8_6(dest, src, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_6 function hipMemcpyAsync_r8_7_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_7_c_size_t function hipMemcpyAsync_r8_7_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_7_c_int function hipMemcpyAsync_r8_7(dest, src, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest real(c_double), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_r8_7 function hipMemcpyAsync_c4_0_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, intent(inout) :: dest complex(c_float_complex), target, intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_c4_0_c_size_t function hipMemcpyAsync_c4_0_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, intent(inout) :: dest complex(c_float_complex), target, intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_c4_0_c_int function hipMemcpyAsync_c4_0(dest, src, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, intent(inout) :: dest complex(c_float_complex), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(1, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_c4_0 function hipMemcpyAsync_c4_1_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:), intent(inout) :: dest complex(c_float_complex), target, dimension(:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_1_c_size_t function hipMemcpyAsync_c4_1_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:), intent(inout) :: dest complex(c_float_complex), target, dimension(:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_1_c_int function hipMemcpyAsync_c4_1(dest, src, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:), intent(inout) :: dest complex(c_float_complex), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_1 function hipMemcpyAsync_c4_2_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_2_c_size_t function hipMemcpyAsync_c4_2_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_2_c_int function hipMemcpyAsync_c4_2(dest, src, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_2 function hipMemcpyAsync_c4_3_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_3_c_size_t function hipMemcpyAsync_c4_3_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_3_c_int function hipMemcpyAsync_c4_3(dest, src, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_3 function hipMemcpyAsync_c4_4_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_4_c_size_t function hipMemcpyAsync_c4_4_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_4_c_int function hipMemcpyAsync_c4_4(dest, src, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_4 function hipMemcpyAsync_c4_5_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_5_c_size_t function hipMemcpyAsync_c4_5_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_5_c_int function hipMemcpyAsync_c4_5(dest, src, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_5 function hipMemcpyAsync_c4_6_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_6_c_size_t function hipMemcpyAsync_c4_6_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_6_c_int function hipMemcpyAsync_c4_6(dest, src, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_6 function hipMemcpyAsync_c4_7_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_7_c_size_t function hipMemcpyAsync_c4_7_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_7_c_int function hipMemcpyAsync_c4_7(dest, src, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 8_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c4_7 function hipMemcpyAsync_c8_0_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, intent(inout) :: dest complex(c_double_complex), target, intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_c8_0_c_size_t function hipMemcpyAsync_c8_0_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, intent(inout) :: dest complex(c_double_complex), target, intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_c8_0_c_int function hipMemcpyAsync_c8_0(dest, src, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, intent(inout) :: dest complex(c_double_complex), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(1, c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_c8_0 function hipMemcpyAsync_c8_1_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:), intent(inout) :: dest complex(c_double_complex), target, dimension(:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_1_c_size_t function hipMemcpyAsync_c8_1_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:), intent(inout) :: dest complex(c_double_complex), target, dimension(:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_1_c_int function hipMemcpyAsync_c8_1(dest, src, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:), intent(inout) :: dest complex(c_double_complex), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_1 function hipMemcpyAsync_c8_2_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_2_c_size_t function hipMemcpyAsync_c8_2_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_2_c_int function hipMemcpyAsync_c8_2(dest, src, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_2 function hipMemcpyAsync_c8_3_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_3_c_size_t function hipMemcpyAsync_c8_3_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_3_c_int function hipMemcpyAsync_c8_3(dest, src, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_3 function hipMemcpyAsync_c8_4_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_4_c_size_t function hipMemcpyAsync_c8_4_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_4_c_int function hipMemcpyAsync_c8_4(dest, src, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_4 function hipMemcpyAsync_c8_5_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_5_c_size_t function hipMemcpyAsync_c8_5_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_5_c_int function hipMemcpyAsync_c8_5(dest, src, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_5 function hipMemcpyAsync_c8_6_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_6_c_size_t function hipMemcpyAsync_c8_6_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_6_c_int function hipMemcpyAsync_c8_6(dest, src, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_6 function hipMemcpyAsync_c8_7_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_7_c_size_t function hipMemcpyAsync_c8_7_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_7_c_int function hipMemcpyAsync_c8_7(dest, src, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 16_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_c8_7 function hipMemcpyAsync_l_0_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, intent(inout) :: dest logical(c_bool), target, intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_l_0_c_size_t function hipMemcpyAsync_l_0_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, intent(inout) :: dest logical(c_bool), target, intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_l_0_c_int function hipMemcpyAsync_l_0(dest, src, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, intent(inout) :: dest logical(c_bool), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(1, c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest), c_loc(src), nbytes, myKind, stream) end function hipMemcpyAsync_l_0 function hipMemcpyAsync_l_1_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:), intent(inout) :: dest logical(c_bool), target, dimension(:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_1_c_size_t function hipMemcpyAsync_l_1_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:), intent(inout) :: dest logical(c_bool), target, dimension(:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_1_c_int function hipMemcpyAsync_l_1(dest, src, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:), intent(inout) :: dest logical(c_bool), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1)), c_loc(src(1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_1 function hipMemcpyAsync_l_2_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_2_c_size_t function hipMemcpyAsync_l_2_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_2_c_int function hipMemcpyAsync_l_2(dest, src, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1)), c_loc(src(1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_2 function hipMemcpyAsync_l_3_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_3_c_size_t function hipMemcpyAsync_l_3_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_3_c_int function hipMemcpyAsync_l_3(dest, src, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1)), c_loc(src(1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_3 function hipMemcpyAsync_l_4_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_4_c_size_t function hipMemcpyAsync_l_4_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_4_c_int function hipMemcpyAsync_l_4(dest, src, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1)), c_loc(src(1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_4 function hipMemcpyAsync_l_5_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_5_c_size_t function hipMemcpyAsync_l_5_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_5_c_int function hipMemcpyAsync_l_5(dest, src, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1)), c_loc(src(1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_5 function hipMemcpyAsync_l_6_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_6_c_size_t function hipMemcpyAsync_l_6_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_6_c_int function hipMemcpyAsync_l_6(dest, src, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_6 function hipMemcpyAsync_l_7_c_size_t(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_size_t), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_7_c_size_t function hipMemcpyAsync_l_7_c_int(dest, src, length, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: length integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(length, c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_7_c_int function hipMemcpyAsync_l_7(dest, src, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: nbytes nbytes = int(size(dest), c_size_t) * 1_c_size_t res = hipMemcpyAsync_(c_loc(dest(1,1,1,1,1,1,1)), c_loc(src(1,1,1,1,1,1,1)), nbytes, myKind, stream) end function hipMemcpyAsync_l_7 function hipMemcpy2D_i4_0_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i4_0_c_size_t function hipMemcpy2D_i4_0_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i4_0_c_int function hipMemcpy2D_i4_1_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i4_1_c_size_t function hipMemcpy2D_i4_1_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i4_1_c_int function hipMemcpy2D_i4_2_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i4_2_c_size_t function hipMemcpy2D_i4_2_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i4_2_c_int function hipMemcpy2D_i4_3_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i4_3_c_size_t function hipMemcpy2D_i4_3_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i4_3_c_int function hipMemcpy2D_i4_4_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i4_4_c_size_t function hipMemcpy2D_i4_4_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i4_4_c_int function hipMemcpy2D_i4_5_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i4_5_c_size_t function hipMemcpy2D_i4_5_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i4_5_c_int function hipMemcpy2D_i4_6_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i4_6_c_size_t function hipMemcpy2D_i4_6_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i4_6_c_int function hipMemcpy2D_i4_7_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i4_7_c_size_t function hipMemcpy2D_i4_7_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i4_7_c_int function hipMemcpy2D_i8_0_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int64_t), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i8_0_c_size_t function hipMemcpy2D_i8_0_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int64_t), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i8_0_c_int function hipMemcpy2D_i8_1_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i8_1_c_size_t function hipMemcpy2D_i8_1_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i8_1_c_int function hipMemcpy2D_i8_2_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i8_2_c_size_t function hipMemcpy2D_i8_2_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i8_2_c_int function hipMemcpy2D_i8_3_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i8_3_c_size_t function hipMemcpy2D_i8_3_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i8_3_c_int function hipMemcpy2D_i8_4_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i8_4_c_size_t function hipMemcpy2D_i8_4_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i8_4_c_int function hipMemcpy2D_i8_5_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i8_5_c_size_t function hipMemcpy2D_i8_5_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i8_5_c_int function hipMemcpy2D_i8_6_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i8_6_c_size_t function hipMemcpy2D_i8_6_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i8_6_c_int function hipMemcpy2D_i8_7_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i8_7_c_size_t function hipMemcpy2D_i8_7_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_i8_7_c_int function hipMemcpy2D_r4_0_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_float), target, intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_float), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r4_0_c_size_t function hipMemcpy2D_r4_0_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_float), target, intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_float), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r4_0_c_int function hipMemcpy2D_r4_1_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_float), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r4_1_c_size_t function hipMemcpy2D_r4_1_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_float), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r4_1_c_int function hipMemcpy2D_r4_2_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r4_2_c_size_t function hipMemcpy2D_r4_2_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r4_2_c_int function hipMemcpy2D_r4_3_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r4_3_c_size_t function hipMemcpy2D_r4_3_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r4_3_c_int function hipMemcpy2D_r4_4_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r4_4_c_size_t function hipMemcpy2D_r4_4_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r4_4_c_int function hipMemcpy2D_r4_5_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r4_5_c_size_t function hipMemcpy2D_r4_5_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r4_5_c_int function hipMemcpy2D_r4_6_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r4_6_c_size_t function hipMemcpy2D_r4_6_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r4_6_c_int function hipMemcpy2D_r4_7_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r4_7_c_size_t function hipMemcpy2D_r4_7_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r4_7_c_int function hipMemcpy2D_r8_0_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_double), target, intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_double), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r8_0_c_size_t function hipMemcpy2D_r8_0_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_double), target, intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_double), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r8_0_c_int function hipMemcpy2D_r8_1_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_double), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r8_1_c_size_t function hipMemcpy2D_r8_1_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_double), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r8_1_c_int function hipMemcpy2D_r8_2_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r8_2_c_size_t function hipMemcpy2D_r8_2_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r8_2_c_int function hipMemcpy2D_r8_3_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r8_3_c_size_t function hipMemcpy2D_r8_3_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r8_3_c_int function hipMemcpy2D_r8_4_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r8_4_c_size_t function hipMemcpy2D_r8_4_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r8_4_c_int function hipMemcpy2D_r8_5_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r8_5_c_size_t function hipMemcpy2D_r8_5_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r8_5_c_int function hipMemcpy2D_r8_6_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r8_6_c_size_t function hipMemcpy2D_r8_6_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r8_6_c_int function hipMemcpy2D_r8_7_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r8_7_c_size_t function hipMemcpy2D_r8_7_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_r8_7_c_int function hipMemcpy2D_c4_0_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_float_complex), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c4_0_c_size_t function hipMemcpy2D_c4_0_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_float_complex), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c4_0_c_int function hipMemcpy2D_c4_1_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c4_1_c_size_t function hipMemcpy2D_c4_1_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c4_1_c_int function hipMemcpy2D_c4_2_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c4_2_c_size_t function hipMemcpy2D_c4_2_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c4_2_c_int function hipMemcpy2D_c4_3_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c4_3_c_size_t function hipMemcpy2D_c4_3_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c4_3_c_int function hipMemcpy2D_c4_4_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c4_4_c_size_t function hipMemcpy2D_c4_4_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c4_4_c_int function hipMemcpy2D_c4_5_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c4_5_c_size_t function hipMemcpy2D_c4_5_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c4_5_c_int function hipMemcpy2D_c4_6_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c4_6_c_size_t function hipMemcpy2D_c4_6_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c4_6_c_int function hipMemcpy2D_c4_7_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c4_7_c_size_t function hipMemcpy2D_c4_7_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c4_7_c_int function hipMemcpy2D_c8_0_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_double_complex), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c8_0_c_size_t function hipMemcpy2D_c8_0_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_double_complex), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c8_0_c_int function hipMemcpy2D_c8_1_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2D_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c8_1_c_size_t function hipMemcpy2D_c8_1_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2D_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c8_1_c_int function hipMemcpy2D_c8_2_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c8_2_c_size_t function hipMemcpy2D_c8_2_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c8_2_c_int function hipMemcpy2D_c8_3_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c8_3_c_size_t function hipMemcpy2D_c8_3_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c8_3_c_int function hipMemcpy2D_c8_4_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c8_4_c_size_t function hipMemcpy2D_c8_4_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c8_4_c_int function hipMemcpy2D_c8_5_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c8_5_c_size_t function hipMemcpy2D_c8_5_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c8_5_c_int function hipMemcpy2D_c8_6_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c8_6_c_size_t function hipMemcpy2D_c8_6_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c8_6_c_int function hipMemcpy2D_c8_7_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c8_7_c_size_t function hipMemcpy2D_c8_7_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_c8_7_c_int function hipMemcpy2D_l_0_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height logical(c_bool), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_l_0_c_size_t function hipMemcpy2D_l_0_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height logical(c_bool), target, intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2D_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_l_0_c_int function hipMemcpy2D_l_1_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2D_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_l_1_c_size_t function hipMemcpy2D_l_1_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2D_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_l_1_c_int function hipMemcpy2D_l_2_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_l_2_c_size_t function hipMemcpy2D_l_2_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_l_2_c_int function hipMemcpy2D_l_3_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_l_3_c_size_t function hipMemcpy2D_l_3_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_l_3_c_int function hipMemcpy2D_l_4_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_l_4_c_size_t function hipMemcpy2D_l_4_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_l_4_c_int function hipMemcpy2D_l_5_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_l_5_c_size_t function hipMemcpy2D_l_5_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_l_5_c_int function hipMemcpy2D_l_6_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_l_6_c_size_t function hipMemcpy2D_l_6_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_l_6_c_int function hipMemcpy2D_l_7_c_size_t(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_l_7_c_size_t function hipMemcpy2D_l_7_c_int(dest, dpitch, src, spitch, width, height, myKind) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2D_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind) end function hipMemcpy2D_l_7_c_int function hipMemcpy2DAsync_i4_0_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i4_0_c_size_t function hipMemcpy2DAsync_i4_0_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i4_0_c_int function hipMemcpy2DAsync_i4_1_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i4_1_c_size_t function hipMemcpy2DAsync_i4_1_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i4_1_c_int function hipMemcpy2DAsync_i4_2_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i4_2_c_size_t function hipMemcpy2DAsync_i4_2_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i4_2_c_int function hipMemcpy2DAsync_i4_3_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i4_3_c_size_t function hipMemcpy2DAsync_i4_3_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i4_3_c_int function hipMemcpy2DAsync_i4_4_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i4_4_c_size_t function hipMemcpy2DAsync_i4_4_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i4_4_c_int function hipMemcpy2DAsync_i4_5_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i4_5_c_size_t function hipMemcpy2DAsync_i4_5_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i4_5_c_int function hipMemcpy2DAsync_i4_6_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i4_6_c_size_t function hipMemcpy2DAsync_i4_6_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i4_6_c_int function hipMemcpy2DAsync_i4_7_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i4_7_c_size_t function hipMemcpy2DAsync_i4_7_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i4_7_c_int function hipMemcpy2DAsync_i8_0_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int64_t), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i8_0_c_size_t function hipMemcpy2DAsync_i8_0_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int64_t), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i8_0_c_int function hipMemcpy2DAsync_i8_1_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i8_1_c_size_t function hipMemcpy2DAsync_i8_1_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i8_1_c_int function hipMemcpy2DAsync_i8_2_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i8_2_c_size_t function hipMemcpy2DAsync_i8_2_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i8_2_c_int function hipMemcpy2DAsync_i8_3_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i8_3_c_size_t function hipMemcpy2DAsync_i8_3_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i8_3_c_int function hipMemcpy2DAsync_i8_4_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i8_4_c_size_t function hipMemcpy2DAsync_i8_4_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i8_4_c_int function hipMemcpy2DAsync_i8_5_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i8_5_c_size_t function hipMemcpy2DAsync_i8_5_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i8_5_c_int function hipMemcpy2DAsync_i8_6_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i8_6_c_size_t function hipMemcpy2DAsync_i8_6_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i8_6_c_int function hipMemcpy2DAsync_i8_7_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i8_7_c_size_t function hipMemcpy2DAsync_i8_7_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height integer(c_int64_t), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_i8_7_c_int function hipMemcpy2DAsync_r4_0_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_float), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r4_0_c_size_t function hipMemcpy2DAsync_r4_0_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_float), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r4_0_c_int function hipMemcpy2DAsync_r4_1_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_float), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r4_1_c_size_t function hipMemcpy2DAsync_r4_1_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_float), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r4_1_c_int function hipMemcpy2DAsync_r4_2_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r4_2_c_size_t function hipMemcpy2DAsync_r4_2_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r4_2_c_int function hipMemcpy2DAsync_r4_3_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r4_3_c_size_t function hipMemcpy2DAsync_r4_3_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r4_3_c_int function hipMemcpy2DAsync_r4_4_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r4_4_c_size_t function hipMemcpy2DAsync_r4_4_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r4_4_c_int function hipMemcpy2DAsync_r4_5_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r4_5_c_size_t function hipMemcpy2DAsync_r4_5_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r4_5_c_int function hipMemcpy2DAsync_r4_6_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r4_6_c_size_t function hipMemcpy2DAsync_r4_6_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r4_6_c_int function hipMemcpy2DAsync_r4_7_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r4_7_c_size_t function hipMemcpy2DAsync_r4_7_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_float), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_float), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 4_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r4_7_c_int function hipMemcpy2DAsync_r8_0_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_double), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r8_0_c_size_t function hipMemcpy2DAsync_r8_0_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_double), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r8_0_c_int function hipMemcpy2DAsync_r8_1_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_double), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r8_1_c_size_t function hipMemcpy2DAsync_r8_1_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_double), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r8_1_c_int function hipMemcpy2DAsync_r8_2_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r8_2_c_size_t function hipMemcpy2DAsync_r8_2_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r8_2_c_int function hipMemcpy2DAsync_r8_3_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r8_3_c_size_t function hipMemcpy2DAsync_r8_3_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r8_3_c_int function hipMemcpy2DAsync_r8_4_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r8_4_c_size_t function hipMemcpy2DAsync_r8_4_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r8_4_c_int function hipMemcpy2DAsync_r8_5_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r8_5_c_size_t function hipMemcpy2DAsync_r8_5_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r8_5_c_int function hipMemcpy2DAsync_r8_6_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r8_6_c_size_t function hipMemcpy2DAsync_r8_6_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r8_6_c_int function hipMemcpy2DAsync_r8_7_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r8_7_c_size_t function hipMemcpy2DAsync_r8_7_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none real(c_double), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height real(c_double), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_r8_7_c_int function hipMemcpy2DAsync_c4_0_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_float_complex), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c4_0_c_size_t function hipMemcpy2DAsync_c4_0_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_float_complex), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c4_0_c_int function hipMemcpy2DAsync_c4_1_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c4_1_c_size_t function hipMemcpy2DAsync_c4_1_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c4_1_c_int function hipMemcpy2DAsync_c4_2_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c4_2_c_size_t function hipMemcpy2DAsync_c4_2_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c4_2_c_int function hipMemcpy2DAsync_c4_3_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c4_3_c_size_t function hipMemcpy2DAsync_c4_3_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c4_3_c_int function hipMemcpy2DAsync_c4_4_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c4_4_c_size_t function hipMemcpy2DAsync_c4_4_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c4_4_c_int function hipMemcpy2DAsync_c4_5_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c4_5_c_size_t function hipMemcpy2DAsync_c4_5_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c4_5_c_int function hipMemcpy2DAsync_c4_6_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c4_6_c_size_t function hipMemcpy2DAsync_c4_6_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c4_6_c_int function hipMemcpy2DAsync_c4_7_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c4_7_c_size_t function hipMemcpy2DAsync_c4_7_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_float_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 8_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c4_7_c_int function hipMemcpy2DAsync_c8_0_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_double_complex), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c8_0_c_size_t function hipMemcpy2DAsync_c8_0_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_double_complex), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c8_0_c_int function hipMemcpy2DAsync_c8_1_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c8_1_c_size_t function hipMemcpy2DAsync_c8_1_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c8_1_c_int function hipMemcpy2DAsync_c8_2_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c8_2_c_size_t function hipMemcpy2DAsync_c8_2_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c8_2_c_int function hipMemcpy2DAsync_c8_3_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c8_3_c_size_t function hipMemcpy2DAsync_c8_3_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c8_3_c_int function hipMemcpy2DAsync_c8_4_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c8_4_c_size_t function hipMemcpy2DAsync_c8_4_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c8_4_c_int function hipMemcpy2DAsync_c8_5_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c8_5_c_size_t function hipMemcpy2DAsync_c8_5_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c8_5_c_int function hipMemcpy2DAsync_c8_6_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c8_6_c_size_t function hipMemcpy2DAsync_c8_6_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c8_6_c_int function hipMemcpy2DAsync_c8_7_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c8_7_c_size_t function hipMemcpy2DAsync_c8_7_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height complex(c_double_complex), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 16_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_c8_7_c_int function hipMemcpy2DAsync_l_0_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height logical(c_bool), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_l_0_c_size_t function hipMemcpy2DAsync_l_0_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height logical(c_bool), target, intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2DAsync_(c_loc(dest), b*int(dpitch,c_size_t), & c_loc(src), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_l_0_c_int function hipMemcpy2DAsync_l_1_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_l_1_c_size_t function hipMemcpy2DAsync_l_1_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1)), b*int(dpitch,c_size_t), & c_loc(src(1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_l_1_c_int function hipMemcpy2DAsync_l_2_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_l_2_c_size_t function hipMemcpy2DAsync_l_2_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_l_2_c_int function hipMemcpy2DAsync_l_3_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_l_3_c_size_t function hipMemcpy2DAsync_l_3_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_l_3_c_int function hipMemcpy2DAsync_l_4_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_l_4_c_size_t function hipMemcpy2DAsync_l_4_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_l_4_c_int function hipMemcpy2DAsync_l_5_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_l_5_c_size_t function hipMemcpy2DAsync_l_5_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_l_5_c_int function hipMemcpy2DAsync_l_6_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_l_6_c_size_t function hipMemcpy2DAsync_l_6_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_l_6_c_int function hipMemcpy2DAsync_l_7_c_size_t(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_size_t), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_l_7_c_size_t function hipMemcpy2DAsync_l_7_c_int(dest, dpitch, src, spitch, width, height, myKind, stream) result(res) use iso_c_binding implicit none logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(inout) :: dest integer(c_int), value :: dpitch, spitch, width, height logical(c_bool), target, dimension(:,:,:,:,:,:,:), intent(in) :: src integer(c_int), value :: myKind type(c_ptr), value :: stream integer(c_int) :: res integer(c_size_t) :: b b = 1_c_size_t res = hipMemcpy2DAsync_(c_loc(dest(1,1,1,1,1,1,1)), b*int(dpitch,c_size_t), & c_loc(src(1,1,1,1,1,1,1)), b*int(spitch,c_size_t), b*int(width,c_size_t), & int(height,c_size_t), myKind, stream) end function hipMemcpy2DAsync_l_7_c_int #endif end module hipfort_hipmemcpy hipfort-rocm-10.0.0/lib/hipfort/hipfort_hiprand.F90000066400000000000000000001602571524740623400221040ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_hiprand use hipfort_hiprand_enums implicit none !> \brief Creates a new random number generator. !> !> Creates a new random number generator of type \p rng_type, !> and returns it in \p generator. That generator will use !> GPU to create random numbers. !> !> Values for \p rng_type are: !> - HIPRAND_RNG_PSEUDO_DEFAULT !> - HIPRAND_RNG_PSEUDO_XORWOW !> - HIPRAND_RNG_PSEUDO_MRG32K3A !> - HIPRAND_RNG_PSEUDO_MTGP32 !> - HIPRAND_RNG_PSEUDO_MT19937 !> - HIPRAND_RNG_PSEUDO_PHILOX4_32_10 !> - HIPRAND_RNG_QUASI_DEFAULT !> - HIPRAND_RNG_QUASI_SOBOL32 !> - HIPRAND_RNG_QUASI_SCRAMBLED_SOBOL32 !> - HIPRAND_RNG_QUASI_SOBOL64 !> - HIPRAND_RNG_QUASI_SCRAMBLED_SOBOL64 !> !> \param generator - Pointer to generator !> \param rng_type - Type of random number generator to create !> !> \return !> - HIPRAND_STATUS_ALLOCATION_FAILED, if memory allocation failed !> - HIPRAND_STATUS_INITIALIZATION_FAILED if there was a problem setting up the GPU !> - HIPRAND_STATUS_VERSION_MISMATCH if the header file version does not match the !> dynamically linked library version !> - HIPRAND_STATUS_TYPE_ERROR if the value for \p rng_type is invalid !> - HIPRAND_STATUS_NOT_IMPLEMENTED if generator of type \p rng_type is not implemented yet !> - HIPRAND_STATUS_SUCCESS if generator was created successfully interface hiprandCreateGenerator #ifdef USE_CUDA_NAMES function hiprandCreateGenerator_(generator,rng_type) bind(c, name="curandCreateGenerator") #else function hiprandCreateGenerator_(generator,rng_type) bind(c, name="hiprandCreateGenerator") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandCreateGenerator_ type(c_ptr) :: generator integer(kind(HIPRAND_RNG_TEST)),value :: rng_type end function end interface !> \brief Creates a new random number generator on host. !> !> Creates a new host random number generator of type \p rng_type !> and returns it in \p generator. Created generator will use !> host CPU to generate random numbers. !> !> Values for \p rng_type are: !> - HIPRAND_RNG_PSEUDO_DEFAULT !> - HIPRAND_RNG_PSEUDO_XORWOW !> - HIPRAND_RNG_PSEUDO_MRG32K3A !> - HIPRAND_RNG_PSEUDO_MTGP32 !> - HIPRAND_RNG_PSEUDO_MT19937 !> - HIPRAND_RNG_PSEUDO_PHILOX4_32_10 !> - HIPRAND_RNG_QUASI_DEFAULT !> - HIPRAND_RNG_QUASI_SOBOL32 !> - HIPRAND_RNG_QUASI_SCRAMBLED_SOBOL32 !> - HIPRAND_RNG_QUASI_SOBOL64 !> - HIPRAND_RNG_QUASI_SCRAMBLED_SOBOL64 !> !> \param generator - Pointer to generator !> \param rng_type - Type of random number generator to create !> !> \return !> - HIPRAND_STATUS_ALLOCATION_FAILED, if memory allocation failed !> - HIPRAND_STATUS_VERSION_MISMATCH if the header file version does not match the !> dynamically linked library version !> - HIPRAND_STATUS_TYPE_ERROR if the value for \p rng_type is invalid !> - HIPRAND_STATUS_NOT_IMPLEMENTED if host generator of type \p rng_type is not implemented yet !> - HIPRAND_STATUS_SUCCESS if generator was created successfully interface hiprandCreateGeneratorHost #ifdef USE_CUDA_NAMES function hiprandCreateGeneratorHost_(generator,rng_type) & bind(c, name="curandCreateGeneratorHost") #else function hiprandCreateGeneratorHost_(generator,rng_type) & bind(c, name="hiprandCreateGeneratorHost") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandCreateGeneratorHost_ type(c_ptr) :: generator integer(kind(HIPRAND_RNG_TEST)),value :: rng_type end function end interface !> \brief Destroys random number generator. !> !> Destroys random number generator and frees related memory. !> !> \param generator - Generator to be destroyed !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was not initialized !> - HIPRAND_STATUS_SUCCESS if generator was destroyed successfully interface hiprandDestroyGenerator #ifdef USE_CUDA_NAMES function hiprandDestroyGenerator_(generator) bind(c, name="curandDestroyGenerator") #else function hiprandDestroyGenerator_(generator) bind(c, name="hiprandDestroyGenerator") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandDestroyGenerator_ type(c_ptr),value :: generator end function end interface !> \brief Generates uniformly distributed 32-bit unsigned integers. !> !> Generates \p n uniformly distributed 32-bit unsigned integers and !> saves them to \p output_data. !> !> Generated numbers are between \p 0 and \p 2^32, including \p 0 and !> excluding \p 2^32. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of 32-bit unsigned integers to generate !> !> Note: \p generator must be not be of type \p HIPRAND_RNG_QUASI_SOBOL64 !> or \p HIPRAND_RNG_QUASI_SCRAMBLED_SOBOL64. !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was not initialized !> - HIPRAND_STATUS_LAUNCH_FAILURE if generator failed to launch kernel !> - HIPRAND_STATUS_SUCCESS if random numbers were successfully generated interface hiprandGenerate #ifdef USE_CUDA_NAMES function hiprandGenerate_(generator,output_data,n) bind(c, name="curandGenerate") #else function hiprandGenerate_(generator,output_data,n) bind(c, name="hiprandGenerate") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerate_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hiprandGenerate_assumed_rank #else module procedure & hiprandGenerate_rank_0,& hiprandGenerate_rank_1 #endif #endif end interface !> \brief Generates uniformly distributed 8-bit unsigned integers. !> !> Generates \p n uniformly distributed 8-bit unsigned integers and !> saves them to \p output_data. !> !> Generated numbers are between \p 0 and \p 2^8, including \p 0 and !> excluding \p 2^8. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of 8-bit unsigned integers to generate !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was not initialized !> - HIPRAND_STATUS_LAUNCH_FAILURE if generator failed to launch kernel !> - HIPRAND_STATUS_SUCCESS if random numbers were successfully generated #ifndef USE_CUDA_NAMES interface hiprandGenerateChar function hiprandGenerateChar_(generator,output_data,n) bind(c, name="hiprandGenerateChar") use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateChar_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n end function end interface #endif !> \brief Generates uniformly distributed 16-bit unsigned integers. !> !> Generates \p n uniformly distributed 16-bit unsigned integers and !> saves them to \p output_data. !> !> Generated numbers are between \p 0 and \p 2^16, including \p 0 and !> excluding \p 2^16. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of 16-bit unsigned integers to generate !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was not initialized !> - HIPRAND_STATUS_LAUNCH_FAILURE if generator failed to launch kernel !> - HIPRAND_STATUS_SUCCESS if random numbers were successfully generated #ifndef USE_CUDA_NAMES interface hiprandGenerateShort function hiprandGenerateShort_(generator,output_data,n) bind(c, name="hiprandGenerateShort") use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateShort_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n end function end interface #endif !> \brief Generates uniformly distributed 64-bit unsigned integers. !> !> Generates \p n uniformly distributed 64-bit unsigned integers and !> saves them to \p output_data. !> !> Generated numbers are between \p 0 and \p 2^64, including \p 0 and !> excluding \p 2^64. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of 64-bit unsigned integers to generate !> !> Note: \p generator must be of type \p HIPRAND_RNG_QUASI_SOBOL64 !> or \p HIPRAND_RNG_QUASI_SCRAMBLED_SOBOL64. !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was not initialized !> - HIPRAND_STATUS_LAUNCH_FAILURE if generator failed to launch kernel !> - HIPRAND_STATUS_SUCCESS if random numbers were successfully generated interface hiprandGenerateLongLong #ifdef USE_CUDA_NAMES function hiprandGenerateLongLong_(generator,output_data,n) & bind(c, name="curandGenerateLongLong") #else function hiprandGenerateLongLong_(generator,output_data,n) & bind(c, name="hiprandGenerateLongLong") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateLongLong_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hiprandGenerateLongLong_assumed_rank #else module procedure & hiprandGenerateLongLong_rank_0,& hiprandGenerateLongLong_rank_1 #endif #endif end interface !> \brief Generates uniformly distributed floats. !> !> Generates \p n uniformly distributed 32-bit floating-point values !> and saves them to \p output_data. !> !> Generated numbers are between \p 0.0f and \p 1.0f, excluding \p 0.0f and !> including \p 1.0f. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of floats to generate !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was not initialized !> - HIPRAND_STATUS_LAUNCH_FAILURE if generator failed to launch kernel !> - HIPRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not a multiple of the dimension !> of used quasi-random generator !> - HIPRAND_STATUS_SUCCESS if random numbers were successfully generated interface hiprandGenerateUniform #ifdef USE_CUDA_NAMES function hiprandGenerateUniform_(generator,output_data,n) bind(c, name="curandGenerateUniform") #else function hiprandGenerateUniform_(generator,output_data,n) bind(c, name="hiprandGenerateUniform") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateUniform_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hiprandGenerateUniform_assumed_rank #else module procedure & hiprandGenerateUniform_rank_0,& hiprandGenerateUniform_rank_1 #endif #endif end interface !> \brief Generates uniformly distributed double-precision floating-point values. !> !> Generates \p n uniformly distributed 64-bit double-precision floating-point !> values and saves them to \p output_data. !> !> Generated numbers are between \p 0.0 and \p 1.0, excluding \p 0.0 and !> including \p 1.0. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of floats to generate !> !> Note: When \p generator is of type: \p HIPRAND_RNG_PSEUDO_MRG32K3A, !> \p HIPRAND_RNG_PSEUDO_MTGP32, \p HIPRAND_RNG_QUASI_SOBOL32, or !> \p HIPRAND_RNG_QUASI_SCRAMBLED_SOBOL32 then the returned \p double !> values are generated from only 32 random bits !> each (one unsigned int value per one generated \p double). !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was not initialized !> - HIPRAND_STATUS_LAUNCH_FAILURE if generator failed to launch kernel !> - HIPRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not a multiple of the dimension !> of used quasi-random generator !> - HIPRAND_STATUS_SUCCESS if random numbers were successfully generated interface hiprandGenerateUniformDouble #ifdef USE_CUDA_NAMES function hiprandGenerateUniformDouble_(generator,output_data,n) & bind(c, name="curandGenerateUniformDouble") #else function hiprandGenerateUniformDouble_(generator,output_data,n) & bind(c, name="hiprandGenerateUniformDouble") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateUniformDouble_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hiprandGenerateUniformDouble_assumed_rank #else module procedure & hiprandGenerateUniformDouble_rank_0,& hiprandGenerateUniformDouble_rank_1 #endif #endif end interface !> \brief Generates uniformly distributed half-precision floating-point values. !> !> Generates \p n uniformly distributed 16-bit half-precision floating-point !> values and saves them to \p output_data. !> !> Generated numbers are between \p 0.0 and \p 1.0, excluding \p 0.0 and !> including \p 1.0. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of halfs to generate !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was not initialized !> - HIPRAND_STATUS_LAUNCH_FAILURE if generator failed to launch kernel !> - HIPRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not a multiple of the dimension !> of used quasi-random generator !> - HIPRAND_STATUS_SUCCESS if random numbers were successfully generated #ifndef USE_CUDA_NAMES interface hiprandGenerateUniformHalf function hiprandGenerateUniformHalf_(generator,output_data,n) & bind(c, name="hiprandGenerateUniformHalf") use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateUniformHalf_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n end function end interface #endif !> \brief Generates normally distributed floats. !> !> Generates \p n normally distributed 32-bit floating-point !> values and saves them to \p output_data. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of floats to generate !> \param mean - Mean value of normal distribution !> \param stddev - Standard deviation value of normal distribution !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was not initialized !> - HIPRAND_STATUS_LAUNCH_FAILURE if generator failed to launch kernel !> - HIPRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not even, \p output_data is not !> aligned to \p sizeof(float2) bytes, or \p n is not a multiple of the dimension !> of used quasi-random generator !> - HIPRAND_STATUS_SUCCESS if random numbers were successfully generated interface hiprandGenerateNormal #ifdef USE_CUDA_NAMES function hiprandGenerateNormal_(generator,output_data,n,mean,stddev) & bind(c, name="curandGenerateNormal") #else function hiprandGenerateNormal_(generator,output_data,n,mean,stddev) & bind(c, name="hiprandGenerateNormal") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateNormal_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n real(c_float),value :: mean real(c_float),value :: stddev end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hiprandGenerateNormal_assumed_rank #else module procedure & hiprandGenerateNormal_rank_0,& hiprandGenerateNormal_rank_1 #endif #endif end interface !> \brief Generates normally distributed doubles. !> !> Generates \p n normally distributed 64-bit double-precision floating-point !> numbers and saves them to \p output_data. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of doubles to generate !> \param mean - Mean value of normal distribution !> \param stddev - Standard deviation value of normal distribution !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was not initialized !> - HIPRAND_STATUS_LAUNCH_FAILURE if generator failed to launch kernel !> - HIPRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not even, \p output_data is not !> aligned to \p sizeof(double2) bytes, or \p n is not a multiple of the dimension !> of used quasi-random generator !> - HIPRAND_STATUS_SUCCESS if random numbers were successfully generated interface hiprandGenerateNormalDouble #ifdef USE_CUDA_NAMES function hiprandGenerateNormalDouble_(generator,output_data,n,mean,stddev) & bind(c, name="curandGenerateNormalDouble") #else function hiprandGenerateNormalDouble_(generator,output_data,n,mean,stddev) & bind(c, name="hiprandGenerateNormalDouble") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateNormalDouble_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n real(c_double),value :: mean real(c_double),value :: stddev end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hiprandGenerateNormalDouble_assumed_rank #else module procedure & hiprandGenerateNormalDouble_rank_0,& hiprandGenerateNormalDouble_rank_1 #endif #endif end interface !> \brief Generates normally distributed halfs. !> !> Generates \p n normally distributed 16-bit half-precision floating-point !> numbers and saves them to \p output_data. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of halfs to generate !> \param mean - Mean value of normal distribution !> \param stddev - Standard deviation value of normal distribution !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was not initialized !> - HIPRAND_STATUS_LAUNCH_FAILURE if generator failed to launch kernel !> - HIPRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not even, \p output_data is not !> aligned to \p sizeof(half2) bytes, or \p n is not a multiple of the dimension !> of used quasi-random generator !> - HIPRAND_STATUS_SUCCESS if random numbers were successfully generated #ifndef USE_CUDA_NAMES interface hiprandGenerateNormalHalf function hiprandGenerateNormalHalf_(generator,output_data,n,mean,stddev) & bind(c, name="hiprandGenerateNormalHalf") use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateNormalHalf_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n integer(c_short),value :: mean integer(c_short),value :: stddev end function end interface #endif !> \brief Generates log-normally distributed floats. !> !> Generates \p n log-normally distributed 32-bit floating-point values !> and saves them to \p output_data. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of floats to generate !> \param mean - Mean value of log normal distribution !> \param stddev - Standard deviation value of log normal distribution !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was not initialized !> - HIPRAND_STATUS_LAUNCH_FAILURE if generator failed to launch kernel !> - HIPRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not even, \p output_data is not !> aligned to \p sizeof(float2) bytes, or \p n is not a multiple of the dimension !> of used quasi-random generator !> - HIPRAND_STATUS_SUCCESS if random numbers were successfully generated interface hiprandGenerateLogNormal #ifdef USE_CUDA_NAMES function hiprandGenerateLogNormal_(generator,output_data,n,mean,stddev) & bind(c, name="curandGenerateLogNormal") #else function hiprandGenerateLogNormal_(generator,output_data,n,mean,stddev) & bind(c, name="hiprandGenerateLogNormal") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateLogNormal_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n real(c_float),value :: mean real(c_float),value :: stddev end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hiprandGenerateLogNormal_assumed_rank #else module procedure & hiprandGenerateLogNormal_rank_0,& hiprandGenerateLogNormal_rank_1 #endif #endif end interface !> \brief Generates log-normally distributed doubles. !> !> Generates \p n log-normally distributed 64-bit double-precision floating-point !> values and saves them to \p output_data. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of doubles to generate !> \param mean - Mean value of log normal distribution !> \param stddev - Standard deviation value of log normal distribution !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was not initialized !> - HIPRAND_STATUS_LAUNCH_FAILURE if generator failed to launch kernel !> - HIPRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not even, \p output_data is not !> aligned to \p sizeof(double2) bytes, or \p n is not a multiple of the dimension !> of used quasi-random generator !> - HIPRAND_STATUS_SUCCESS if random numbers were successfully generated interface hiprandGenerateLogNormalDouble #ifdef USE_CUDA_NAMES function hiprandGenerateLogNormalDouble_(generator,output_data,n,mean,stddev) & bind(c, name="curandGenerateLogNormalDouble") #else function hiprandGenerateLogNormalDouble_(generator,output_data,n,mean,stddev) & bind(c, name="hiprandGenerateLogNormalDouble") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateLogNormalDouble_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n real(c_double),value :: mean real(c_double),value :: stddev end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hiprandGenerateLogNormalDouble_assumed_rank #else module procedure & hiprandGenerateLogNormalDouble_rank_0,& hiprandGenerateLogNormalDouble_rank_1 #endif #endif end interface !> \brief Generates log-normally distributed halfs. !> !> Generates \p n log-normally distributed 16-bit half-precision floating-point !> values and saves them to \p output_data. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of halfs to generate !> \param mean - Mean value of log normal distribution !> \param stddev - Standard deviation value of log normal distribution !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was not initialized !> - HIPRAND_STATUS_LAUNCH_FAILURE if generator failed to launch kernel !> - HIPRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not even, \p output_data is not !> aligned to \p sizeof(half2) bytes, or \p n is not a multiple of the dimension !> of used quasi-random generator !> - HIPRAND_STATUS_SUCCESS if random numbers were successfully generated #ifndef USE_CUDA_NAMES interface hiprandGenerateLogNormalHalf function hiprandGenerateLogNormalHalf_(generator,output_data,n,mean,stddev) & bind(c, name="hiprandGenerateLogNormalHalf") use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateLogNormalHalf_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n integer(c_short),value :: mean integer(c_short),value :: stddev end function end interface #endif !> \brief Generates Poisson-distributed 32-bit unsigned integers. !> !> Generates \p n Poisson-distributed 32-bit unsigned integers and !> saves them to \p output_data. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of 32-bit unsigned integers to generate !> \param lambda - lambda for the Poisson distribution !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was not initialized !> - HIPRAND_STATUS_LAUNCH_FAILURE if generator failed to launch kernel !> - HIPRAND_STATUS_OUT_OF_RANGE if lambda is non-positive !> - HIPRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not a multiple of the dimension !> of used quasi-random generator !> - HIPRAND_STATUS_SUCCESS if random numbers were successfully generated interface hiprandGeneratePoisson #ifdef USE_CUDA_NAMES function hiprandGeneratePoisson_(generator,output_data,n,lambda) & bind(c, name="curandGeneratePoisson") #else function hiprandGeneratePoisson_(generator,output_data,n,lambda) & bind(c, name="hiprandGeneratePoisson") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGeneratePoisson_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n real(c_double),value :: lambda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hiprandGeneratePoisson_assumed_rank #else module procedure & hiprandGeneratePoisson_rank_0,& hiprandGeneratePoisson_rank_1 #endif #endif end interface !> \brief Initializes the generator's state on GPU or host. !> !> Initializes the generator's state on GPU or host. !> !> If hiprandGenerateSeeds() was not called for a generator, it will be !> automatically called by functions which generates random numbers like !> hiprandGenerate(), hiprandGenerateUniform(), hiprandGenerateNormal() etc. !> !> \param generator - Generator to initialize !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was never created !> - HIPRAND_STATUS_PREEXISTING_FAILURE if there was an existing error from !> a previous kernel launch !> - HIPRAND_STATUS_LAUNCH_FAILURE if the kernel launch failed for any reason !> - HIPRAND_STATUS_SUCCESS if the seeds were generated successfully interface hiprandGenerateSeeds #ifdef USE_CUDA_NAMES function hiprandGenerateSeeds_(generator) bind(c, name="curandGenerateSeeds") #else function hiprandGenerateSeeds_(generator) bind(c, name="hiprandGenerateSeeds") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateSeeds_ type(c_ptr),value :: generator end function end interface !> \brief Sets the current stream for kernel launches. !> !> Sets the current stream for all kernel launches of the generator. !> All functions will use this stream. !> !> \param generator - Generator to modify !> \param stream - Stream to use or NULL for default stream !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was not initialized !> - HIPRAND_STATUS_SUCCESS if stream was set successfully interface hiprandSetStream #ifdef USE_CUDA_NAMES function hiprandSetStream_(generator,stream) bind(c, name="curandSetStream") #else function hiprandSetStream_(generator,stream) bind(c, name="hiprandSetStream") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandSetStream_ type(c_ptr),value :: generator type(c_ptr),value :: stream end function end interface !> \brief Sets the seed of a pseudo-random number generator. !> !> Sets the seed of the pseudo-random number generator. !> !> - This operation resets the generator's internal state. !> - This operation does not change the generator's offset. !> !> \param generator - Pseudo-random number generator !> \param seed - New seed value !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was not initialized !> - HIPRAND_STATUS_TYPE_ERROR if the generator is a quasi random number generator !> - HIPRAND_STATUS_SUCCESS if seed was set successfully interface hiprandSetPseudoRandomGeneratorSeed #ifdef USE_CUDA_NAMES function hiprandSetPseudoRandomGeneratorSeed_(generator,seed) & bind(c, name="curandSetPseudoRandomGeneratorSeed") #else function hiprandSetPseudoRandomGeneratorSeed_(generator,seed) & bind(c, name="hiprandSetPseudoRandomGeneratorSeed") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandSetPseudoRandomGeneratorSeed_ type(c_ptr),value :: generator integer(c_int64_t),value :: seed end function end interface !> \brief Sets the offset of a random number generator. !> !> Sets the absolute offset of the random number generator. !> !> - This operation resets the generator's internal state. !> - This operation does not change the generator's seed. !> !> Absolute offset cannot be set if generator's type is !> HIPRAND_RNG_PSEUDO_MTGP32 or HIPRAND_RNG_PSEUDO_MT19937. !> !> \param generator - Random number generator !> \param offset - New absolute offset !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was not initialized !> - HIPRAND_STATUS_SUCCESS if offset was successfully set !> - HIPRAND_STATUS_TYPE_ERROR if generator's type is HIPRAND_RNG_PSEUDO_MTGP32 !> or HIPRAND_RNG_PSEUDO_MT19937 interface hiprandSetGeneratorOffset #ifdef USE_CUDA_NAMES function hiprandSetGeneratorOffset_(generator,offset) bind(c, name="curandSetGeneratorOffset") #else function hiprandSetGeneratorOffset_(generator,offset) bind(c, name="hiprandSetGeneratorOffset") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandSetGeneratorOffset_ type(c_ptr),value :: generator integer(c_int64_t),value :: offset end function end interface !> \brief Sets the ordering of a random number generator. !> !> Sets the ordering of the results of a random number generator. !> !> - This operation resets the generator's internal state. !> - This operation does not change the generator's seed. !> !> \param generator - Random number generator !> \param order - New ordering of results !> !> The ordering choices for pseudorandom sequences are !> HIPRAND_ORDERING_PSEUDO_DEFAULT and !> HIPRAND_ORDERING_PSEUDO_LEGACY. !> The default ordering is HIPRAND_ORDERING_PSEUDO_DEFAULT, which is equal to !> HIPRAND_ORDERING_PSEUDO_LEGACY for now. !> !> For quasirandom sequences there is only one ordering, HIPRAND_ORDERING_QUASI_DEFAULT. !> !> \return !> - HIPRAND_STATUS_NOT_INITIALIZED if the generator was not initialized !> - HIPRAND_STATUS_OUT_OF_RANGE if the ordering is not valid !> - HIPRAND_STATUS_SUCCESS if the ordering was successfully set !> - HIPRAND_STATUS_TYPE_ERROR if generator's type is not valid interface hiprandSetGeneratorOrdering #ifdef USE_CUDA_NAMES function hiprandSetGeneratorOrdering_(generator,order) & bind(c, name="curandSetGeneratorOrdering") #else function hiprandSetGeneratorOrdering_(generator,order) & bind(c, name="hiprandSetGeneratorOrdering") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandSetGeneratorOrdering_ type(c_ptr),value :: generator integer(kind(HIPRAND_ORDERING_PSEUDO_BEST)),value :: order end function end interface !> \brief Set the number of dimensions of a quasi-random number generator. !> !> Set the number of dimensions of a quasi-random number generator. !> Supported values of \p dimensions are 1 to 20000. !> !> - This operation resets the generator's internal state. !> - This operation does not change the generator's offset. !> !> \param generator - Quasi-random number generator !> \param dimensions - Number of dimensions !> !> \return !> - HIPRAND_STATUS_NOT_CREATED if the generator wasn't created !> - HIPRAND_STATUS_TYPE_ERROR if the generator is not a quasi-random number generator !> - HIPRAND_STATUS_OUT_OF_RANGE if \p dimensions is out of range !> - HIPRAND_STATUS_SUCCESS if the number of dimensions was set successfully interface hiprandSetQuasiRandomGeneratorDimensions #ifdef USE_CUDA_NAMES function hiprandSetQuasiRandomGeneratorDimensions_(generator,dimensions) & bind(c, name="curandSetQuasiRandomGeneratorDimensions") #else function hiprandSetQuasiRandomGeneratorDimensions_(generator,dimensions) & bind(c, name="hiprandSetQuasiRandomGeneratorDimensions") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandSetQuasiRandomGeneratorDimensions_ type(c_ptr),value :: generator integer(c_int),value :: dimensions end function end interface !> \brief Returns the version number of the cuRAND or rocRAND library. !> !> Returns in \p version the version number of the underlying cuRAND or !> rocRAND library. !> !> \param version - Version of the library !> !> \return !> - HIPRAND_STATUS_OUT_OF_RANGE if \p version is NULL !> - HIPRAND_STATUS_SUCCESS if the version number was successfully returned interface hiprandGetVersion #ifdef USE_CUDA_NAMES function hiprandGetVersion_(version) bind(c, name="curandGetVersion") #else function hiprandGetVersion_(version) bind(c, name="hiprandGetVersion") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGetVersion_ integer(c_int) :: version end function end interface !> \brief Construct the histogram for a Poisson distribution. !> !> Construct the histogram for the Poisson distribution with lambda \p lambda. !> !> \param lambda - lambda for the Poisson distribution !> \param discrete_distribution - pointer to the histogram in device memory !> !> \return !> - HIPRAND_STATUS_ALLOCATION_FAILED if memory could not be allocated !> - HIPRAND_STATUS_OUT_OF_RANGE if \p discrete_distribution pointer was null !> - HIPRAND_STATUS_OUT_OF_RANGE if lambda is non-positive !> - HIPRAND_STATUS_SUCCESS if the histogram was constructed successfully interface hiprandCreatePoissonDistribution #ifdef USE_CUDA_NAMES function hiprandCreatePoissonDistribution_(lambda,discrete_distribution) & bind(c, name="curandCreatePoissonDistribution") #else function hiprandCreatePoissonDistribution_(lambda,discrete_distribution) & bind(c, name="hiprandCreatePoissonDistribution") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandCreatePoissonDistribution_ real(c_double),value :: lambda type(c_ptr) :: discrete_distribution end function end interface !> \brief Destroy the histogram array for a discrete distribution. !> !> Destroy the histogram array for a discrete distribution created by !> hiprandCreatePoissonDistribution. !> !> \param discrete_distribution - pointer to the histogram in device memory !> !> \return !> - HIPRAND_STATUS_OUT_OF_RANGE if \p discrete_distribution was null !> - HIPRAND_STATUS_SUCCESS if the histogram was destroyed successfully interface hiprandDestroyDistribution #ifdef USE_CUDA_NAMES function hiprandDestroyDistribution_(discrete_distribution) & bind(c, name="curandDestroyDistribution") #else function hiprandDestroyDistribution_(discrete_distribution) & bind(c, name="hiprandDestroyDistribution") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandDestroyDistribution_ type(c_ptr),value :: discrete_distribution end function end interface !> \brief Retrieves the Sobol 32 direction vector array specified by \p set. !> !> \param vectors - Pointer to the Sobol 32 direction vector array. !> \param set - Specifies which hipRAND vector set for quasirandom generators to retrieve. !> !> \return !> - HIPRAND_STATUS_OUT_OF_RANGE if \p set is invalid !> - HIPRAND_STATUS_SUCCESS if \p vectors was set successfully interface hiprandGetDirectionVectors32 #ifdef USE_CUDA_NAMES function hiprandGetDirectionVectors32_(vectors,set) bind(c, name="curandGetDirectionVectors32") #else function hiprandGetDirectionVectors32_(vectors,set) bind(c, name="hiprandGetDirectionVectors32") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGetDirectionVectors32_ type(c_ptr) :: vectors integer(kind(HIPRAND_DIRECTION_VECTORS_32_JOEKUO6)),value :: set end function end interface !> \brief Retrieves the Sobol 64 direction vector array specified by \p set. !> !> \param vectors - Pointer to the Sobol 64 direction vector array. !> \param set - Specifies which hipRAND vector set for quasirandom generators to retrieve. !> !> \return !> - HIPRAND_STATUS_OUT_OF_RANGE if \p set is invalid !> - HIPRAND_STATUS_SUCCESS if \p vectors was set successfully interface hiprandGetDirectionVectors64 #ifdef USE_CUDA_NAMES function hiprandGetDirectionVectors64_(vectors,set) bind(c, name="curandGetDirectionVectors64") #else function hiprandGetDirectionVectors64_(vectors,set) bind(c, name="hiprandGetDirectionVectors64") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGetDirectionVectors64_ type(c_ptr) :: vectors integer(kind(HIPRAND_DIRECTION_VECTORS_32_JOEKUO6)),value :: set end function end interface !> \brief Retrieves the scramble constants for 32-bit scrambled Sobol generation. !> !> \param constants - Pointer to the constants pointer. !> !> \return !> - HIPRAND_STATUS_SUCCESS if the pointer was set successfully interface hiprandGetScrambleConstants32 #ifdef USE_CUDA_NAMES function hiprandGetScrambleConstants32_(constants) bind(c, name="curandGetScrambleConstants32") #else function hiprandGetScrambleConstants32_(constants) bind(c, name="hiprandGetScrambleConstants32") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGetScrambleConstants32_ type(c_ptr) :: constants end function end interface !> \brief Retrieves the scramble constants for 64-bit scrambled Sobol generation. !> !> \param constants - Pointer to the constants pointer. !> !> \return !> - HIPRAND_STATUS_SUCCESS if the pointer was set successfully interface hiprandGetScrambleConstants64 #ifdef USE_CUDA_NAMES function hiprandGetScrambleConstants64_(constants) bind(c, name="curandGetScrambleConstants64") #else function hiprandGetScrambleConstants64_(constants) bind(c, name="hiprandGetScrambleConstants64") #endif use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGetScrambleConstants64_ type(c_ptr) :: constants end function end interface #ifdef USE_FPOINTER_INTERFACES contains #ifdef USE_ASSUMED_RANK_INTERFACES function hiprandGenerate_assumed_rank(generator,output_data,n) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerate_assumed_rank type(c_ptr) :: generator integer(c_int),target,contiguous,dimension(..) :: output_data integer(c_size_t) :: n ! hiprandGenerate_assumed_rank = hiprandGenerate_(generator,c_loc(output_data),n) end function #else function hiprandGenerate_rank_0(generator,output_data,n) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerate_rank_0 type(c_ptr) :: generator integer(c_int),target :: output_data integer(c_size_t) :: n ! hiprandGenerate_rank_0 = hiprandGenerate_(generator,c_loc(output_data),n) end function function hiprandGenerate_rank_1(generator,output_data,n) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerate_rank_1 type(c_ptr) :: generator integer(c_int),target,dimension(:) :: output_data integer(c_size_t) :: n ! hiprandGenerate_rank_1 = hiprandGenerate_(generator,c_loc(output_data),n) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hiprandGenerateLongLong_assumed_rank(generator,output_data,n) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateLongLong_assumed_rank type(c_ptr) :: generator integer(c_int64_t),target,contiguous,dimension(..) :: output_data integer(c_size_t) :: n ! hiprandGenerateLongLong_assumed_rank = hiprandGenerateLongLong_(generator, & c_loc(output_data),n) end function #else function hiprandGenerateLongLong_rank_0(generator,output_data,n) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateLongLong_rank_0 type(c_ptr) :: generator integer(c_int64_t),target :: output_data integer(c_size_t) :: n ! hiprandGenerateLongLong_rank_0 = hiprandGenerateLongLong_(generator,c_loc(output_data),n) end function function hiprandGenerateLongLong_rank_1(generator,output_data,n) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateLongLong_rank_1 type(c_ptr) :: generator integer(c_int64_t),target,dimension(:) :: output_data integer(c_size_t) :: n ! hiprandGenerateLongLong_rank_1 = hiprandGenerateLongLong_(generator,c_loc(output_data),n) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hiprandGenerateUniform_assumed_rank(generator,output_data,n) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateUniform_assumed_rank type(c_ptr) :: generator real(c_float),target,contiguous,dimension(..) :: output_data integer(c_size_t) :: n ! hiprandGenerateUniform_assumed_rank = hiprandGenerateUniform_(generator,c_loc(output_data),n) end function #else function hiprandGenerateUniform_rank_0(generator,output_data,n) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateUniform_rank_0 type(c_ptr) :: generator real(c_float),target :: output_data integer(c_size_t) :: n ! hiprandGenerateUniform_rank_0 = hiprandGenerateUniform_(generator,c_loc(output_data),n) end function function hiprandGenerateUniform_rank_1(generator,output_data,n) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateUniform_rank_1 type(c_ptr) :: generator real(c_float),target,dimension(:) :: output_data integer(c_size_t) :: n ! hiprandGenerateUniform_rank_1 = hiprandGenerateUniform_(generator,c_loc(output_data),n) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hiprandGenerateUniformDouble_assumed_rank(generator,output_data,n) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateUniformDouble_assumed_rank type(c_ptr) :: generator real(c_double),target,contiguous,dimension(..) :: output_data integer(c_size_t) :: n ! hiprandGenerateUniformDouble_assumed_rank = hiprandGenerateUniformDouble_(generator, & c_loc(output_data),n) end function #else function hiprandGenerateUniformDouble_rank_0(generator,output_data,n) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateUniformDouble_rank_0 type(c_ptr) :: generator real(c_double),target :: output_data integer(c_size_t) :: n ! hiprandGenerateUniformDouble_rank_0 = hiprandGenerateUniformDouble_(generator, & c_loc(output_data),n) end function function hiprandGenerateUniformDouble_rank_1(generator,output_data,n) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateUniformDouble_rank_1 type(c_ptr) :: generator real(c_double),target,dimension(:) :: output_data integer(c_size_t) :: n ! hiprandGenerateUniformDouble_rank_1 = hiprandGenerateUniformDouble_(generator, & c_loc(output_data),n) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hiprandGenerateNormal_assumed_rank(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateNormal_assumed_rank type(c_ptr) :: generator real(c_float),target,contiguous,dimension(..) :: output_data integer(c_size_t) :: n real(c_float) :: mean real(c_float) :: stddev ! hiprandGenerateNormal_assumed_rank = hiprandGenerateNormal_(generator,c_loc(output_data),n, & mean,stddev) end function #else function hiprandGenerateNormal_rank_0(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateNormal_rank_0 type(c_ptr) :: generator real(c_float),target :: output_data integer(c_size_t) :: n real(c_float) :: mean real(c_float) :: stddev ! hiprandGenerateNormal_rank_0 = hiprandGenerateNormal_(generator,c_loc(output_data),n,mean, & stddev) end function function hiprandGenerateNormal_rank_1(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateNormal_rank_1 type(c_ptr) :: generator real(c_float),target,dimension(:) :: output_data integer(c_size_t) :: n real(c_float) :: mean real(c_float) :: stddev ! hiprandGenerateNormal_rank_1 = hiprandGenerateNormal_(generator,c_loc(output_data),n,mean, & stddev) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hiprandGenerateNormalDouble_assumed_rank(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateNormalDouble_assumed_rank type(c_ptr) :: generator real(c_double),target,contiguous,dimension(..) :: output_data integer(c_size_t) :: n real(c_double) :: mean real(c_double) :: stddev ! hiprandGenerateNormalDouble_assumed_rank = hiprandGenerateNormalDouble_(generator, & c_loc(output_data),n,mean,stddev) end function #else function hiprandGenerateNormalDouble_rank_0(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateNormalDouble_rank_0 type(c_ptr) :: generator real(c_double),target :: output_data integer(c_size_t) :: n real(c_double) :: mean real(c_double) :: stddev ! hiprandGenerateNormalDouble_rank_0 = hiprandGenerateNormalDouble_(generator, & c_loc(output_data),n,mean,stddev) end function function hiprandGenerateNormalDouble_rank_1(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateNormalDouble_rank_1 type(c_ptr) :: generator real(c_double),target,dimension(:) :: output_data integer(c_size_t) :: n real(c_double) :: mean real(c_double) :: stddev ! hiprandGenerateNormalDouble_rank_1 = hiprandGenerateNormalDouble_(generator, & c_loc(output_data),n,mean,stddev) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hiprandGenerateLogNormal_assumed_rank(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateLogNormal_assumed_rank type(c_ptr) :: generator real(c_float),target,contiguous,dimension(..) :: output_data integer(c_size_t) :: n real(c_float) :: mean real(c_float) :: stddev ! hiprandGenerateLogNormal_assumed_rank = hiprandGenerateLogNormal_(generator, & c_loc(output_data),n,mean,stddev) end function #else function hiprandGenerateLogNormal_rank_0(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateLogNormal_rank_0 type(c_ptr) :: generator real(c_float),target :: output_data integer(c_size_t) :: n real(c_float) :: mean real(c_float) :: stddev ! hiprandGenerateLogNormal_rank_0 = hiprandGenerateLogNormal_(generator,c_loc(output_data),n, & mean,stddev) end function function hiprandGenerateLogNormal_rank_1(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateLogNormal_rank_1 type(c_ptr) :: generator real(c_float),target,dimension(:) :: output_data integer(c_size_t) :: n real(c_float) :: mean real(c_float) :: stddev ! hiprandGenerateLogNormal_rank_1 = hiprandGenerateLogNormal_(generator,c_loc(output_data),n, & mean,stddev) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hiprandGenerateLogNormalDouble_assumed_rank(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateLogNormalDouble_assumed_rank type(c_ptr) :: generator real(c_double),target,contiguous,dimension(..) :: output_data integer(c_size_t) :: n real(c_double) :: mean real(c_double) :: stddev ! hiprandGenerateLogNormalDouble_assumed_rank = hiprandGenerateLogNormalDouble_(generator, & c_loc(output_data),n,mean,stddev) end function #else function hiprandGenerateLogNormalDouble_rank_0(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateLogNormalDouble_rank_0 type(c_ptr) :: generator real(c_double),target :: output_data integer(c_size_t) :: n real(c_double) :: mean real(c_double) :: stddev ! hiprandGenerateLogNormalDouble_rank_0 = hiprandGenerateLogNormalDouble_(generator, & c_loc(output_data),n,mean,stddev) end function function hiprandGenerateLogNormalDouble_rank_1(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGenerateLogNormalDouble_rank_1 type(c_ptr) :: generator real(c_double),target,dimension(:) :: output_data integer(c_size_t) :: n real(c_double) :: mean real(c_double) :: stddev ! hiprandGenerateLogNormalDouble_rank_1 = hiprandGenerateLogNormalDouble_(generator, & c_loc(output_data),n,mean,stddev) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hiprandGeneratePoisson_assumed_rank(generator,output_data,n,lambda) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGeneratePoisson_assumed_rank type(c_ptr) :: generator integer(c_int),target,contiguous,dimension(..) :: output_data integer(c_size_t) :: n real(c_double) :: lambda ! hiprandGeneratePoisson_assumed_rank = hiprandGeneratePoisson_(generator,c_loc(output_data), & n,lambda) end function #else function hiprandGeneratePoisson_rank_0(generator,output_data,n,lambda) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGeneratePoisson_rank_0 type(c_ptr) :: generator integer(c_int),target :: output_data integer(c_size_t) :: n real(c_double) :: lambda ! hiprandGeneratePoisson_rank_0 = hiprandGeneratePoisson_(generator,c_loc(output_data),n,lambda) end function function hiprandGeneratePoisson_rank_1(generator,output_data,n,lambda) use iso_c_binding use hipfort_hiprand_enums implicit none integer(kind(HIPRAND_STATUS_SUCCESS)) :: hiprandGeneratePoisson_rank_1 type(c_ptr) :: generator integer(c_int),target,dimension(:) :: output_data integer(c_size_t) :: n real(c_double) :: lambda ! hiprandGeneratePoisson_rank_1 = hiprandGeneratePoisson_(generator,c_loc(output_data),n,lambda) end function #endif #endif end module hipfort_hiprand hipfort-rocm-10.0.0/lib/hipfort/hipfort_hiprand_enums.F90000066400000000000000000000115671524740623400233120ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_hiprand_enums use, intrinsic :: iso_c_binding implicit none ! hiprandStatus enum, bind(c) enumerator :: HIPRAND_STATUS_SUCCESS = 0 enumerator :: HIPRAND_STATUS_VERSION_MISMATCH = 100 enumerator :: HIPRAND_STATUS_NOT_INITIALIZED = 101 enumerator :: HIPRAND_STATUS_ALLOCATION_FAILED = 102 enumerator :: HIPRAND_STATUS_TYPE_ERROR = 103 enumerator :: HIPRAND_STATUS_OUT_OF_RANGE = 104 enumerator :: HIPRAND_STATUS_LENGTH_NOT_MULTIPLE = 105 enumerator :: HIPRAND_STATUS_DOUBLE_PRECISION_REQUIRED = 106 enumerator :: HIPRAND_STATUS_LAUNCH_FAILURE = 201 enumerator :: HIPRAND_STATUS_PREEXISTING_FAILURE = 202 enumerator :: HIPRAND_STATUS_INITIALIZATION_FAILED = 203 enumerator :: HIPRAND_STATUS_ARCH_MISMATCH = 204 enumerator :: HIPRAND_STATUS_INTERNAL_ERROR = 999 enumerator :: HIPRAND_STATUS_NOT_IMPLEMENTED = 1000 end enum ! hiprandRngType enum, bind(c) enumerator :: HIPRAND_RNG_TEST = 0 #ifdef USE_CUDA_NAMES enumerator :: HIPRAND_RNG_PSEUDO_DEFAULT = 100 #else enumerator :: HIPRAND_RNG_PSEUDO_DEFAULT = 400 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPRAND_RNG_PSEUDO_XORWOW = 101 #else enumerator :: HIPRAND_RNG_PSEUDO_XORWOW = 401 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPRAND_RNG_PSEUDO_MRG32K3A = 121 #else enumerator :: HIPRAND_RNG_PSEUDO_MRG32K3A = 402 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPRAND_RNG_PSEUDO_MTGP32 = 141 #else enumerator :: HIPRAND_RNG_PSEUDO_MTGP32 = 403 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPRAND_RNG_PSEUDO_MT19937 = 142 #else enumerator :: HIPRAND_RNG_PSEUDO_MT19937 = 404 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPRAND_RNG_PSEUDO_PHILOX4_32_10 = 161 #else enumerator :: HIPRAND_RNG_PSEUDO_PHILOX4_32_10 = 405 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPRAND_RNG_QUASI_DEFAULT = 200 #else enumerator :: HIPRAND_RNG_QUASI_DEFAULT = 500 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPRAND_RNG_QUASI_SOBOL32 = 201 #else enumerator :: HIPRAND_RNG_QUASI_SOBOL32 = 501 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPRAND_RNG_QUASI_SCRAMBLED_SOBOL32 = 202 #else enumerator :: HIPRAND_RNG_QUASI_SCRAMBLED_SOBOL32 = 502 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPRAND_RNG_QUASI_SOBOL64 = 203 #else enumerator :: HIPRAND_RNG_QUASI_SOBOL64 = 503 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPRAND_RNG_QUASI_SCRAMBLED_SOBOL64 = 204 #else enumerator :: HIPRAND_RNG_QUASI_SCRAMBLED_SOBOL64 = 504 #endif end enum ! hiprandOrdering enum, bind(c) enumerator :: HIPRAND_ORDERING_PSEUDO_BEST = 100 enumerator :: HIPRAND_ORDERING_PSEUDO_DEFAULT = 101 enumerator :: HIPRAND_ORDERING_PSEUDO_SEEDED = 102 enumerator :: HIPRAND_ORDERING_PSEUDO_LEGACY = 103 enumerator :: HIPRAND_ORDERING_PSEUDO_DYNAMIC = 104 enumerator :: HIPRAND_ORDERING_QUASI_DEFAULT = 201 end enum ! hiprandDirectionVectorSet enum, bind(c) enumerator :: HIPRAND_DIRECTION_VECTORS_32_JOEKUO6 = 101 enumerator :: HIPRAND_SCRAMBLED_DIRECTION_VECTORS_32_JOEKUO6 = 102 enumerator :: HIPRAND_DIRECTION_VECTORS_64_JOEKUO6 = 103 enumerator :: HIPRAND_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6 = 104 end enum integer(c_int), parameter :: HIPRAND_VERSION = 300400 integer(c_int), parameter :: HIPRAND_DEFAULT_MAX_BLOCK_SIZE = 256 integer(c_int), parameter :: HIPRAND_DEFAULT_MIN_WARPS_PER_EU = 1 end module hipfort_hiprand_enums hipfort-rocm-10.0.0/lib/hipfort/hipfort_hipsolver.F90000066400000000000000000033030551524740623400224700ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_hipsolver use hipfort_hipsolver_enums implicit none #ifndef USE_CUDA_NAMES interface hipsolverCreate function hipsolverCreate_(handle) bind(c, name="hipsolverCreate") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCreate_ type(c_ptr) :: handle end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDestroy function hipsolverDestroy_(handle) bind(c, name="hipsolverDestroy") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDestroy_ type(c_ptr),value :: handle end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSetStream function hipsolverSetStream_(handle,streamId) bind(c, name="hipsolverSetStream") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSetStream_ type(c_ptr),value :: handle type(c_ptr),value :: streamId end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverGetStream function hipsolverGetStream_(handle,streamId) bind(c, name="hipsolverGetStream") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverGetStream_ type(c_ptr),value :: handle type(c_ptr) :: streamId end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSetDeterministicMode function hipsolverSetDeterministicMode_(handle,mode) & bind(c, name="hipsolverSetDeterministicMode") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSetDeterministicMode_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_DETERMINISTIC_RESULTS)),value :: mode end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverGetDeterministicMode function hipsolverGetDeterministicMode_(handle,mode) & bind(c, name="hipsolverGetDeterministicMode") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverGetDeterministicMode_ type(c_ptr),value :: handle type(c_ptr),value :: mode end function end interface #endif interface hipsolverCreateGesvdjInfo #ifdef USE_CUDA_NAMES function hipsolverCreateGesvdjInfo_(myInfo) bind(c, name="cusolverDnCreateGesvdjInfo") #else function hipsolverCreateGesvdjInfo_(myInfo) bind(c, name="hipsolverCreateGesvdjInfo") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCreateGesvdjInfo_ type(c_ptr) :: myInfo end function end interface interface hipsolverDestroyGesvdjInfo #ifdef USE_CUDA_NAMES function hipsolverDestroyGesvdjInfo_(myInfo) bind(c, name="cusolverDnDestroyGesvdjInfo") #else function hipsolverDestroyGesvdjInfo_(myInfo) bind(c, name="hipsolverDestroyGesvdjInfo") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDestroyGesvdjInfo_ type(c_ptr),value :: myInfo end function end interface interface hipsolverXgesvdjSetMaxSweeps #ifdef USE_CUDA_NAMES function hipsolverXgesvdjSetMaxSweeps_(myInfo,max_sweeps) & bind(c, name="cusolverDnXgesvdjSetMaxSweeps") #else function hipsolverXgesvdjSetMaxSweeps_(myInfo,max_sweeps) & bind(c, name="hipsolverXgesvdjSetMaxSweeps") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverXgesvdjSetMaxSweeps_ type(c_ptr),value :: myInfo integer(c_int),value :: max_sweeps end function end interface interface hipsolverXgesvdjSetSortEig #ifdef USE_CUDA_NAMES function hipsolverXgesvdjSetSortEig_(myInfo,sort_eig) & bind(c, name="cusolverDnXgesvdjSetSortEig") #else function hipsolverXgesvdjSetSortEig_(myInfo,sort_eig) bind(c, name="hipsolverXgesvdjSetSortEig") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverXgesvdjSetSortEig_ type(c_ptr),value :: myInfo integer(c_int),value :: sort_eig end function end interface interface hipsolverXgesvdjSetTolerance #ifdef USE_CUDA_NAMES function hipsolverXgesvdjSetTolerance_(myInfo,tolerance) & bind(c, name="cusolverDnXgesvdjSetTolerance") #else function hipsolverXgesvdjSetTolerance_(myInfo,tolerance) & bind(c, name="hipsolverXgesvdjSetTolerance") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverXgesvdjSetTolerance_ type(c_ptr),value :: myInfo real(c_double),value :: tolerance end function end interface interface hipsolverXgesvdjGetResidual #ifdef USE_CUDA_NAMES function hipsolverXgesvdjGetResidual_(handle,myInfo,residual) & bind(c, name="cusolverDnXgesvdjGetResidual") #else function hipsolverXgesvdjGetResidual_(handle,myInfo,residual) & bind(c, name="hipsolverXgesvdjGetResidual") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverXgesvdjGetResidual_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo real(c_double) :: residual end function end interface interface hipsolverXgesvdjGetSweeps #ifdef USE_CUDA_NAMES function hipsolverXgesvdjGetSweeps_(handle,myInfo,executed_sweeps) & bind(c, name="cusolverDnXgesvdjGetSweeps") #else function hipsolverXgesvdjGetSweeps_(handle,myInfo,executed_sweeps) & bind(c, name="hipsolverXgesvdjGetSweeps") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverXgesvdjGetSweeps_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int) :: executed_sweeps end function end interface interface hipsolverCreateSyevjInfo #ifdef USE_CUDA_NAMES function hipsolverCreateSyevjInfo_(myInfo) bind(c, name="cusolverDnCreateSyevjInfo") #else function hipsolverCreateSyevjInfo_(myInfo) bind(c, name="hipsolverCreateSyevjInfo") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCreateSyevjInfo_ type(c_ptr) :: myInfo end function end interface interface hipsolverDestroySyevjInfo #ifdef USE_CUDA_NAMES function hipsolverDestroySyevjInfo_(myInfo) bind(c, name="cusolverDnDestroySyevjInfo") #else function hipsolverDestroySyevjInfo_(myInfo) bind(c, name="hipsolverDestroySyevjInfo") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDestroySyevjInfo_ type(c_ptr),value :: myInfo end function end interface interface hipsolverXsyevjSetMaxSweeps #ifdef USE_CUDA_NAMES function hipsolverXsyevjSetMaxSweeps_(myInfo,max_sweeps) & bind(c, name="cusolverDnXsyevjSetMaxSweeps") #else function hipsolverXsyevjSetMaxSweeps_(myInfo,max_sweeps) & bind(c, name="hipsolverXsyevjSetMaxSweeps") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverXsyevjSetMaxSweeps_ type(c_ptr),value :: myInfo integer(c_int),value :: max_sweeps end function end interface interface hipsolverXsyevjSetSortEig #ifdef USE_CUDA_NAMES function hipsolverXsyevjSetSortEig_(myInfo,sort_eig) bind(c, name="cusolverDnXsyevjSetSortEig") #else function hipsolverXsyevjSetSortEig_(myInfo,sort_eig) bind(c, name="hipsolverXsyevjSetSortEig") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverXsyevjSetSortEig_ type(c_ptr),value :: myInfo integer(c_int),value :: sort_eig end function end interface interface hipsolverXsyevjSetTolerance #ifdef USE_CUDA_NAMES function hipsolverXsyevjSetTolerance_(myInfo,tolerance) & bind(c, name="cusolverDnXsyevjSetTolerance") #else function hipsolverXsyevjSetTolerance_(myInfo,tolerance) & bind(c, name="hipsolverXsyevjSetTolerance") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverXsyevjSetTolerance_ type(c_ptr),value :: myInfo real(c_double),value :: tolerance end function end interface interface hipsolverXsyevjGetResidual #ifdef USE_CUDA_NAMES function hipsolverXsyevjGetResidual_(handle,myInfo,residual) & bind(c, name="cusolverDnXsyevjGetResidual") #else function hipsolverXsyevjGetResidual_(handle,myInfo,residual) & bind(c, name="hipsolverXsyevjGetResidual") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverXsyevjGetResidual_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo real(c_double) :: residual end function end interface interface hipsolverXsyevjGetSweeps #ifdef USE_CUDA_NAMES function hipsolverXsyevjGetSweeps_(handle,myInfo,executed_sweeps) & bind(c, name="cusolverDnXsyevjGetSweeps") #else function hipsolverXsyevjGetSweeps_(handle,myInfo,executed_sweeps) & bind(c, name="hipsolverXsyevjGetSweeps") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverXsyevjGetSweeps_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int) :: executed_sweeps end function end interface #ifndef USE_CUDA_NAMES interface hipsolverSorgbr_bufferSize function hipsolverSorgbr_bufferSize_(handle,side,m,n,k,A,lda,tau,lwork) & bind(c, name="hipsolverSorgbr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgbr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda real(c_float) :: tau integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSorgbr_bufferSize_assumed_rank #else module procedure & hipsolverSorgbr_bufferSize_rank_0,& hipsolverSorgbr_bufferSize_rank_1,& hipsolverSorgbr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDorgbr_bufferSize function hipsolverDorgbr_bufferSize_(handle,side,m,n,k,A,lda,tau,lwork) & bind(c, name="hipsolverDorgbr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgbr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda real(c_double) :: tau integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDorgbr_bufferSize_assumed_rank #else module procedure & hipsolverDorgbr_bufferSize_rank_0,& hipsolverDorgbr_bufferSize_rank_1,& hipsolverDorgbr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCungbr_bufferSize function hipsolverCungbr_bufferSize_(handle,side,m,n,k,A,lda,tau,lwork) & bind(c, name="hipsolverCungbr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungbr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda complex(c_float_complex) :: tau integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCungbr_bufferSize_assumed_rank #else module procedure & hipsolverCungbr_bufferSize_rank_0,& hipsolverCungbr_bufferSize_rank_1,& hipsolverCungbr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZungbr_bufferSize function hipsolverZungbr_bufferSize_(handle,side,m,n,k,A,lda,tau,lwork) & bind(c, name="hipsolverZungbr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungbr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda complex(c_double_complex) :: tau integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZungbr_bufferSize_assumed_rank #else module procedure & hipsolverZungbr_bufferSize_rank_0,& hipsolverZungbr_bufferSize_rank_1,& hipsolverZungbr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSorgbr function hipsolverSorgbr_(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverSorgbr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgbr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda real(c_float) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSorgbr_assumed_rank #else module procedure & hipsolverSorgbr_rank_0,& hipsolverSorgbr_rank_1,& hipsolverSorgbr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDorgbr function hipsolverDorgbr_(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDorgbr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgbr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda real(c_double) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDorgbr_assumed_rank #else module procedure & hipsolverDorgbr_rank_0,& hipsolverDorgbr_rank_1,& hipsolverDorgbr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCungbr function hipsolverCungbr_(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverCungbr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungbr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda complex(c_float_complex) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCungbr_assumed_rank #else module procedure & hipsolverCungbr_rank_0,& hipsolverCungbr_rank_1,& hipsolverCungbr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZungbr function hipsolverZungbr_(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverZungbr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungbr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda complex(c_double_complex) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZungbr_assumed_rank #else module procedure & hipsolverZungbr_rank_0,& hipsolverZungbr_rank_1,& hipsolverZungbr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSorgqr_bufferSize function hipsolverSorgqr_bufferSize_(handle,m,n,k,A,lda,tau,lwork) & bind(c, name="hipsolverSorgqr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgqr_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda real(c_float) :: tau integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSorgqr_bufferSize_assumed_rank #else module procedure & hipsolverSorgqr_bufferSize_rank_0,& hipsolverSorgqr_bufferSize_rank_1,& hipsolverSorgqr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDorgqr_bufferSize function hipsolverDorgqr_bufferSize_(handle,m,n,k,A,lda,tau,lwork) & bind(c, name="hipsolverDorgqr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgqr_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda real(c_double) :: tau integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDorgqr_bufferSize_assumed_rank #else module procedure & hipsolverDorgqr_bufferSize_rank_0,& hipsolverDorgqr_bufferSize_rank_1,& hipsolverDorgqr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCungqr_bufferSize function hipsolverCungqr_bufferSize_(handle,m,n,k,A,lda,tau,lwork) & bind(c, name="hipsolverCungqr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungqr_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda complex(c_float_complex) :: tau integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCungqr_bufferSize_assumed_rank #else module procedure & hipsolverCungqr_bufferSize_rank_0,& hipsolverCungqr_bufferSize_rank_1,& hipsolverCungqr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZungqr_bufferSize function hipsolverZungqr_bufferSize_(handle,m,n,k,A,lda,tau,lwork) & bind(c, name="hipsolverZungqr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungqr_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda complex(c_double_complex) :: tau integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZungqr_bufferSize_assumed_rank #else module procedure & hipsolverZungqr_bufferSize_rank_0,& hipsolverZungqr_bufferSize_rank_1,& hipsolverZungqr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSorgqr function hipsolverSorgqr_(handle,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverSorgqr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgqr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda real(c_float) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSorgqr_assumed_rank #else module procedure & hipsolverSorgqr_rank_0,& hipsolverSorgqr_rank_1,& hipsolverSorgqr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDorgqr function hipsolverDorgqr_(handle,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDorgqr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgqr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda real(c_double) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDorgqr_assumed_rank #else module procedure & hipsolverDorgqr_rank_0,& hipsolverDorgqr_rank_1,& hipsolverDorgqr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCungqr function hipsolverCungqr_(handle,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverCungqr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungqr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda complex(c_float_complex) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCungqr_assumed_rank #else module procedure & hipsolverCungqr_rank_0,& hipsolverCungqr_rank_1,& hipsolverCungqr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZungqr function hipsolverZungqr_(handle,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverZungqr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungqr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda complex(c_double_complex) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZungqr_assumed_rank #else module procedure & hipsolverZungqr_rank_0,& hipsolverZungqr_rank_1,& hipsolverZungqr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSorgtr_bufferSize function hipsolverSorgtr_bufferSize_(handle,uplo,n,A,lda,tau,lwork) & bind(c, name="hipsolverSorgtr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgtr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float) :: tau integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSorgtr_bufferSize_assumed_rank #else module procedure & hipsolverSorgtr_bufferSize_rank_0,& hipsolverSorgtr_bufferSize_rank_1,& hipsolverSorgtr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDorgtr_bufferSize function hipsolverDorgtr_bufferSize_(handle,uplo,n,A,lda,tau,lwork) & bind(c, name="hipsolverDorgtr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgtr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double) :: tau integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDorgtr_bufferSize_assumed_rank #else module procedure & hipsolverDorgtr_bufferSize_rank_0,& hipsolverDorgtr_bufferSize_rank_1,& hipsolverDorgtr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCungtr_bufferSize function hipsolverCungtr_bufferSize_(handle,uplo,n,A,lda,tau,lwork) & bind(c, name="hipsolverCungtr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungtr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda complex(c_float_complex) :: tau integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCungtr_bufferSize_assumed_rank #else module procedure & hipsolverCungtr_bufferSize_rank_0,& hipsolverCungtr_bufferSize_rank_1,& hipsolverCungtr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZungtr_bufferSize function hipsolverZungtr_bufferSize_(handle,uplo,n,A,lda,tau,lwork) & bind(c, name="hipsolverZungtr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungtr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda complex(c_double_complex) :: tau integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZungtr_bufferSize_assumed_rank #else module procedure & hipsolverZungtr_bufferSize_rank_0,& hipsolverZungtr_bufferSize_rank_1,& hipsolverZungtr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSorgtr function hipsolverSorgtr_(handle,uplo,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverSorgtr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgtr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSorgtr_assumed_rank #else module procedure & hipsolverSorgtr_rank_0,& hipsolverSorgtr_rank_1,& hipsolverSorgtr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDorgtr function hipsolverDorgtr_(handle,uplo,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDorgtr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgtr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDorgtr_assumed_rank #else module procedure & hipsolverDorgtr_rank_0,& hipsolverDorgtr_rank_1,& hipsolverDorgtr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCungtr function hipsolverCungtr_(handle,uplo,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverCungtr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungtr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda complex(c_float_complex) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCungtr_assumed_rank #else module procedure & hipsolverCungtr_rank_0,& hipsolverCungtr_rank_1,& hipsolverCungtr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZungtr function hipsolverZungtr_(handle,uplo,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverZungtr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungtr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda complex(c_double_complex) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZungtr_assumed_rank #else module procedure & hipsolverZungtr_rank_0,& hipsolverZungtr_rank_1,& hipsolverZungtr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSormqr_bufferSize function hipsolverSormqr_bufferSize_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) & bind(c, name="hipsolverSormqr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormqr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda real(c_float) :: tau type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSormqr_bufferSize_assumed_rank #else module procedure & hipsolverSormqr_bufferSize_rank_0,& hipsolverSormqr_bufferSize_rank_1,& hipsolverSormqr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDormqr_bufferSize function hipsolverDormqr_bufferSize_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) & bind(c, name="hipsolverDormqr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormqr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda real(c_double) :: tau type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDormqr_bufferSize_assumed_rank #else module procedure & hipsolverDormqr_bufferSize_rank_0,& hipsolverDormqr_bufferSize_rank_1,& hipsolverDormqr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCunmqr_bufferSize function hipsolverCunmqr_bufferSize_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) & bind(c, name="hipsolverCunmqr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmqr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda complex(c_float_complex) :: tau type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCunmqr_bufferSize_assumed_rank #else module procedure & hipsolverCunmqr_bufferSize_rank_0,& hipsolverCunmqr_bufferSize_rank_1,& hipsolverCunmqr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZunmqr_bufferSize function hipsolverZunmqr_bufferSize_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) & bind(c, name="hipsolverZunmqr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmqr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda complex(c_double_complex) :: tau type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZunmqr_bufferSize_assumed_rank #else module procedure & hipsolverZunmqr_bufferSize_rank_0,& hipsolverZunmqr_bufferSize_rank_1,& hipsolverZunmqr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSormqr function hipsolverSormqr_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="hipsolverSormqr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormqr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda real(c_float) :: tau type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSormqr_assumed_rank #else module procedure & hipsolverSormqr_rank_0,& hipsolverSormqr_rank_1,& hipsolverSormqr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDormqr function hipsolverDormqr_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="hipsolverDormqr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormqr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda real(c_double) :: tau type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDormqr_assumed_rank #else module procedure & hipsolverDormqr_rank_0,& hipsolverDormqr_rank_1,& hipsolverDormqr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCunmqr function hipsolverCunmqr_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="hipsolverCunmqr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmqr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda complex(c_float_complex) :: tau type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCunmqr_assumed_rank #else module procedure & hipsolverCunmqr_rank_0,& hipsolverCunmqr_rank_1,& hipsolverCunmqr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZunmqr function hipsolverZunmqr_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="hipsolverZunmqr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmqr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda complex(c_double_complex) :: tau type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZunmqr_assumed_rank #else module procedure & hipsolverZunmqr_rank_0,& hipsolverZunmqr_rank_1,& hipsolverZunmqr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSormtr_bufferSize function hipsolverSormtr_bufferSize_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) & bind(c, name="hipsolverSormtr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormtr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float) :: tau type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSormtr_bufferSize_assumed_rank #else module procedure & hipsolverSormtr_bufferSize_rank_0,& hipsolverSormtr_bufferSize_rank_1,& hipsolverSormtr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDormtr_bufferSize function hipsolverDormtr_bufferSize_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) & bind(c, name="hipsolverDormtr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormtr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double) :: tau type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDormtr_bufferSize_assumed_rank #else module procedure & hipsolverDormtr_bufferSize_rank_0,& hipsolverDormtr_bufferSize_rank_1,& hipsolverDormtr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCunmtr_bufferSize function hipsolverCunmtr_bufferSize_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) & bind(c, name="hipsolverCunmtr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmtr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda complex(c_float_complex) :: tau type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCunmtr_bufferSize_assumed_rank #else module procedure & hipsolverCunmtr_bufferSize_rank_0,& hipsolverCunmtr_bufferSize_rank_1,& hipsolverCunmtr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZunmtr_bufferSize function hipsolverZunmtr_bufferSize_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) & bind(c, name="hipsolverZunmtr_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmtr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda complex(c_double_complex) :: tau type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZunmtr_bufferSize_assumed_rank #else module procedure & hipsolverZunmtr_bufferSize_rank_0,& hipsolverZunmtr_bufferSize_rank_1,& hipsolverZunmtr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSormtr function hipsolverSormtr_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="hipsolverSormtr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormtr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float) :: tau type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSormtr_assumed_rank #else module procedure & hipsolverSormtr_rank_0,& hipsolverSormtr_rank_1,& hipsolverSormtr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDormtr function hipsolverDormtr_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="hipsolverDormtr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormtr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double) :: tau type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDormtr_assumed_rank #else module procedure & hipsolverDormtr_rank_0,& hipsolverDormtr_rank_1,& hipsolverDormtr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCunmtr function hipsolverCunmtr_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="hipsolverCunmtr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmtr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda complex(c_float_complex) :: tau type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCunmtr_assumed_rank #else module procedure & hipsolverCunmtr_rank_0,& hipsolverCunmtr_rank_1,& hipsolverCunmtr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZunmtr function hipsolverZunmtr_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="hipsolverZunmtr") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmtr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda complex(c_double_complex) :: tau type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZunmtr_assumed_rank #else module procedure & hipsolverZunmtr_rank_0,& hipsolverZunmtr_rank_1,& hipsolverZunmtr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSgebrd_bufferSize function hipsolverSgebrd_bufferSize_(handle,m,n,lwork) & bind(c, name="hipsolverSgebrd_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgebrd_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int) :: lwork end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDgebrd_bufferSize function hipsolverDgebrd_bufferSize_(handle,m,n,lwork) & bind(c, name="hipsolverDgebrd_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgebrd_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int) :: lwork end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCgebrd_bufferSize function hipsolverCgebrd_bufferSize_(handle,m,n,lwork) & bind(c, name="hipsolverCgebrd_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgebrd_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int) :: lwork end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZgebrd_bufferSize function hipsolverZgebrd_bufferSize_(handle,m,n,lwork) & bind(c, name="hipsolverZgebrd_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgebrd_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int) :: lwork end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSgebrd function hipsolverSgebrd_(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) & bind(c, name="hipsolverSgebrd") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgebrd_ 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 type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSgebrd_assumed_rank #else module procedure & hipsolverSgebrd_rank_0,& hipsolverSgebrd_rank_1,& hipsolverSgebrd_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDgebrd function hipsolverDgebrd_(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) & bind(c, name="hipsolverDgebrd") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgebrd_ 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 type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDgebrd_assumed_rank #else module procedure & hipsolverDgebrd_rank_0,& hipsolverDgebrd_rank_1,& hipsolverDgebrd_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCgebrd function hipsolverCgebrd_(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) & bind(c, name="hipsolverCgebrd") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgebrd_ 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 type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCgebrd_assumed_rank #else module procedure & hipsolverCgebrd_rank_0,& hipsolverCgebrd_rank_1,& hipsolverCgebrd_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZgebrd function hipsolverZgebrd_(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) & bind(c, name="hipsolverZgebrd") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgebrd_ 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 type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZgebrd_assumed_rank #else module procedure & hipsolverZgebrd_rank_0,& hipsolverZgebrd_rank_1,& hipsolverZgebrd_full_rank #endif #endif end interface #endif interface hipsolverSSgels_bufferSize #ifdef USE_CUDA_NAMES function hipsolverSSgels_bufferSize_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,lwork) & bind(c, name="cusolverDnSSgels_bufferSize") #else function hipsolverSSgels_bufferSize_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,lwork) & bind(c, name="hipsolverSSgels_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSSgels_bufferSize_ type(c_ptr),value :: handle 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 :: X integer(c_int),value :: ldx integer(c_size_t) :: lwork end function end interface interface hipsolverDDgels_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDDgels_bufferSize_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,lwork) & bind(c, name="cusolverDnDDgels_bufferSize") #else function hipsolverDDgels_bufferSize_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,lwork) & bind(c, name="hipsolverDDgels_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDDgels_bufferSize_ type(c_ptr),value :: handle 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 :: X integer(c_int),value :: ldx integer(c_size_t) :: lwork end function end interface interface hipsolverCCgels_bufferSize #ifdef USE_CUDA_NAMES function hipsolverCCgels_bufferSize_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,lwork) & bind(c, name="cusolverDnCCgels_bufferSize") #else function hipsolverCCgels_bufferSize_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,lwork) & bind(c, name="hipsolverCCgels_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCCgels_bufferSize_ type(c_ptr),value :: handle 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 :: X integer(c_int),value :: ldx integer(c_size_t) :: lwork end function end interface interface hipsolverZZgels_bufferSize #ifdef USE_CUDA_NAMES function hipsolverZZgels_bufferSize_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,lwork) & bind(c, name="cusolverDnZZgels_bufferSize") #else function hipsolverZZgels_bufferSize_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,lwork) & bind(c, name="hipsolverZZgels_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZZgels_bufferSize_ type(c_ptr),value :: handle 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 :: X integer(c_int),value :: ldx integer(c_size_t) :: lwork end function end interface interface hipsolverSSgels #ifdef USE_CUDA_NAMES function hipsolverSSgels_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="cusolverDnSSgels") #else function hipsolverSSgels_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="hipsolverSSgels") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSSgels_ type(c_ptr),value :: handle 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 :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t),value :: lwork type(c_ptr),value :: niters type(c_ptr),value :: devInfo end function end interface interface hipsolverDDgels #ifdef USE_CUDA_NAMES function hipsolverDDgels_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="cusolverDnDDgels") #else function hipsolverDDgels_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="hipsolverDDgels") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDDgels_ type(c_ptr),value :: handle 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 :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t),value :: lwork type(c_ptr),value :: niters type(c_ptr),value :: devInfo end function end interface interface hipsolverCCgels #ifdef USE_CUDA_NAMES function hipsolverCCgels_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="cusolverDnCCgels") #else function hipsolverCCgels_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="hipsolverCCgels") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCCgels_ type(c_ptr),value :: handle 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 :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t),value :: lwork type(c_ptr),value :: niters type(c_ptr),value :: devInfo end function end interface interface hipsolverZZgels #ifdef USE_CUDA_NAMES function hipsolverZZgels_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="cusolverDnZZgels") #else function hipsolverZZgels_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="hipsolverZZgels") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZZgels_ type(c_ptr),value :: handle 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 :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t),value :: lwork type(c_ptr),value :: niters type(c_ptr),value :: devInfo end function end interface #ifndef USE_CUDA_NAMES interface hipsolverSgeqrf_bufferSize function hipsolverSgeqrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="hipsolverSgeqrf_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgeqrf_bufferSize_ 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) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSgeqrf_bufferSize_assumed_rank #else module procedure & hipsolverSgeqrf_bufferSize_rank_0,& hipsolverSgeqrf_bufferSize_rank_1,& hipsolverSgeqrf_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDgeqrf_bufferSize function hipsolverDgeqrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="hipsolverDgeqrf_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgeqrf_bufferSize_ 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) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDgeqrf_bufferSize_assumed_rank #else module procedure & hipsolverDgeqrf_bufferSize_rank_0,& hipsolverDgeqrf_bufferSize_rank_1,& hipsolverDgeqrf_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCgeqrf_bufferSize function hipsolverCgeqrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="hipsolverCgeqrf_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgeqrf_bufferSize_ 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) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCgeqrf_bufferSize_assumed_rank #else module procedure & hipsolverCgeqrf_bufferSize_rank_0,& hipsolverCgeqrf_bufferSize_rank_1,& hipsolverCgeqrf_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZgeqrf_bufferSize function hipsolverZgeqrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="hipsolverZgeqrf_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgeqrf_bufferSize_ 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) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZgeqrf_bufferSize_assumed_rank #else module procedure & hipsolverZgeqrf_bufferSize_rank_0,& hipsolverZgeqrf_bufferSize_rank_1,& hipsolverZgeqrf_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSgeqrf function hipsolverSgeqrf_(handle,m,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverSgeqrf") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgeqrf_ 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 real(c_float) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSgeqrf_assumed_rank #else module procedure & hipsolverSgeqrf_rank_0,& hipsolverSgeqrf_rank_1,& hipsolverSgeqrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDgeqrf function hipsolverDgeqrf_(handle,m,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDgeqrf") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgeqrf_ 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 real(c_double) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDgeqrf_assumed_rank #else module procedure & hipsolverDgeqrf_rank_0,& hipsolverDgeqrf_rank_1,& hipsolverDgeqrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCgeqrf function hipsolverCgeqrf_(handle,m,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverCgeqrf") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgeqrf_ 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 complex(c_float_complex) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCgeqrf_assumed_rank #else module procedure & hipsolverCgeqrf_rank_0,& hipsolverCgeqrf_rank_1,& hipsolverCgeqrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZgeqrf function hipsolverZgeqrf_(handle,m,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverZgeqrf") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgeqrf_ 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 complex(c_double_complex) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZgeqrf_assumed_rank #else module procedure & hipsolverZgeqrf_rank_0,& hipsolverZgeqrf_rank_1,& hipsolverZgeqrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSSgesv_bufferSize function hipsolverSSgesv_bufferSize_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) & bind(c, name="hipsolverSSgesv_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSSgesv_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx integer(c_size_t) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSSgesv_bufferSize_assumed_rank #else module procedure & hipsolverSSgesv_bufferSize_rank_0,& hipsolverSSgesv_bufferSize_rank_1,& hipsolverSSgesv_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDDgesv_bufferSize function hipsolverDDgesv_bufferSize_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) & bind(c, name="hipsolverDDgesv_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDDgesv_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx integer(c_size_t) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDDgesv_bufferSize_assumed_rank #else module procedure & hipsolverDDgesv_bufferSize_rank_0,& hipsolverDDgesv_bufferSize_rank_1,& hipsolverDDgesv_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCCgesv_bufferSize function hipsolverCCgesv_bufferSize_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) & bind(c, name="hipsolverCCgesv_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCCgesv_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx integer(c_size_t) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCCgesv_bufferSize_assumed_rank #else module procedure & hipsolverCCgesv_bufferSize_rank_0,& hipsolverCCgesv_bufferSize_rank_1,& hipsolverCCgesv_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZZgesv_bufferSize function hipsolverZZgesv_bufferSize_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) & bind(c, name="hipsolverZZgesv_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZZgesv_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx integer(c_size_t) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZZgesv_bufferSize_assumed_rank #else module procedure & hipsolverZZgesv_bufferSize_rank_0,& hipsolverZZgesv_bufferSize_rank_1,& hipsolverZZgesv_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSSgesv function hipsolverSSgesv_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="hipsolverSSgesv") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSSgesv_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t),value :: lwork type(c_ptr),value :: niters integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSSgesv_assumed_rank #else module procedure & hipsolverSSgesv_rank_0,& hipsolverSSgesv_rank_1,& hipsolverSSgesv_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDDgesv function hipsolverDDgesv_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="hipsolverDDgesv") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDDgesv_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t),value :: lwork type(c_ptr),value :: niters integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDDgesv_assumed_rank #else module procedure & hipsolverDDgesv_rank_0,& hipsolverDDgesv_rank_1,& hipsolverDDgesv_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCCgesv function hipsolverCCgesv_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="hipsolverCCgesv") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCCgesv_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t),value :: lwork type(c_ptr),value :: niters integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCCgesv_assumed_rank #else module procedure & hipsolverCCgesv_rank_0,& hipsolverCCgesv_rank_1,& hipsolverCCgesv_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZZgesv function hipsolverZZgesv_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="hipsolverZZgesv") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZZgesv_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t),value :: lwork type(c_ptr),value :: niters integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZZgesv_assumed_rank #else module procedure & hipsolverZZgesv_rank_0,& hipsolverZZgesv_rank_1,& hipsolverZZgesv_full_rank #endif #endif end interface #endif interface hipsolverSgesvd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverSgesvd_bufferSize_(handle,jobu,jobv,m,n,lwork) & bind(c, name="cusolverDnSgesvd_bufferSize") #else function hipsolverSgesvd_bufferSize_(handle,jobu,jobv,m,n,lwork) & bind(c, name="hipsolverSgesvd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgesvd_bufferSize_ type(c_ptr),value :: handle character(c_char),value :: jobu character(c_char),value :: jobv integer(c_int),value :: m integer(c_int),value :: n integer(c_int) :: lwork end function end interface interface hipsolverDgesvd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDgesvd_bufferSize_(handle,jobu,jobv,m,n,lwork) & bind(c, name="cusolverDnDgesvd_bufferSize") #else function hipsolverDgesvd_bufferSize_(handle,jobu,jobv,m,n,lwork) & bind(c, name="hipsolverDgesvd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgesvd_bufferSize_ type(c_ptr),value :: handle character(c_char),value :: jobu character(c_char),value :: jobv integer(c_int),value :: m integer(c_int),value :: n integer(c_int) :: lwork end function end interface interface hipsolverCgesvd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverCgesvd_bufferSize_(handle,jobu,jobv,m,n,lwork) & bind(c, name="cusolverDnCgesvd_bufferSize") #else function hipsolverCgesvd_bufferSize_(handle,jobu,jobv,m,n,lwork) & bind(c, name="hipsolverCgesvd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgesvd_bufferSize_ type(c_ptr),value :: handle character(c_char),value :: jobu character(c_char),value :: jobv integer(c_int),value :: m integer(c_int),value :: n integer(c_int) :: lwork end function end interface interface hipsolverZgesvd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverZgesvd_bufferSize_(handle,jobu,jobv,m,n,lwork) & bind(c, name="cusolverDnZgesvd_bufferSize") #else function hipsolverZgesvd_bufferSize_(handle,jobu,jobv,m,n,lwork) & bind(c, name="hipsolverZgesvd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgesvd_bufferSize_ type(c_ptr),value :: handle character(c_char),value :: jobu character(c_char),value :: jobv integer(c_int),value :: m integer(c_int),value :: n integer(c_int) :: lwork end function end interface interface hipsolverSgesvd #ifdef USE_CUDA_NAMES function hipsolverSgesvd_(handle,jobu,jobv,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,rwork,devInfo) & bind(c, name="cusolverDnSgesvd") #else function hipsolverSgesvd_(handle,jobu,jobv,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,rwork,devInfo) & bind(c, name="hipsolverSgesvd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgesvd_ type(c_ptr),value :: handle character(c_char),value :: jobu character(c_char),value :: jobv integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: rwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDgesvd #ifdef USE_CUDA_NAMES function hipsolverDgesvd_(handle,jobu,jobv,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,rwork,devInfo) & bind(c, name="cusolverDnDgesvd") #else function hipsolverDgesvd_(handle,jobu,jobv,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,rwork,devInfo) & bind(c, name="hipsolverDgesvd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgesvd_ type(c_ptr),value :: handle character(c_char),value :: jobu character(c_char),value :: jobv integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: rwork type(c_ptr),value :: devInfo end function end interface interface hipsolverCgesvd #ifdef USE_CUDA_NAMES function hipsolverCgesvd_(handle,jobu,jobv,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,rwork,devInfo) & bind(c, name="cusolverDnCgesvd") #else function hipsolverCgesvd_(handle,jobu,jobv,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,rwork,devInfo) & bind(c, name="hipsolverCgesvd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgesvd_ type(c_ptr),value :: handle character(c_char),value :: jobu character(c_char),value :: jobv integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: rwork type(c_ptr),value :: devInfo end function end interface interface hipsolverZgesvd #ifdef USE_CUDA_NAMES function hipsolverZgesvd_(handle,jobu,jobv,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,rwork,devInfo) & bind(c, name="cusolverDnZgesvd") #else function hipsolverZgesvd_(handle,jobu,jobv,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,rwork,devInfo) & bind(c, name="hipsolverZgesvd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgesvd_ type(c_ptr),value :: handle character(c_char),value :: jobu character(c_char),value :: jobv integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: rwork type(c_ptr),value :: devInfo end function end interface #ifndef USE_CUDA_NAMES interface hipsolverSgesvdj_bufferSize function hipsolverSgesvdj_bufferSize_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,lwork,params) & bind(c, name="hipsolverSgesvdj_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgesvdj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: econ integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int) :: lwork type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDgesvdj_bufferSize function hipsolverDgesvdj_bufferSize_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,lwork,params) & bind(c, name="hipsolverDgesvdj_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgesvdj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: econ integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int) :: lwork type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCgesvdj_bufferSize function hipsolverCgesvdj_bufferSize_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,lwork,params) & bind(c, name="hipsolverCgesvdj_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgesvdj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: econ integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int) :: lwork type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZgesvdj_bufferSize function hipsolverZgesvdj_bufferSize_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,lwork,params) & bind(c, name="hipsolverZgesvdj_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgesvdj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: econ integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int) :: lwork type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSgesvdj function hipsolverSgesvdj_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo,params) & bind(c, name="hipsolverSgesvdj") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgesvdj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: econ integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDgesvdj function hipsolverDgesvdj_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo,params) & bind(c, name="hipsolverDgesvdj") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgesvdj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: econ integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCgesvdj function hipsolverCgesvdj_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo,params) & bind(c, name="hipsolverCgesvdj") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgesvdj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: econ integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZgesvdj function hipsolverZgesvdj_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo,params) & bind(c, name="hipsolverZgesvdj") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgesvdj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: econ integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSgesvdjBatched_bufferSize function hipsolverSgesvdjBatched_bufferSize_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,lwork,params, & batch_count) & bind(c, name="hipsolverSgesvdjBatched_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgesvdjBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int) :: lwork type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDgesvdjBatched_bufferSize function hipsolverDgesvdjBatched_bufferSize_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,lwork,params, & batch_count) & bind(c, name="hipsolverDgesvdjBatched_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgesvdjBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int) :: lwork type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCgesvdjBatched_bufferSize function hipsolverCgesvdjBatched_bufferSize_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,lwork,params, & batch_count) & bind(c, name="hipsolverCgesvdjBatched_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgesvdjBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int) :: lwork type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZgesvdjBatched_bufferSize function hipsolverZgesvdjBatched_bufferSize_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,lwork,params, & batch_count) & bind(c, name="hipsolverZgesvdjBatched_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgesvdjBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int) :: lwork type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSgesvdjBatched function hipsolverSgesvdjBatched_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params,batch_count) & bind(c, name="hipsolverSgesvdjBatched") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgesvdjBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDgesvdjBatched function hipsolverDgesvdjBatched_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params,batch_count) & bind(c, name="hipsolverDgesvdjBatched") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgesvdjBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCgesvdjBatched function hipsolverCgesvdjBatched_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params,batch_count) & bind(c, name="hipsolverCgesvdjBatched") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgesvdjBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZgesvdjBatched function hipsolverZgesvdjBatched_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params,batch_count) & bind(c, name="hipsolverZgesvdjBatched") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgesvdjBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSgetrf_bufferSize function hipsolverSgetrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="hipsolverSgetrf_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrf_bufferSize_ 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) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSgetrf_bufferSize_assumed_rank #else module procedure & hipsolverSgetrf_bufferSize_rank_0,& hipsolverSgetrf_bufferSize_rank_1,& hipsolverSgetrf_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDgetrf_bufferSize function hipsolverDgetrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="hipsolverDgetrf_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrf_bufferSize_ 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) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDgetrf_bufferSize_assumed_rank #else module procedure & hipsolverDgetrf_bufferSize_rank_0,& hipsolverDgetrf_bufferSize_rank_1,& hipsolverDgetrf_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCgetrf_bufferSize function hipsolverCgetrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="hipsolverCgetrf_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrf_bufferSize_ 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) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCgetrf_bufferSize_assumed_rank #else module procedure & hipsolverCgetrf_bufferSize_rank_0,& hipsolverCgetrf_bufferSize_rank_1,& hipsolverCgetrf_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZgetrf_bufferSize function hipsolverZgetrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="hipsolverZgetrf_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrf_bufferSize_ 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) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZgetrf_bufferSize_assumed_rank #else module procedure & hipsolverZgetrf_bufferSize_rank_0,& hipsolverZgetrf_bufferSize_rank_1,& hipsolverZgetrf_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSgetrf function hipsolverSgetrf_(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) & bind(c, name="hipsolverSgetrf") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrf_ 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 type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devIpiv integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSgetrf_assumed_rank #else module procedure & hipsolverSgetrf_rank_0,& hipsolverSgetrf_rank_1,& hipsolverSgetrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDgetrf function hipsolverDgetrf_(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) & bind(c, name="hipsolverDgetrf") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrf_ 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 type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devIpiv integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDgetrf_assumed_rank #else module procedure & hipsolverDgetrf_rank_0,& hipsolverDgetrf_rank_1,& hipsolverDgetrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCgetrf function hipsolverCgetrf_(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) & bind(c, name="hipsolverCgetrf") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrf_ 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 type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devIpiv integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCgetrf_assumed_rank #else module procedure & hipsolverCgetrf_rank_0,& hipsolverCgetrf_rank_1,& hipsolverCgetrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZgetrf function hipsolverZgetrf_(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) & bind(c, name="hipsolverZgetrf") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrf_ 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 type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devIpiv integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZgetrf_assumed_rank #else module procedure & hipsolverZgetrf_rank_0,& hipsolverZgetrf_rank_1,& hipsolverZgetrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSgetrs_bufferSize function hipsolverSgetrs_bufferSize_(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) & bind(c, name="hipsolverSgetrs_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrs_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSgetrs_bufferSize_assumed_rank #else module procedure & hipsolverSgetrs_bufferSize_rank_0,& hipsolverSgetrs_bufferSize_rank_1,& hipsolverSgetrs_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDgetrs_bufferSize function hipsolverDgetrs_bufferSize_(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) & bind(c, name="hipsolverDgetrs_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrs_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDgetrs_bufferSize_assumed_rank #else module procedure & hipsolverDgetrs_bufferSize_rank_0,& hipsolverDgetrs_bufferSize_rank_1,& hipsolverDgetrs_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCgetrs_bufferSize function hipsolverCgetrs_bufferSize_(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) & bind(c, name="hipsolverCgetrs_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrs_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCgetrs_bufferSize_assumed_rank #else module procedure & hipsolverCgetrs_bufferSize_rank_0,& hipsolverCgetrs_bufferSize_rank_1,& hipsolverCgetrs_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZgetrs_bufferSize function hipsolverZgetrs_bufferSize_(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) & bind(c, name="hipsolverZgetrs_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrs_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZgetrs_bufferSize_assumed_rank #else module procedure & hipsolverZgetrs_bufferSize_rank_0,& hipsolverZgetrs_bufferSize_rank_1,& hipsolverZgetrs_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSgetrs function hipsolverSgetrs_(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork,devInfo) & bind(c, name="hipsolverSgetrs") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrs_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSgetrs_assumed_rank #else module procedure & hipsolverSgetrs_rank_0,& hipsolverSgetrs_rank_1,& hipsolverSgetrs_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDgetrs function hipsolverDgetrs_(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork,devInfo) & bind(c, name="hipsolverDgetrs") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrs_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDgetrs_assumed_rank #else module procedure & hipsolverDgetrs_rank_0,& hipsolverDgetrs_rank_1,& hipsolverDgetrs_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCgetrs function hipsolverCgetrs_(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork,devInfo) & bind(c, name="hipsolverCgetrs") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrs_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCgetrs_assumed_rank #else module procedure & hipsolverCgetrs_rank_0,& hipsolverCgetrs_rank_1,& hipsolverCgetrs_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZgetrs function hipsolverZgetrs_(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork,devInfo) & bind(c, name="hipsolverZgetrs") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrs_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZgetrs_assumed_rank #else module procedure & hipsolverZgetrs_rank_0,& hipsolverZgetrs_rank_1,& hipsolverZgetrs_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSpotrf_bufferSize function hipsolverSpotrf_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="hipsolverSpotrf_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrf_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSpotrf_bufferSize_assumed_rank #else module procedure & hipsolverSpotrf_bufferSize_rank_0,& hipsolverSpotrf_bufferSize_rank_1,& hipsolverSpotrf_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDpotrf_bufferSize function hipsolverDpotrf_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="hipsolverDpotrf_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrf_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDpotrf_bufferSize_assumed_rank #else module procedure & hipsolverDpotrf_bufferSize_rank_0,& hipsolverDpotrf_bufferSize_rank_1,& hipsolverDpotrf_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCpotrf_bufferSize function hipsolverCpotrf_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="hipsolverCpotrf_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrf_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCpotrf_bufferSize_assumed_rank #else module procedure & hipsolverCpotrf_bufferSize_rank_0,& hipsolverCpotrf_bufferSize_rank_1,& hipsolverCpotrf_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZpotrf_bufferSize function hipsolverZpotrf_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="hipsolverZpotrf_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrf_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZpotrf_bufferSize_assumed_rank #else module procedure & hipsolverZpotrf_bufferSize_rank_0,& hipsolverZpotrf_bufferSize_rank_1,& hipsolverZpotrf_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSpotrf function hipsolverSpotrf_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="hipsolverSpotrf") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrf_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSpotrf_assumed_rank #else module procedure & hipsolverSpotrf_rank_0,& hipsolverSpotrf_rank_1,& hipsolverSpotrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDpotrf function hipsolverDpotrf_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="hipsolverDpotrf") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrf_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDpotrf_assumed_rank #else module procedure & hipsolverDpotrf_rank_0,& hipsolverDpotrf_rank_1,& hipsolverDpotrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCpotrf function hipsolverCpotrf_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="hipsolverCpotrf") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrf_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCpotrf_assumed_rank #else module procedure & hipsolverCpotrf_rank_0,& hipsolverCpotrf_rank_1,& hipsolverCpotrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZpotrf function hipsolverZpotrf_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="hipsolverZpotrf") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrf_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZpotrf_assumed_rank #else module procedure & hipsolverZpotrf_rank_0,& hipsolverZpotrf_rank_1,& hipsolverZpotrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSpotrfBatched_bufferSize function hipsolverSpotrfBatched_bufferSize_(handle,uplo,n,A,lda,lwork,batch_count) & bind(c, name="hipsolverSpotrfBatched_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrfBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDpotrfBatched_bufferSize function hipsolverDpotrfBatched_bufferSize_(handle,uplo,n,A,lda,lwork,batch_count) & bind(c, name="hipsolverDpotrfBatched_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrfBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCpotrfBatched_bufferSize function hipsolverCpotrfBatched_bufferSize_(handle,uplo,n,A,lda,lwork,batch_count) & bind(c, name="hipsolverCpotrfBatched_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrfBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZpotrfBatched_bufferSize function hipsolverZpotrfBatched_bufferSize_(handle,uplo,n,A,lda,lwork,batch_count) & bind(c, name="hipsolverZpotrfBatched_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrfBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSpotrfBatched function hipsolverSpotrfBatched_(handle,uplo,n,A,lda,work,lwork,devInfo,batch_count) & bind(c, name="hipsolverSpotrfBatched") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrfBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDpotrfBatched function hipsolverDpotrfBatched_(handle,uplo,n,A,lda,work,lwork,devInfo,batch_count) & bind(c, name="hipsolverDpotrfBatched") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrfBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCpotrfBatched function hipsolverCpotrfBatched_(handle,uplo,n,A,lda,work,lwork,devInfo,batch_count) & bind(c, name="hipsolverCpotrfBatched") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrfBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZpotrfBatched function hipsolverZpotrfBatched_(handle,uplo,n,A,lda,work,lwork,devInfo,batch_count) & bind(c, name="hipsolverZpotrfBatched") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrfBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSpotri_bufferSize function hipsolverSpotri_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="hipsolverSpotri_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotri_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSpotri_bufferSize_assumed_rank #else module procedure & hipsolverSpotri_bufferSize_rank_0,& hipsolverSpotri_bufferSize_rank_1,& hipsolverSpotri_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDpotri_bufferSize function hipsolverDpotri_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="hipsolverDpotri_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotri_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDpotri_bufferSize_assumed_rank #else module procedure & hipsolverDpotri_bufferSize_rank_0,& hipsolverDpotri_bufferSize_rank_1,& hipsolverDpotri_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCpotri_bufferSize function hipsolverCpotri_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="hipsolverCpotri_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotri_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCpotri_bufferSize_assumed_rank #else module procedure & hipsolverCpotri_bufferSize_rank_0,& hipsolverCpotri_bufferSize_rank_1,& hipsolverCpotri_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZpotri_bufferSize function hipsolverZpotri_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="hipsolverZpotri_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotri_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZpotri_bufferSize_assumed_rank #else module procedure & hipsolverZpotri_bufferSize_rank_0,& hipsolverZpotri_bufferSize_rank_1,& hipsolverZpotri_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSpotri function hipsolverSpotri_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="hipsolverSpotri") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotri_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSpotri_assumed_rank #else module procedure & hipsolverSpotri_rank_0,& hipsolverSpotri_rank_1,& hipsolverSpotri_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDpotri function hipsolverDpotri_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="hipsolverDpotri") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotri_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDpotri_assumed_rank #else module procedure & hipsolverDpotri_rank_0,& hipsolverDpotri_rank_1,& hipsolverDpotri_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCpotri function hipsolverCpotri_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="hipsolverCpotri") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotri_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCpotri_assumed_rank #else module procedure & hipsolverCpotri_rank_0,& hipsolverCpotri_rank_1,& hipsolverCpotri_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZpotri function hipsolverZpotri_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="hipsolverZpotri") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotri_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZpotri_assumed_rank #else module procedure & hipsolverZpotri_rank_0,& hipsolverZpotri_rank_1,& hipsolverZpotri_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSpotrs_bufferSize function hipsolverSpotrs_bufferSize_(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) & bind(c, name="hipsolverSpotrs_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrs_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSpotrs_bufferSize_assumed_rank #else module procedure & hipsolverSpotrs_bufferSize_rank_0,& hipsolverSpotrs_bufferSize_rank_1,& hipsolverSpotrs_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDpotrs_bufferSize function hipsolverDpotrs_bufferSize_(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) & bind(c, name="hipsolverDpotrs_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrs_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDpotrs_bufferSize_assumed_rank #else module procedure & hipsolverDpotrs_bufferSize_rank_0,& hipsolverDpotrs_bufferSize_rank_1,& hipsolverDpotrs_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCpotrs_bufferSize function hipsolverCpotrs_bufferSize_(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) & bind(c, name="hipsolverCpotrs_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrs_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCpotrs_bufferSize_assumed_rank #else module procedure & hipsolverCpotrs_bufferSize_rank_0,& hipsolverCpotrs_bufferSize_rank_1,& hipsolverCpotrs_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZpotrs_bufferSize function hipsolverZpotrs_bufferSize_(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) & bind(c, name="hipsolverZpotrs_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrs_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZpotrs_bufferSize_assumed_rank #else module procedure & hipsolverZpotrs_bufferSize_rank_0,& hipsolverZpotrs_bufferSize_rank_1,& hipsolverZpotrs_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSpotrs function hipsolverSpotrs_(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) & bind(c, name="hipsolverSpotrs") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrs_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSpotrs_assumed_rank #else module procedure & hipsolverSpotrs_rank_0,& hipsolverSpotrs_rank_1,& hipsolverSpotrs_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDpotrs function hipsolverDpotrs_(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) & bind(c, name="hipsolverDpotrs") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrs_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDpotrs_assumed_rank #else module procedure & hipsolverDpotrs_rank_0,& hipsolverDpotrs_rank_1,& hipsolverDpotrs_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCpotrs function hipsolverCpotrs_(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) & bind(c, name="hipsolverCpotrs") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrs_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCpotrs_assumed_rank #else module procedure & hipsolverCpotrs_rank_0,& hipsolverCpotrs_rank_1,& hipsolverCpotrs_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZpotrs function hipsolverZpotrs_(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) & bind(c, name="hipsolverZpotrs") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrs_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZpotrs_assumed_rank #else module procedure & hipsolverZpotrs_rank_0,& hipsolverZpotrs_rank_1,& hipsolverZpotrs_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSpotrsBatched_bufferSize function hipsolverSpotrsBatched_bufferSize_(handle,uplo,n,nrhs,A,lda,B,ldb,lwork,batch_count) & bind(c, name="hipsolverSpotrsBatched_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrsBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 integer(c_int) :: lwork integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDpotrsBatched_bufferSize function hipsolverDpotrsBatched_bufferSize_(handle,uplo,n,nrhs,A,lda,B,ldb,lwork,batch_count) & bind(c, name="hipsolverDpotrsBatched_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrsBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 integer(c_int) :: lwork integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCpotrsBatched_bufferSize function hipsolverCpotrsBatched_bufferSize_(handle,uplo,n,nrhs,A,lda,B,ldb,lwork,batch_count) & bind(c, name="hipsolverCpotrsBatched_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrsBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 integer(c_int) :: lwork integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZpotrsBatched_bufferSize function hipsolverZpotrsBatched_bufferSize_(handle,uplo,n,nrhs,A,lda,B,ldb,lwork,batch_count) & bind(c, name="hipsolverZpotrsBatched_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrsBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 integer(c_int) :: lwork integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSpotrsBatched function hipsolverSpotrsBatched_(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo, & batch_count) & bind(c, name="hipsolverSpotrsBatched") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrsBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 :: work integer(c_int),value :: lwork integer(c_int) :: devInfo integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDpotrsBatched function hipsolverDpotrsBatched_(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo, & batch_count) & bind(c, name="hipsolverDpotrsBatched") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrsBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 :: work integer(c_int),value :: lwork integer(c_int) :: devInfo integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCpotrsBatched function hipsolverCpotrsBatched_(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo, & batch_count) & bind(c, name="hipsolverCpotrsBatched") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrsBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 :: work integer(c_int),value :: lwork integer(c_int) :: devInfo integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZpotrsBatched function hipsolverZpotrsBatched_(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo, & batch_count) & bind(c, name="hipsolverZpotrsBatched") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrsBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 :: work integer(c_int),value :: lwork integer(c_int) :: devInfo integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSsyevd_bufferSize function hipsolverSsyevd_bufferSize_(handle,jobz,uplo,n,A,lda,D,lwork) & bind(c, name="hipsolverSsyevd_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsyevd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSsyevd_bufferSize_assumed_rank #else module procedure & hipsolverSsyevd_bufferSize_rank_0,& hipsolverSsyevd_bufferSize_rank_1,& hipsolverSsyevd_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDsyevd_bufferSize function hipsolverDsyevd_bufferSize_(handle,jobz,uplo,n,A,lda,D,lwork) & bind(c, name="hipsolverDsyevd_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsyevd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDsyevd_bufferSize_assumed_rank #else module procedure & hipsolverDsyevd_bufferSize_rank_0,& hipsolverDsyevd_bufferSize_rank_1,& hipsolverDsyevd_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCheevd_bufferSize function hipsolverCheevd_bufferSize_(handle,jobz,uplo,n,A,lda,D,lwork) & bind(c, name="hipsolverCheevd_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCheevd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCheevd_bufferSize_assumed_rank #else module procedure & hipsolverCheevd_bufferSize_rank_0,& hipsolverCheevd_bufferSize_rank_1,& hipsolverCheevd_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZheevd_bufferSize function hipsolverZheevd_bufferSize_(handle,jobz,uplo,n,A,lda,D,lwork) & bind(c, name="hipsolverZheevd_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZheevd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZheevd_bufferSize_assumed_rank #else module procedure & hipsolverZheevd_bufferSize_rank_0,& hipsolverZheevd_bufferSize_rank_1,& hipsolverZheevd_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSsyevd function hipsolverSsyevd_(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) & bind(c, name="hipsolverSsyevd") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsyevd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSsyevd_assumed_rank #else module procedure & hipsolverSsyevd_rank_0,& hipsolverSsyevd_rank_1,& hipsolverSsyevd_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDsyevd function hipsolverDsyevd_(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) & bind(c, name="hipsolverDsyevd") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsyevd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDsyevd_assumed_rank #else module procedure & hipsolverDsyevd_rank_0,& hipsolverDsyevd_rank_1,& hipsolverDsyevd_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCheevd function hipsolverCheevd_(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) & bind(c, name="hipsolverCheevd") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCheevd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCheevd_assumed_rank #else module procedure & hipsolverCheevd_rank_0,& hipsolverCheevd_rank_1,& hipsolverCheevd_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZheevd function hipsolverZheevd_(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) & bind(c, name="hipsolverZheevd") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZheevd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZheevd_assumed_rank #else module procedure & hipsolverZheevd_rank_0,& hipsolverZheevd_rank_1,& hipsolverZheevd_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSsyevdx_bufferSize function hipsolverSsyevdx_bufferSize_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W,lwork) & bind(c, name="hipsolverSsyevdx_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsyevdx_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu integer(c_int) :: nev type(c_ptr),value :: W integer(c_int) :: lwork end function end interface #endif interface hipsolverDsyevdx_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDsyevdx_bufferSize_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W,lwork) & bind(c, name="cusolverDnDsyevdx_bufferSize") #else function hipsolverDsyevdx_bufferSize_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W,lwork) & bind(c, name="hipsolverDsyevdx_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsyevdx_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int) :: lwork end function end interface #ifndef USE_CUDA_NAMES interface hipsolverCheevdx_bufferSize function hipsolverCheevdx_bufferSize_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W,lwork) & bind(c, name="hipsolverCheevdx_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCheevdx_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu integer(c_int) :: nev type(c_ptr),value :: W integer(c_int) :: lwork end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZheevdx_bufferSize function hipsolverZheevdx_bufferSize_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W,lwork) & bind(c, name="hipsolverZheevdx_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZheevdx_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu integer(c_int) :: nev type(c_ptr),value :: W integer(c_int) :: lwork end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSsyevdx function hipsolverSsyevdx_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W,work,lwork, & devInfo) & bind(c, name="hipsolverSsyevdx") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsyevdx_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface #endif interface hipsolverDsyevdx #ifdef USE_CUDA_NAMES function hipsolverDsyevdx_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W,work,lwork, & devInfo) & bind(c, name="cusolverDnDsyevdx") #else function hipsolverDsyevdx_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W,work,lwork, & devInfo) & bind(c, name="hipsolverDsyevdx") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsyevdx_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface #ifndef USE_CUDA_NAMES interface hipsolverCheevdx function hipsolverCheevdx_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W,work,lwork, & devInfo) & bind(c, name="hipsolverCheevdx") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCheevdx_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu integer(c_int) :: nev type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZheevdx function hipsolverZheevdx_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W,work,lwork, & devInfo) & bind(c, name="hipsolverZheevdx") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZheevdx_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu integer(c_int) :: nev type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSsyevj_bufferSize function hipsolverSsyevj_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params) & bind(c, name="hipsolverSsyevj_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsyevj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDsyevj_bufferSize function hipsolverDsyevj_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params) & bind(c, name="hipsolverDsyevj_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsyevj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCheevj_bufferSize function hipsolverCheevj_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params) & bind(c, name="hipsolverCheevj_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCheevj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZheevj_bufferSize function hipsolverZheevj_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params) & bind(c, name="hipsolverZheevj_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZheevj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSsyevj function hipsolverSsyevj_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params) & bind(c, name="hipsolverSsyevj") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsyevj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDsyevj function hipsolverDsyevj_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params) & bind(c, name="hipsolverDsyevj") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsyevj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCheevj function hipsolverCheevj_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params) & bind(c, name="hipsolverCheevj") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCheevj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZheevj function hipsolverZheevj_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params) & bind(c, name="hipsolverZheevj") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZheevj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSsyevjBatched_bufferSize function hipsolverSsyevjBatched_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params, & batch_count) & bind(c, name="hipsolverSsyevjBatched_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsyevjBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDsyevjBatched_bufferSize function hipsolverDsyevjBatched_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params, & batch_count) & bind(c, name="hipsolverDsyevjBatched_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsyevjBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCheevjBatched_bufferSize function hipsolverCheevjBatched_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params, & batch_count) & bind(c, name="hipsolverCheevjBatched_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCheevjBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZheevjBatched_bufferSize function hipsolverZheevjBatched_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params, & batch_count) & bind(c, name="hipsolverZheevjBatched_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZheevjBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSsyevjBatched function hipsolverSsyevjBatched_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params, & batch_count) & bind(c, name="hipsolverSsyevjBatched") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsyevjBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface #endif interface hipsolverDsyevjBatched #ifdef USE_CUDA_NAMES function hipsolverDsyevjBatched_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params, & batch_count) & bind(c, name="cusolverDnDsyevjBatched") #else function hipsolverDsyevjBatched_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params, & batch_count) & bind(c, name="hipsolverDsyevjBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsyevjBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface #ifndef USE_CUDA_NAMES interface hipsolverCheevjBatched function hipsolverCheevjBatched_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params, & batch_count) & bind(c, name="hipsolverCheevjBatched") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCheevjBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZheevjBatched function hipsolverZheevjBatched_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params, & batch_count) & bind(c, name="hipsolverZheevjBatched") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZheevjBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSsygvd_bufferSize function hipsolverSsygvd_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) & bind(c, name="hipsolverSsygvd_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsygvd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSsygvd_bufferSize_assumed_rank #else module procedure & hipsolverSsygvd_bufferSize_rank_0,& hipsolverSsygvd_bufferSize_rank_1,& hipsolverSsygvd_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDsygvd_bufferSize function hipsolverDsygvd_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) & bind(c, name="hipsolverDsygvd_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsygvd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDsygvd_bufferSize_assumed_rank #else module procedure & hipsolverDsygvd_bufferSize_rank_0,& hipsolverDsygvd_bufferSize_rank_1,& hipsolverDsygvd_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverChegvd_bufferSize function hipsolverChegvd_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) & bind(c, name="hipsolverChegvd_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChegvd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverChegvd_bufferSize_assumed_rank #else module procedure & hipsolverChegvd_bufferSize_rank_0,& hipsolverChegvd_bufferSize_rank_1,& hipsolverChegvd_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZhegvd_bufferSize function hipsolverZhegvd_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) & bind(c, name="hipsolverZhegvd_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhegvd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZhegvd_bufferSize_assumed_rank #else module procedure & hipsolverZhegvd_bufferSize_rank_0,& hipsolverZhegvd_bufferSize_rank_1,& hipsolverZhegvd_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSsygvd function hipsolverSsygvd_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) & bind(c, name="hipsolverSsygvd") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsygvd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSsygvd_assumed_rank #else module procedure & hipsolverSsygvd_rank_0,& hipsolverSsygvd_rank_1,& hipsolverSsygvd_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDsygvd function hipsolverDsygvd_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) & bind(c, name="hipsolverDsygvd") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsygvd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDsygvd_assumed_rank #else module procedure & hipsolverDsygvd_rank_0,& hipsolverDsygvd_rank_1,& hipsolverDsygvd_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverChegvd function hipsolverChegvd_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) & bind(c, name="hipsolverChegvd") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChegvd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverChegvd_assumed_rank #else module procedure & hipsolverChegvd_rank_0,& hipsolverChegvd_rank_1,& hipsolverChegvd_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZhegvd function hipsolverZhegvd_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) & bind(c, name="hipsolverZhegvd") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhegvd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZhegvd_assumed_rank #else module procedure & hipsolverZhegvd_rank_0,& hipsolverZhegvd_rank_1,& hipsolverZhegvd_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSsygvdx_bufferSize function hipsolverSsygvdx_bufferSize_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il,iu, & nev,W,lwork) & bind(c, name="hipsolverSsygvdx_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsygvdx_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu integer(c_int) :: nev type(c_ptr),value :: W integer(c_int) :: lwork end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDsygvdx_bufferSize function hipsolverDsygvdx_bufferSize_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il,iu, & nev,W,lwork) & bind(c, name="hipsolverDsygvdx_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsygvdx_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu integer(c_int) :: nev type(c_ptr),value :: W integer(c_int) :: lwork end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverChegvdx_bufferSize function hipsolverChegvdx_bufferSize_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il,iu, & nev,W,lwork) & bind(c, name="hipsolverChegvdx_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChegvdx_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu integer(c_int) :: nev type(c_ptr),value :: W integer(c_int) :: lwork end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZhegvdx_bufferSize function hipsolverZhegvdx_bufferSize_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il,iu, & nev,W,lwork) & bind(c, name="hipsolverZhegvdx_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhegvdx_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu integer(c_int) :: nev type(c_ptr),value :: W integer(c_int) :: lwork end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSsygvdx function hipsolverSsygvdx_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il,iu,nev,W,work, & lwork,devInfo) & bind(c, name="hipsolverSsygvdx") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsygvdx_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu integer(c_int) :: nev type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDsygvdx function hipsolverDsygvdx_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il,iu,nev,W,work, & lwork,devInfo) & bind(c, name="hipsolverDsygvdx") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsygvdx_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu integer(c_int) :: nev type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverChegvdx function hipsolverChegvdx_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il,iu,nev,W,work, & lwork,devInfo) & bind(c, name="hipsolverChegvdx") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChegvdx_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu integer(c_int) :: nev type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZhegvdx function hipsolverZhegvdx_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il,iu,nev,W,work, & lwork,devInfo) & bind(c, name="hipsolverZhegvdx") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhegvdx_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu integer(c_int) :: nev type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSsygvj_bufferSize function hipsolverSsygvj_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork,params) & bind(c, name="hipsolverSsygvj_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsygvj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDsygvj_bufferSize function hipsolverDsygvj_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork,params) & bind(c, name="hipsolverDsygvj_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsygvj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverChegvj_bufferSize function hipsolverChegvj_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork,params) & bind(c, name="hipsolverChegvj_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChegvj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZhegvj_bufferSize function hipsolverZhegvj_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork,params) & bind(c, name="hipsolverZhegvj_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhegvj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSsygvj function hipsolverSsygvj_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo,params) & bind(c, name="hipsolverSsygvj") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsygvj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDsygvj function hipsolverDsygvj_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo,params) & bind(c, name="hipsolverDsygvj") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsygvj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverChegvj function hipsolverChegvj_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo,params) & bind(c, name="hipsolverChegvj") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChegvj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZhegvj function hipsolverZhegvj_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo,params) & bind(c, name="hipsolverZhegvj") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhegvj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo type(c_ptr),value :: params end function end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSsytrd_bufferSize function hipsolverSsytrd_bufferSize_(handle,uplo,n,A,lda,D,E,tau,lwork) & bind(c, name="hipsolverSsytrd_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E real(c_float) :: tau integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSsytrd_bufferSize_assumed_rank #else module procedure & hipsolverSsytrd_bufferSize_rank_0,& hipsolverSsytrd_bufferSize_rank_1,& hipsolverSsytrd_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDsytrd_bufferSize function hipsolverDsytrd_bufferSize_(handle,uplo,n,A,lda,D,E,tau,lwork) & bind(c, name="hipsolverDsytrd_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E real(c_double) :: tau integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDsytrd_bufferSize_assumed_rank #else module procedure & hipsolverDsytrd_bufferSize_rank_0,& hipsolverDsytrd_bufferSize_rank_1,& hipsolverDsytrd_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverChetrd_bufferSize function hipsolverChetrd_bufferSize_(handle,uplo,n,A,lda,D,E,tau,lwork) & bind(c, name="hipsolverChetrd_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChetrd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E complex(c_float_complex) :: tau integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverChetrd_bufferSize_assumed_rank #else module procedure & hipsolverChetrd_bufferSize_rank_0,& hipsolverChetrd_bufferSize_rank_1,& hipsolverChetrd_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZhetrd_bufferSize function hipsolverZhetrd_bufferSize_(handle,uplo,n,A,lda,D,E,tau,lwork) & bind(c, name="hipsolverZhetrd_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhetrd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E complex(c_double_complex) :: tau integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZhetrd_bufferSize_assumed_rank #else module procedure & hipsolverZhetrd_bufferSize_rank_0,& hipsolverZhetrd_bufferSize_rank_1,& hipsolverZhetrd_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSsytrd function hipsolverSsytrd_(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) & bind(c, name="hipsolverSsytrd") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E real(c_float) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSsytrd_assumed_rank #else module procedure & hipsolverSsytrd_rank_0,& hipsolverSsytrd_rank_1,& hipsolverSsytrd_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDsytrd function hipsolverDsytrd_(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) & bind(c, name="hipsolverDsytrd") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E real(c_double) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDsytrd_assumed_rank #else module procedure & hipsolverDsytrd_rank_0,& hipsolverDsytrd_rank_1,& hipsolverDsytrd_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverChetrd function hipsolverChetrd_(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) & bind(c, name="hipsolverChetrd") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChetrd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E complex(c_float_complex) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverChetrd_assumed_rank #else module procedure & hipsolverChetrd_rank_0,& hipsolverChetrd_rank_1,& hipsolverChetrd_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZhetrd function hipsolverZhetrd_(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) & bind(c, name="hipsolverZhetrd") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhetrd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E complex(c_double_complex) :: tau type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZhetrd_assumed_rank #else module procedure & hipsolverZhetrd_rank_0,& hipsolverZhetrd_rank_1,& hipsolverZhetrd_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSsytrf_bufferSize function hipsolverSsytrf_bufferSize_(handle,n,A,lda,lwork) & bind(c, name="hipsolverSsytrf_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrf_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSsytrf_bufferSize_assumed_rank #else module procedure & hipsolverSsytrf_bufferSize_rank_0,& hipsolverSsytrf_bufferSize_rank_1,& hipsolverSsytrf_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDsytrf_bufferSize function hipsolverDsytrf_bufferSize_(handle,n,A,lda,lwork) & bind(c, name="hipsolverDsytrf_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrf_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDsytrf_bufferSize_assumed_rank #else module procedure & hipsolverDsytrf_bufferSize_rank_0,& hipsolverDsytrf_bufferSize_rank_1,& hipsolverDsytrf_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCsytrf_bufferSize function hipsolverCsytrf_bufferSize_(handle,n,A,lda,lwork) & bind(c, name="hipsolverCsytrf_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCsytrf_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCsytrf_bufferSize_assumed_rank #else module procedure & hipsolverCsytrf_bufferSize_rank_0,& hipsolverCsytrf_bufferSize_rank_1,& hipsolverCsytrf_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZsytrf_bufferSize function hipsolverZsytrf_bufferSize_(handle,n,A,lda,lwork) & bind(c, name="hipsolverZsytrf_bufferSize") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZsytrf_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZsytrf_bufferSize_assumed_rank #else module procedure & hipsolverZsytrf_bufferSize_rank_0,& hipsolverZsytrf_bufferSize_rank_1,& hipsolverZsytrf_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverSsytrf function hipsolverSsytrf_(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) & bind(c, name="hipsolverSsytrf") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrf_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverSsytrf_assumed_rank #else module procedure & hipsolverSsytrf_rank_0,& hipsolverSsytrf_rank_1,& hipsolverSsytrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverDsytrf function hipsolverDsytrf_(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) & bind(c, name="hipsolverDsytrf") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrf_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverDsytrf_assumed_rank #else module procedure & hipsolverDsytrf_rank_0,& hipsolverDsytrf_rank_1,& hipsolverDsytrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverCsytrf function hipsolverCsytrf_(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) & bind(c, name="hipsolverCsytrf") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCsytrf_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverCsytrf_assumed_rank #else module procedure & hipsolverCsytrf_rank_0,& hipsolverCsytrf_rank_1,& hipsolverCsytrf_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsolverZsytrf function hipsolverZsytrf_(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) & bind(c, name="hipsolverZsytrf") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZsytrf_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: work integer(c_int),value :: lwork integer(c_int) :: devInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsolverZsytrf_assumed_rank #else module procedure & hipsolverZsytrf_rank_0,& hipsolverZsytrf_rank_1,& hipsolverZsytrf_full_rank #endif #endif end interface #endif !> \brief An alias for `hipsolverCreate`. interface hipsolverDnCreate #ifdef USE_CUDA_NAMES function hipsolverDnCreate_(handle) bind(c, name="cusolverDnCreate") #else function hipsolverDnCreate_(handle) bind(c, name="hipsolverDnCreate") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCreate_ type(c_ptr) :: handle end function end interface !> \brief An alias for `hipsolverDestroy`. interface hipsolverDnDestroy #ifdef USE_CUDA_NAMES function hipsolverDnDestroy_(handle) bind(c, name="cusolverDnDestroy") #else function hipsolverDnDestroy_(handle) bind(c, name="hipsolverDnDestroy") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDestroy_ type(c_ptr),value :: handle end function end interface !> \brief An alias for `hipsolverSetStream`. interface hipsolverDnSetStream #ifdef USE_CUDA_NAMES function hipsolverDnSetStream_(handle,streamId) bind(c, name="cusolverDnSetStream") #else function hipsolverDnSetStream_(handle,streamId) bind(c, name="hipsolverDnSetStream") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSetStream_ type(c_ptr),value :: handle type(c_ptr),value :: streamId end function end interface !> \brief An alias for `hipsolverGetStream`. interface hipsolverDnGetStream #ifdef USE_CUDA_NAMES function hipsolverDnGetStream_(handle,streamId) bind(c, name="cusolverDnGetStream") #else function hipsolverDnGetStream_(handle,streamId) bind(c, name="hipsolverDnGetStream") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnGetStream_ type(c_ptr),value :: handle type(c_ptr) :: streamId end function end interface !> \brief An alias for `hipsolverSetDeterministicMode`. interface hipsolverDnSetDeterministicMode #ifdef USE_CUDA_NAMES function hipsolverDnSetDeterministicMode_(handle,mode) & bind(c, name="cusolverDnSetDeterministicMode") #else function hipsolverDnSetDeterministicMode_(handle,mode) & bind(c, name="hipsolverDnSetDeterministicMode") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSetDeterministicMode_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_DETERMINISTIC_RESULTS)),value :: mode end function end interface !> \brief An alias for `hipsolverGetDeterministicMode`. interface hipsolverDnGetDeterministicMode #ifdef USE_CUDA_NAMES function hipsolverDnGetDeterministicMode_(handle,mode) & bind(c, name="cusolverDnGetDeterministicMode") #else function hipsolverDnGetDeterministicMode_(handle,mode) & bind(c, name="hipsolverDnGetDeterministicMode") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnGetDeterministicMode_ type(c_ptr),value :: handle type(c_ptr),value :: mode end function end interface interface hipsolverDnCreateGesvdjInfo #ifdef USE_CUDA_NAMES function hipsolverDnCreateGesvdjInfo_(myInfo) bind(c, name="cusolverDnCreateGesvdjInfo") #else function hipsolverDnCreateGesvdjInfo_(myInfo) bind(c, name="hipsolverDnCreateGesvdjInfo") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCreateGesvdjInfo_ type(c_ptr) :: myInfo end function end interface interface hipsolverDnDestroyGesvdjInfo #ifdef USE_CUDA_NAMES function hipsolverDnDestroyGesvdjInfo_(myInfo) bind(c, name="cusolverDnDestroyGesvdjInfo") #else function hipsolverDnDestroyGesvdjInfo_(myInfo) bind(c, name="hipsolverDnDestroyGesvdjInfo") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDestroyGesvdjInfo_ type(c_ptr),value :: myInfo end function end interface interface hipsolverDnXgesvdjSetMaxSweeps #ifdef USE_CUDA_NAMES function hipsolverDnXgesvdjSetMaxSweeps_(myInfo,max_sweeps) & bind(c, name="cusolverDnXgesvdjSetMaxSweeps") #else function hipsolverDnXgesvdjSetMaxSweeps_(myInfo,max_sweeps) & bind(c, name="hipsolverDnXgesvdjSetMaxSweeps") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXgesvdjSetMaxSweeps_ type(c_ptr),value :: myInfo integer(c_int),value :: max_sweeps end function end interface interface hipsolverDnXgesvdjSetSortEig #ifdef USE_CUDA_NAMES function hipsolverDnXgesvdjSetSortEig_(myInfo,sort_eig) & bind(c, name="cusolverDnXgesvdjSetSortEig") #else function hipsolverDnXgesvdjSetSortEig_(myInfo,sort_eig) & bind(c, name="hipsolverDnXgesvdjSetSortEig") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXgesvdjSetSortEig_ type(c_ptr),value :: myInfo integer(c_int),value :: sort_eig end function end interface interface hipsolverDnXgesvdjSetTolerance #ifdef USE_CUDA_NAMES function hipsolverDnXgesvdjSetTolerance_(myInfo,tolerance) & bind(c, name="cusolverDnXgesvdjSetTolerance") #else function hipsolverDnXgesvdjSetTolerance_(myInfo,tolerance) & bind(c, name="hipsolverDnXgesvdjSetTolerance") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXgesvdjSetTolerance_ type(c_ptr),value :: myInfo real(c_double),value :: tolerance end function end interface interface hipsolverDnXgesvdjGetResidual #ifdef USE_CUDA_NAMES function hipsolverDnXgesvdjGetResidual_(handle,myInfo,residual) & bind(c, name="cusolverDnXgesvdjGetResidual") #else function hipsolverDnXgesvdjGetResidual_(handle,myInfo,residual) & bind(c, name="hipsolverDnXgesvdjGetResidual") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXgesvdjGetResidual_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo real(c_double) :: residual end function end interface interface hipsolverDnXgesvdjGetSweeps #ifdef USE_CUDA_NAMES function hipsolverDnXgesvdjGetSweeps_(handle,myInfo,executed_sweeps) & bind(c, name="cusolverDnXgesvdjGetSweeps") #else function hipsolverDnXgesvdjGetSweeps_(handle,myInfo,executed_sweeps) & bind(c, name="hipsolverDnXgesvdjGetSweeps") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXgesvdjGetSweeps_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int) :: executed_sweeps end function end interface interface hipsolverDnCreateSyevjInfo #ifdef USE_CUDA_NAMES function hipsolverDnCreateSyevjInfo_(myInfo) bind(c, name="cusolverDnCreateSyevjInfo") #else function hipsolverDnCreateSyevjInfo_(myInfo) bind(c, name="hipsolverDnCreateSyevjInfo") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCreateSyevjInfo_ type(c_ptr) :: myInfo end function end interface interface hipsolverDnDestroySyevjInfo #ifdef USE_CUDA_NAMES function hipsolverDnDestroySyevjInfo_(myInfo) bind(c, name="cusolverDnDestroySyevjInfo") #else function hipsolverDnDestroySyevjInfo_(myInfo) bind(c, name="hipsolverDnDestroySyevjInfo") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDestroySyevjInfo_ type(c_ptr),value :: myInfo end function end interface interface hipsolverDnXsyevjSetMaxSweeps #ifdef USE_CUDA_NAMES function hipsolverDnXsyevjSetMaxSweeps_(myInfo,max_sweeps) & bind(c, name="cusolverDnXsyevjSetMaxSweeps") #else function hipsolverDnXsyevjSetMaxSweeps_(myInfo,max_sweeps) & bind(c, name="hipsolverDnXsyevjSetMaxSweeps") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXsyevjSetMaxSweeps_ type(c_ptr),value :: myInfo integer(c_int),value :: max_sweeps end function end interface interface hipsolverDnXsyevjSetSortEig #ifdef USE_CUDA_NAMES function hipsolverDnXsyevjSetSortEig_(myInfo,sort_eig) & bind(c, name="cusolverDnXsyevjSetSortEig") #else function hipsolverDnXsyevjSetSortEig_(myInfo,sort_eig) & bind(c, name="hipsolverDnXsyevjSetSortEig") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXsyevjSetSortEig_ type(c_ptr),value :: myInfo integer(c_int),value :: sort_eig end function end interface interface hipsolverDnXsyevjSetTolerance #ifdef USE_CUDA_NAMES function hipsolverDnXsyevjSetTolerance_(myInfo,tolerance) & bind(c, name="cusolverDnXsyevjSetTolerance") #else function hipsolverDnXsyevjSetTolerance_(myInfo,tolerance) & bind(c, name="hipsolverDnXsyevjSetTolerance") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXsyevjSetTolerance_ type(c_ptr),value :: myInfo real(c_double),value :: tolerance end function end interface interface hipsolverDnXsyevjGetResidual #ifdef USE_CUDA_NAMES function hipsolverDnXsyevjGetResidual_(handle,myInfo,residual) & bind(c, name="cusolverDnXsyevjGetResidual") #else function hipsolverDnXsyevjGetResidual_(handle,myInfo,residual) & bind(c, name="hipsolverDnXsyevjGetResidual") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXsyevjGetResidual_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo real(c_double) :: residual end function end interface interface hipsolverDnXsyevjGetSweeps #ifdef USE_CUDA_NAMES function hipsolverDnXsyevjGetSweeps_(handle,myInfo,executed_sweeps) & bind(c, name="cusolverDnXsyevjGetSweeps") #else function hipsolverDnXsyevjGetSweeps_(handle,myInfo,executed_sweeps) & bind(c, name="hipsolverDnXsyevjGetSweeps") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXsyevjGetSweeps_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int) :: executed_sweeps end function end interface interface hipsolverDnSorgbr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSorgbr_bufferSize_(handle,side,m,n,k,A,lda,tau,lwork) & bind(c, name="cusolverDnSorgbr_bufferSize") #else function hipsolverDnSorgbr_bufferSize_(handle,side,m,n,k,A,lda,tau,lwork) & bind(c, name="hipsolverDnSorgbr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSorgbr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau integer(c_int) :: lwork end function end interface interface hipsolverDnDorgbr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDorgbr_bufferSize_(handle,side,m,n,k,A,lda,tau,lwork) & bind(c, name="cusolverDnDorgbr_bufferSize") #else function hipsolverDnDorgbr_bufferSize_(handle,side,m,n,k,A,lda,tau,lwork) & bind(c, name="hipsolverDnDorgbr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDorgbr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau integer(c_int) :: lwork end function end interface interface hipsolverDnCungbr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCungbr_bufferSize_(handle,side,m,n,k,A,lda,tau,lwork) & bind(c, name="cusolverDnCungbr_bufferSize") #else function hipsolverDnCungbr_bufferSize_(handle,side,m,n,k,A,lda,tau,lwork) & bind(c, name="hipsolverDnCungbr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCungbr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau integer(c_int) :: lwork end function end interface interface hipsolverDnZungbr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZungbr_bufferSize_(handle,side,m,n,k,A,lda,tau,lwork) & bind(c, name="cusolverDnZungbr_bufferSize") #else function hipsolverDnZungbr_bufferSize_(handle,side,m,n,k,A,lda,tau,lwork) & bind(c, name="hipsolverDnZungbr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZungbr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau integer(c_int) :: lwork end function end interface interface hipsolverDnSorgbr #ifdef USE_CUDA_NAMES function hipsolverDnSorgbr_(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="cusolverDnSorgbr") #else function hipsolverDnSorgbr_(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnSorgbr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSorgbr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDorgbr #ifdef USE_CUDA_NAMES function hipsolverDnDorgbr_(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="cusolverDnDorgbr") #else function hipsolverDnDorgbr_(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnDorgbr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDorgbr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnCungbr #ifdef USE_CUDA_NAMES function hipsolverDnCungbr_(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="cusolverDnCungbr") #else function hipsolverDnCungbr_(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnCungbr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCungbr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZungbr #ifdef USE_CUDA_NAMES function hipsolverDnZungbr_(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="cusolverDnZungbr") #else function hipsolverDnZungbr_(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnZungbr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZungbr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnSorgqr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSorgqr_bufferSize_(handle,m,n,k,A,lda,tau,lwork) & bind(c, name="cusolverDnSorgqr_bufferSize") #else function hipsolverDnSorgqr_bufferSize_(handle,m,n,k,A,lda,tau,lwork) & bind(c, name="hipsolverDnSorgqr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSorgqr_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau integer(c_int) :: lwork end function end interface interface hipsolverDnDorgqr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDorgqr_bufferSize_(handle,m,n,k,A,lda,tau,lwork) & bind(c, name="cusolverDnDorgqr_bufferSize") #else function hipsolverDnDorgqr_bufferSize_(handle,m,n,k,A,lda,tau,lwork) & bind(c, name="hipsolverDnDorgqr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDorgqr_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau integer(c_int) :: lwork end function end interface interface hipsolverDnCungqr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCungqr_bufferSize_(handle,m,n,k,A,lda,tau,lwork) & bind(c, name="cusolverDnCungqr_bufferSize") #else function hipsolverDnCungqr_bufferSize_(handle,m,n,k,A,lda,tau,lwork) & bind(c, name="hipsolverDnCungqr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCungqr_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau integer(c_int) :: lwork end function end interface interface hipsolverDnZungqr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZungqr_bufferSize_(handle,m,n,k,A,lda,tau,lwork) & bind(c, name="cusolverDnZungqr_bufferSize") #else function hipsolverDnZungqr_bufferSize_(handle,m,n,k,A,lda,tau,lwork) & bind(c, name="hipsolverDnZungqr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZungqr_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau integer(c_int) :: lwork end function end interface interface hipsolverDnSorgqr #ifdef USE_CUDA_NAMES function hipsolverDnSorgqr_(handle,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="cusolverDnSorgqr") #else function hipsolverDnSorgqr_(handle,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnSorgqr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSorgqr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDorgqr #ifdef USE_CUDA_NAMES function hipsolverDnDorgqr_(handle,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="cusolverDnDorgqr") #else function hipsolverDnDorgqr_(handle,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnDorgqr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDorgqr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnCungqr #ifdef USE_CUDA_NAMES function hipsolverDnCungqr_(handle,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="cusolverDnCungqr") #else function hipsolverDnCungqr_(handle,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnCungqr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCungqr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZungqr #ifdef USE_CUDA_NAMES function hipsolverDnZungqr_(handle,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="cusolverDnZungqr") #else function hipsolverDnZungqr_(handle,m,n,k,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnZungqr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZungqr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnSorgtr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSorgtr_bufferSize_(handle,uplo,n,A,lda,tau,lwork) & bind(c, name="cusolverDnSorgtr_bufferSize") #else function hipsolverDnSorgtr_bufferSize_(handle,uplo,n,A,lda,tau,lwork) & bind(c, name="hipsolverDnSorgtr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSorgtr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau integer(c_int) :: lwork end function end interface interface hipsolverDnDorgtr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDorgtr_bufferSize_(handle,uplo,n,A,lda,tau,lwork) & bind(c, name="cusolverDnDorgtr_bufferSize") #else function hipsolverDnDorgtr_bufferSize_(handle,uplo,n,A,lda,tau,lwork) & bind(c, name="hipsolverDnDorgtr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDorgtr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau integer(c_int) :: lwork end function end interface interface hipsolverDnCungtr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCungtr_bufferSize_(handle,uplo,n,A,lda,tau,lwork) & bind(c, name="cusolverDnCungtr_bufferSize") #else function hipsolverDnCungtr_bufferSize_(handle,uplo,n,A,lda,tau,lwork) & bind(c, name="hipsolverDnCungtr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCungtr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau integer(c_int) :: lwork end function end interface interface hipsolverDnZungtr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZungtr_bufferSize_(handle,uplo,n,A,lda,tau,lwork) & bind(c, name="cusolverDnZungtr_bufferSize") #else function hipsolverDnZungtr_bufferSize_(handle,uplo,n,A,lda,tau,lwork) & bind(c, name="hipsolverDnZungtr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZungtr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau integer(c_int) :: lwork end function end interface interface hipsolverDnSorgtr #ifdef USE_CUDA_NAMES function hipsolverDnSorgtr_(handle,uplo,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="cusolverDnSorgtr") #else function hipsolverDnSorgtr_(handle,uplo,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnSorgtr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSorgtr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDorgtr #ifdef USE_CUDA_NAMES function hipsolverDnDorgtr_(handle,uplo,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="cusolverDnDorgtr") #else function hipsolverDnDorgtr_(handle,uplo,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnDorgtr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDorgtr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnCungtr #ifdef USE_CUDA_NAMES function hipsolverDnCungtr_(handle,uplo,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="cusolverDnCungtr") #else function hipsolverDnCungtr_(handle,uplo,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnCungtr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCungtr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZungtr #ifdef USE_CUDA_NAMES function hipsolverDnZungtr_(handle,uplo,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="cusolverDnZungtr") #else function hipsolverDnZungtr_(handle,uplo,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnZungtr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZungtr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnSormqr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSormqr_bufferSize_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) & bind(c, name="cusolverDnSormqr_bufferSize") #else function hipsolverDnSormqr_bufferSize_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) & bind(c, name="hipsolverDnSormqr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSormqr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int) :: lwork end function end interface interface hipsolverDnDormqr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDormqr_bufferSize_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) & bind(c, name="cusolverDnDormqr_bufferSize") #else function hipsolverDnDormqr_bufferSize_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) & bind(c, name="hipsolverDnDormqr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDormqr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int) :: lwork end function end interface interface hipsolverDnCunmqr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCunmqr_bufferSize_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) & bind(c, name="cusolverDnCunmqr_bufferSize") #else function hipsolverDnCunmqr_bufferSize_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) & bind(c, name="hipsolverDnCunmqr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCunmqr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int) :: lwork end function end interface interface hipsolverDnZunmqr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZunmqr_bufferSize_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) & bind(c, name="cusolverDnZunmqr_bufferSize") #else function hipsolverDnZunmqr_bufferSize_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) & bind(c, name="hipsolverDnZunmqr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZunmqr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int) :: lwork end function end interface interface hipsolverDnSormqr #ifdef USE_CUDA_NAMES function hipsolverDnSormqr_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="cusolverDnSormqr") #else function hipsolverDnSormqr_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="hipsolverDnSormqr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSormqr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDormqr #ifdef USE_CUDA_NAMES function hipsolverDnDormqr_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="cusolverDnDormqr") #else function hipsolverDnDormqr_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="hipsolverDnDormqr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDormqr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnCunmqr #ifdef USE_CUDA_NAMES function hipsolverDnCunmqr_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="cusolverDnCunmqr") #else function hipsolverDnCunmqr_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="hipsolverDnCunmqr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCunmqr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZunmqr #ifdef USE_CUDA_NAMES function hipsolverDnZunmqr_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="cusolverDnZunmqr") #else function hipsolverDnZunmqr_(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="hipsolverDnZunmqr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZunmqr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnSormtr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSormtr_bufferSize_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) & bind(c, name="cusolverDnSormtr_bufferSize") #else function hipsolverDnSormtr_bufferSize_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) & bind(c, name="hipsolverDnSormtr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSormtr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int) :: lwork end function end interface interface hipsolverDnDormtr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDormtr_bufferSize_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) & bind(c, name="cusolverDnDormtr_bufferSize") #else function hipsolverDnDormtr_bufferSize_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) & bind(c, name="hipsolverDnDormtr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDormtr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int) :: lwork end function end interface interface hipsolverDnCunmtr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCunmtr_bufferSize_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) & bind(c, name="cusolverDnCunmtr_bufferSize") #else function hipsolverDnCunmtr_bufferSize_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) & bind(c, name="hipsolverDnCunmtr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCunmtr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int) :: lwork end function end interface interface hipsolverDnZunmtr_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZunmtr_bufferSize_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) & bind(c, name="cusolverDnZunmtr_bufferSize") #else function hipsolverDnZunmtr_bufferSize_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) & bind(c, name="hipsolverDnZunmtr_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZunmtr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int) :: lwork end function end interface interface hipsolverDnSormtr #ifdef USE_CUDA_NAMES function hipsolverDnSormtr_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="cusolverDnSormtr") #else function hipsolverDnSormtr_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="hipsolverDnSormtr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSormtr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDormtr #ifdef USE_CUDA_NAMES function hipsolverDnDormtr_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="cusolverDnDormtr") #else function hipsolverDnDormtr_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="hipsolverDnDormtr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDormtr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnCunmtr #ifdef USE_CUDA_NAMES function hipsolverDnCunmtr_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="cusolverDnCunmtr") #else function hipsolverDnCunmtr_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="hipsolverDnCunmtr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCunmtr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZunmtr #ifdef USE_CUDA_NAMES function hipsolverDnZunmtr_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="cusolverDnZunmtr") #else function hipsolverDnZunmtr_(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) & bind(c, name="hipsolverDnZunmtr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZunmtr_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_SIDE_LEFT)),value :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: tau type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnSgebrd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSgebrd_bufferSize_(handle,m,n,lwork) & bind(c, name="cusolverDnSgebrd_bufferSize") #else function hipsolverDnSgebrd_bufferSize_(handle,m,n,lwork) & bind(c, name="hipsolverDnSgebrd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSgebrd_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int) :: lwork end function end interface interface hipsolverDnDgebrd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDgebrd_bufferSize_(handle,m,n,lwork) & bind(c, name="cusolverDnDgebrd_bufferSize") #else function hipsolverDnDgebrd_bufferSize_(handle,m,n,lwork) & bind(c, name="hipsolverDnDgebrd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDgebrd_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int) :: lwork end function end interface interface hipsolverDnCgebrd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCgebrd_bufferSize_(handle,m,n,lwork) & bind(c, name="cusolverDnCgebrd_bufferSize") #else function hipsolverDnCgebrd_bufferSize_(handle,m,n,lwork) & bind(c, name="hipsolverDnCgebrd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCgebrd_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int) :: lwork end function end interface interface hipsolverDnZgebrd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZgebrd_bufferSize_(handle,m,n,lwork) & bind(c, name="cusolverDnZgebrd_bufferSize") #else function hipsolverDnZgebrd_bufferSize_(handle,m,n,lwork) & bind(c, name="hipsolverDnZgebrd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZgebrd_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int) :: lwork end function end interface interface hipsolverDnSgebrd #ifdef USE_CUDA_NAMES function hipsolverDnSgebrd_(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) & bind(c, name="cusolverDnSgebrd") #else function hipsolverDnSgebrd_(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) & bind(c, name="hipsolverDnSgebrd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSgebrd_ 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 type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDgebrd #ifdef USE_CUDA_NAMES function hipsolverDnDgebrd_(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) & bind(c, name="cusolverDnDgebrd") #else function hipsolverDnDgebrd_(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) & bind(c, name="hipsolverDnDgebrd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDgebrd_ 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 type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnCgebrd #ifdef USE_CUDA_NAMES function hipsolverDnCgebrd_(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) & bind(c, name="cusolverDnCgebrd") #else function hipsolverDnCgebrd_(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) & bind(c, name="hipsolverDnCgebrd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCgebrd_ 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 type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZgebrd #ifdef USE_CUDA_NAMES function hipsolverDnZgebrd_(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) & bind(c, name="cusolverDnZgebrd") #else function hipsolverDnZgebrd_(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) & bind(c, name="hipsolverDnZgebrd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZgebrd_ 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 type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnSSgels_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSSgels_bufferSize_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork) & bind(c, name="cusolverDnSSgels_bufferSize") #else function hipsolverDnSSgels_bufferSize_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork) & bind(c, name="hipsolverDnSSgels_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSSgels_bufferSize_ type(c_ptr),value :: handle 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 :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t) :: lwork end function end interface interface hipsolverDnDDgels_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDDgels_bufferSize_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork) & bind(c, name="cusolverDnDDgels_bufferSize") #else function hipsolverDnDDgels_bufferSize_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork) & bind(c, name="hipsolverDnDDgels_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDDgels_bufferSize_ type(c_ptr),value :: handle 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 :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t) :: lwork end function end interface interface hipsolverDnCCgels_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCCgels_bufferSize_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork) & bind(c, name="cusolverDnCCgels_bufferSize") #else function hipsolverDnCCgels_bufferSize_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork) & bind(c, name="hipsolverDnCCgels_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCCgels_bufferSize_ type(c_ptr),value :: handle 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 :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t) :: lwork end function end interface interface hipsolverDnZZgels_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZZgels_bufferSize_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork) & bind(c, name="cusolverDnZZgels_bufferSize") #else function hipsolverDnZZgels_bufferSize_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork) & bind(c, name="hipsolverDnZZgels_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZZgels_bufferSize_ type(c_ptr),value :: handle 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 :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t) :: lwork end function end interface interface hipsolverDnSSgels #ifdef USE_CUDA_NAMES function hipsolverDnSSgels_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="cusolverDnSSgels") #else function hipsolverDnSSgels_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="hipsolverDnSSgels") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSSgels_ type(c_ptr),value :: handle 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 :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t),value :: lwork type(c_ptr),value :: niters type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDDgels #ifdef USE_CUDA_NAMES function hipsolverDnDDgels_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="cusolverDnDDgels") #else function hipsolverDnDDgels_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="hipsolverDnDDgels") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDDgels_ type(c_ptr),value :: handle 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 :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t),value :: lwork type(c_ptr),value :: niters type(c_ptr),value :: devInfo end function end interface interface hipsolverDnCCgels #ifdef USE_CUDA_NAMES function hipsolverDnCCgels_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="cusolverDnCCgels") #else function hipsolverDnCCgels_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="hipsolverDnCCgels") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCCgels_ type(c_ptr),value :: handle 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 :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t),value :: lwork type(c_ptr),value :: niters type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZZgels #ifdef USE_CUDA_NAMES function hipsolverDnZZgels_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="cusolverDnZZgels") #else function hipsolverDnZZgels_(handle,m,n,nrhs,A,lda,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="hipsolverDnZZgels") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZZgels_ type(c_ptr),value :: handle 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 :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t),value :: lwork type(c_ptr),value :: niters type(c_ptr),value :: devInfo end function end interface interface hipsolverDnSgeqrf_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSgeqrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="cusolverDnSgeqrf_bufferSize") #else function hipsolverDnSgeqrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="hipsolverDnSgeqrf_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSgeqrf_bufferSize_ 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) :: lwork end function end interface interface hipsolverDnDgeqrf_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDgeqrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="cusolverDnDgeqrf_bufferSize") #else function hipsolverDnDgeqrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="hipsolverDnDgeqrf_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDgeqrf_bufferSize_ 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) :: lwork end function end interface interface hipsolverDnCgeqrf_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCgeqrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="cusolverDnCgeqrf_bufferSize") #else function hipsolverDnCgeqrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="hipsolverDnCgeqrf_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCgeqrf_bufferSize_ 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) :: lwork end function end interface interface hipsolverDnZgeqrf_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZgeqrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="cusolverDnZgeqrf_bufferSize") #else function hipsolverDnZgeqrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="hipsolverDnZgeqrf_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZgeqrf_bufferSize_ 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) :: lwork end function end interface interface hipsolverDnSgeqrf #ifdef USE_CUDA_NAMES function hipsolverDnSgeqrf_(handle,m,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="cusolverDnSgeqrf") #else function hipsolverDnSgeqrf_(handle,m,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnSgeqrf") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSgeqrf_ 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 type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDgeqrf #ifdef USE_CUDA_NAMES function hipsolverDnDgeqrf_(handle,m,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="cusolverDnDgeqrf") #else function hipsolverDnDgeqrf_(handle,m,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnDgeqrf") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDgeqrf_ 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 type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnCgeqrf #ifdef USE_CUDA_NAMES function hipsolverDnCgeqrf_(handle,m,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="cusolverDnCgeqrf") #else function hipsolverDnCgeqrf_(handle,m,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnCgeqrf") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCgeqrf_ 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 type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZgeqrf #ifdef USE_CUDA_NAMES function hipsolverDnZgeqrf_(handle,m,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="cusolverDnZgeqrf") #else function hipsolverDnZgeqrf_(handle,m,n,A,lda,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnZgeqrf") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZgeqrf_ 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 type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnSSgesv_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSSgesv_bufferSize_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork) & bind(c, name="cusolverDnSSgesv_bufferSize") #else function hipsolverDnSSgesv_bufferSize_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork) & bind(c, name="hipsolverDnSSgesv_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSSgesv_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t) :: lwork end function end interface interface hipsolverDnDDgesv_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDDgesv_bufferSize_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork) & bind(c, name="cusolverDnDDgesv_bufferSize") #else function hipsolverDnDDgesv_bufferSize_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork) & bind(c, name="hipsolverDnDDgesv_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDDgesv_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t) :: lwork end function end interface interface hipsolverDnCCgesv_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCCgesv_bufferSize_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork) & bind(c, name="cusolverDnCCgesv_bufferSize") #else function hipsolverDnCCgesv_bufferSize_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork) & bind(c, name="hipsolverDnCCgesv_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCCgesv_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t) :: lwork end function end interface interface hipsolverDnZZgesv_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZZgesv_bufferSize_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork) & bind(c, name="cusolverDnZZgesv_bufferSize") #else function hipsolverDnZZgesv_bufferSize_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork) & bind(c, name="hipsolverDnZZgesv_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZZgesv_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t) :: lwork end function end interface interface hipsolverDnSSgesv #ifdef USE_CUDA_NAMES function hipsolverDnSSgesv_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="cusolverDnSSgesv") #else function hipsolverDnSSgesv_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="hipsolverDnSSgesv") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSSgesv_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t),value :: lwork type(c_ptr),value :: niters type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDDgesv #ifdef USE_CUDA_NAMES function hipsolverDnDDgesv_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="cusolverDnDDgesv") #else function hipsolverDnDDgesv_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="hipsolverDnDDgesv") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDDgesv_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t),value :: lwork type(c_ptr),value :: niters type(c_ptr),value :: devInfo end function end interface interface hipsolverDnCCgesv #ifdef USE_CUDA_NAMES function hipsolverDnCCgesv_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="cusolverDnCCgesv") #else function hipsolverDnCCgesv_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="hipsolverDnCCgesv") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCCgesv_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t),value :: lwork type(c_ptr),value :: niters type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZZgesv #ifdef USE_CUDA_NAMES function hipsolverDnZZgesv_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="cusolverDnZZgesv") #else function hipsolverDnZZgesv_(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters,devInfo) & bind(c, name="hipsolverDnZZgesv") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZZgesv_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx type(c_ptr),value :: work integer(c_size_t),value :: lwork type(c_ptr),value :: niters type(c_ptr),value :: devInfo end function end interface interface hipsolverDnSgesvd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSgesvd_bufferSize_(handle,m,n,lwork) & bind(c, name="cusolverDnSgesvd_bufferSize") #else function hipsolverDnSgesvd_bufferSize_(handle,m,n,lwork) & bind(c, name="hipsolverDnSgesvd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSgesvd_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int) :: lwork end function end interface interface hipsolverDnDgesvd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDgesvd_bufferSize_(handle,m,n,lwork) & bind(c, name="cusolverDnDgesvd_bufferSize") #else function hipsolverDnDgesvd_bufferSize_(handle,m,n,lwork) & bind(c, name="hipsolverDnDgesvd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDgesvd_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int) :: lwork end function end interface interface hipsolverDnCgesvd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCgesvd_bufferSize_(handle,m,n,lwork) & bind(c, name="cusolverDnCgesvd_bufferSize") #else function hipsolverDnCgesvd_bufferSize_(handle,m,n,lwork) & bind(c, name="hipsolverDnCgesvd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCgesvd_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int) :: lwork end function end interface interface hipsolverDnZgesvd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZgesvd_bufferSize_(handle,m,n,lwork) & bind(c, name="cusolverDnZgesvd_bufferSize") #else function hipsolverDnZgesvd_bufferSize_(handle,m,n,lwork) & bind(c, name="hipsolverDnZgesvd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZgesvd_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int) :: lwork end function end interface interface hipsolverDnSgesvd #ifdef USE_CUDA_NAMES function hipsolverDnSgesvd_(handle,jobu,jobv,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,rwork,devInfo) & bind(c, name="cusolverDnSgesvd") #else function hipsolverDnSgesvd_(handle,jobu,jobv,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,rwork,devInfo) & bind(c, name="hipsolverDnSgesvd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSgesvd_ type(c_ptr),value :: handle character(c_char),value :: jobu character(c_char),value :: jobv integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: rwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDgesvd #ifdef USE_CUDA_NAMES function hipsolverDnDgesvd_(handle,jobu,jobv,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,rwork,devInfo) & bind(c, name="cusolverDnDgesvd") #else function hipsolverDnDgesvd_(handle,jobu,jobv,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,rwork,devInfo) & bind(c, name="hipsolverDnDgesvd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDgesvd_ type(c_ptr),value :: handle character(c_char),value :: jobu character(c_char),value :: jobv integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: rwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnCgesvd #ifdef USE_CUDA_NAMES function hipsolverDnCgesvd_(handle,jobu,jobv,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,rwork,devInfo) & bind(c, name="cusolverDnCgesvd") #else function hipsolverDnCgesvd_(handle,jobu,jobv,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,rwork,devInfo) & bind(c, name="hipsolverDnCgesvd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCgesvd_ type(c_ptr),value :: handle character(c_char),value :: jobu character(c_char),value :: jobv integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: rwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZgesvd #ifdef USE_CUDA_NAMES function hipsolverDnZgesvd_(handle,jobu,jobv,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,rwork,devInfo) & bind(c, name="cusolverDnZgesvd") #else function hipsolverDnZgesvd_(handle,jobu,jobv,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,rwork,devInfo) & bind(c, name="hipsolverDnZgesvd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZgesvd_ type(c_ptr),value :: handle character(c_char),value :: jobu character(c_char),value :: jobv integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: rwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnSgesvdj_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSgesvdj_bufferSize_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,lwork,params) & bind(c, name="cusolverDnSgesvdj_bufferSize") #else function hipsolverDnSgesvdj_bufferSize_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,lwork,params) & bind(c, name="hipsolverDnSgesvdj_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSgesvdj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: econ integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int) :: lwork type(c_ptr),value :: params end function end interface interface hipsolverDnDgesvdj_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDgesvdj_bufferSize_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,lwork,params) & bind(c, name="cusolverDnDgesvdj_bufferSize") #else function hipsolverDnDgesvdj_bufferSize_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,lwork,params) & bind(c, name="hipsolverDnDgesvdj_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDgesvdj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: econ integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int) :: lwork type(c_ptr),value :: params end function end interface interface hipsolverDnCgesvdj_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCgesvdj_bufferSize_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,lwork,params) & bind(c, name="cusolverDnCgesvdj_bufferSize") #else function hipsolverDnCgesvdj_bufferSize_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,lwork,params) & bind(c, name="hipsolverDnCgesvdj_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCgesvdj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: econ integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int) :: lwork type(c_ptr),value :: params end function end interface interface hipsolverDnZgesvdj_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZgesvdj_bufferSize_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,lwork,params) & bind(c, name="cusolverDnZgesvdj_bufferSize") #else function hipsolverDnZgesvdj_bufferSize_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,lwork,params) & bind(c, name="hipsolverDnZgesvdj_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZgesvdj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: econ integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int) :: lwork type(c_ptr),value :: params end function end interface interface hipsolverDnSgesvdj #ifdef USE_CUDA_NAMES function hipsolverDnSgesvdj_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params) & bind(c, name="cusolverDnSgesvdj") #else function hipsolverDnSgesvdj_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params) & bind(c, name="hipsolverDnSgesvdj") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSgesvdj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: econ integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params end function end interface interface hipsolverDnDgesvdj #ifdef USE_CUDA_NAMES function hipsolverDnDgesvdj_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params) & bind(c, name="cusolverDnDgesvdj") #else function hipsolverDnDgesvdj_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params) & bind(c, name="hipsolverDnDgesvdj") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDgesvdj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: econ integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params end function end interface interface hipsolverDnCgesvdj #ifdef USE_CUDA_NAMES function hipsolverDnCgesvdj_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params) & bind(c, name="cusolverDnCgesvdj") #else function hipsolverDnCgesvdj_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params) & bind(c, name="hipsolverDnCgesvdj") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCgesvdj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: econ integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params end function end interface interface hipsolverDnZgesvdj #ifdef USE_CUDA_NAMES function hipsolverDnZgesvdj_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params) & bind(c, name="cusolverDnZgesvdj") #else function hipsolverDnZgesvdj_(handle,jobz,econ,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params) & bind(c, name="hipsolverDnZgesvdj") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZgesvdj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: econ integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params end function end interface interface hipsolverDnSgesvdjBatched_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSgesvdjBatched_bufferSize_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,lwork, & params,batch_count) & bind(c, name="cusolverDnSgesvdjBatched_bufferSize") #else function hipsolverDnSgesvdjBatched_bufferSize_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,lwork, & params,batch_count) & bind(c, name="hipsolverDnSgesvdjBatched_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSgesvdjBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int) :: lwork type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface interface hipsolverDnDgesvdjBatched_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDgesvdjBatched_bufferSize_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,lwork, & params,batch_count) & bind(c, name="cusolverDnDgesvdjBatched_bufferSize") #else function hipsolverDnDgesvdjBatched_bufferSize_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,lwork, & params,batch_count) & bind(c, name="hipsolverDnDgesvdjBatched_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDgesvdjBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int) :: lwork type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface interface hipsolverDnCgesvdjBatched_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCgesvdjBatched_bufferSize_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,lwork, & params,batch_count) & bind(c, name="cusolverDnCgesvdjBatched_bufferSize") #else function hipsolverDnCgesvdjBatched_bufferSize_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,lwork, & params,batch_count) & bind(c, name="hipsolverDnCgesvdjBatched_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCgesvdjBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int) :: lwork type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface interface hipsolverDnZgesvdjBatched_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZgesvdjBatched_bufferSize_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,lwork, & params,batch_count) & bind(c, name="cusolverDnZgesvdjBatched_bufferSize") #else function hipsolverDnZgesvdjBatched_bufferSize_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,lwork, & params,batch_count) & bind(c, name="hipsolverDnZgesvdjBatched_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZgesvdjBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int) :: lwork type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface interface hipsolverDnSgesvdjBatched #ifdef USE_CUDA_NAMES function hipsolverDnSgesvdjBatched_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params,batch_count) & bind(c, name="cusolverDnSgesvdjBatched") #else function hipsolverDnSgesvdjBatched_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params,batch_count) & bind(c, name="hipsolverDnSgesvdjBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSgesvdjBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface interface hipsolverDnDgesvdjBatched #ifdef USE_CUDA_NAMES function hipsolverDnDgesvdjBatched_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params,batch_count) & bind(c, name="cusolverDnDgesvdjBatched") #else function hipsolverDnDgesvdjBatched_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params,batch_count) & bind(c, name="hipsolverDnDgesvdjBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDgesvdjBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface interface hipsolverDnCgesvdjBatched #ifdef USE_CUDA_NAMES function hipsolverDnCgesvdjBatched_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params,batch_count) & bind(c, name="cusolverDnCgesvdjBatched") #else function hipsolverDnCgesvdjBatched_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params,batch_count) & bind(c, name="hipsolverDnCgesvdjBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCgesvdjBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface interface hipsolverDnZgesvdjBatched #ifdef USE_CUDA_NAMES function hipsolverDnZgesvdjBatched_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params,batch_count) & bind(c, name="cusolverDnZgesvdjBatched") #else function hipsolverDnZgesvdjBatched_(handle,jobz,m,n,A,lda,S,U,ldu,V,ldv,work,lwork,devInfo, & params,batch_count) & bind(c, name="hipsolverDnZgesvdjBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZgesvdjBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface interface hipsolverDnSgesvdaStridedBatched_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSgesvdaStridedBatched_bufferSize_(handle,jobz,rank,m,n,A,lda,strideA,S, & strideS,U,ldu,strideU,V,ldv,strideV,lwork,batch_count) & bind(c, name="cusolverDnSgesvdaStridedBatched_bufferSize") #else function hipsolverDnSgesvdaStridedBatched_bufferSize_(handle,jobz,rank,m,n,A,lda,strideA,S, & strideS,U,ldu,strideU,V,ldv,strideV,lwork,batch_count) & bind(c, name="hipsolverDnSgesvdaStridedBatched_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSgesvdaStridedBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: rank integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV integer(c_int) :: lwork integer(c_int),value :: batch_count end function end interface interface hipsolverDnDgesvdaStridedBatched_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDgesvdaStridedBatched_bufferSize_(handle,jobz,rank,m,n,A,lda,strideA,S, & strideS,U,ldu,strideU,V,ldv,strideV,lwork,batch_count) & bind(c, name="cusolverDnDgesvdaStridedBatched_bufferSize") #else function hipsolverDnDgesvdaStridedBatched_bufferSize_(handle,jobz,rank,m,n,A,lda,strideA,S, & strideS,U,ldu,strideU,V,ldv,strideV,lwork,batch_count) & bind(c, name="hipsolverDnDgesvdaStridedBatched_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDgesvdaStridedBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: rank integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV integer(c_int) :: lwork integer(c_int),value :: batch_count end function end interface interface hipsolverDnCgesvdaStridedBatched_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCgesvdaStridedBatched_bufferSize_(handle,jobz,rank,m,n,A,lda,strideA,S, & strideS,U,ldu,strideU,V,ldv,strideV,lwork,batch_count) & bind(c, name="cusolverDnCgesvdaStridedBatched_bufferSize") #else function hipsolverDnCgesvdaStridedBatched_bufferSize_(handle,jobz,rank,m,n,A,lda,strideA,S, & strideS,U,ldu,strideU,V,ldv,strideV,lwork,batch_count) & bind(c, name="hipsolverDnCgesvdaStridedBatched_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCgesvdaStridedBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: rank integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV integer(c_int) :: lwork integer(c_int),value :: batch_count end function end interface interface hipsolverDnZgesvdaStridedBatched_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZgesvdaStridedBatched_bufferSize_(handle,jobz,rank,m,n,A,lda,strideA,S, & strideS,U,ldu,strideU,V,ldv,strideV,lwork,batch_count) & bind(c, name="cusolverDnZgesvdaStridedBatched_bufferSize") #else function hipsolverDnZgesvdaStridedBatched_bufferSize_(handle,jobz,rank,m,n,A,lda,strideA,S, & strideS,U,ldu,strideU,V,ldv,strideV,lwork,batch_count) & bind(c, name="hipsolverDnZgesvdaStridedBatched_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZgesvdaStridedBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: rank integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV integer(c_int) :: lwork integer(c_int),value :: batch_count end function end interface interface hipsolverDnSgesvdaStridedBatched #ifdef USE_CUDA_NAMES function hipsolverDnSgesvdaStridedBatched_(handle,jobz,rank,m,n,A,lda,strideA,S,strideS,U,ldu, & strideU,V,ldv,strideV,work,lwork,devInfo,hRnrmF,batch_count) & bind(c, name="cusolverDnSgesvdaStridedBatched") #else function hipsolverDnSgesvdaStridedBatched_(handle,jobz,rank,m,n,A,lda,strideA,S,strideS,U,ldu, & strideU,V,ldv,strideV,work,lwork,devInfo,hRnrmF,batch_count) & bind(c, name="hipsolverDnSgesvdaStridedBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSgesvdaStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: rank integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: hRnrmF integer(c_int),value :: batch_count end function end interface interface hipsolverDnDgesvdaStridedBatched #ifdef USE_CUDA_NAMES function hipsolverDnDgesvdaStridedBatched_(handle,jobz,rank,m,n,A,lda,strideA,S,strideS,U,ldu, & strideU,V,ldv,strideV,work,lwork,devInfo,hRnrmF,batch_count) & bind(c, name="cusolverDnDgesvdaStridedBatched") #else function hipsolverDnDgesvdaStridedBatched_(handle,jobz,rank,m,n,A,lda,strideA,S,strideS,U,ldu, & strideU,V,ldv,strideV,work,lwork,devInfo,hRnrmF,batch_count) & bind(c, name="hipsolverDnDgesvdaStridedBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDgesvdaStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: rank integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: hRnrmF integer(c_int),value :: batch_count end function end interface interface hipsolverDnCgesvdaStridedBatched #ifdef USE_CUDA_NAMES function hipsolverDnCgesvdaStridedBatched_(handle,jobz,rank,m,n,A,lda,strideA,S,strideS,U,ldu, & strideU,V,ldv,strideV,work,lwork,devInfo,hRnrmF,batch_count) & bind(c, name="cusolverDnCgesvdaStridedBatched") #else function hipsolverDnCgesvdaStridedBatched_(handle,jobz,rank,m,n,A,lda,strideA,S,strideS,U,ldu, & strideU,V,ldv,strideV,work,lwork,devInfo,hRnrmF,batch_count) & bind(c, name="hipsolverDnCgesvdaStridedBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCgesvdaStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: rank integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: hRnrmF integer(c_int),value :: batch_count end function end interface interface hipsolverDnZgesvdaStridedBatched #ifdef USE_CUDA_NAMES function hipsolverDnZgesvdaStridedBatched_(handle,jobz,rank,m,n,A,lda,strideA,S,strideS,U,ldu, & strideU,V,ldv,strideV,work,lwork,devInfo,hRnrmF,batch_count) & bind(c, name="cusolverDnZgesvdaStridedBatched") #else function hipsolverDnZgesvdaStridedBatched_(handle,jobz,rank,m,n,A,lda,strideA,S,strideS,U,ldu, & strideU,V,ldv,strideV,work,lwork,devInfo,hRnrmF,batch_count) & bind(c, name="hipsolverDnZgesvdaStridedBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZgesvdaStridedBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(c_int),value :: rank integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: hRnrmF integer(c_int),value :: batch_count end function end interface interface hipsolverDnSgetrf_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSgetrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="cusolverDnSgetrf_bufferSize") #else function hipsolverDnSgetrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="hipsolverDnSgetrf_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSgetrf_bufferSize_ 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) :: lwork end function end interface interface hipsolverDnDgetrf_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDgetrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="cusolverDnDgetrf_bufferSize") #else function hipsolverDnDgetrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="hipsolverDnDgetrf_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDgetrf_bufferSize_ 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) :: lwork end function end interface interface hipsolverDnCgetrf_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCgetrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="cusolverDnCgetrf_bufferSize") #else function hipsolverDnCgetrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="hipsolverDnCgetrf_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCgetrf_bufferSize_ 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) :: lwork end function end interface interface hipsolverDnZgetrf_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZgetrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="cusolverDnZgetrf_bufferSize") #else function hipsolverDnZgetrf_bufferSize_(handle,m,n,A,lda,lwork) & bind(c, name="hipsolverDnZgetrf_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZgetrf_bufferSize_ 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) :: lwork end function end interface interface hipsolverDnSgetrf #ifdef USE_CUDA_NAMES function hipsolverDnSgetrf_(handle,m,n,A,lda,work,devIpiv,devInfo) & bind(c, name="cusolverDnSgetrf") #else function hipsolverDnSgetrf_(handle,m,n,A,lda,work,devIpiv,devInfo) & bind(c, name="hipsolverDnSgetrf") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSgetrf_ 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 type(c_ptr),value :: work type(c_ptr),value :: devIpiv type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDgetrf #ifdef USE_CUDA_NAMES function hipsolverDnDgetrf_(handle,m,n,A,lda,work,devIpiv,devInfo) & bind(c, name="cusolverDnDgetrf") #else function hipsolverDnDgetrf_(handle,m,n,A,lda,work,devIpiv,devInfo) & bind(c, name="hipsolverDnDgetrf") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDgetrf_ 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 type(c_ptr),value :: work type(c_ptr),value :: devIpiv type(c_ptr),value :: devInfo end function end interface interface hipsolverDnCgetrf #ifdef USE_CUDA_NAMES function hipsolverDnCgetrf_(handle,m,n,A,lda,work,devIpiv,devInfo) & bind(c, name="cusolverDnCgetrf") #else function hipsolverDnCgetrf_(handle,m,n,A,lda,work,devIpiv,devInfo) & bind(c, name="hipsolverDnCgetrf") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCgetrf_ 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 type(c_ptr),value :: work type(c_ptr),value :: devIpiv type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZgetrf #ifdef USE_CUDA_NAMES function hipsolverDnZgetrf_(handle,m,n,A,lda,work,devIpiv,devInfo) & bind(c, name="cusolverDnZgetrf") #else function hipsolverDnZgetrf_(handle,m,n,A,lda,work,devIpiv,devInfo) & bind(c, name="hipsolverDnZgetrf") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZgetrf_ 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 type(c_ptr),value :: work type(c_ptr),value :: devIpiv type(c_ptr),value :: devInfo end function end interface interface hipsolverDnSgetrs #ifdef USE_CUDA_NAMES function hipsolverDnSgetrs_(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,devInfo) & bind(c, name="cusolverDnSgetrs") #else function hipsolverDnSgetrs_(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,devInfo) & bind(c, name="hipsolverDnSgetrs") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSgetrs_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDgetrs #ifdef USE_CUDA_NAMES function hipsolverDnDgetrs_(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,devInfo) & bind(c, name="cusolverDnDgetrs") #else function hipsolverDnDgetrs_(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,devInfo) & bind(c, name="hipsolverDnDgetrs") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDgetrs_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: devInfo end function end interface interface hipsolverDnCgetrs #ifdef USE_CUDA_NAMES function hipsolverDnCgetrs_(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,devInfo) & bind(c, name="cusolverDnCgetrs") #else function hipsolverDnCgetrs_(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,devInfo) & bind(c, name="hipsolverDnCgetrs") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCgetrs_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZgetrs #ifdef USE_CUDA_NAMES function hipsolverDnZgetrs_(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,devInfo) & bind(c, name="cusolverDnZgetrs") #else function hipsolverDnZgetrs_(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,devInfo) & bind(c, name="hipsolverDnZgetrs") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZgetrs_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devIpiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: devInfo end function end interface interface hipsolverDnSpotrf_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSpotrf_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="cusolverDnSpotrf_bufferSize") #else function hipsolverDnSpotrf_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="hipsolverDnSpotrf_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSpotrf_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function end interface interface hipsolverDnDpotrf_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDpotrf_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="cusolverDnDpotrf_bufferSize") #else function hipsolverDnDpotrf_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="hipsolverDnDpotrf_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDpotrf_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function end interface interface hipsolverDnCpotrf_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCpotrf_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="cusolverDnCpotrf_bufferSize") #else function hipsolverDnCpotrf_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="hipsolverDnCpotrf_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCpotrf_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function end interface interface hipsolverDnZpotrf_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZpotrf_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="cusolverDnZpotrf_bufferSize") #else function hipsolverDnZpotrf_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="hipsolverDnZpotrf_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZpotrf_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function end interface interface hipsolverDnSpotrf #ifdef USE_CUDA_NAMES function hipsolverDnSpotrf_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="cusolverDnSpotrf") #else function hipsolverDnSpotrf_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="hipsolverDnSpotrf") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSpotrf_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDpotrf #ifdef USE_CUDA_NAMES function hipsolverDnDpotrf_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="cusolverDnDpotrf") #else function hipsolverDnDpotrf_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="hipsolverDnDpotrf") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDpotrf_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnCpotrf #ifdef USE_CUDA_NAMES function hipsolverDnCpotrf_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="cusolverDnCpotrf") #else function hipsolverDnCpotrf_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="hipsolverDnCpotrf") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCpotrf_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZpotrf #ifdef USE_CUDA_NAMES function hipsolverDnZpotrf_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="cusolverDnZpotrf") #else function hipsolverDnZpotrf_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="hipsolverDnZpotrf") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZpotrf_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnSpotrfBatched #ifdef USE_CUDA_NAMES function hipsolverDnSpotrfBatched_(handle,uplo,n,A,lda,devInfo,batch_count) & bind(c, name="cusolverDnSpotrfBatched") #else function hipsolverDnSpotrfBatched_(handle,uplo,n,A,lda,devInfo,batch_count) & bind(c, name="hipsolverDnSpotrfBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSpotrfBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devInfo integer(c_int),value :: batch_count end function end interface interface hipsolverDnDpotrfBatched #ifdef USE_CUDA_NAMES function hipsolverDnDpotrfBatched_(handle,uplo,n,A,lda,devInfo,batch_count) & bind(c, name="cusolverDnDpotrfBatched") #else function hipsolverDnDpotrfBatched_(handle,uplo,n,A,lda,devInfo,batch_count) & bind(c, name="hipsolverDnDpotrfBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDpotrfBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devInfo integer(c_int),value :: batch_count end function end interface interface hipsolverDnCpotrfBatched #ifdef USE_CUDA_NAMES function hipsolverDnCpotrfBatched_(handle,uplo,n,A,lda,devInfo,batch_count) & bind(c, name="cusolverDnCpotrfBatched") #else function hipsolverDnCpotrfBatched_(handle,uplo,n,A,lda,devInfo,batch_count) & bind(c, name="hipsolverDnCpotrfBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCpotrfBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devInfo integer(c_int),value :: batch_count end function end interface interface hipsolverDnZpotrfBatched #ifdef USE_CUDA_NAMES function hipsolverDnZpotrfBatched_(handle,uplo,n,A,lda,devInfo,batch_count) & bind(c, name="cusolverDnZpotrfBatched") #else function hipsolverDnZpotrfBatched_(handle,uplo,n,A,lda,devInfo,batch_count) & bind(c, name="hipsolverDnZpotrfBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZpotrfBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: devInfo integer(c_int),value :: batch_count end function end interface interface hipsolverDnSpotri_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSpotri_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="cusolverDnSpotri_bufferSize") #else function hipsolverDnSpotri_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="hipsolverDnSpotri_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSpotri_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function end interface interface hipsolverDnDpotri_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDpotri_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="cusolverDnDpotri_bufferSize") #else function hipsolverDnDpotri_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="hipsolverDnDpotri_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDpotri_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function end interface interface hipsolverDnCpotri_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCpotri_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="cusolverDnCpotri_bufferSize") #else function hipsolverDnCpotri_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="hipsolverDnCpotri_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCpotri_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function end interface interface hipsolverDnZpotri_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZpotri_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="cusolverDnZpotri_bufferSize") #else function hipsolverDnZpotri_bufferSize_(handle,uplo,n,A,lda,lwork) & bind(c, name="hipsolverDnZpotri_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZpotri_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function end interface interface hipsolverDnSpotri #ifdef USE_CUDA_NAMES function hipsolverDnSpotri_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="cusolverDnSpotri") #else function hipsolverDnSpotri_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="hipsolverDnSpotri") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSpotri_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDpotri #ifdef USE_CUDA_NAMES function hipsolverDnDpotri_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="cusolverDnDpotri") #else function hipsolverDnDpotri_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="hipsolverDnDpotri") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDpotri_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnCpotri #ifdef USE_CUDA_NAMES function hipsolverDnCpotri_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="cusolverDnCpotri") #else function hipsolverDnCpotri_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="hipsolverDnCpotri") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCpotri_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZpotri #ifdef USE_CUDA_NAMES function hipsolverDnZpotri_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="cusolverDnZpotri") #else function hipsolverDnZpotri_(handle,uplo,n,A,lda,work,lwork,devInfo) & bind(c, name="hipsolverDnZpotri") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZpotri_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnSpotrs #ifdef USE_CUDA_NAMES function hipsolverDnSpotrs_(handle,uplo,n,nrhs,A,lda,B,ldb,devInfo) & bind(c, name="cusolverDnSpotrs") #else function hipsolverDnSpotrs_(handle,uplo,n,nrhs,A,lda,B,ldb,devInfo) & bind(c, name="hipsolverDnSpotrs") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSpotrs_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 :: devInfo end function end interface interface hipsolverDnDpotrs #ifdef USE_CUDA_NAMES function hipsolverDnDpotrs_(handle,uplo,n,nrhs,A,lda,B,ldb,devInfo) & bind(c, name="cusolverDnDpotrs") #else function hipsolverDnDpotrs_(handle,uplo,n,nrhs,A,lda,B,ldb,devInfo) & bind(c, name="hipsolverDnDpotrs") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDpotrs_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 :: devInfo end function end interface interface hipsolverDnCpotrs #ifdef USE_CUDA_NAMES function hipsolverDnCpotrs_(handle,uplo,n,nrhs,A,lda,B,ldb,devInfo) & bind(c, name="cusolverDnCpotrs") #else function hipsolverDnCpotrs_(handle,uplo,n,nrhs,A,lda,B,ldb,devInfo) & bind(c, name="hipsolverDnCpotrs") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCpotrs_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 :: devInfo end function end interface interface hipsolverDnZpotrs #ifdef USE_CUDA_NAMES function hipsolverDnZpotrs_(handle,uplo,n,nrhs,A,lda,B,ldb,devInfo) & bind(c, name="cusolverDnZpotrs") #else function hipsolverDnZpotrs_(handle,uplo,n,nrhs,A,lda,B,ldb,devInfo) & bind(c, name="hipsolverDnZpotrs") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZpotrs_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 :: devInfo end function end interface interface hipsolverDnSpotrsBatched #ifdef USE_CUDA_NAMES function hipsolverDnSpotrsBatched_(handle,uplo,n,nrhs,A,lda,B,ldb,devInfo,batch_count) & bind(c, name="cusolverDnSpotrsBatched") #else function hipsolverDnSpotrsBatched_(handle,uplo,n,nrhs,A,lda,B,ldb,devInfo,batch_count) & bind(c, name="hipsolverDnSpotrsBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSpotrsBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 :: devInfo integer(c_int),value :: batch_count end function end interface interface hipsolverDnDpotrsBatched #ifdef USE_CUDA_NAMES function hipsolverDnDpotrsBatched_(handle,uplo,n,nrhs,A,lda,B,ldb,devInfo,batch_count) & bind(c, name="cusolverDnDpotrsBatched") #else function hipsolverDnDpotrsBatched_(handle,uplo,n,nrhs,A,lda,B,ldb,devInfo,batch_count) & bind(c, name="hipsolverDnDpotrsBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDpotrsBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 :: devInfo integer(c_int),value :: batch_count end function end interface interface hipsolverDnCpotrsBatched #ifdef USE_CUDA_NAMES function hipsolverDnCpotrsBatched_(handle,uplo,n,nrhs,A,lda,B,ldb,devInfo,batch_count) & bind(c, name="cusolverDnCpotrsBatched") #else function hipsolverDnCpotrsBatched_(handle,uplo,n,nrhs,A,lda,B,ldb,devInfo,batch_count) & bind(c, name="hipsolverDnCpotrsBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCpotrsBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 :: devInfo integer(c_int),value :: batch_count end function end interface interface hipsolverDnZpotrsBatched #ifdef USE_CUDA_NAMES function hipsolverDnZpotrsBatched_(handle,uplo,n,nrhs,A,lda,B,ldb,devInfo,batch_count) & bind(c, name="cusolverDnZpotrsBatched") #else function hipsolverDnZpotrsBatched_(handle,uplo,n,nrhs,A,lda,B,ldb,devInfo,batch_count) & bind(c, name="hipsolverDnZpotrsBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZpotrsBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo 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 :: devInfo integer(c_int),value :: batch_count end function end interface interface hipsolverDnSsyevd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSsyevd_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork) & bind(c, name="cusolverDnSsyevd_bufferSize") #else function hipsolverDnSsyevd_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork) & bind(c, name="hipsolverDnSsyevd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSsyevd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork end function end interface interface hipsolverDnDsyevd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDsyevd_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork) & bind(c, name="cusolverDnDsyevd_bufferSize") #else function hipsolverDnDsyevd_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork) & bind(c, name="hipsolverDnDsyevd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDsyevd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork end function end interface interface hipsolverDnCheevd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCheevd_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork) & bind(c, name="cusolverDnCheevd_bufferSize") #else function hipsolverDnCheevd_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork) & bind(c, name="hipsolverDnCheevd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCheevd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork end function end interface interface hipsolverDnZheevd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZheevd_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork) & bind(c, name="cusolverDnZheevd_bufferSize") #else function hipsolverDnZheevd_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork) & bind(c, name="hipsolverDnZheevd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZheevd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork end function end interface interface hipsolverDnSsyevd #ifdef USE_CUDA_NAMES function hipsolverDnSsyevd_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo) & bind(c, name="cusolverDnSsyevd") #else function hipsolverDnSsyevd_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo) & bind(c, name="hipsolverDnSsyevd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSsyevd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDsyevd #ifdef USE_CUDA_NAMES function hipsolverDnDsyevd_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo) & bind(c, name="cusolverDnDsyevd") #else function hipsolverDnDsyevd_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo) & bind(c, name="hipsolverDnDsyevd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDsyevd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnCheevd #ifdef USE_CUDA_NAMES function hipsolverDnCheevd_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo) & bind(c, name="cusolverDnCheevd") #else function hipsolverDnCheevd_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo) & bind(c, name="hipsolverDnCheevd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCheevd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZheevd #ifdef USE_CUDA_NAMES function hipsolverDnZheevd_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo) & bind(c, name="cusolverDnZheevd") #else function hipsolverDnZheevd_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo) & bind(c, name="hipsolverDnZheevd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZheevd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnSsyevdx_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSsyevdx_bufferSize_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W, & lwork) & bind(c, name="cusolverDnSsyevdx_bufferSize") #else function hipsolverDnSsyevdx_bufferSize_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W, & lwork) & bind(c, name="hipsolverDnSsyevdx_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSsyevdx_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int) :: lwork end function end interface interface hipsolverDnDsyevdx_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDsyevdx_bufferSize_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W, & lwork) & bind(c, name="cusolverDnDsyevdx_bufferSize") #else function hipsolverDnDsyevdx_bufferSize_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W, & lwork) & bind(c, name="hipsolverDnDsyevdx_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDsyevdx_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int) :: lwork end function end interface interface hipsolverDnCheevdx_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCheevdx_bufferSize_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W, & lwork) & bind(c, name="cusolverDnCheevdx_bufferSize") #else function hipsolverDnCheevdx_bufferSize_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W, & lwork) & bind(c, name="hipsolverDnCheevdx_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCheevdx_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int) :: lwork end function end interface interface hipsolverDnZheevdx_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZheevdx_bufferSize_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W, & lwork) & bind(c, name="cusolverDnZheevdx_bufferSize") #else function hipsolverDnZheevdx_bufferSize_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W, & lwork) & bind(c, name="hipsolverDnZheevdx_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZheevdx_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int) :: lwork end function end interface interface hipsolverDnSsyevdx #ifdef USE_CUDA_NAMES function hipsolverDnSsyevdx_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W,work,lwork, & devInfo) & bind(c, name="cusolverDnSsyevdx") #else function hipsolverDnSsyevdx_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W,work,lwork, & devInfo) & bind(c, name="hipsolverDnSsyevdx") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSsyevdx_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDsyevdx #ifdef USE_CUDA_NAMES function hipsolverDnDsyevdx_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W,work,lwork, & devInfo) & bind(c, name="cusolverDnDsyevdx") #else function hipsolverDnDsyevdx_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W,work,lwork, & devInfo) & bind(c, name="hipsolverDnDsyevdx") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDsyevdx_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnCheevdx #ifdef USE_CUDA_NAMES function hipsolverDnCheevdx_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W,work,lwork, & devInfo) & bind(c, name="cusolverDnCheevdx") #else function hipsolverDnCheevdx_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W,work,lwork, & devInfo) & bind(c, name="hipsolverDnCheevdx") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCheevdx_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZheevdx #ifdef USE_CUDA_NAMES function hipsolverDnZheevdx_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W,work,lwork, & devInfo) & bind(c, name="cusolverDnZheevdx") #else function hipsolverDnZheevdx_(handle,jobz,range,uplo,n,A,lda,vl,vu,il,iu,nev,W,work,lwork, & devInfo) & bind(c, name="hipsolverDnZheevdx") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZheevdx_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnSsyevj_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSsyevj_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params) & bind(c, name="cusolverDnSsyevj_bufferSize") #else function hipsolverDnSsyevj_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params) & bind(c, name="hipsolverDnSsyevj_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSsyevj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params end function end interface interface hipsolverDnDsyevj_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDsyevj_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params) & bind(c, name="cusolverDnDsyevj_bufferSize") #else function hipsolverDnDsyevj_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params) & bind(c, name="hipsolverDnDsyevj_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDsyevj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params end function end interface interface hipsolverDnCheevj_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCheevj_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params) & bind(c, name="cusolverDnCheevj_bufferSize") #else function hipsolverDnCheevj_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params) & bind(c, name="hipsolverDnCheevj_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCheevj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params end function end interface interface hipsolverDnZheevj_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZheevj_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params) & bind(c, name="cusolverDnZheevj_bufferSize") #else function hipsolverDnZheevj_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params) & bind(c, name="hipsolverDnZheevj_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZheevj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params end function end interface interface hipsolverDnSsyevj #ifdef USE_CUDA_NAMES function hipsolverDnSsyevj_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params) & bind(c, name="cusolverDnSsyevj") #else function hipsolverDnSsyevj_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params) & bind(c, name="hipsolverDnSsyevj") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSsyevj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params end function end interface interface hipsolverDnDsyevj #ifdef USE_CUDA_NAMES function hipsolverDnDsyevj_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params) & bind(c, name="cusolverDnDsyevj") #else function hipsolverDnDsyevj_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params) & bind(c, name="hipsolverDnDsyevj") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDsyevj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params end function end interface interface hipsolverDnCheevj #ifdef USE_CUDA_NAMES function hipsolverDnCheevj_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params) & bind(c, name="cusolverDnCheevj") #else function hipsolverDnCheevj_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params) & bind(c, name="hipsolverDnCheevj") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCheevj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params end function end interface interface hipsolverDnZheevj #ifdef USE_CUDA_NAMES function hipsolverDnZheevj_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params) & bind(c, name="cusolverDnZheevj") #else function hipsolverDnZheevj_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params) & bind(c, name="hipsolverDnZheevj") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZheevj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params end function end interface interface hipsolverDnSsyevjBatched_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSsyevjBatched_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params, & batch_count) & bind(c, name="cusolverDnSsyevjBatched_bufferSize") #else function hipsolverDnSsyevjBatched_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params, & batch_count) & bind(c, name="hipsolverDnSsyevjBatched_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSsyevjBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface interface hipsolverDnDsyevjBatched_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDsyevjBatched_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params, & batch_count) & bind(c, name="cusolverDnDsyevjBatched_bufferSize") #else function hipsolverDnDsyevjBatched_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params, & batch_count) & bind(c, name="hipsolverDnDsyevjBatched_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDsyevjBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface interface hipsolverDnCheevjBatched_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCheevjBatched_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params, & batch_count) & bind(c, name="cusolverDnCheevjBatched_bufferSize") #else function hipsolverDnCheevjBatched_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params, & batch_count) & bind(c, name="hipsolverDnCheevjBatched_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCheevjBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface interface hipsolverDnZheevjBatched_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZheevjBatched_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params, & batch_count) & bind(c, name="cusolverDnZheevjBatched_bufferSize") #else function hipsolverDnZheevjBatched_bufferSize_(handle,jobz,uplo,n,A,lda,W,lwork,params, & batch_count) & bind(c, name="hipsolverDnZheevjBatched_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZheevjBatched_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface interface hipsolverDnSsyevjBatched #ifdef USE_CUDA_NAMES function hipsolverDnSsyevjBatched_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params, & batch_count) & bind(c, name="cusolverDnSsyevjBatched") #else function hipsolverDnSsyevjBatched_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params, & batch_count) & bind(c, name="hipsolverDnSsyevjBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSsyevjBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface interface hipsolverDnDsyevjBatched #ifdef USE_CUDA_NAMES function hipsolverDnDsyevjBatched_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params, & batch_count) & bind(c, name="cusolverDnDsyevjBatched") #else function hipsolverDnDsyevjBatched_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params, & batch_count) & bind(c, name="hipsolverDnDsyevjBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDsyevjBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface interface hipsolverDnCheevjBatched #ifdef USE_CUDA_NAMES function hipsolverDnCheevjBatched_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params, & batch_count) & bind(c, name="cusolverDnCheevjBatched") #else function hipsolverDnCheevjBatched_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params, & batch_count) & bind(c, name="hipsolverDnCheevjBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCheevjBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface interface hipsolverDnZheevjBatched #ifdef USE_CUDA_NAMES function hipsolverDnZheevjBatched_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params, & batch_count) & bind(c, name="cusolverDnZheevjBatched") #else function hipsolverDnZheevjBatched_(handle,jobz,uplo,n,A,lda,W,work,lwork,devInfo,params, & batch_count) & bind(c, name="hipsolverDnZheevjBatched") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZheevjBatched_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params integer(c_int),value :: batch_count end function end interface interface hipsolverDnSsygvd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSsygvd_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) & bind(c, name="cusolverDnSsygvd_bufferSize") #else function hipsolverDnSsygvd_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) & bind(c, name="hipsolverDnSsygvd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSsygvd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W integer(c_int) :: lwork end function end interface interface hipsolverDnDsygvd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDsygvd_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) & bind(c, name="cusolverDnDsygvd_bufferSize") #else function hipsolverDnDsygvd_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) & bind(c, name="hipsolverDnDsygvd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDsygvd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W integer(c_int) :: lwork end function end interface interface hipsolverDnChegvd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnChegvd_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) & bind(c, name="cusolverDnChegvd_bufferSize") #else function hipsolverDnChegvd_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) & bind(c, name="hipsolverDnChegvd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnChegvd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W integer(c_int) :: lwork end function end interface interface hipsolverDnZhegvd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZhegvd_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) & bind(c, name="cusolverDnZhegvd_bufferSize") #else function hipsolverDnZhegvd_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) & bind(c, name="hipsolverDnZhegvd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZhegvd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W integer(c_int) :: lwork end function end interface interface hipsolverDnSsygvd #ifdef USE_CUDA_NAMES function hipsolverDnSsygvd_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) & bind(c, name="cusolverDnSsygvd") #else function hipsolverDnSsygvd_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) & bind(c, name="hipsolverDnSsygvd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSsygvd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDsygvd #ifdef USE_CUDA_NAMES function hipsolverDnDsygvd_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) & bind(c, name="cusolverDnDsygvd") #else function hipsolverDnDsygvd_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) & bind(c, name="hipsolverDnDsygvd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDsygvd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnChegvd #ifdef USE_CUDA_NAMES function hipsolverDnChegvd_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) & bind(c, name="cusolverDnChegvd") #else function hipsolverDnChegvd_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) & bind(c, name="hipsolverDnChegvd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnChegvd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZhegvd #ifdef USE_CUDA_NAMES function hipsolverDnZhegvd_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) & bind(c, name="cusolverDnZhegvd") #else function hipsolverDnZhegvd_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) & bind(c, name="hipsolverDnZhegvd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZhegvd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnSsygvdx_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSsygvdx_bufferSize_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il, & iu,nev,W,lwork) & bind(c, name="cusolverDnSsygvdx_bufferSize") #else function hipsolverDnSsygvdx_bufferSize_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il, & iu,nev,W,lwork) & bind(c, name="hipsolverDnSsygvdx_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSsygvdx_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int) :: lwork end function end interface interface hipsolverDnDsygvdx_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDsygvdx_bufferSize_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il, & iu,nev,W,lwork) & bind(c, name="cusolverDnDsygvdx_bufferSize") #else function hipsolverDnDsygvdx_bufferSize_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il, & iu,nev,W,lwork) & bind(c, name="hipsolverDnDsygvdx_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDsygvdx_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int) :: lwork end function end interface interface hipsolverDnChegvdx_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnChegvdx_bufferSize_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il, & iu,nev,W,lwork) & bind(c, name="cusolverDnChegvdx_bufferSize") #else function hipsolverDnChegvdx_bufferSize_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il, & iu,nev,W,lwork) & bind(c, name="hipsolverDnChegvdx_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnChegvdx_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int) :: lwork end function end interface interface hipsolverDnZhegvdx_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZhegvdx_bufferSize_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il, & iu,nev,W,lwork) & bind(c, name="cusolverDnZhegvdx_bufferSize") #else function hipsolverDnZhegvdx_bufferSize_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il, & iu,nev,W,lwork) & bind(c, name="hipsolverDnZhegvdx_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZhegvdx_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int) :: lwork end function end interface interface hipsolverDnSsygvdx #ifdef USE_CUDA_NAMES function hipsolverDnSsygvdx_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il,iu,nev,W, & work,lwork,devInfo) & bind(c, name="cusolverDnSsygvdx") #else function hipsolverDnSsygvdx_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il,iu,nev,W, & work,lwork,devInfo) & bind(c, name="hipsolverDnSsygvdx") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSsygvdx_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDsygvdx #ifdef USE_CUDA_NAMES function hipsolverDnDsygvdx_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il,iu,nev,W, & work,lwork,devInfo) & bind(c, name="cusolverDnDsygvdx") #else function hipsolverDnDsygvdx_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il,iu,nev,W, & work,lwork,devInfo) & bind(c, name="hipsolverDnDsygvdx") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDsygvdx_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnChegvdx #ifdef USE_CUDA_NAMES function hipsolverDnChegvdx_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il,iu,nev,W, & work,lwork,devInfo) & bind(c, name="cusolverDnChegvdx") #else function hipsolverDnChegvdx_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il,iu,nev,W, & work,lwork,devInfo) & bind(c, name="hipsolverDnChegvdx") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnChegvdx_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZhegvdx #ifdef USE_CUDA_NAMES function hipsolverDnZhegvdx_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il,iu,nev,W, & work,lwork,devInfo) & bind(c, name="cusolverDnZhegvdx") #else function hipsolverDnZhegvdx_(handle,itype,jobz,range,uplo,n,A,lda,B,ldb,vl,vu,il,iu,nev,W, & work,lwork,devInfo) & bind(c, name="hipsolverDnZhegvdx") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZhegvdx_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_EIG_RANGE_ALL)),value :: range integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnSsygvj_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSsygvj_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork,params) & bind(c, name="cusolverDnSsygvj_bufferSize") #else function hipsolverDnSsygvj_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork,params) & bind(c, name="hipsolverDnSsygvj_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSsygvj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params end function end interface interface hipsolverDnDsygvj_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDsygvj_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork,params) & bind(c, name="cusolverDnDsygvj_bufferSize") #else function hipsolverDnDsygvj_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork,params) & bind(c, name="hipsolverDnDsygvj_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDsygvj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params end function end interface interface hipsolverDnChegvj_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnChegvj_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork,params) & bind(c, name="cusolverDnChegvj_bufferSize") #else function hipsolverDnChegvj_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork,params) & bind(c, name="hipsolverDnChegvj_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnChegvj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params end function end interface interface hipsolverDnZhegvj_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZhegvj_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork,params) & bind(c, name="cusolverDnZhegvj_bufferSize") #else function hipsolverDnZhegvj_bufferSize_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork,params) & bind(c, name="hipsolverDnZhegvj_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZhegvj_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W integer(c_int) :: lwork type(c_ptr),value :: params end function end interface interface hipsolverDnSsygvj #ifdef USE_CUDA_NAMES function hipsolverDnSsygvj_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo,params) & bind(c, name="cusolverDnSsygvj") #else function hipsolverDnSsygvj_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo,params) & bind(c, name="hipsolverDnSsygvj") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSsygvj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params end function end interface interface hipsolverDnDsygvj #ifdef USE_CUDA_NAMES function hipsolverDnDsygvj_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo,params) & bind(c, name="cusolverDnDsygvj") #else function hipsolverDnDsygvj_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo,params) & bind(c, name="hipsolverDnDsygvj") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDsygvj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params end function end interface interface hipsolverDnChegvj #ifdef USE_CUDA_NAMES function hipsolverDnChegvj_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo,params) & bind(c, name="cusolverDnChegvj") #else function hipsolverDnChegvj_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo,params) & bind(c, name="hipsolverDnChegvj") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnChegvj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params end function end interface interface hipsolverDnZhegvj #ifdef USE_CUDA_NAMES function hipsolverDnZhegvj_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo,params) & bind(c, name="cusolverDnZhegvj") #else function hipsolverDnZhegvj_(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo,params) & bind(c, name="hipsolverDnZhegvj") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZhegvj_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)),value :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: W type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo type(c_ptr),value :: params end function end interface interface hipsolverDnSsytrd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSsytrd_bufferSize_(handle,uplo,n,A,lda,D,E,tau,lwork) & bind(c, name="cusolverDnSsytrd_bufferSize") #else function hipsolverDnSsytrd_bufferSize_(handle,uplo,n,A,lda,D,E,tau,lwork) & bind(c, name="hipsolverDnSsytrd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSsytrd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tau integer(c_int) :: lwork end function end interface interface hipsolverDnDsytrd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDsytrd_bufferSize_(handle,uplo,n,A,lda,D,E,tau,lwork) & bind(c, name="cusolverDnDsytrd_bufferSize") #else function hipsolverDnDsytrd_bufferSize_(handle,uplo,n,A,lda,D,E,tau,lwork) & bind(c, name="hipsolverDnDsytrd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDsytrd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tau integer(c_int) :: lwork end function end interface interface hipsolverDnChetrd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnChetrd_bufferSize_(handle,uplo,n,A,lda,D,E,tau,lwork) & bind(c, name="cusolverDnChetrd_bufferSize") #else function hipsolverDnChetrd_bufferSize_(handle,uplo,n,A,lda,D,E,tau,lwork) & bind(c, name="hipsolverDnChetrd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnChetrd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tau integer(c_int) :: lwork end function end interface interface hipsolverDnZhetrd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZhetrd_bufferSize_(handle,uplo,n,A,lda,D,E,tau,lwork) & bind(c, name="cusolverDnZhetrd_bufferSize") #else function hipsolverDnZhetrd_bufferSize_(handle,uplo,n,A,lda,D,E,tau,lwork) & bind(c, name="hipsolverDnZhetrd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZhetrd_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tau integer(c_int) :: lwork end function end interface interface hipsolverDnSsytrd #ifdef USE_CUDA_NAMES function hipsolverDnSsytrd_(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) & bind(c, name="cusolverDnSsytrd") #else function hipsolverDnSsytrd_(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnSsytrd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSsytrd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDsytrd #ifdef USE_CUDA_NAMES function hipsolverDnDsytrd_(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) & bind(c, name="cusolverDnDsytrd") #else function hipsolverDnDsytrd_(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnDsytrd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDsytrd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnChetrd #ifdef USE_CUDA_NAMES function hipsolverDnChetrd_(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) & bind(c, name="cusolverDnChetrd") #else function hipsolverDnChetrd_(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnChetrd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnChetrd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZhetrd #ifdef USE_CUDA_NAMES function hipsolverDnZhetrd_(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) & bind(c, name="cusolverDnZhetrd") #else function hipsolverDnZhetrd_(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) & bind(c, name="hipsolverDnZhetrd") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZhetrd_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tau type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnSsytrf_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnSsytrf_bufferSize_(handle,n,A,lda,lwork) & bind(c, name="cusolverDnSsytrf_bufferSize") #else function hipsolverDnSsytrf_bufferSize_(handle,n,A,lda,lwork) & bind(c, name="hipsolverDnSsytrf_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSsytrf_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function end interface interface hipsolverDnDsytrf_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnDsytrf_bufferSize_(handle,n,A,lda,lwork) & bind(c, name="cusolverDnDsytrf_bufferSize") #else function hipsolverDnDsytrf_bufferSize_(handle,n,A,lda,lwork) & bind(c, name="hipsolverDnDsytrf_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDsytrf_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function end interface interface hipsolverDnCsytrf_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnCsytrf_bufferSize_(handle,n,A,lda,lwork) & bind(c, name="cusolverDnCsytrf_bufferSize") #else function hipsolverDnCsytrf_bufferSize_(handle,n,A,lda,lwork) & bind(c, name="hipsolverDnCsytrf_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCsytrf_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function end interface interface hipsolverDnZsytrf_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnZsytrf_bufferSize_(handle,n,A,lda,lwork) & bind(c, name="cusolverDnZsytrf_bufferSize") #else function hipsolverDnZsytrf_bufferSize_(handle,n,A,lda,lwork) & bind(c, name="hipsolverDnZsytrf_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZsytrf_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int) :: lwork end function end interface interface hipsolverDnSsytrf #ifdef USE_CUDA_NAMES function hipsolverDnSsytrf_(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) & bind(c, name="cusolverDnSsytrf") #else function hipsolverDnSsytrf_(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) & bind(c, name="hipsolverDnSsytrf") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSsytrf_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnDsytrf #ifdef USE_CUDA_NAMES function hipsolverDnDsytrf_(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) & bind(c, name="cusolverDnDsytrf") #else function hipsolverDnDsytrf_(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) & bind(c, name="hipsolverDnDsytrf") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDsytrf_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnCsytrf #ifdef USE_CUDA_NAMES function hipsolverDnCsytrf_(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) & bind(c, name="cusolverDnCsytrf") #else function hipsolverDnCsytrf_(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) & bind(c, name="hipsolverDnCsytrf") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCsytrf_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnZsytrf #ifdef USE_CUDA_NAMES function hipsolverDnZsytrf_(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) & bind(c, name="cusolverDnZsytrf") #else function hipsolverDnZsytrf_(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) & bind(c, name="hipsolverDnZsytrf") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnZsytrf_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: work integer(c_int),value :: lwork type(c_ptr),value :: devInfo end function end interface interface hipsolverDnCreateParams #ifdef USE_CUDA_NAMES function hipsolverDnCreateParams_(params) bind(c, name="cusolverDnCreateParams") #else function hipsolverDnCreateParams_(params) bind(c, name="hipsolverDnCreateParams") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnCreateParams_ type(c_ptr) :: params end function end interface interface hipsolverDnDestroyParams #ifdef USE_CUDA_NAMES function hipsolverDnDestroyParams_(params) bind(c, name="cusolverDnDestroyParams") #else function hipsolverDnDestroyParams_(params) bind(c, name="hipsolverDnDestroyParams") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnDestroyParams_ type(c_ptr),value :: params end function end interface interface hipsolverDnSetAdvOptions #ifdef USE_CUDA_NAMES function hipsolverDnSetAdvOptions_(params,func,alg) bind(c, name="cusolverDnSetAdvOptions") #else function hipsolverDnSetAdvOptions_(params,func,alg) bind(c, name="hipsolverDnSetAdvOptions") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnSetAdvOptions_ type(c_ptr),value :: params integer(kind(HIPSOLVERDN_GETRF)),value :: func integer(kind(HIPSOLVER_ALG_0)),value :: alg end function end interface interface hipsolverDnXgeev_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnXgeev_bufferSize_(handle,params,jobvl,jobvr,n,dataTypeA,A,lda,dataTypeW,W, & dataTypeVL,VL,ldvl,dataTypeVR,VR,ldvr,computeType,lworkOnDevice,lworkOnHost) & bind(c, name="cusolverDnXgeev_bufferSize") #else function hipsolverDnXgeev_bufferSize_(handle,params,jobvl,jobvr,n,dataTypeA,A,lda,dataTypeW,W, & dataTypeVL,VL,ldvl,dataTypeVR,VR,ldvr,computeType,lworkOnDevice,lworkOnHost) & bind(c, name="hipsolverDnXgeev_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums use hipfort_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXgeev_bufferSize_ type(c_ptr),value :: handle type(c_ptr),value :: params integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobvl integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobvr integer(c_int64_t),value :: n integer(kind(HIP_R_32F)),value :: dataTypeA type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(kind(HIP_R_32F)),value :: dataTypeW type(c_ptr),value :: W integer(kind(HIP_R_32F)),value :: dataTypeVL type(c_ptr),value :: VL integer(c_int64_t),value :: ldvl integer(kind(HIP_R_32F)),value :: dataTypeVR type(c_ptr),value :: VR integer(c_int64_t),value :: ldvr integer(kind(HIP_R_32F)),value :: computeType type(c_ptr),value :: lworkOnDevice type(c_ptr),value :: lworkOnHost end function end interface interface hipsolverDnXgeev #ifdef USE_CUDA_NAMES function hipsolverDnXgeev_(handle,params,jobvl,jobvr,n,dataTypeA,A,lda,dataTypeW,W,dataTypeVL, & VL,ldvl,dataTypeVR,VR,ldvr,computeType,workOnDevice,lworkOnDevice,workOnHost,lworkOnHost, & devInfo) & bind(c, name="cusolverDnXgeev") #else function hipsolverDnXgeev_(handle,params,jobvl,jobvr,n,dataTypeA,A,lda,dataTypeW,W,dataTypeVL, & VL,ldvl,dataTypeVR,VR,ldvr,computeType,workOnDevice,lworkOnDevice,workOnHost,lworkOnHost, & devInfo) & bind(c, name="hipsolverDnXgeev") #endif use iso_c_binding use hipfort_hipsolver_enums use hipfort_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXgeev_ type(c_ptr),value :: handle type(c_ptr),value :: params integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobvl integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobvr integer(c_int64_t),value :: n integer(kind(HIP_R_32F)),value :: dataTypeA type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(kind(HIP_R_32F)),value :: dataTypeW type(c_ptr),value :: W integer(kind(HIP_R_32F)),value :: dataTypeVL type(c_ptr),value :: VL integer(c_int64_t),value :: ldvl integer(kind(HIP_R_32F)),value :: dataTypeVR type(c_ptr),value :: VR integer(c_int64_t),value :: ldvr integer(kind(HIP_R_32F)),value :: computeType type(c_ptr),value :: workOnDevice integer(c_size_t),value :: lworkOnDevice type(c_ptr),value :: workOnHost integer(c_size_t),value :: lworkOnHost type(c_ptr),value :: devInfo end function end interface interface hipsolverDnXgeqrf_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnXgeqrf_bufferSize_(handle,params,m,n,dataTypeA,A,lda,dataTypeTau,tau, & computeType,lworkOnDevice,lworkOnHost) & bind(c, name="cusolverDnXgeqrf_bufferSize") #else function hipsolverDnXgeqrf_bufferSize_(handle,params,m,n,dataTypeA,A,lda,dataTypeTau,tau, & computeType,lworkOnDevice,lworkOnHost) & bind(c, name="hipsolverDnXgeqrf_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums use hipfort_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXgeqrf_bufferSize_ type(c_ptr),value :: handle type(c_ptr),value :: params integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(kind(HIP_R_32F)),value :: dataTypeA type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(kind(HIP_R_32F)),value :: dataTypeTau type(c_ptr),value :: tau integer(kind(HIP_R_32F)),value :: computeType type(c_ptr),value :: lworkOnDevice type(c_ptr),value :: lworkOnHost end function end interface interface hipsolverDnXgeqrf #ifdef USE_CUDA_NAMES function hipsolverDnXgeqrf_(handle,params,m,n,dataTypeA,A,lda,dataTypeTau,tau,computeType, & workOnDevice,lworkOnDevice,workOnHost,lworkOnHost,devInfo) & bind(c, name="cusolverDnXgeqrf") #else function hipsolverDnXgeqrf_(handle,params,m,n,dataTypeA,A,lda,dataTypeTau,tau,computeType, & workOnDevice,lworkOnDevice,workOnHost,lworkOnHost,devInfo) & bind(c, name="hipsolverDnXgeqrf") #endif use iso_c_binding use hipfort_hipsolver_enums use hipfort_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXgeqrf_ type(c_ptr),value :: handle type(c_ptr),value :: params integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(kind(HIP_R_32F)),value :: dataTypeA type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(kind(HIP_R_32F)),value :: dataTypeTau type(c_ptr),value :: tau integer(kind(HIP_R_32F)),value :: computeType type(c_ptr),value :: workOnDevice integer(c_size_t),value :: lworkOnDevice type(c_ptr),value :: workOnHost integer(c_size_t),value :: lworkOnHost type(c_ptr),value :: devInfo end function end interface interface hipsolverDnXgetrf_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnXgetrf_bufferSize_(handle,params,m,n,dataTypeA,A,lda,computeType, & lworkOnDevice,lworkOnHost) & bind(c, name="cusolverDnXgetrf_bufferSize") #else function hipsolverDnXgetrf_bufferSize_(handle,params,m,n,dataTypeA,A,lda,computeType, & lworkOnDevice,lworkOnHost) & bind(c, name="hipsolverDnXgetrf_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums use hipfort_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXgetrf_bufferSize_ type(c_ptr),value :: handle type(c_ptr),value :: params integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(kind(HIP_R_32F)),value :: dataTypeA type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(kind(HIP_R_32F)),value :: computeType integer(c_size_t) :: lworkOnDevice integer(c_size_t) :: lworkOnHost end function end interface interface hipsolverDnXgetrf #ifdef USE_CUDA_NAMES function hipsolverDnXgetrf_(handle,params,m,n,dataTypeA,A,lda,devIpiv,computeType, & workOnDevice,lworkOnDevice,workOnHost,lworkOnHost,devInfo) & bind(c, name="cusolverDnXgetrf") #else function hipsolverDnXgetrf_(handle,params,m,n,dataTypeA,A,lda,devIpiv,computeType, & workOnDevice,lworkOnDevice,workOnHost,lworkOnHost,devInfo) & bind(c, name="hipsolverDnXgetrf") #endif use iso_c_binding use hipfort_hipsolver_enums use hipfort_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXgetrf_ type(c_ptr),value :: handle type(c_ptr),value :: params integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(kind(HIP_R_32F)),value :: dataTypeA type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: devIpiv integer(kind(HIP_R_32F)),value :: computeType type(c_ptr),value :: workOnDevice integer(c_size_t),value :: lworkOnDevice type(c_ptr),value :: workOnHost integer(c_size_t),value :: lworkOnHost integer(c_int) :: devInfo end function end interface interface hipsolverDnXgetrs #ifdef USE_CUDA_NAMES function hipsolverDnXgetrs_(handle,params,trans,n,nrhs,dataTypeA,A,lda,devIpiv,dataTypeB,B, & ldb,devInfo) & bind(c, name="cusolverDnXgetrs") #else function hipsolverDnXgetrs_(handle,params,trans,n,nrhs,dataTypeA,A,lda,devIpiv,dataTypeB,B, & ldb,devInfo) & bind(c, name="hipsolverDnXgetrs") #endif use iso_c_binding use hipfort_hipsolver_enums use hipfort_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXgetrs_ type(c_ptr),value :: handle type(c_ptr),value :: params integer(kind(HIPSOLVER_OP_N)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs integer(kind(HIP_R_32F)),value :: dataTypeA type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: devIpiv integer(kind(HIP_R_32F)),value :: dataTypeB type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int) :: devInfo end function end interface interface hipsolverDnXpotrf_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnXpotrf_bufferSize_(handle,params,uplo,n,dataTypeA,A,lda,computeType, & lworkOnDevice,lworkOnHost) & bind(c, name="cusolverDnXpotrf_bufferSize") #else function hipsolverDnXpotrf_bufferSize_(handle,params,uplo,n,dataTypeA,A,lda,computeType, & lworkOnDevice,lworkOnHost) & bind(c, name="hipsolverDnXpotrf_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums use hipfort_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXpotrf_bufferSize_ type(c_ptr),value :: handle type(c_ptr),value :: params integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(kind(HIP_R_32F)),value :: dataTypeA type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(kind(HIP_R_32F)),value :: computeType type(c_ptr),value :: lworkOnDevice type(c_ptr),value :: lworkOnHost end function end interface interface hipsolverDnXpotrf #ifdef USE_CUDA_NAMES function hipsolverDnXpotrf_(handle,params,uplo,n,dataTypeA,A,lda,computeType,workOnDevice, & lworkOnDevice,workOnHost,lworkOnHost,myInfo) & bind(c, name="cusolverDnXpotrf") #else function hipsolverDnXpotrf_(handle,params,uplo,n,dataTypeA,A,lda,computeType,workOnDevice, & lworkOnDevice,workOnHost,lworkOnHost,myInfo) & bind(c, name="hipsolverDnXpotrf") #endif use iso_c_binding use hipfort_hipsolver_enums use hipfort_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXpotrf_ type(c_ptr),value :: handle type(c_ptr),value :: params integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(kind(HIP_R_32F)),value :: dataTypeA type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(kind(HIP_R_32F)),value :: computeType type(c_ptr),value :: workOnDevice integer(c_size_t),value :: lworkOnDevice type(c_ptr),value :: workOnHost integer(c_size_t),value :: lworkOnHost type(c_ptr),value :: myInfo end function end interface interface hipsolverDnXpotrs #ifdef USE_CUDA_NAMES function hipsolverDnXpotrs_(handle,params,uplo,n,nrhs,dataTypeA,A,lda,dataTypeB,B,ldb,myInfo) & bind(c, name="cusolverDnXpotrs") #else function hipsolverDnXpotrs_(handle,params,uplo,n,nrhs,dataTypeA,A,lda,dataTypeB,B,ldb,myInfo) & bind(c, name="hipsolverDnXpotrs") #endif use iso_c_binding use hipfort_hipsolver_enums use hipfort_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXpotrs_ type(c_ptr),value :: handle type(c_ptr),value :: params integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs integer(kind(HIP_R_32F)),value :: dataTypeA type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(kind(HIP_R_32F)),value :: dataTypeB type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: myInfo end function end interface interface hipsolverDnXsyevd_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnXsyevd_bufferSize_(handle,params,jobz,uplo,n,dataTypeA,A,lda,dataTypeW,W, & computeType,lworkOnDevice,lworkOnHost) & bind(c, name="cusolverDnXsyevd_bufferSize") #else function hipsolverDnXsyevd_bufferSize_(handle,params,jobz,uplo,n,dataTypeA,A,lda,dataTypeW,W, & computeType,lworkOnDevice,lworkOnHost) & bind(c, name="hipsolverDnXsyevd_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums use hipfort_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXsyevd_bufferSize_ type(c_ptr),value :: handle type(c_ptr),value :: params integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(kind(HIP_R_32F)),value :: dataTypeA type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(kind(HIP_R_32F)),value :: dataTypeW type(c_ptr),value :: W integer(kind(HIP_R_32F)),value :: computeType type(c_ptr),value :: lworkOnDevice type(c_ptr),value :: lworkOnHost end function end interface interface hipsolverDnXsyevd #ifdef USE_CUDA_NAMES function hipsolverDnXsyevd_(handle,params,jobz,uplo,n,dataTypeA,A,lda,dataTypeW,W,computeType, & workOnDevice,lworkOnDevice,workOnHost,lworkOnHost,devInfo) & bind(c, name="cusolverDnXsyevd") #else function hipsolverDnXsyevd_(handle,params,jobz,uplo,n,dataTypeA,A,lda,dataTypeW,W,computeType, & workOnDevice,lworkOnDevice,workOnHost,lworkOnHost,devInfo) & bind(c, name="hipsolverDnXsyevd") #endif use iso_c_binding use hipfort_hipsolver_enums use hipfort_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXsyevd_ type(c_ptr),value :: handle type(c_ptr),value :: params integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(kind(HIP_R_32F)),value :: dataTypeA type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(kind(HIP_R_32F)),value :: dataTypeW type(c_ptr),value :: W integer(kind(HIP_R_32F)),value :: computeType type(c_ptr),value :: workOnDevice integer(c_size_t),value :: lworkOnDevice type(c_ptr),value :: workOnHost integer(c_size_t),value :: lworkOnHost type(c_ptr),value :: devInfo end function end interface interface hipsolverDnXsyevBatched_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnXsyevBatched_bufferSize_(handle,params,jobz,uplo,n,dataTypeA,A,lda, & dataTypeW,W,computeType,lworkOnDevice,lworkOnHost,batchSize) & bind(c, name="cusolverDnXsyevBatched_bufferSize") #else function hipsolverDnXsyevBatched_bufferSize_(handle,params,jobz,uplo,n,dataTypeA,A,lda, & dataTypeW,W,computeType,lworkOnDevice,lworkOnHost,batchSize) & bind(c, name="hipsolverDnXsyevBatched_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums use hipfort_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXsyevBatched_bufferSize_ type(c_ptr),value :: handle type(c_ptr),value :: params integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(kind(HIP_R_32F)),value :: dataTypeA type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(kind(HIP_R_32F)),value :: dataTypeW type(c_ptr),value :: W integer(kind(HIP_R_32F)),value :: computeType type(c_ptr),value :: lworkOnDevice type(c_ptr),value :: lworkOnHost integer(c_int64_t),value :: batchSize end function end interface interface hipsolverDnXsyevBatched #ifdef USE_CUDA_NAMES function hipsolverDnXsyevBatched_(handle,params,jobz,uplo,n,dataTypeA,A,lda,dataTypeW,W, & computeType,workOnDevice,lworkOnDevice,workOnHost,lworkOnHost,devInfo,batchSize) & bind(c, name="cusolverDnXsyevBatched") #else function hipsolverDnXsyevBatched_(handle,params,jobz,uplo,n,dataTypeA,A,lda,dataTypeW,W, & computeType,workOnDevice,lworkOnDevice,workOnHost,lworkOnHost,devInfo,batchSize) & bind(c, name="hipsolverDnXsyevBatched") #endif use iso_c_binding use hipfort_hipsolver_enums use hipfort_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXsyevBatched_ type(c_ptr),value :: handle type(c_ptr),value :: params integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)),value :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(kind(HIP_R_32F)),value :: dataTypeA type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(kind(HIP_R_32F)),value :: dataTypeW type(c_ptr),value :: W integer(kind(HIP_R_32F)),value :: computeType type(c_ptr),value :: workOnDevice integer(c_size_t),value :: lworkOnDevice type(c_ptr),value :: workOnHost integer(c_size_t),value :: lworkOnHost type(c_ptr),value :: devInfo integer(c_int64_t),value :: batchSize end function end interface interface hipsolverDnXsytrs_bufferSize #ifdef USE_CUDA_NAMES function hipsolverDnXsytrs_bufferSize_(handle,uplo,n,nrhs,dataTypeA,A,lda,devIpiv,dataTypeB,B, & ldb,lworkOnDevice,lworkOnHost) & bind(c, name="cusolverDnXsytrs_bufferSize") #else function hipsolverDnXsytrs_bufferSize_(handle,uplo,n,nrhs,dataTypeA,A,lda,devIpiv,dataTypeB,B, & ldb,lworkOnDevice,lworkOnHost) & bind(c, name="hipsolverDnXsytrs_bufferSize") #endif use iso_c_binding use hipfort_hipsolver_enums use hipfort_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXsytrs_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs integer(kind(HIP_R_32F)),value :: dataTypeA type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: devIpiv integer(kind(HIP_R_32F)),value :: dataTypeB type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: lworkOnDevice type(c_ptr),value :: lworkOnHost end function end interface interface hipsolverDnXsytrs #ifdef USE_CUDA_NAMES function hipsolverDnXsytrs_(handle,uplo,n,nrhs,dataTypeA,A,lda,devIpiv,dataTypeB,B,ldb, & workOnDevice,lworkOnDevice,workOnHost,lworkOnHost,devInfo) & bind(c, name="cusolverDnXsytrs") #else function hipsolverDnXsytrs_(handle,uplo,n,nrhs,dataTypeA,A,lda,devIpiv,dataTypeB,B,ldb, & workOnDevice,lworkOnDevice,workOnHost,lworkOnHost,devInfo) & bind(c, name="hipsolverDnXsytrs") #endif use iso_c_binding use hipfort_hipsolver_enums use hipfort_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDnXsytrs_ type(c_ptr),value :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs integer(kind(HIP_R_32F)),value :: dataTypeA type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: devIpiv integer(kind(HIP_R_32F)),value :: dataTypeB type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: workOnDevice integer(c_size_t),value :: lworkOnDevice type(c_ptr),value :: workOnHost integer(c_size_t),value :: lworkOnHost type(c_ptr),value :: devInfo end function end interface interface hipsolverRfCreate #ifdef USE_CUDA_NAMES function hipsolverRfCreate_(handle) bind(c, name="cusolverRfCreate") #else function hipsolverRfCreate_(handle) bind(c, name="hipsolverRfCreate") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfCreate_ type(c_ptr) :: handle end function end interface interface hipsolverRfDestroy #ifdef USE_CUDA_NAMES function hipsolverRfDestroy_(handle) bind(c, name="cusolverRfDestroy") #else function hipsolverRfDestroy_(handle) bind(c, name="hipsolverRfDestroy") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfDestroy_ type(c_ptr),value :: handle end function end interface interface hipsolverRfSetupDevice #ifdef USE_CUDA_NAMES function hipsolverRfSetupDevice_(n,nnzA,csrRowPtrA,csrColIndA,csrValA,nnzL,csrRowPtrL, & csrColIndL,csrValL,nnzU,csrRowPtrU,csrColIndU,csrValU,P,Q,handle) & bind(c, name="cusolverRfSetupDevice") #else function hipsolverRfSetupDevice_(n,nnzA,csrRowPtrA,csrColIndA,csrValA,nnzL,csrRowPtrL, & csrColIndL,csrValL,nnzU,csrRowPtrU,csrColIndU,csrValU,P,Q,handle) & bind(c, name="hipsolverRfSetupDevice") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfSetupDevice_ integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: csrValA integer(c_int),value :: nnzL type(c_ptr),value :: csrRowPtrL type(c_ptr),value :: csrColIndL type(c_ptr),value :: csrValL integer(c_int),value :: nnzU type(c_ptr),value :: csrRowPtrU type(c_ptr),value :: csrColIndU type(c_ptr),value :: csrValU type(c_ptr),value :: P type(c_ptr),value :: Q type(c_ptr),value :: handle end function end interface interface hipsolverRfSetupHost #ifdef USE_CUDA_NAMES function hipsolverRfSetupHost_(n,nnzA,h_csrRowPtrA,h_csrColIndA,h_csrValA,nnzL,h_csrRowPtrL, & h_csrColIndL,h_csrValL,nnzU,h_csrRowPtrU,h_csrColIndU,h_csrValU,h_P,h_Q,handle) & bind(c, name="cusolverRfSetupHost") #else function hipsolverRfSetupHost_(n,nnzA,h_csrRowPtrA,h_csrColIndA,h_csrValA,nnzL,h_csrRowPtrL, & h_csrColIndL,h_csrValL,nnzU,h_csrRowPtrU,h_csrColIndU,h_csrValU,h_P,h_Q,handle) & bind(c, name="hipsolverRfSetupHost") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfSetupHost_ integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: h_csrRowPtrA type(c_ptr),value :: h_csrColIndA type(c_ptr),value :: h_csrValA integer(c_int),value :: nnzL type(c_ptr),value :: h_csrRowPtrL type(c_ptr),value :: h_csrColIndL type(c_ptr),value :: h_csrValL integer(c_int),value :: nnzU type(c_ptr),value :: h_csrRowPtrU type(c_ptr),value :: h_csrColIndU type(c_ptr),value :: h_csrValU type(c_ptr),value :: h_P type(c_ptr),value :: h_Q type(c_ptr),value :: handle end function end interface interface hipsolverRfAccessBundledFactorsDevice #ifdef USE_CUDA_NAMES function hipsolverRfAccessBundledFactorsDevice_(handle,nnzM,Mp,Mi,Mx) & bind(c, name="cusolverRfAccessBundledFactorsDevice") #else function hipsolverRfAccessBundledFactorsDevice_(handle,nnzM,Mp,Mi,Mx) & bind(c, name="hipsolverRfAccessBundledFactorsDevice") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfAccessBundledFactorsDevice_ type(c_ptr),value :: handle integer(c_int) :: nnzM type(c_ptr) :: Mp type(c_ptr) :: Mi type(c_ptr) :: Mx end function end interface interface hipsolverRfAnalyze #ifdef USE_CUDA_NAMES function hipsolverRfAnalyze_(handle) bind(c, name="cusolverRfAnalyze") #else function hipsolverRfAnalyze_(handle) bind(c, name="hipsolverRfAnalyze") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfAnalyze_ type(c_ptr),value :: handle end function end interface interface hipsolverRfExtractBundledFactorsHost #ifdef USE_CUDA_NAMES function hipsolverRfExtractBundledFactorsHost_(handle,h_nnzM,h_Mp,h_Mi,h_Mx) & bind(c, name="cusolverRfExtractBundledFactorsHost") #else function hipsolverRfExtractBundledFactorsHost_(handle,h_nnzM,h_Mp,h_Mi,h_Mx) & bind(c, name="hipsolverRfExtractBundledFactorsHost") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfExtractBundledFactorsHost_ type(c_ptr),value :: handle integer(c_int) :: h_nnzM type(c_ptr) :: h_Mp type(c_ptr) :: h_Mi type(c_ptr) :: h_Mx end function end interface interface hipsolverRfExtractSplitFactorsHost #ifdef USE_CUDA_NAMES function hipsolverRfExtractSplitFactorsHost_(handle,h_nnzL,h_Lp,h_Li,h_Lx,h_nnzU,h_Up,h_Ui, & h_Ux) & bind(c, name="cusolverRfExtractSplitFactorsHost") #else function hipsolverRfExtractSplitFactorsHost_(handle,h_nnzL,h_Lp,h_Li,h_Lx,h_nnzU,h_Up,h_Ui, & h_Ux) & bind(c, name="hipsolverRfExtractSplitFactorsHost") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfExtractSplitFactorsHost_ type(c_ptr),value :: handle integer(c_int) :: h_nnzL type(c_ptr) :: h_Lp type(c_ptr) :: h_Li type(c_ptr) :: h_Lx integer(c_int) :: h_nnzU type(c_ptr) :: h_Up type(c_ptr) :: h_Ui type(c_ptr) :: h_Ux end function end interface #ifndef USE_CUDA_NAMES interface hipsolverRfGet_Algs function hipsolverRfGet_Algs_(handle,fact_alg,solve_alg) bind(c, name="hipsolverRfGet_Algs") use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfGet_Algs_ type(c_ptr),value :: handle type(c_ptr),value :: fact_alg type(c_ptr),value :: solve_alg end function end interface #endif interface hipsolverRfGetMatrixFormat #ifdef USE_CUDA_NAMES function hipsolverRfGetMatrixFormat_(handle,myFormat,diag) & bind(c, name="cusolverRfGetMatrixFormat") #else function hipsolverRfGetMatrixFormat_(handle,myFormat,diag) & bind(c, name="hipsolverRfGetMatrixFormat") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfGetMatrixFormat_ type(c_ptr),value :: handle type(c_ptr),value :: myFormat type(c_ptr),value :: diag end function end interface interface hipsolverRfGetNumericBoostReport #ifdef USE_CUDA_NAMES function hipsolverRfGetNumericBoostReport_(handle,report) & bind(c, name="cusolverRfGetNumericBoostReport") #else function hipsolverRfGetNumericBoostReport_(handle,report) & bind(c, name="hipsolverRfGetNumericBoostReport") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfGetNumericBoostReport_ type(c_ptr),value :: handle type(c_ptr),value :: report end function end interface interface hipsolverRfGetNumericProperties #ifdef USE_CUDA_NAMES function hipsolverRfGetNumericProperties_(handle,zero,boost) & bind(c, name="cusolverRfGetNumericProperties") #else function hipsolverRfGetNumericProperties_(handle,zero,boost) & bind(c, name="hipsolverRfGetNumericProperties") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfGetNumericProperties_ type(c_ptr),value :: handle real(c_double) :: zero real(c_double) :: boost end function end interface interface hipsolverRfGetResetValuesFastMode #ifdef USE_CUDA_NAMES function hipsolverRfGetResetValuesFastMode_(handle,fastMode) & bind(c, name="cusolverRfGetResetValuesFastMode") #else function hipsolverRfGetResetValuesFastMode_(handle,fastMode) & bind(c, name="hipsolverRfGetResetValuesFastMode") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfGetResetValuesFastMode_ type(c_ptr),value :: handle type(c_ptr),value :: fastMode end function end interface interface hipsolverRfRefactor #ifdef USE_CUDA_NAMES function hipsolverRfRefactor_(handle) bind(c, name="cusolverRfRefactor") #else function hipsolverRfRefactor_(handle) bind(c, name="hipsolverRfRefactor") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfRefactor_ type(c_ptr),value :: handle end function end interface interface hipsolverRfResetValues #ifdef USE_CUDA_NAMES function hipsolverRfResetValues_(n,nnzA,csrRowPtrA,csrColIndA,csrValA,P,Q,handle) & bind(c, name="cusolverRfResetValues") #else function hipsolverRfResetValues_(n,nnzA,csrRowPtrA,csrColIndA,csrValA,P,Q,handle) & bind(c, name="hipsolverRfResetValues") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfResetValues_ integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: csrValA type(c_ptr),value :: P type(c_ptr),value :: Q type(c_ptr),value :: handle end function end interface interface hipsolverRfSetAlgs #ifdef USE_CUDA_NAMES function hipsolverRfSetAlgs_(handle,fact_alg,solve_alg) bind(c, name="cusolverRfSetAlgs") #else function hipsolverRfSetAlgs_(handle,fact_alg,solve_alg) bind(c, name="hipsolverRfSetAlgs") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfSetAlgs_ type(c_ptr),value :: handle integer(kind(HIPSOLVERRF_FACTORIZATION_ALG0)),value :: fact_alg integer(kind(HIPSOLVERRF_TRIANGULAR_SOLVE_ALG1)),value :: solve_alg end function end interface interface hipsolverRfSetMatrixFormat #ifdef USE_CUDA_NAMES function hipsolverRfSetMatrixFormat_(handle,myFormat,diag) & bind(c, name="cusolverRfSetMatrixFormat") #else function hipsolverRfSetMatrixFormat_(handle,myFormat,diag) & bind(c, name="hipsolverRfSetMatrixFormat") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfSetMatrixFormat_ type(c_ptr),value :: handle integer(kind(HIPSOLVERRF_MATRIX_FORMAT_CSR)),value :: myFormat integer(kind(HIPSOLVERRF_UNIT_DIAGONAL_STORED_L)),value :: diag end function end interface interface hipsolverRfSetNumericProperties #ifdef USE_CUDA_NAMES function hipsolverRfSetNumericProperties_(handle,effective_zero,boost_val) & bind(c, name="cusolverRfSetNumericProperties") #else function hipsolverRfSetNumericProperties_(handle,effective_zero,boost_val) & bind(c, name="hipsolverRfSetNumericProperties") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfSetNumericProperties_ type(c_ptr),value :: handle real(c_double),value :: effective_zero real(c_double),value :: boost_val end function end interface interface hipsolverRfSetResetValuesFastMode #ifdef USE_CUDA_NAMES function hipsolverRfSetResetValuesFastMode_(handle,fastMode) & bind(c, name="cusolverRfSetResetValuesFastMode") #else function hipsolverRfSetResetValuesFastMode_(handle,fastMode) & bind(c, name="hipsolverRfSetResetValuesFastMode") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfSetResetValuesFastMode_ type(c_ptr),value :: handle integer(kind(HIPSOLVERRF_RESET_VALUES_FAST_MODE_OFF)),value :: fastMode end function end interface interface hipsolverRfSolve #ifdef USE_CUDA_NAMES function hipsolverRfSolve_(handle,P,Q,nrhs,Temp,ldt,XF,ldxf) bind(c, name="cusolverRfSolve") #else function hipsolverRfSolve_(handle,P,Q,nrhs,Temp,ldt,XF,ldxf) bind(c, name="hipsolverRfSolve") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfSolve_ type(c_ptr),value :: handle type(c_ptr),value :: P type(c_ptr),value :: Q integer(c_int),value :: nrhs type(c_ptr),value :: Temp integer(c_int),value :: ldt type(c_ptr),value :: XF integer(c_int),value :: ldxf end function end interface interface hipsolverRfBatchSetupHost #ifdef USE_CUDA_NAMES function hipsolverRfBatchSetupHost_(batchSize,n,nnzA,h_csrRowPtrA,h_csrColIndA, & h_csrValA_array,nnzL,h_csrRowPtrL,h_csrColIndL,h_csrValL,nnzU,h_csrRowPtrU,h_csrColIndU, & h_csrValU,h_P,h_Q,handle) & bind(c, name="cusolverRfBatchSetupHost") #else function hipsolverRfBatchSetupHost_(batchSize,n,nnzA,h_csrRowPtrA,h_csrColIndA, & h_csrValA_array,nnzL,h_csrRowPtrL,h_csrColIndL,h_csrValL,nnzU,h_csrRowPtrU,h_csrColIndU, & h_csrValU,h_P,h_Q,handle) & bind(c, name="hipsolverRfBatchSetupHost") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfBatchSetupHost_ integer(c_int),value :: batchSize integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: h_csrRowPtrA type(c_ptr),value :: h_csrColIndA type(c_ptr) :: h_csrValA_array integer(c_int),value :: nnzL type(c_ptr),value :: h_csrRowPtrL type(c_ptr),value :: h_csrColIndL type(c_ptr),value :: h_csrValL integer(c_int),value :: nnzU type(c_ptr),value :: h_csrRowPtrU type(c_ptr),value :: h_csrColIndU type(c_ptr),value :: h_csrValU type(c_ptr),value :: h_P type(c_ptr),value :: h_Q type(c_ptr),value :: handle end function end interface interface hipsolverRfBatchAnalyze #ifdef USE_CUDA_NAMES function hipsolverRfBatchAnalyze_(handle) bind(c, name="cusolverRfBatchAnalyze") #else function hipsolverRfBatchAnalyze_(handle) bind(c, name="hipsolverRfBatchAnalyze") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfBatchAnalyze_ type(c_ptr),value :: handle end function end interface interface hipsolverRfBatchRefactor #ifdef USE_CUDA_NAMES function hipsolverRfBatchRefactor_(handle) bind(c, name="cusolverRfBatchRefactor") #else function hipsolverRfBatchRefactor_(handle) bind(c, name="hipsolverRfBatchRefactor") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfBatchRefactor_ type(c_ptr),value :: handle end function end interface interface hipsolverRfBatchResetValues #ifdef USE_CUDA_NAMES function hipsolverRfBatchResetValues_(batchSize,n,nnzA,csrRowPtrA,csrColIndA,csrValA_array,P, & Q,handle) & bind(c, name="cusolverRfBatchResetValues") #else function hipsolverRfBatchResetValues_(batchSize,n,nnzA,csrRowPtrA,csrColIndA,csrValA_array,P, & Q,handle) & bind(c, name="hipsolverRfBatchResetValues") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfBatchResetValues_ integer(c_int),value :: batchSize integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr) :: csrValA_array type(c_ptr),value :: P type(c_ptr),value :: Q type(c_ptr),value :: handle end function end interface interface hipsolverRfBatchSolve #ifdef USE_CUDA_NAMES function hipsolverRfBatchSolve_(handle,P,Q,nrhs,Temp,ldt,XF_array,ldxf) & bind(c, name="cusolverRfBatchSolve") #else function hipsolverRfBatchSolve_(handle,P,Q,nrhs,Temp,ldt,XF_array,ldxf) & bind(c, name="hipsolverRfBatchSolve") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfBatchSolve_ type(c_ptr),value :: handle type(c_ptr),value :: P type(c_ptr),value :: Q integer(c_int),value :: nrhs type(c_ptr),value :: Temp integer(c_int),value :: ldt type(c_ptr) :: XF_array integer(c_int),value :: ldxf end function end interface interface hipsolverRfBatchZeroPivot #ifdef USE_CUDA_NAMES function hipsolverRfBatchZeroPivot_(handle,position) bind(c, name="cusolverRfBatchZeroPivot") #else function hipsolverRfBatchZeroPivot_(handle,position) bind(c, name="hipsolverRfBatchZeroPivot") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverRfBatchZeroPivot_ type(c_ptr),value :: handle integer(c_int) :: position end function end interface interface hipsolverSpCreate #ifdef USE_CUDA_NAMES function hipsolverSpCreate_(handle) bind(c, name="cusolverSpCreate") #else function hipsolverSpCreate_(handle) bind(c, name="hipsolverSpCreate") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpCreate_ type(c_ptr) :: handle end function end interface interface hipsolverSpDestroy #ifdef USE_CUDA_NAMES function hipsolverSpDestroy_(handle) bind(c, name="cusolverSpDestroy") #else function hipsolverSpDestroy_(handle) bind(c, name="hipsolverSpDestroy") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpDestroy_ type(c_ptr),value :: handle end function end interface interface hipsolverSpSetStream #ifdef USE_CUDA_NAMES function hipsolverSpSetStream_(handle,streamId) bind(c, name="cusolverSpSetStream") #else function hipsolverSpSetStream_(handle,streamId) bind(c, name="hipsolverSpSetStream") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpSetStream_ type(c_ptr),value :: handle type(c_ptr),value :: streamId end function end interface interface hipsolverSpScsrlsvchol #ifdef USE_CUDA_NAMES function hipsolverSpScsrlsvchol_(handle,n,nnzA,descrA,csrVal,csrRowPtr,csrColInd,b,tolerance, & reorder,x,singularity) & bind(c, name="cusolverSpScsrlsvchol") #else function hipsolverSpScsrlsvchol_(handle,n,nnzA,descrA,csrVal,csrRowPtr,csrColInd,b,tolerance, & reorder,x,singularity) & bind(c, name="hipsolverSpScsrlsvchol") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpScsrlsvchol_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: b real(c_float),value :: tolerance integer(c_int),value :: reorder type(c_ptr),value :: x integer(c_int) :: singularity end function end interface interface hipsolverSpDcsrlsvchol #ifdef USE_CUDA_NAMES function hipsolverSpDcsrlsvchol_(handle,n,nnzA,descrA,csrVal,csrRowPtr,csrColInd,b,tolerance, & reorder,x,singularity) & bind(c, name="cusolverSpDcsrlsvchol") #else function hipsolverSpDcsrlsvchol_(handle,n,nnzA,descrA,csrVal,csrRowPtr,csrColInd,b,tolerance, & reorder,x,singularity) & bind(c, name="hipsolverSpDcsrlsvchol") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpDcsrlsvchol_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: b real(c_double),value :: tolerance integer(c_int),value :: reorder type(c_ptr),value :: x integer(c_int) :: singularity end function end interface interface hipsolverSpScsrlsvcholHost #ifdef USE_CUDA_NAMES function hipsolverSpScsrlsvcholHost_(handle,n,nnzA,descrA,csrVal,csrRowPtr,csrColInd,b, & tolerance,reorder,x,singularity) & bind(c, name="cusolverSpScsrlsvcholHost") #else function hipsolverSpScsrlsvcholHost_(handle,n,nnzA,descrA,csrVal,csrRowPtr,csrColInd,b, & tolerance,reorder,x,singularity) & bind(c, name="hipsolverSpScsrlsvcholHost") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpScsrlsvcholHost_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: b real(c_float),value :: tolerance integer(c_int),value :: reorder type(c_ptr),value :: x integer(c_int) :: singularity end function end interface interface hipsolverSpDcsrlsvcholHost #ifdef USE_CUDA_NAMES function hipsolverSpDcsrlsvcholHost_(handle,n,nnzA,descrA,csrVal,csrRowPtr,csrColInd,b, & tolerance,reorder,x,singularity) & bind(c, name="cusolverSpDcsrlsvcholHost") #else function hipsolverSpDcsrlsvcholHost_(handle,n,nnzA,descrA,csrVal,csrRowPtr,csrColInd,b, & tolerance,reorder,x,singularity) & bind(c, name="hipsolverSpDcsrlsvcholHost") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpDcsrlsvcholHost_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: b real(c_double),value :: tolerance integer(c_int),value :: reorder type(c_ptr),value :: x type(c_ptr),value :: singularity end function end interface interface hipsolverSpScsrlsvqr #ifdef USE_CUDA_NAMES function hipsolverSpScsrlsvqr_(handle,n,nnz,descrA,csrVal,csrRowPts,csrColInd,b,tolerance, & reorder,x,singularity) & bind(c, name="cusolverSpScsrlsvqr") #else function hipsolverSpScsrlsvqr_(handle,n,nnz,descrA,csrVal,csrRowPts,csrColInd,b,tolerance, & reorder,x,singularity) & bind(c, name="hipsolverSpScsrlsvqr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpScsrlsvqr_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPts type(c_ptr),value :: csrColInd type(c_ptr),value :: b real(c_double),value :: tolerance integer(c_int),value :: reorder type(c_ptr),value :: x type(c_ptr),value :: singularity end function end interface interface hipsolverSpDcsrlsvqr #ifdef USE_CUDA_NAMES function hipsolverSpDcsrlsvqr_(handle,n,nnz,descrA,csrVal,csrRowPts,csrColInd,b,tolerance, & reorder,x,singularity) & bind(c, name="cusolverSpDcsrlsvqr") #else function hipsolverSpDcsrlsvqr_(handle,n,nnz,descrA,csrVal,csrRowPts,csrColInd,b,tolerance, & reorder,x,singularity) & bind(c, name="hipsolverSpDcsrlsvqr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpDcsrlsvqr_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPts type(c_ptr),value :: csrColInd type(c_ptr),value :: b real(c_double),value :: tolerance integer(c_int),value :: reorder type(c_ptr),value :: x type(c_ptr),value :: singularity end function end interface interface hipsolverSpCcsrlsvqr #ifdef USE_CUDA_NAMES function hipsolverSpCcsrlsvqr_(handle,n,nnz,descrA,csrVal,csrRowPts,csrColInd,b,tolerance, & reorder,x,singularity) & bind(c, name="cusolverSpCcsrlsvqr") #else function hipsolverSpCcsrlsvqr_(handle,n,nnz,descrA,csrVal,csrRowPts,csrColInd,b,tolerance, & reorder,x,singularity) & bind(c, name="hipsolverSpCcsrlsvqr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpCcsrlsvqr_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPts type(c_ptr),value :: csrColInd type(c_ptr),value :: b real(c_double),value :: tolerance integer(c_int),value :: reorder type(c_ptr),value :: x type(c_ptr),value :: singularity end function end interface interface hipsolverSpZcsrlsvqr #ifdef USE_CUDA_NAMES function hipsolverSpZcsrlsvqr_(handle,n,nnz,descrA,csrVal,csrRowPts,csrColInd,b,tolerance, & reorder,x,singularity) & bind(c, name="cusolverSpZcsrlsvqr") #else function hipsolverSpZcsrlsvqr_(handle,n,nnz,descrA,csrVal,csrRowPts,csrColInd,b,tolerance, & reorder,x,singularity) & bind(c, name="hipsolverSpZcsrlsvqr") #endif use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpZcsrlsvqr_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPts type(c_ptr),value :: csrColInd type(c_ptr),value :: b real(c_double),value :: tolerance integer(c_int),value :: reorder type(c_ptr),value :: x type(c_ptr),value :: singularity end function end interface #ifdef USE_FPOINTER_INTERFACES contains #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSorgbr_bufferSize_assumed_rank(handle,side,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgbr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: tau integer(c_int) :: lwork ! hipsolverSorgbr_bufferSize_assumed_rank = hipsolverSorgbr_bufferSize_(handle,side,m,n,k, & c_loc(A),lda,tau,lwork) end function #else function hipsolverSorgbr_bufferSize_rank_0(handle,side,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgbr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float) :: tau integer(c_int) :: lwork ! hipsolverSorgbr_bufferSize_rank_0 = hipsolverSorgbr_bufferSize_(handle,side,m,n,k,c_loc(A), & lda,tau,lwork) end function function hipsolverSorgbr_bufferSize_rank_1(handle,side,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgbr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: tau integer(c_int) :: lwork ! hipsolverSorgbr_bufferSize_rank_1 = hipsolverSorgbr_bufferSize_(handle,side,m,n,k,c_loc(A), & lda,tau,lwork) end function function hipsolverSorgbr_bufferSize_full_rank(handle,side,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgbr_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: tau integer(c_int) :: lwork ! hipsolverSorgbr_bufferSize_full_rank = hipsolverSorgbr_bufferSize_(handle,side,m,n,k, & c_loc(A),lda,tau,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDorgbr_bufferSize_assumed_rank(handle,side,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgbr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: tau integer(c_int) :: lwork ! hipsolverDorgbr_bufferSize_assumed_rank = hipsolverDorgbr_bufferSize_(handle,side,m,n,k, & c_loc(A),lda,tau,lwork) end function #else function hipsolverDorgbr_bufferSize_rank_0(handle,side,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgbr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double) :: tau integer(c_int) :: lwork ! hipsolverDorgbr_bufferSize_rank_0 = hipsolverDorgbr_bufferSize_(handle,side,m,n,k,c_loc(A), & lda,tau,lwork) end function function hipsolverDorgbr_bufferSize_rank_1(handle,side,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgbr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: tau integer(c_int) :: lwork ! hipsolverDorgbr_bufferSize_rank_1 = hipsolverDorgbr_bufferSize_(handle,side,m,n,k,c_loc(A), & lda,tau,lwork) end function function hipsolverDorgbr_bufferSize_full_rank(handle,side,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgbr_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: tau integer(c_int) :: lwork ! hipsolverDorgbr_bufferSize_full_rank = hipsolverDorgbr_bufferSize_(handle,side,m,n,k, & c_loc(A),lda,tau,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCungbr_bufferSize_assumed_rank(handle,side,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungbr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex) :: tau integer(c_int) :: lwork ! hipsolverCungbr_bufferSize_assumed_rank = hipsolverCungbr_bufferSize_(handle,side,m,n,k, & c_loc(A),lda,tau,lwork) end function #else function hipsolverCungbr_bufferSize_rank_0(handle,side,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungbr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex) :: tau integer(c_int) :: lwork ! hipsolverCungbr_bufferSize_rank_0 = hipsolverCungbr_bufferSize_(handle,side,m,n,k,c_loc(A), & lda,tau,lwork) end function function hipsolverCungbr_bufferSize_rank_1(handle,side,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungbr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau integer(c_int) :: lwork ! hipsolverCungbr_bufferSize_rank_1 = hipsolverCungbr_bufferSize_(handle,side,m,n,k,c_loc(A), & lda,tau,lwork) end function function hipsolverCungbr_bufferSize_full_rank(handle,side,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungbr_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau integer(c_int) :: lwork ! hipsolverCungbr_bufferSize_full_rank = hipsolverCungbr_bufferSize_(handle,side,m,n,k, & c_loc(A),lda,tau,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZungbr_bufferSize_assumed_rank(handle,side,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungbr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex) :: tau integer(c_int) :: lwork ! hipsolverZungbr_bufferSize_assumed_rank = hipsolverZungbr_bufferSize_(handle,side,m,n,k, & c_loc(A),lda,tau,lwork) end function #else function hipsolverZungbr_bufferSize_rank_0(handle,side,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungbr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex) :: tau integer(c_int) :: lwork ! hipsolverZungbr_bufferSize_rank_0 = hipsolverZungbr_bufferSize_(handle,side,m,n,k,c_loc(A), & lda,tau,lwork) end function function hipsolverZungbr_bufferSize_rank_1(handle,side,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungbr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau integer(c_int) :: lwork ! hipsolverZungbr_bufferSize_rank_1 = hipsolverZungbr_bufferSize_(handle,side,m,n,k,c_loc(A), & lda,tau,lwork) end function function hipsolverZungbr_bufferSize_full_rank(handle,side,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungbr_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau integer(c_int) :: lwork ! hipsolverZungbr_bufferSize_full_rank = hipsolverZungbr_bufferSize_(handle,side,m,n,k, & c_loc(A),lda,tau,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSorgbr_assumed_rank(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgbr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSorgbr_assumed_rank = hipsolverSorgbr_(handle,side,m,n,k,c_loc(A),lda,tau,work, & lwork,devInfo) end function #else function hipsolverSorgbr_rank_0(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgbr_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSorgbr_rank_0 = hipsolverSorgbr_(handle,side,m,n,k,c_loc(A),lda,tau,work,lwork, & devInfo) end function function hipsolverSorgbr_rank_1(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgbr_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSorgbr_rank_1 = hipsolverSorgbr_(handle,side,m,n,k,c_loc(A),lda,tau,work,lwork, & devInfo) end function function hipsolverSorgbr_full_rank(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgbr_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSorgbr_full_rank = hipsolverSorgbr_(handle,side,m,n,k,c_loc(A),lda,tau,work,lwork, & devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDorgbr_assumed_rank(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgbr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDorgbr_assumed_rank = hipsolverDorgbr_(handle,side,m,n,k,c_loc(A),lda,tau,work, & lwork,devInfo) end function #else function hipsolverDorgbr_rank_0(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgbr_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDorgbr_rank_0 = hipsolverDorgbr_(handle,side,m,n,k,c_loc(A),lda,tau,work,lwork, & devInfo) end function function hipsolverDorgbr_rank_1(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgbr_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDorgbr_rank_1 = hipsolverDorgbr_(handle,side,m,n,k,c_loc(A),lda,tau,work,lwork, & devInfo) end function function hipsolverDorgbr_full_rank(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgbr_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDorgbr_full_rank = hipsolverDorgbr_(handle,side,m,n,k,c_loc(A),lda,tau,work,lwork, & devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCungbr_assumed_rank(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungbr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCungbr_assumed_rank = hipsolverCungbr_(handle,side,m,n,k,c_loc(A),lda,tau,work, & lwork,devInfo) end function #else function hipsolverCungbr_rank_0(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungbr_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCungbr_rank_0 = hipsolverCungbr_(handle,side,m,n,k,c_loc(A),lda,tau,work,lwork, & devInfo) end function function hipsolverCungbr_rank_1(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungbr_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCungbr_rank_1 = hipsolverCungbr_(handle,side,m,n,k,c_loc(A),lda,tau,work,lwork, & devInfo) end function function hipsolverCungbr_full_rank(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungbr_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCungbr_full_rank = hipsolverCungbr_(handle,side,m,n,k,c_loc(A),lda,tau,work,lwork, & devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZungbr_assumed_rank(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungbr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZungbr_assumed_rank = hipsolverZungbr_(handle,side,m,n,k,c_loc(A),lda,tau,work, & lwork,devInfo) end function #else function hipsolverZungbr_rank_0(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungbr_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZungbr_rank_0 = hipsolverZungbr_(handle,side,m,n,k,c_loc(A),lda,tau,work,lwork, & devInfo) end function function hipsolverZungbr_rank_1(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungbr_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZungbr_rank_1 = hipsolverZungbr_(handle,side,m,n,k,c_loc(A),lda,tau,work,lwork, & devInfo) end function function hipsolverZungbr_full_rank(handle,side,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungbr_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZungbr_full_rank = hipsolverZungbr_(handle,side,m,n,k,c_loc(A),lda,tau,work,lwork, & devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSorgqr_bufferSize_assumed_rank(handle,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgqr_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: tau integer(c_int) :: lwork ! hipsolverSorgqr_bufferSize_assumed_rank = hipsolverSorgqr_bufferSize_(handle,m,n,k,c_loc(A), & lda,tau,lwork) end function #else function hipsolverSorgqr_bufferSize_rank_0(handle,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgqr_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float) :: tau integer(c_int) :: lwork ! hipsolverSorgqr_bufferSize_rank_0 = hipsolverSorgqr_bufferSize_(handle,m,n,k,c_loc(A),lda, & tau,lwork) end function function hipsolverSorgqr_bufferSize_rank_1(handle,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgqr_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: tau integer(c_int) :: lwork ! hipsolverSorgqr_bufferSize_rank_1 = hipsolverSorgqr_bufferSize_(handle,m,n,k,c_loc(A),lda, & tau,lwork) end function function hipsolverSorgqr_bufferSize_full_rank(handle,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgqr_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: tau integer(c_int) :: lwork ! hipsolverSorgqr_bufferSize_full_rank = hipsolverSorgqr_bufferSize_(handle,m,n,k,c_loc(A), & lda,tau,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDorgqr_bufferSize_assumed_rank(handle,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgqr_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: tau integer(c_int) :: lwork ! hipsolverDorgqr_bufferSize_assumed_rank = hipsolverDorgqr_bufferSize_(handle,m,n,k,c_loc(A), & lda,tau,lwork) end function #else function hipsolverDorgqr_bufferSize_rank_0(handle,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgqr_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double) :: tau integer(c_int) :: lwork ! hipsolverDorgqr_bufferSize_rank_0 = hipsolverDorgqr_bufferSize_(handle,m,n,k,c_loc(A),lda, & tau,lwork) end function function hipsolverDorgqr_bufferSize_rank_1(handle,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgqr_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: tau integer(c_int) :: lwork ! hipsolverDorgqr_bufferSize_rank_1 = hipsolverDorgqr_bufferSize_(handle,m,n,k,c_loc(A),lda, & tau,lwork) end function function hipsolverDorgqr_bufferSize_full_rank(handle,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgqr_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: tau integer(c_int) :: lwork ! hipsolverDorgqr_bufferSize_full_rank = hipsolverDorgqr_bufferSize_(handle,m,n,k,c_loc(A), & lda,tau,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCungqr_bufferSize_assumed_rank(handle,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungqr_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex) :: tau integer(c_int) :: lwork ! hipsolverCungqr_bufferSize_assumed_rank = hipsolverCungqr_bufferSize_(handle,m,n,k,c_loc(A), & lda,tau,lwork) end function #else function hipsolverCungqr_bufferSize_rank_0(handle,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungqr_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex) :: tau integer(c_int) :: lwork ! hipsolverCungqr_bufferSize_rank_0 = hipsolverCungqr_bufferSize_(handle,m,n,k,c_loc(A),lda, & tau,lwork) end function function hipsolverCungqr_bufferSize_rank_1(handle,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungqr_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau integer(c_int) :: lwork ! hipsolverCungqr_bufferSize_rank_1 = hipsolverCungqr_bufferSize_(handle,m,n,k,c_loc(A),lda, & tau,lwork) end function function hipsolverCungqr_bufferSize_full_rank(handle,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungqr_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau integer(c_int) :: lwork ! hipsolverCungqr_bufferSize_full_rank = hipsolverCungqr_bufferSize_(handle,m,n,k,c_loc(A), & lda,tau,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZungqr_bufferSize_assumed_rank(handle,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungqr_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex) :: tau integer(c_int) :: lwork ! hipsolverZungqr_bufferSize_assumed_rank = hipsolverZungqr_bufferSize_(handle,m,n,k,c_loc(A), & lda,tau,lwork) end function #else function hipsolverZungqr_bufferSize_rank_0(handle,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungqr_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex) :: tau integer(c_int) :: lwork ! hipsolverZungqr_bufferSize_rank_0 = hipsolverZungqr_bufferSize_(handle,m,n,k,c_loc(A),lda, & tau,lwork) end function function hipsolverZungqr_bufferSize_rank_1(handle,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungqr_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau integer(c_int) :: lwork ! hipsolverZungqr_bufferSize_rank_1 = hipsolverZungqr_bufferSize_(handle,m,n,k,c_loc(A),lda, & tau,lwork) end function function hipsolverZungqr_bufferSize_full_rank(handle,m,n,k,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungqr_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau integer(c_int) :: lwork ! hipsolverZungqr_bufferSize_full_rank = hipsolverZungqr_bufferSize_(handle,m,n,k,c_loc(A), & lda,tau,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSorgqr_assumed_rank(handle,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgqr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSorgqr_assumed_rank = hipsolverSorgqr_(handle,m,n,k,c_loc(A),lda,tau,work,lwork, & devInfo) end function #else function hipsolverSorgqr_rank_0(handle,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgqr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSorgqr_rank_0 = hipsolverSorgqr_(handle,m,n,k,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverSorgqr_rank_1(handle,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgqr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSorgqr_rank_1 = hipsolverSorgqr_(handle,m,n,k,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverSorgqr_full_rank(handle,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgqr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSorgqr_full_rank = hipsolverSorgqr_(handle,m,n,k,c_loc(A),lda,tau,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDorgqr_assumed_rank(handle,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgqr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDorgqr_assumed_rank = hipsolverDorgqr_(handle,m,n,k,c_loc(A),lda,tau,work,lwork, & devInfo) end function #else function hipsolverDorgqr_rank_0(handle,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgqr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDorgqr_rank_0 = hipsolverDorgqr_(handle,m,n,k,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverDorgqr_rank_1(handle,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgqr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDorgqr_rank_1 = hipsolverDorgqr_(handle,m,n,k,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverDorgqr_full_rank(handle,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgqr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDorgqr_full_rank = hipsolverDorgqr_(handle,m,n,k,c_loc(A),lda,tau,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCungqr_assumed_rank(handle,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungqr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCungqr_assumed_rank = hipsolverCungqr_(handle,m,n,k,c_loc(A),lda,tau,work,lwork, & devInfo) end function #else function hipsolverCungqr_rank_0(handle,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungqr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCungqr_rank_0 = hipsolverCungqr_(handle,m,n,k,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverCungqr_rank_1(handle,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungqr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCungqr_rank_1 = hipsolverCungqr_(handle,m,n,k,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverCungqr_full_rank(handle,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungqr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCungqr_full_rank = hipsolverCungqr_(handle,m,n,k,c_loc(A),lda,tau,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZungqr_assumed_rank(handle,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungqr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZungqr_assumed_rank = hipsolverZungqr_(handle,m,n,k,c_loc(A),lda,tau,work,lwork, & devInfo) end function #else function hipsolverZungqr_rank_0(handle,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungqr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZungqr_rank_0 = hipsolverZungqr_(handle,m,n,k,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverZungqr_rank_1(handle,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungqr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZungqr_rank_1 = hipsolverZungqr_(handle,m,n,k,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverZungqr_full_rank(handle,m,n,k,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungqr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZungqr_full_rank = hipsolverZungqr_(handle,m,n,k,c_loc(A),lda,tau,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSorgtr_bufferSize_assumed_rank(handle,uplo,n,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgtr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: tau integer(c_int) :: lwork ! hipsolverSorgtr_bufferSize_assumed_rank = hipsolverSorgtr_bufferSize_(handle,uplo,n, & c_loc(A),lda,tau,lwork) end function #else function hipsolverSorgtr_bufferSize_rank_0(handle,uplo,n,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgtr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float) :: tau integer(c_int) :: lwork ! hipsolverSorgtr_bufferSize_rank_0 = hipsolverSorgtr_bufferSize_(handle,uplo,n,c_loc(A),lda, & tau,lwork) end function function hipsolverSorgtr_bufferSize_rank_1(handle,uplo,n,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgtr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: tau integer(c_int) :: lwork ! hipsolverSorgtr_bufferSize_rank_1 = hipsolverSorgtr_bufferSize_(handle,uplo,n,c_loc(A),lda, & tau,lwork) end function function hipsolverSorgtr_bufferSize_full_rank(handle,uplo,n,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgtr_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: tau integer(c_int) :: lwork ! hipsolverSorgtr_bufferSize_full_rank = hipsolverSorgtr_bufferSize_(handle,uplo,n,c_loc(A), & lda,tau,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDorgtr_bufferSize_assumed_rank(handle,uplo,n,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgtr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: tau integer(c_int) :: lwork ! hipsolverDorgtr_bufferSize_assumed_rank = hipsolverDorgtr_bufferSize_(handle,uplo,n, & c_loc(A),lda,tau,lwork) end function #else function hipsolverDorgtr_bufferSize_rank_0(handle,uplo,n,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgtr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double) :: tau integer(c_int) :: lwork ! hipsolverDorgtr_bufferSize_rank_0 = hipsolverDorgtr_bufferSize_(handle,uplo,n,c_loc(A),lda, & tau,lwork) end function function hipsolverDorgtr_bufferSize_rank_1(handle,uplo,n,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgtr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: tau integer(c_int) :: lwork ! hipsolverDorgtr_bufferSize_rank_1 = hipsolverDorgtr_bufferSize_(handle,uplo,n,c_loc(A),lda, & tau,lwork) end function function hipsolverDorgtr_bufferSize_full_rank(handle,uplo,n,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgtr_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: tau integer(c_int) :: lwork ! hipsolverDorgtr_bufferSize_full_rank = hipsolverDorgtr_bufferSize_(handle,uplo,n,c_loc(A), & lda,tau,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCungtr_bufferSize_assumed_rank(handle,uplo,n,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungtr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex) :: tau integer(c_int) :: lwork ! hipsolverCungtr_bufferSize_assumed_rank = hipsolverCungtr_bufferSize_(handle,uplo,n, & c_loc(A),lda,tau,lwork) end function #else function hipsolverCungtr_bufferSize_rank_0(handle,uplo,n,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungtr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex) :: tau integer(c_int) :: lwork ! hipsolverCungtr_bufferSize_rank_0 = hipsolverCungtr_bufferSize_(handle,uplo,n,c_loc(A),lda, & tau,lwork) end function function hipsolverCungtr_bufferSize_rank_1(handle,uplo,n,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungtr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau integer(c_int) :: lwork ! hipsolverCungtr_bufferSize_rank_1 = hipsolverCungtr_bufferSize_(handle,uplo,n,c_loc(A),lda, & tau,lwork) end function function hipsolverCungtr_bufferSize_full_rank(handle,uplo,n,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungtr_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau integer(c_int) :: lwork ! hipsolverCungtr_bufferSize_full_rank = hipsolverCungtr_bufferSize_(handle,uplo,n,c_loc(A), & lda,tau,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZungtr_bufferSize_assumed_rank(handle,uplo,n,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungtr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex) :: tau integer(c_int) :: lwork ! hipsolverZungtr_bufferSize_assumed_rank = hipsolverZungtr_bufferSize_(handle,uplo,n, & c_loc(A),lda,tau,lwork) end function #else function hipsolverZungtr_bufferSize_rank_0(handle,uplo,n,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungtr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex) :: tau integer(c_int) :: lwork ! hipsolverZungtr_bufferSize_rank_0 = hipsolverZungtr_bufferSize_(handle,uplo,n,c_loc(A),lda, & tau,lwork) end function function hipsolverZungtr_bufferSize_rank_1(handle,uplo,n,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungtr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau integer(c_int) :: lwork ! hipsolverZungtr_bufferSize_rank_1 = hipsolverZungtr_bufferSize_(handle,uplo,n,c_loc(A),lda, & tau,lwork) end function function hipsolverZungtr_bufferSize_full_rank(handle,uplo,n,A,lda,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungtr_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau integer(c_int) :: lwork ! hipsolverZungtr_bufferSize_full_rank = hipsolverZungtr_bufferSize_(handle,uplo,n,c_loc(A), & lda,tau,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSorgtr_assumed_rank(handle,uplo,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgtr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSorgtr_assumed_rank = hipsolverSorgtr_(handle,uplo,n,c_loc(A),lda,tau,work,lwork, & devInfo) end function #else function hipsolverSorgtr_rank_0(handle,uplo,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgtr_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSorgtr_rank_0 = hipsolverSorgtr_(handle,uplo,n,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverSorgtr_rank_1(handle,uplo,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgtr_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSorgtr_rank_1 = hipsolverSorgtr_(handle,uplo,n,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverSorgtr_full_rank(handle,uplo,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSorgtr_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSorgtr_full_rank = hipsolverSorgtr_(handle,uplo,n,c_loc(A),lda,tau,work,lwork, & devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDorgtr_assumed_rank(handle,uplo,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgtr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDorgtr_assumed_rank = hipsolverDorgtr_(handle,uplo,n,c_loc(A),lda,tau,work,lwork, & devInfo) end function #else function hipsolverDorgtr_rank_0(handle,uplo,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgtr_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDorgtr_rank_0 = hipsolverDorgtr_(handle,uplo,n,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverDorgtr_rank_1(handle,uplo,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgtr_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDorgtr_rank_1 = hipsolverDorgtr_(handle,uplo,n,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverDorgtr_full_rank(handle,uplo,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDorgtr_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDorgtr_full_rank = hipsolverDorgtr_(handle,uplo,n,c_loc(A),lda,tau,work,lwork, & devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCungtr_assumed_rank(handle,uplo,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungtr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCungtr_assumed_rank = hipsolverCungtr_(handle,uplo,n,c_loc(A),lda,tau,work,lwork, & devInfo) end function #else function hipsolverCungtr_rank_0(handle,uplo,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungtr_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCungtr_rank_0 = hipsolverCungtr_(handle,uplo,n,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverCungtr_rank_1(handle,uplo,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungtr_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCungtr_rank_1 = hipsolverCungtr_(handle,uplo,n,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverCungtr_full_rank(handle,uplo,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCungtr_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCungtr_full_rank = hipsolverCungtr_(handle,uplo,n,c_loc(A),lda,tau,work,lwork, & devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZungtr_assumed_rank(handle,uplo,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungtr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZungtr_assumed_rank = hipsolverZungtr_(handle,uplo,n,c_loc(A),lda,tau,work,lwork, & devInfo) end function #else function hipsolverZungtr_rank_0(handle,uplo,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungtr_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZungtr_rank_0 = hipsolverZungtr_(handle,uplo,n,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverZungtr_rank_1(handle,uplo,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungtr_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZungtr_rank_1 = hipsolverZungtr_(handle,uplo,n,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverZungtr_full_rank(handle,uplo,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZungtr_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZungtr_full_rank = hipsolverZungtr_(handle,uplo,n,c_loc(A),lda,tau,work,lwork, & devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSormqr_bufferSize_assumed_rank(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormqr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: tau real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverSormqr_bufferSize_assumed_rank = hipsolverSormqr_bufferSize_(handle,side,trans,m,n, & k,c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function #else function hipsolverSormqr_bufferSize_rank_0(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormqr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float) :: tau real(c_float),target :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverSormqr_bufferSize_rank_0 = hipsolverSormqr_bufferSize_(handle,side,trans,m,n,k, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function function hipsolverSormqr_bufferSize_rank_1(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormqr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: tau real(c_float),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverSormqr_bufferSize_rank_1 = hipsolverSormqr_bufferSize_(handle,side,trans,m,n,k, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function function hipsolverSormqr_bufferSize_full_rank(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormqr_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: tau real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverSormqr_bufferSize_full_rank = hipsolverSormqr_bufferSize_(handle,side,trans,m,n,k, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDormqr_bufferSize_assumed_rank(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormqr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: tau real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverDormqr_bufferSize_assumed_rank = hipsolverDormqr_bufferSize_(handle,side,trans,m,n, & k,c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function #else function hipsolverDormqr_bufferSize_rank_0(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormqr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double) :: tau real(c_double),target :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverDormqr_bufferSize_rank_0 = hipsolverDormqr_bufferSize_(handle,side,trans,m,n,k, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function function hipsolverDormqr_bufferSize_rank_1(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormqr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: tau real(c_double),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverDormqr_bufferSize_rank_1 = hipsolverDormqr_bufferSize_(handle,side,trans,m,n,k, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function function hipsolverDormqr_bufferSize_full_rank(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormqr_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: tau real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverDormqr_bufferSize_full_rank = hipsolverDormqr_bufferSize_(handle,side,trans,m,n,k, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCunmqr_bufferSize_assumed_rank(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmqr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex) :: tau complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverCunmqr_bufferSize_assumed_rank = hipsolverCunmqr_bufferSize_(handle,side,trans,m,n, & k,c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function #else function hipsolverCunmqr_bufferSize_rank_0(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmqr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex) :: tau complex(c_float_complex),target :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverCunmqr_bufferSize_rank_0 = hipsolverCunmqr_bufferSize_(handle,side,trans,m,n,k, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function function hipsolverCunmqr_bufferSize_rank_1(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmqr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverCunmqr_bufferSize_rank_1 = hipsolverCunmqr_bufferSize_(handle,side,trans,m,n,k, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function function hipsolverCunmqr_bufferSize_full_rank(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmqr_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverCunmqr_bufferSize_full_rank = hipsolverCunmqr_bufferSize_(handle,side,trans,m,n,k, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZunmqr_bufferSize_assumed_rank(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmqr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex) :: tau complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverZunmqr_bufferSize_assumed_rank = hipsolverZunmqr_bufferSize_(handle,side,trans,m,n, & k,c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function #else function hipsolverZunmqr_bufferSize_rank_0(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmqr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex) :: tau complex(c_double_complex),target :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverZunmqr_bufferSize_rank_0 = hipsolverZunmqr_bufferSize_(handle,side,trans,m,n,k, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function function hipsolverZunmqr_bufferSize_rank_1(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmqr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverZunmqr_bufferSize_rank_1 = hipsolverZunmqr_bufferSize_(handle,side,trans,m,n,k, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function function hipsolverZunmqr_bufferSize_full_rank(handle,side,trans,m,n,k,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmqr_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverZunmqr_bufferSize_full_rank = hipsolverZunmqr_bufferSize_(handle,side,trans,m,n,k, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSormqr_assumed_rank(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormqr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: tau real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSormqr_assumed_rank = hipsolverSormqr_(handle,side,trans,m,n,k,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function #else function hipsolverSormqr_rank_0(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormqr_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float) :: tau real(c_float),target :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSormqr_rank_0 = hipsolverSormqr_(handle,side,trans,m,n,k,c_loc(A),lda,tau,c_loc(C), & ldc,work,lwork,devInfo) end function function hipsolverSormqr_rank_1(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormqr_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: tau real(c_float),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSormqr_rank_1 = hipsolverSormqr_(handle,side,trans,m,n,k,c_loc(A),lda,tau,c_loc(C), & ldc,work,lwork,devInfo) end function function hipsolverSormqr_full_rank(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormqr_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: tau real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSormqr_full_rank = hipsolverSormqr_(handle,side,trans,m,n,k,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDormqr_assumed_rank(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormqr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: tau real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDormqr_assumed_rank = hipsolverDormqr_(handle,side,trans,m,n,k,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function #else function hipsolverDormqr_rank_0(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormqr_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double) :: tau real(c_double),target :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDormqr_rank_0 = hipsolverDormqr_(handle,side,trans,m,n,k,c_loc(A),lda,tau,c_loc(C), & ldc,work,lwork,devInfo) end function function hipsolverDormqr_rank_1(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormqr_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: tau real(c_double),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDormqr_rank_1 = hipsolverDormqr_(handle,side,trans,m,n,k,c_loc(A),lda,tau,c_loc(C), & ldc,work,lwork,devInfo) end function function hipsolverDormqr_full_rank(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormqr_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: tau real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDormqr_full_rank = hipsolverDormqr_(handle,side,trans,m,n,k,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCunmqr_assumed_rank(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmqr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex) :: tau complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCunmqr_assumed_rank = hipsolverCunmqr_(handle,side,trans,m,n,k,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function #else function hipsolverCunmqr_rank_0(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmqr_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex) :: tau complex(c_float_complex),target :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCunmqr_rank_0 = hipsolverCunmqr_(handle,side,trans,m,n,k,c_loc(A),lda,tau,c_loc(C), & ldc,work,lwork,devInfo) end function function hipsolverCunmqr_rank_1(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmqr_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCunmqr_rank_1 = hipsolverCunmqr_(handle,side,trans,m,n,k,c_loc(A),lda,tau,c_loc(C), & ldc,work,lwork,devInfo) end function function hipsolverCunmqr_full_rank(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmqr_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCunmqr_full_rank = hipsolverCunmqr_(handle,side,trans,m,n,k,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZunmqr_assumed_rank(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmqr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex) :: tau complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZunmqr_assumed_rank = hipsolverZunmqr_(handle,side,trans,m,n,k,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function #else function hipsolverZunmqr_rank_0(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmqr_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex) :: tau complex(c_double_complex),target :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZunmqr_rank_0 = hipsolverZunmqr_(handle,side,trans,m,n,k,c_loc(A),lda,tau,c_loc(C), & ldc,work,lwork,devInfo) end function function hipsolverZunmqr_rank_1(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmqr_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZunmqr_rank_1 = hipsolverZunmqr_(handle,side,trans,m,n,k,c_loc(A),lda,tau,c_loc(C), & ldc,work,lwork,devInfo) end function function hipsolverZunmqr_full_rank(handle,side,trans,m,n,k,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmqr_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZunmqr_full_rank = hipsolverZunmqr_(handle,side,trans,m,n,k,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSormtr_bufferSize_assumed_rank(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc, & lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormtr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: tau real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverSormtr_bufferSize_assumed_rank = hipsolverSormtr_bufferSize_(handle,side,uplo, & trans,m,n,c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function #else function hipsolverSormtr_bufferSize_rank_0(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormtr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float) :: tau real(c_float),target :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverSormtr_bufferSize_rank_0 = hipsolverSormtr_bufferSize_(handle,side,uplo,trans,m,n, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function function hipsolverSormtr_bufferSize_rank_1(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormtr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: tau real(c_float),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverSormtr_bufferSize_rank_1 = hipsolverSormtr_bufferSize_(handle,side,uplo,trans,m,n, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function function hipsolverSormtr_bufferSize_full_rank(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormtr_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: tau real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverSormtr_bufferSize_full_rank = hipsolverSormtr_bufferSize_(handle,side,uplo,trans,m, & n,c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDormtr_bufferSize_assumed_rank(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc, & lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormtr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: tau real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverDormtr_bufferSize_assumed_rank = hipsolverDormtr_bufferSize_(handle,side,uplo, & trans,m,n,c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function #else function hipsolverDormtr_bufferSize_rank_0(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormtr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double) :: tau real(c_double),target :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverDormtr_bufferSize_rank_0 = hipsolverDormtr_bufferSize_(handle,side,uplo,trans,m,n, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function function hipsolverDormtr_bufferSize_rank_1(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormtr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: tau real(c_double),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverDormtr_bufferSize_rank_1 = hipsolverDormtr_bufferSize_(handle,side,uplo,trans,m,n, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function function hipsolverDormtr_bufferSize_full_rank(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormtr_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: tau real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverDormtr_bufferSize_full_rank = hipsolverDormtr_bufferSize_(handle,side,uplo,trans,m, & n,c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCunmtr_bufferSize_assumed_rank(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc, & lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmtr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex) :: tau complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverCunmtr_bufferSize_assumed_rank = hipsolverCunmtr_bufferSize_(handle,side,uplo, & trans,m,n,c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function #else function hipsolverCunmtr_bufferSize_rank_0(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmtr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex) :: tau complex(c_float_complex),target :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverCunmtr_bufferSize_rank_0 = hipsolverCunmtr_bufferSize_(handle,side,uplo,trans,m,n, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function function hipsolverCunmtr_bufferSize_rank_1(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmtr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverCunmtr_bufferSize_rank_1 = hipsolverCunmtr_bufferSize_(handle,side,uplo,trans,m,n, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function function hipsolverCunmtr_bufferSize_full_rank(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmtr_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverCunmtr_bufferSize_full_rank = hipsolverCunmtr_bufferSize_(handle,side,uplo,trans,m, & n,c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZunmtr_bufferSize_assumed_rank(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc, & lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmtr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex) :: tau complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverZunmtr_bufferSize_assumed_rank = hipsolverZunmtr_bufferSize_(handle,side,uplo, & trans,m,n,c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function #else function hipsolverZunmtr_bufferSize_rank_0(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmtr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex) :: tau complex(c_double_complex),target :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverZunmtr_bufferSize_rank_0 = hipsolverZunmtr_bufferSize_(handle,side,uplo,trans,m,n, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function function hipsolverZunmtr_bufferSize_rank_1(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmtr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverZunmtr_bufferSize_rank_1 = hipsolverZunmtr_bufferSize_(handle,side,uplo,trans,m,n, & c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function function hipsolverZunmtr_bufferSize_full_rank(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmtr_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int) :: lwork ! hipsolverZunmtr_bufferSize_full_rank = hipsolverZunmtr_bufferSize_(handle,side,uplo,trans,m, & n,c_loc(A),lda,tau,c_loc(C),ldc,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSormtr_assumed_rank(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormtr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: tau real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSormtr_assumed_rank = hipsolverSormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function #else function hipsolverSormtr_rank_0(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormtr_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float) :: tau real(c_float),target :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSormtr_rank_0 = hipsolverSormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function function hipsolverSormtr_rank_1(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormtr_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: tau real(c_float),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSormtr_rank_1 = hipsolverSormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function function hipsolverSormtr_full_rank(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSormtr_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: tau real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSormtr_full_rank = hipsolverSormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDormtr_assumed_rank(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormtr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: tau real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDormtr_assumed_rank = hipsolverDormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function #else function hipsolverDormtr_rank_0(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormtr_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double) :: tau real(c_double),target :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDormtr_rank_0 = hipsolverDormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function function hipsolverDormtr_rank_1(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormtr_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: tau real(c_double),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDormtr_rank_1 = hipsolverDormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function function hipsolverDormtr_full_rank(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDormtr_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: tau real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDormtr_full_rank = hipsolverDormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCunmtr_assumed_rank(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmtr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex) :: tau complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCunmtr_assumed_rank = hipsolverCunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function #else function hipsolverCunmtr_rank_0(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmtr_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex) :: tau complex(c_float_complex),target :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCunmtr_rank_0 = hipsolverCunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function function hipsolverCunmtr_rank_1(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmtr_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCunmtr_rank_1 = hipsolverCunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function function hipsolverCunmtr_full_rank(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCunmtr_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCunmtr_full_rank = hipsolverCunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZunmtr_assumed_rank(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmtr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex) :: tau complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZunmtr_assumed_rank = hipsolverZunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function #else function hipsolverZunmtr_rank_0(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmtr_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex) :: tau complex(c_double_complex),target :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZunmtr_rank_0 = hipsolverZunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function function hipsolverZunmtr_rank_1(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmtr_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZunmtr_rank_1 = hipsolverZunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function function hipsolverZunmtr_full_rank(handle,side,uplo,trans,m,n,A,lda,tau,C,ldc,work,lwork, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZunmtr_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_SIDE_LEFT)) :: side integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZunmtr_full_rank = hipsolverZunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda,tau, & c_loc(C),ldc,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSgebrd_assumed_rank(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgebrd_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E real(c_float),target,contiguous,dimension(..) :: tauq real(c_float),target,contiguous,dimension(..) :: taup type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSgebrd_assumed_rank = hipsolverSgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),work,lwork,devInfo) end function #else function hipsolverSgebrd_rank_0(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgebrd_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E real(c_float),target :: tauq real(c_float),target :: taup type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSgebrd_rank_0 = hipsolverSgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),work,lwork,devInfo) end function function hipsolverSgebrd_rank_1(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgebrd_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:) :: tauq real(c_float),target,dimension(:) :: taup type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSgebrd_rank_1 = hipsolverSgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),work,lwork,devInfo) end function function hipsolverSgebrd_full_rank(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgebrd_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:) :: tauq real(c_float),target,dimension(:) :: taup type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSgebrd_full_rank = hipsolverSgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDgebrd_assumed_rank(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgebrd_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E real(c_double),target,contiguous,dimension(..) :: tauq real(c_double),target,contiguous,dimension(..) :: taup type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDgebrd_assumed_rank = hipsolverDgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),work,lwork,devInfo) end function #else function hipsolverDgebrd_rank_0(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgebrd_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E real(c_double),target :: tauq real(c_double),target :: taup type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDgebrd_rank_0 = hipsolverDgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),work,lwork,devInfo) end function function hipsolverDgebrd_rank_1(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgebrd_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:) :: tauq real(c_double),target,dimension(:) :: taup type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDgebrd_rank_1 = hipsolverDgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),work,lwork,devInfo) end function function hipsolverDgebrd_full_rank(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgebrd_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:) :: tauq real(c_double),target,dimension(:) :: taup type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDgebrd_full_rank = hipsolverDgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCgebrd_assumed_rank(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgebrd_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E complex(c_float_complex),target,contiguous,dimension(..) :: tauq complex(c_float_complex),target,contiguous,dimension(..) :: taup type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCgebrd_assumed_rank = hipsolverCgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),work,lwork,devInfo) end function #else function hipsolverCgebrd_rank_0(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgebrd_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E complex(c_float_complex),target :: tauq complex(c_float_complex),target :: taup type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCgebrd_rank_0 = hipsolverCgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),work,lwork,devInfo) end function function hipsolverCgebrd_rank_1(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgebrd_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:) :: tauq complex(c_float_complex),target,dimension(:) :: taup type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCgebrd_rank_1 = hipsolverCgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),work,lwork,devInfo) end function function hipsolverCgebrd_full_rank(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgebrd_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:) :: tauq complex(c_float_complex),target,dimension(:) :: taup type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCgebrd_full_rank = hipsolverCgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZgebrd_assumed_rank(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgebrd_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E complex(c_double_complex),target,contiguous,dimension(..) :: tauq complex(c_double_complex),target,contiguous,dimension(..) :: taup type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZgebrd_assumed_rank = hipsolverZgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),work,lwork,devInfo) end function #else function hipsolverZgebrd_rank_0(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgebrd_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E complex(c_double_complex),target :: tauq complex(c_double_complex),target :: taup type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZgebrd_rank_0 = hipsolverZgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),work,lwork,devInfo) end function function hipsolverZgebrd_rank_1(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgebrd_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:) :: tauq complex(c_double_complex),target,dimension(:) :: taup type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZgebrd_rank_1 = hipsolverZgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),work,lwork,devInfo) end function function hipsolverZgebrd_full_rank(handle,m,n,A,lda,D,E,tauq,taup,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgebrd_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:) :: tauq complex(c_double_complex),target,dimension(:) :: taup type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZgebrd_full_rank = hipsolverZgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSgeqrf_bufferSize_assumed_rank(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgeqrf_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSgeqrf_bufferSize_assumed_rank = hipsolverSgeqrf_bufferSize_(handle,m,n,c_loc(A), & lda,lwork) end function #else function hipsolverSgeqrf_bufferSize_rank_0(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgeqrf_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSgeqrf_bufferSize_rank_0 = hipsolverSgeqrf_bufferSize_(handle,m,n,c_loc(A),lda,lwork) end function function hipsolverSgeqrf_bufferSize_rank_1(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgeqrf_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSgeqrf_bufferSize_rank_1 = hipsolverSgeqrf_bufferSize_(handle,m,n,c_loc(A),lda,lwork) end function function hipsolverSgeqrf_bufferSize_full_rank(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgeqrf_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSgeqrf_bufferSize_full_rank = hipsolverSgeqrf_bufferSize_(handle,m,n,c_loc(A),lda, & lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDgeqrf_bufferSize_assumed_rank(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgeqrf_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDgeqrf_bufferSize_assumed_rank = hipsolverDgeqrf_bufferSize_(handle,m,n,c_loc(A), & lda,lwork) end function #else function hipsolverDgeqrf_bufferSize_rank_0(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgeqrf_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDgeqrf_bufferSize_rank_0 = hipsolverDgeqrf_bufferSize_(handle,m,n,c_loc(A),lda,lwork) end function function hipsolverDgeqrf_bufferSize_rank_1(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgeqrf_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDgeqrf_bufferSize_rank_1 = hipsolverDgeqrf_bufferSize_(handle,m,n,c_loc(A),lda,lwork) end function function hipsolverDgeqrf_bufferSize_full_rank(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgeqrf_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDgeqrf_bufferSize_full_rank = hipsolverDgeqrf_bufferSize_(handle,m,n,c_loc(A),lda, & lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCgeqrf_bufferSize_assumed_rank(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgeqrf_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCgeqrf_bufferSize_assumed_rank = hipsolverCgeqrf_bufferSize_(handle,m,n,c_loc(A), & lda,lwork) end function #else function hipsolverCgeqrf_bufferSize_rank_0(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgeqrf_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCgeqrf_bufferSize_rank_0 = hipsolverCgeqrf_bufferSize_(handle,m,n,c_loc(A),lda,lwork) end function function hipsolverCgeqrf_bufferSize_rank_1(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgeqrf_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCgeqrf_bufferSize_rank_1 = hipsolverCgeqrf_bufferSize_(handle,m,n,c_loc(A),lda,lwork) end function function hipsolverCgeqrf_bufferSize_full_rank(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgeqrf_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCgeqrf_bufferSize_full_rank = hipsolverCgeqrf_bufferSize_(handle,m,n,c_loc(A),lda, & lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZgeqrf_bufferSize_assumed_rank(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgeqrf_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZgeqrf_bufferSize_assumed_rank = hipsolverZgeqrf_bufferSize_(handle,m,n,c_loc(A), & lda,lwork) end function #else function hipsolverZgeqrf_bufferSize_rank_0(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgeqrf_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZgeqrf_bufferSize_rank_0 = hipsolverZgeqrf_bufferSize_(handle,m,n,c_loc(A),lda,lwork) end function function hipsolverZgeqrf_bufferSize_rank_1(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgeqrf_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZgeqrf_bufferSize_rank_1 = hipsolverZgeqrf_bufferSize_(handle,m,n,c_loc(A),lda,lwork) end function function hipsolverZgeqrf_bufferSize_full_rank(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgeqrf_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZgeqrf_bufferSize_full_rank = hipsolverZgeqrf_bufferSize_(handle,m,n,c_loc(A),lda, & lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSgeqrf_assumed_rank(handle,m,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgeqrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSgeqrf_assumed_rank = hipsolverSgeqrf_(handle,m,n,c_loc(A),lda,tau,work,lwork, & devInfo) end function #else function hipsolverSgeqrf_rank_0(handle,m,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgeqrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSgeqrf_rank_0 = hipsolverSgeqrf_(handle,m,n,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverSgeqrf_rank_1(handle,m,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgeqrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSgeqrf_rank_1 = hipsolverSgeqrf_(handle,m,n,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverSgeqrf_full_rank(handle,m,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgeqrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSgeqrf_full_rank = hipsolverSgeqrf_(handle,m,n,c_loc(A),lda,tau,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDgeqrf_assumed_rank(handle,m,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgeqrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDgeqrf_assumed_rank = hipsolverDgeqrf_(handle,m,n,c_loc(A),lda,tau,work,lwork, & devInfo) end function #else function hipsolverDgeqrf_rank_0(handle,m,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgeqrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDgeqrf_rank_0 = hipsolverDgeqrf_(handle,m,n,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverDgeqrf_rank_1(handle,m,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgeqrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDgeqrf_rank_1 = hipsolverDgeqrf_(handle,m,n,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverDgeqrf_full_rank(handle,m,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgeqrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDgeqrf_full_rank = hipsolverDgeqrf_(handle,m,n,c_loc(A),lda,tau,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCgeqrf_assumed_rank(handle,m,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgeqrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCgeqrf_assumed_rank = hipsolverCgeqrf_(handle,m,n,c_loc(A),lda,tau,work,lwork, & devInfo) end function #else function hipsolverCgeqrf_rank_0(handle,m,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgeqrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCgeqrf_rank_0 = hipsolverCgeqrf_(handle,m,n,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverCgeqrf_rank_1(handle,m,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgeqrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCgeqrf_rank_1 = hipsolverCgeqrf_(handle,m,n,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverCgeqrf_full_rank(handle,m,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgeqrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCgeqrf_full_rank = hipsolverCgeqrf_(handle,m,n,c_loc(A),lda,tau,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZgeqrf_assumed_rank(handle,m,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgeqrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZgeqrf_assumed_rank = hipsolverZgeqrf_(handle,m,n,c_loc(A),lda,tau,work,lwork, & devInfo) end function #else function hipsolverZgeqrf_rank_0(handle,m,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgeqrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZgeqrf_rank_0 = hipsolverZgeqrf_(handle,m,n,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverZgeqrf_rank_1(handle,m,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgeqrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZgeqrf_rank_1 = hipsolverZgeqrf_(handle,m,n,c_loc(A),lda,tau,work,lwork,devInfo) end function function hipsolverZgeqrf_full_rank(handle,m,n,A,lda,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgeqrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZgeqrf_full_rank = hipsolverZgeqrf_(handle,m,n,c_loc(A),lda,tau,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSSgesv_bufferSize_assumed_rank(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSSgesv_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: devIpiv real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: X integer(c_int) :: ldx integer(c_size_t) :: lwork ! hipsolverSSgesv_bufferSize_assumed_rank = hipsolverSSgesv_bufferSize_(handle,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,c_loc(X),ldx,lwork) end function #else function hipsolverSSgesv_bufferSize_rank_0(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSSgesv_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target :: A integer(c_int) :: lda integer(c_int),target :: devIpiv real(c_float),target :: B integer(c_int) :: ldb real(c_float),target :: X integer(c_int) :: ldx integer(c_size_t) :: lwork ! hipsolverSSgesv_bufferSize_rank_0 = hipsolverSSgesv_bufferSize_(handle,n,nrhs,c_loc(A),lda, & c_loc(devIpiv),c_loc(B),ldb,c_loc(X),ldx,lwork) end function function hipsolverSSgesv_bufferSize_rank_1(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSSgesv_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: X integer(c_int) :: ldx integer(c_size_t) :: lwork ! hipsolverSSgesv_bufferSize_rank_1 = hipsolverSSgesv_bufferSize_(handle,n,nrhs,c_loc(A),lda, & c_loc(devIpiv),c_loc(B),ldb,c_loc(X),ldx,lwork) end function function hipsolverSSgesv_bufferSize_full_rank(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSSgesv_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:,:) :: X integer(c_int) :: ldx integer(c_size_t) :: lwork ! hipsolverSSgesv_bufferSize_full_rank = hipsolverSSgesv_bufferSize_(handle,n,nrhs,c_loc(A), & lda,c_loc(devIpiv),c_loc(B),ldb,c_loc(X),ldx,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDDgesv_bufferSize_assumed_rank(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDDgesv_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: devIpiv real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: X integer(c_int) :: ldx integer(c_size_t) :: lwork ! hipsolverDDgesv_bufferSize_assumed_rank = hipsolverDDgesv_bufferSize_(handle,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,c_loc(X),ldx,lwork) end function #else function hipsolverDDgesv_bufferSize_rank_0(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDDgesv_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target :: A integer(c_int) :: lda integer(c_int),target :: devIpiv real(c_double),target :: B integer(c_int) :: ldb real(c_double),target :: X integer(c_int) :: ldx integer(c_size_t) :: lwork ! hipsolverDDgesv_bufferSize_rank_0 = hipsolverDDgesv_bufferSize_(handle,n,nrhs,c_loc(A),lda, & c_loc(devIpiv),c_loc(B),ldb,c_loc(X),ldx,lwork) end function function hipsolverDDgesv_bufferSize_rank_1(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDDgesv_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: X integer(c_int) :: ldx integer(c_size_t) :: lwork ! hipsolverDDgesv_bufferSize_rank_1 = hipsolverDDgesv_bufferSize_(handle,n,nrhs,c_loc(A),lda, & c_loc(devIpiv),c_loc(B),ldb,c_loc(X),ldx,lwork) end function function hipsolverDDgesv_bufferSize_full_rank(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDDgesv_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:,:) :: X integer(c_int) :: ldx integer(c_size_t) :: lwork ! hipsolverDDgesv_bufferSize_full_rank = hipsolverDDgesv_bufferSize_(handle,n,nrhs,c_loc(A), & lda,c_loc(devIpiv),c_loc(B),ldb,c_loc(X),ldx,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCCgesv_bufferSize_assumed_rank(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCCgesv_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: devIpiv complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_float_complex),target,contiguous,dimension(..) :: X integer(c_int) :: ldx integer(c_size_t) :: lwork ! hipsolverCCgesv_bufferSize_assumed_rank = hipsolverCCgesv_bufferSize_(handle,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,c_loc(X),ldx,lwork) end function #else function hipsolverCCgesv_bufferSize_rank_0(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCCgesv_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int),target :: devIpiv complex(c_float_complex),target :: B integer(c_int) :: ldb complex(c_float_complex),target :: X integer(c_int) :: ldx integer(c_size_t) :: lwork ! hipsolverCCgesv_bufferSize_rank_0 = hipsolverCCgesv_bufferSize_(handle,n,nrhs,c_loc(A),lda, & c_loc(devIpiv),c_loc(B),ldb,c_loc(X),ldx,lwork) end function function hipsolverCCgesv_bufferSize_rank_1(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCCgesv_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_float_complex),target,dimension(:) :: X integer(c_int) :: ldx integer(c_size_t) :: lwork ! hipsolverCCgesv_bufferSize_rank_1 = hipsolverCCgesv_bufferSize_(handle,n,nrhs,c_loc(A),lda, & c_loc(devIpiv),c_loc(B),ldb,c_loc(X),ldx,lwork) end function function hipsolverCCgesv_bufferSize_full_rank(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCCgesv_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_float_complex),target,dimension(:,:) :: X integer(c_int) :: ldx integer(c_size_t) :: lwork ! hipsolverCCgesv_bufferSize_full_rank = hipsolverCCgesv_bufferSize_(handle,n,nrhs,c_loc(A), & lda,c_loc(devIpiv),c_loc(B),ldb,c_loc(X),ldx,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZZgesv_bufferSize_assumed_rank(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZZgesv_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: devIpiv complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_double_complex),target,contiguous,dimension(..) :: X integer(c_int) :: ldx integer(c_size_t) :: lwork ! hipsolverZZgesv_bufferSize_assumed_rank = hipsolverZZgesv_bufferSize_(handle,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,c_loc(X),ldx,lwork) end function #else function hipsolverZZgesv_bufferSize_rank_0(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZZgesv_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int),target :: devIpiv complex(c_double_complex),target :: B integer(c_int) :: ldb complex(c_double_complex),target :: X integer(c_int) :: ldx integer(c_size_t) :: lwork ! hipsolverZZgesv_bufferSize_rank_0 = hipsolverZZgesv_bufferSize_(handle,n,nrhs,c_loc(A),lda, & c_loc(devIpiv),c_loc(B),ldb,c_loc(X),ldx,lwork) end function function hipsolverZZgesv_bufferSize_rank_1(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZZgesv_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_double_complex),target,dimension(:) :: X integer(c_int) :: ldx integer(c_size_t) :: lwork ! hipsolverZZgesv_bufferSize_rank_1 = hipsolverZZgesv_bufferSize_(handle,n,nrhs,c_loc(A),lda, & c_loc(devIpiv),c_loc(B),ldb,c_loc(X),ldx,lwork) end function function hipsolverZZgesv_bufferSize_full_rank(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZZgesv_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_double_complex),target,dimension(:,:) :: X integer(c_int) :: ldx integer(c_size_t) :: lwork ! hipsolverZZgesv_bufferSize_full_rank = hipsolverZZgesv_bufferSize_(handle,n,nrhs,c_loc(A), & lda,c_loc(devIpiv),c_loc(B),ldb,c_loc(X),ldx,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSSgesv_assumed_rank(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork, & niters,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSSgesv_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: devIpiv real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: X integer(c_int) :: ldx type(c_ptr) :: work integer(c_size_t) :: lwork type(c_ptr) :: niters integer(c_int) :: devInfo ! hipsolverSSgesv_assumed_rank = hipsolverSSgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,c_loc(X),ldx,work,lwork,niters,devInfo) end function #else function hipsolverSSgesv_rank_0(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSSgesv_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target :: A integer(c_int) :: lda integer(c_int),target :: devIpiv real(c_float),target :: B integer(c_int) :: ldb real(c_float),target :: X integer(c_int) :: ldx type(c_ptr) :: work integer(c_size_t) :: lwork type(c_ptr) :: niters integer(c_int) :: devInfo ! hipsolverSSgesv_rank_0 = hipsolverSSgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,c_loc(X),ldx,work,lwork,niters,devInfo) end function function hipsolverSSgesv_rank_1(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSSgesv_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: X integer(c_int) :: ldx type(c_ptr) :: work integer(c_size_t) :: lwork type(c_ptr) :: niters integer(c_int) :: devInfo ! hipsolverSSgesv_rank_1 = hipsolverSSgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,c_loc(X),ldx,work,lwork,niters,devInfo) end function function hipsolverSSgesv_full_rank(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSSgesv_full_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:,:) :: X integer(c_int) :: ldx type(c_ptr) :: work integer(c_size_t) :: lwork type(c_ptr) :: niters integer(c_int) :: devInfo ! hipsolverSSgesv_full_rank = hipsolverSSgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,c_loc(X),ldx,work,lwork,niters,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDDgesv_assumed_rank(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork, & niters,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDDgesv_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: devIpiv real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: X integer(c_int) :: ldx type(c_ptr) :: work integer(c_size_t) :: lwork type(c_ptr) :: niters integer(c_int) :: devInfo ! hipsolverDDgesv_assumed_rank = hipsolverDDgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,c_loc(X),ldx,work,lwork,niters,devInfo) end function #else function hipsolverDDgesv_rank_0(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDDgesv_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target :: A integer(c_int) :: lda integer(c_int),target :: devIpiv real(c_double),target :: B integer(c_int) :: ldb real(c_double),target :: X integer(c_int) :: ldx type(c_ptr) :: work integer(c_size_t) :: lwork type(c_ptr) :: niters integer(c_int) :: devInfo ! hipsolverDDgesv_rank_0 = hipsolverDDgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,c_loc(X),ldx,work,lwork,niters,devInfo) end function function hipsolverDDgesv_rank_1(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDDgesv_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: X integer(c_int) :: ldx type(c_ptr) :: work integer(c_size_t) :: lwork type(c_ptr) :: niters integer(c_int) :: devInfo ! hipsolverDDgesv_rank_1 = hipsolverDDgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,c_loc(X),ldx,work,lwork,niters,devInfo) end function function hipsolverDDgesv_full_rank(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDDgesv_full_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:,:) :: X integer(c_int) :: ldx type(c_ptr) :: work integer(c_size_t) :: lwork type(c_ptr) :: niters integer(c_int) :: devInfo ! hipsolverDDgesv_full_rank = hipsolverDDgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,c_loc(X),ldx,work,lwork,niters,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCCgesv_assumed_rank(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork, & niters,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCCgesv_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: devIpiv complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_float_complex),target,contiguous,dimension(..) :: X integer(c_int) :: ldx type(c_ptr) :: work integer(c_size_t) :: lwork type(c_ptr) :: niters integer(c_int) :: devInfo ! hipsolverCCgesv_assumed_rank = hipsolverCCgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,c_loc(X),ldx,work,lwork,niters,devInfo) end function #else function hipsolverCCgesv_rank_0(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCCgesv_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int),target :: devIpiv complex(c_float_complex),target :: B integer(c_int) :: ldb complex(c_float_complex),target :: X integer(c_int) :: ldx type(c_ptr) :: work integer(c_size_t) :: lwork type(c_ptr) :: niters integer(c_int) :: devInfo ! hipsolverCCgesv_rank_0 = hipsolverCCgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,c_loc(X),ldx,work,lwork,niters,devInfo) end function function hipsolverCCgesv_rank_1(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCCgesv_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_float_complex),target,dimension(:) :: X integer(c_int) :: ldx type(c_ptr) :: work integer(c_size_t) :: lwork type(c_ptr) :: niters integer(c_int) :: devInfo ! hipsolverCCgesv_rank_1 = hipsolverCCgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,c_loc(X),ldx,work,lwork,niters,devInfo) end function function hipsolverCCgesv_full_rank(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCCgesv_full_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_float_complex),target,dimension(:,:) :: X integer(c_int) :: ldx type(c_ptr) :: work integer(c_size_t) :: lwork type(c_ptr) :: niters integer(c_int) :: devInfo ! hipsolverCCgesv_full_rank = hipsolverCCgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,c_loc(X),ldx,work,lwork,niters,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZZgesv_assumed_rank(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork, & niters,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZZgesv_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: devIpiv complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_double_complex),target,contiguous,dimension(..) :: X integer(c_int) :: ldx type(c_ptr) :: work integer(c_size_t) :: lwork type(c_ptr) :: niters integer(c_int) :: devInfo ! hipsolverZZgesv_assumed_rank = hipsolverZZgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,c_loc(X),ldx,work,lwork,niters,devInfo) end function #else function hipsolverZZgesv_rank_0(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZZgesv_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int),target :: devIpiv complex(c_double_complex),target :: B integer(c_int) :: ldb complex(c_double_complex),target :: X integer(c_int) :: ldx type(c_ptr) :: work integer(c_size_t) :: lwork type(c_ptr) :: niters integer(c_int) :: devInfo ! hipsolverZZgesv_rank_0 = hipsolverZZgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,c_loc(X),ldx,work,lwork,niters,devInfo) end function function hipsolverZZgesv_rank_1(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZZgesv_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_double_complex),target,dimension(:) :: X integer(c_int) :: ldx type(c_ptr) :: work integer(c_size_t) :: lwork type(c_ptr) :: niters integer(c_int) :: devInfo ! hipsolverZZgesv_rank_1 = hipsolverZZgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,c_loc(X),ldx,work,lwork,niters,devInfo) end function function hipsolverZZgesv_full_rank(handle,n,nrhs,A,lda,devIpiv,B,ldb,X,ldx,work,lwork,niters, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZZgesv_full_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_double_complex),target,dimension(:,:) :: X integer(c_int) :: ldx type(c_ptr) :: work integer(c_size_t) :: lwork type(c_ptr) :: niters integer(c_int) :: devInfo ! hipsolverZZgesv_full_rank = hipsolverZZgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,c_loc(X),ldx,work,lwork,niters,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSgetrf_bufferSize_assumed_rank(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrf_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSgetrf_bufferSize_assumed_rank = hipsolverSgetrf_bufferSize_(handle,m,n,c_loc(A), & lda,lwork) end function #else function hipsolverSgetrf_bufferSize_rank_0(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrf_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSgetrf_bufferSize_rank_0 = hipsolverSgetrf_bufferSize_(handle,m,n,c_loc(A),lda,lwork) end function function hipsolverSgetrf_bufferSize_rank_1(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrf_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSgetrf_bufferSize_rank_1 = hipsolverSgetrf_bufferSize_(handle,m,n,c_loc(A),lda,lwork) end function function hipsolverSgetrf_bufferSize_full_rank(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrf_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSgetrf_bufferSize_full_rank = hipsolverSgetrf_bufferSize_(handle,m,n,c_loc(A),lda, & lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDgetrf_bufferSize_assumed_rank(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrf_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDgetrf_bufferSize_assumed_rank = hipsolverDgetrf_bufferSize_(handle,m,n,c_loc(A), & lda,lwork) end function #else function hipsolverDgetrf_bufferSize_rank_0(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrf_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDgetrf_bufferSize_rank_0 = hipsolverDgetrf_bufferSize_(handle,m,n,c_loc(A),lda,lwork) end function function hipsolverDgetrf_bufferSize_rank_1(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrf_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDgetrf_bufferSize_rank_1 = hipsolverDgetrf_bufferSize_(handle,m,n,c_loc(A),lda,lwork) end function function hipsolverDgetrf_bufferSize_full_rank(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrf_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDgetrf_bufferSize_full_rank = hipsolverDgetrf_bufferSize_(handle,m,n,c_loc(A),lda, & lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCgetrf_bufferSize_assumed_rank(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrf_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCgetrf_bufferSize_assumed_rank = hipsolverCgetrf_bufferSize_(handle,m,n,c_loc(A), & lda,lwork) end function #else function hipsolverCgetrf_bufferSize_rank_0(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrf_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCgetrf_bufferSize_rank_0 = hipsolverCgetrf_bufferSize_(handle,m,n,c_loc(A),lda,lwork) end function function hipsolverCgetrf_bufferSize_rank_1(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrf_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCgetrf_bufferSize_rank_1 = hipsolverCgetrf_bufferSize_(handle,m,n,c_loc(A),lda,lwork) end function function hipsolverCgetrf_bufferSize_full_rank(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrf_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCgetrf_bufferSize_full_rank = hipsolverCgetrf_bufferSize_(handle,m,n,c_loc(A),lda, & lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZgetrf_bufferSize_assumed_rank(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrf_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZgetrf_bufferSize_assumed_rank = hipsolverZgetrf_bufferSize_(handle,m,n,c_loc(A), & lda,lwork) end function #else function hipsolverZgetrf_bufferSize_rank_0(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrf_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZgetrf_bufferSize_rank_0 = hipsolverZgetrf_bufferSize_(handle,m,n,c_loc(A),lda,lwork) end function function hipsolverZgetrf_bufferSize_rank_1(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrf_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZgetrf_bufferSize_rank_1 = hipsolverZgetrf_bufferSize_(handle,m,n,c_loc(A),lda,lwork) end function function hipsolverZgetrf_bufferSize_full_rank(handle,m,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrf_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZgetrf_bufferSize_full_rank = hipsolverZgetrf_bufferSize_(handle,m,n,c_loc(A),lda, & lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSgetrf_assumed_rank(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int),target,contiguous,dimension(..) :: devIpiv integer(c_int) :: devInfo ! hipsolverSgetrf_assumed_rank = hipsolverSgetrf_(handle,m,n,c_loc(A),lda,work,lwork, & c_loc(devIpiv),devInfo) end function #else function hipsolverSgetrf_rank_0(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int),target :: devIpiv integer(c_int) :: devInfo ! hipsolverSgetrf_rank_0 = hipsolverSgetrf_(handle,m,n,c_loc(A),lda,work,lwork,c_loc(devIpiv), & devInfo) end function function hipsolverSgetrf_rank_1(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int),target,dimension(:) :: devIpiv integer(c_int) :: devInfo ! hipsolverSgetrf_rank_1 = hipsolverSgetrf_(handle,m,n,c_loc(A),lda,work,lwork,c_loc(devIpiv), & devInfo) end function function hipsolverSgetrf_full_rank(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int),target,dimension(:) :: devIpiv integer(c_int) :: devInfo ! hipsolverSgetrf_full_rank = hipsolverSgetrf_(handle,m,n,c_loc(A),lda,work,lwork, & c_loc(devIpiv),devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDgetrf_assumed_rank(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int),target,contiguous,dimension(..) :: devIpiv integer(c_int) :: devInfo ! hipsolverDgetrf_assumed_rank = hipsolverDgetrf_(handle,m,n,c_loc(A),lda,work,lwork, & c_loc(devIpiv),devInfo) end function #else function hipsolverDgetrf_rank_0(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int),target :: devIpiv integer(c_int) :: devInfo ! hipsolverDgetrf_rank_0 = hipsolverDgetrf_(handle,m,n,c_loc(A),lda,work,lwork,c_loc(devIpiv), & devInfo) end function function hipsolverDgetrf_rank_1(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int),target,dimension(:) :: devIpiv integer(c_int) :: devInfo ! hipsolverDgetrf_rank_1 = hipsolverDgetrf_(handle,m,n,c_loc(A),lda,work,lwork,c_loc(devIpiv), & devInfo) end function function hipsolverDgetrf_full_rank(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int),target,dimension(:) :: devIpiv integer(c_int) :: devInfo ! hipsolverDgetrf_full_rank = hipsolverDgetrf_(handle,m,n,c_loc(A),lda,work,lwork, & c_loc(devIpiv),devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCgetrf_assumed_rank(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int),target,contiguous,dimension(..) :: devIpiv integer(c_int) :: devInfo ! hipsolverCgetrf_assumed_rank = hipsolverCgetrf_(handle,m,n,c_loc(A),lda,work,lwork, & c_loc(devIpiv),devInfo) end function #else function hipsolverCgetrf_rank_0(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int),target :: devIpiv integer(c_int) :: devInfo ! hipsolverCgetrf_rank_0 = hipsolverCgetrf_(handle,m,n,c_loc(A),lda,work,lwork,c_loc(devIpiv), & devInfo) end function function hipsolverCgetrf_rank_1(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int),target,dimension(:) :: devIpiv integer(c_int) :: devInfo ! hipsolverCgetrf_rank_1 = hipsolverCgetrf_(handle,m,n,c_loc(A),lda,work,lwork,c_loc(devIpiv), & devInfo) end function function hipsolverCgetrf_full_rank(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int),target,dimension(:) :: devIpiv integer(c_int) :: devInfo ! hipsolverCgetrf_full_rank = hipsolverCgetrf_(handle,m,n,c_loc(A),lda,work,lwork, & c_loc(devIpiv),devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZgetrf_assumed_rank(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int),target,contiguous,dimension(..) :: devIpiv integer(c_int) :: devInfo ! hipsolverZgetrf_assumed_rank = hipsolverZgetrf_(handle,m,n,c_loc(A),lda,work,lwork, & c_loc(devIpiv),devInfo) end function #else function hipsolverZgetrf_rank_0(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int),target :: devIpiv integer(c_int) :: devInfo ! hipsolverZgetrf_rank_0 = hipsolverZgetrf_(handle,m,n,c_loc(A),lda,work,lwork,c_loc(devIpiv), & devInfo) end function function hipsolverZgetrf_rank_1(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int),target,dimension(:) :: devIpiv integer(c_int) :: devInfo ! hipsolverZgetrf_rank_1 = hipsolverZgetrf_(handle,m,n,c_loc(A),lda,work,lwork,c_loc(devIpiv), & devInfo) end function function hipsolverZgetrf_full_rank(handle,m,n,A,lda,work,lwork,devIpiv,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int),target,dimension(:) :: devIpiv integer(c_int) :: devInfo ! hipsolverZgetrf_full_rank = hipsolverZgetrf_(handle,m,n,c_loc(A),lda,work,lwork, & c_loc(devIpiv),devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSgetrs_bufferSize_assumed_rank(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrs_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: devIpiv real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverSgetrs_bufferSize_assumed_rank = hipsolverSgetrs_bufferSize_(handle,trans,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,lwork) end function #else function hipsolverSgetrs_bufferSize_rank_0(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrs_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target :: A integer(c_int) :: lda integer(c_int),target :: devIpiv real(c_float),target :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverSgetrs_bufferSize_rank_0 = hipsolverSgetrs_bufferSize_(handle,trans,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,lwork) end function function hipsolverSgetrs_bufferSize_rank_1(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrs_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverSgetrs_bufferSize_rank_1 = hipsolverSgetrs_bufferSize_(handle,trans,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,lwork) end function function hipsolverSgetrs_bufferSize_full_rank(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrs_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverSgetrs_bufferSize_full_rank = hipsolverSgetrs_bufferSize_(handle,trans,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDgetrs_bufferSize_assumed_rank(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrs_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: devIpiv real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverDgetrs_bufferSize_assumed_rank = hipsolverDgetrs_bufferSize_(handle,trans,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,lwork) end function #else function hipsolverDgetrs_bufferSize_rank_0(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrs_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target :: A integer(c_int) :: lda integer(c_int),target :: devIpiv real(c_double),target :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverDgetrs_bufferSize_rank_0 = hipsolverDgetrs_bufferSize_(handle,trans,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,lwork) end function function hipsolverDgetrs_bufferSize_rank_1(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrs_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverDgetrs_bufferSize_rank_1 = hipsolverDgetrs_bufferSize_(handle,trans,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,lwork) end function function hipsolverDgetrs_bufferSize_full_rank(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrs_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverDgetrs_bufferSize_full_rank = hipsolverDgetrs_bufferSize_(handle,trans,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCgetrs_bufferSize_assumed_rank(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrs_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: devIpiv complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverCgetrs_bufferSize_assumed_rank = hipsolverCgetrs_bufferSize_(handle,trans,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,lwork) end function #else function hipsolverCgetrs_bufferSize_rank_0(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrs_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int),target :: devIpiv complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverCgetrs_bufferSize_rank_0 = hipsolverCgetrs_bufferSize_(handle,trans,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,lwork) end function function hipsolverCgetrs_bufferSize_rank_1(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrs_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverCgetrs_bufferSize_rank_1 = hipsolverCgetrs_bufferSize_(handle,trans,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,lwork) end function function hipsolverCgetrs_bufferSize_full_rank(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrs_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverCgetrs_bufferSize_full_rank = hipsolverCgetrs_bufferSize_(handle,trans,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZgetrs_bufferSize_assumed_rank(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrs_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: devIpiv complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverZgetrs_bufferSize_assumed_rank = hipsolverZgetrs_bufferSize_(handle,trans,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,lwork) end function #else function hipsolverZgetrs_bufferSize_rank_0(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrs_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int),target :: devIpiv complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverZgetrs_bufferSize_rank_0 = hipsolverZgetrs_bufferSize_(handle,trans,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,lwork) end function function hipsolverZgetrs_bufferSize_rank_1(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrs_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverZgetrs_bufferSize_rank_1 = hipsolverZgetrs_bufferSize_(handle,trans,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,lwork) end function function hipsolverZgetrs_bufferSize_full_rank(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrs_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverZgetrs_bufferSize_full_rank = hipsolverZgetrs_bufferSize_(handle,trans,n,nrhs, & c_loc(A),lda,c_loc(devIpiv),c_loc(B),ldb,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSgetrs_assumed_rank(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrs_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: devIpiv real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSgetrs_assumed_rank = hipsolverSgetrs_(handle,trans,n,nrhs,c_loc(A),lda, & c_loc(devIpiv),c_loc(B),ldb,work,lwork,devInfo) end function #else function hipsolverSgetrs_rank_0(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrs_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target :: A integer(c_int) :: lda integer(c_int),target :: devIpiv real(c_float),target :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSgetrs_rank_0 = hipsolverSgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,work,lwork,devInfo) end function function hipsolverSgetrs_rank_1(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrs_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv real(c_float),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSgetrs_rank_1 = hipsolverSgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,work,lwork,devInfo) end function function hipsolverSgetrs_full_rank(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSgetrs_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSgetrs_full_rank = hipsolverSgetrs_(handle,trans,n,nrhs,c_loc(A),lda, & c_loc(devIpiv),c_loc(B),ldb,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDgetrs_assumed_rank(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrs_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: devIpiv real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDgetrs_assumed_rank = hipsolverDgetrs_(handle,trans,n,nrhs,c_loc(A),lda, & c_loc(devIpiv),c_loc(B),ldb,work,lwork,devInfo) end function #else function hipsolverDgetrs_rank_0(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrs_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target :: A integer(c_int) :: lda integer(c_int),target :: devIpiv real(c_double),target :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDgetrs_rank_0 = hipsolverDgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,work,lwork,devInfo) end function function hipsolverDgetrs_rank_1(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrs_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv real(c_double),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDgetrs_rank_1 = hipsolverDgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,work,lwork,devInfo) end function function hipsolverDgetrs_full_rank(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDgetrs_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDgetrs_full_rank = hipsolverDgetrs_(handle,trans,n,nrhs,c_loc(A),lda, & c_loc(devIpiv),c_loc(B),ldb,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCgetrs_assumed_rank(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrs_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: devIpiv complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCgetrs_assumed_rank = hipsolverCgetrs_(handle,trans,n,nrhs,c_loc(A),lda, & c_loc(devIpiv),c_loc(B),ldb,work,lwork,devInfo) end function #else function hipsolverCgetrs_rank_0(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrs_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int),target :: devIpiv complex(c_float_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCgetrs_rank_0 = hipsolverCgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,work,lwork,devInfo) end function function hipsolverCgetrs_rank_1(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrs_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCgetrs_rank_1 = hipsolverCgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,work,lwork,devInfo) end function function hipsolverCgetrs_full_rank(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCgetrs_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCgetrs_full_rank = hipsolverCgetrs_(handle,trans,n,nrhs,c_loc(A),lda, & c_loc(devIpiv),c_loc(B),ldb,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZgetrs_assumed_rank(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork, & devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrs_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: devIpiv complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZgetrs_assumed_rank = hipsolverZgetrs_(handle,trans,n,nrhs,c_loc(A),lda, & c_loc(devIpiv),c_loc(B),ldb,work,lwork,devInfo) end function #else function hipsolverZgetrs_rank_0(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrs_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int),target :: devIpiv complex(c_double_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZgetrs_rank_0 = hipsolverZgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,work,lwork,devInfo) end function function hipsolverZgetrs_rank_1(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrs_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZgetrs_rank_1 = hipsolverZgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(devIpiv), & c_loc(B),ldb,work,lwork,devInfo) end function function hipsolverZgetrs_full_rank(handle,trans,n,nrhs,A,lda,devIpiv,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZgetrs_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_OP_N)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: devIpiv complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZgetrs_full_rank = hipsolverZgetrs_(handle,trans,n,nrhs,c_loc(A),lda, & c_loc(devIpiv),c_loc(B),ldb,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSpotrf_bufferSize_assumed_rank(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrf_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSpotrf_bufferSize_assumed_rank = hipsolverSpotrf_bufferSize_(handle,uplo,n, & c_loc(A),lda,lwork) end function #else function hipsolverSpotrf_bufferSize_rank_0(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrf_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSpotrf_bufferSize_rank_0 = hipsolverSpotrf_bufferSize_(handle,uplo,n,c_loc(A),lda, & lwork) end function function hipsolverSpotrf_bufferSize_rank_1(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrf_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSpotrf_bufferSize_rank_1 = hipsolverSpotrf_bufferSize_(handle,uplo,n,c_loc(A),lda, & lwork) end function function hipsolverSpotrf_bufferSize_full_rank(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrf_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSpotrf_bufferSize_full_rank = hipsolverSpotrf_bufferSize_(handle,uplo,n,c_loc(A), & lda,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDpotrf_bufferSize_assumed_rank(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrf_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDpotrf_bufferSize_assumed_rank = hipsolverDpotrf_bufferSize_(handle,uplo,n, & c_loc(A),lda,lwork) end function #else function hipsolverDpotrf_bufferSize_rank_0(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrf_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDpotrf_bufferSize_rank_0 = hipsolverDpotrf_bufferSize_(handle,uplo,n,c_loc(A),lda, & lwork) end function function hipsolverDpotrf_bufferSize_rank_1(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrf_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDpotrf_bufferSize_rank_1 = hipsolverDpotrf_bufferSize_(handle,uplo,n,c_loc(A),lda, & lwork) end function function hipsolverDpotrf_bufferSize_full_rank(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrf_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDpotrf_bufferSize_full_rank = hipsolverDpotrf_bufferSize_(handle,uplo,n,c_loc(A), & lda,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCpotrf_bufferSize_assumed_rank(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrf_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCpotrf_bufferSize_assumed_rank = hipsolverCpotrf_bufferSize_(handle,uplo,n, & c_loc(A),lda,lwork) end function #else function hipsolverCpotrf_bufferSize_rank_0(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrf_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCpotrf_bufferSize_rank_0 = hipsolverCpotrf_bufferSize_(handle,uplo,n,c_loc(A),lda, & lwork) end function function hipsolverCpotrf_bufferSize_rank_1(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrf_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCpotrf_bufferSize_rank_1 = hipsolverCpotrf_bufferSize_(handle,uplo,n,c_loc(A),lda, & lwork) end function function hipsolverCpotrf_bufferSize_full_rank(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrf_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCpotrf_bufferSize_full_rank = hipsolverCpotrf_bufferSize_(handle,uplo,n,c_loc(A), & lda,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZpotrf_bufferSize_assumed_rank(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrf_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZpotrf_bufferSize_assumed_rank = hipsolverZpotrf_bufferSize_(handle,uplo,n, & c_loc(A),lda,lwork) end function #else function hipsolverZpotrf_bufferSize_rank_0(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrf_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZpotrf_bufferSize_rank_0 = hipsolverZpotrf_bufferSize_(handle,uplo,n,c_loc(A),lda, & lwork) end function function hipsolverZpotrf_bufferSize_rank_1(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrf_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZpotrf_bufferSize_rank_1 = hipsolverZpotrf_bufferSize_(handle,uplo,n,c_loc(A),lda, & lwork) end function function hipsolverZpotrf_bufferSize_full_rank(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrf_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZpotrf_bufferSize_full_rank = hipsolverZpotrf_bufferSize_(handle,uplo,n,c_loc(A), & lda,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSpotrf_assumed_rank(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrf_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSpotrf_assumed_rank = hipsolverSpotrf_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function #else function hipsolverSpotrf_rank_0(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrf_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSpotrf_rank_0 = hipsolverSpotrf_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function function hipsolverSpotrf_rank_1(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrf_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSpotrf_rank_1 = hipsolverSpotrf_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function function hipsolverSpotrf_full_rank(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrf_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSpotrf_full_rank = hipsolverSpotrf_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDpotrf_assumed_rank(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrf_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDpotrf_assumed_rank = hipsolverDpotrf_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function #else function hipsolverDpotrf_rank_0(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrf_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDpotrf_rank_0 = hipsolverDpotrf_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function function hipsolverDpotrf_rank_1(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrf_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDpotrf_rank_1 = hipsolverDpotrf_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function function hipsolverDpotrf_full_rank(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrf_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDpotrf_full_rank = hipsolverDpotrf_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCpotrf_assumed_rank(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrf_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCpotrf_assumed_rank = hipsolverCpotrf_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function #else function hipsolverCpotrf_rank_0(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrf_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCpotrf_rank_0 = hipsolverCpotrf_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function function hipsolverCpotrf_rank_1(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrf_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCpotrf_rank_1 = hipsolverCpotrf_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function function hipsolverCpotrf_full_rank(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrf_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCpotrf_full_rank = hipsolverCpotrf_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZpotrf_assumed_rank(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrf_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZpotrf_assumed_rank = hipsolverZpotrf_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function #else function hipsolverZpotrf_rank_0(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrf_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZpotrf_rank_0 = hipsolverZpotrf_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function function hipsolverZpotrf_rank_1(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrf_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZpotrf_rank_1 = hipsolverZpotrf_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function function hipsolverZpotrf_full_rank(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrf_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZpotrf_full_rank = hipsolverZpotrf_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSpotri_bufferSize_assumed_rank(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotri_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSpotri_bufferSize_assumed_rank = hipsolverSpotri_bufferSize_(handle,uplo,n, & c_loc(A),lda,lwork) end function #else function hipsolverSpotri_bufferSize_rank_0(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotri_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSpotri_bufferSize_rank_0 = hipsolverSpotri_bufferSize_(handle,uplo,n,c_loc(A),lda, & lwork) end function function hipsolverSpotri_bufferSize_rank_1(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotri_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSpotri_bufferSize_rank_1 = hipsolverSpotri_bufferSize_(handle,uplo,n,c_loc(A),lda, & lwork) end function function hipsolverSpotri_bufferSize_full_rank(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotri_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSpotri_bufferSize_full_rank = hipsolverSpotri_bufferSize_(handle,uplo,n,c_loc(A), & lda,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDpotri_bufferSize_assumed_rank(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotri_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDpotri_bufferSize_assumed_rank = hipsolverDpotri_bufferSize_(handle,uplo,n, & c_loc(A),lda,lwork) end function #else function hipsolverDpotri_bufferSize_rank_0(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotri_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDpotri_bufferSize_rank_0 = hipsolverDpotri_bufferSize_(handle,uplo,n,c_loc(A),lda, & lwork) end function function hipsolverDpotri_bufferSize_rank_1(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotri_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDpotri_bufferSize_rank_1 = hipsolverDpotri_bufferSize_(handle,uplo,n,c_loc(A),lda, & lwork) end function function hipsolverDpotri_bufferSize_full_rank(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotri_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDpotri_bufferSize_full_rank = hipsolverDpotri_bufferSize_(handle,uplo,n,c_loc(A), & lda,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCpotri_bufferSize_assumed_rank(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotri_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCpotri_bufferSize_assumed_rank = hipsolverCpotri_bufferSize_(handle,uplo,n, & c_loc(A),lda,lwork) end function #else function hipsolverCpotri_bufferSize_rank_0(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotri_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCpotri_bufferSize_rank_0 = hipsolverCpotri_bufferSize_(handle,uplo,n,c_loc(A),lda, & lwork) end function function hipsolverCpotri_bufferSize_rank_1(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotri_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCpotri_bufferSize_rank_1 = hipsolverCpotri_bufferSize_(handle,uplo,n,c_loc(A),lda, & lwork) end function function hipsolverCpotri_bufferSize_full_rank(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotri_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCpotri_bufferSize_full_rank = hipsolverCpotri_bufferSize_(handle,uplo,n,c_loc(A), & lda,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZpotri_bufferSize_assumed_rank(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotri_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZpotri_bufferSize_assumed_rank = hipsolverZpotri_bufferSize_(handle,uplo,n, & c_loc(A),lda,lwork) end function #else function hipsolverZpotri_bufferSize_rank_0(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotri_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZpotri_bufferSize_rank_0 = hipsolverZpotri_bufferSize_(handle,uplo,n,c_loc(A),lda, & lwork) end function function hipsolverZpotri_bufferSize_rank_1(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotri_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZpotri_bufferSize_rank_1 = hipsolverZpotri_bufferSize_(handle,uplo,n,c_loc(A),lda, & lwork) end function function hipsolverZpotri_bufferSize_full_rank(handle,uplo,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotri_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZpotri_bufferSize_full_rank = hipsolverZpotri_bufferSize_(handle,uplo,n,c_loc(A), & lda,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSpotri_assumed_rank(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotri_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSpotri_assumed_rank = hipsolverSpotri_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function #else function hipsolverSpotri_rank_0(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotri_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSpotri_rank_0 = hipsolverSpotri_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function function hipsolverSpotri_rank_1(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotri_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSpotri_rank_1 = hipsolverSpotri_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function function hipsolverSpotri_full_rank(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotri_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSpotri_full_rank = hipsolverSpotri_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDpotri_assumed_rank(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotri_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDpotri_assumed_rank = hipsolverDpotri_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function #else function hipsolverDpotri_rank_0(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotri_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDpotri_rank_0 = hipsolverDpotri_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function function hipsolverDpotri_rank_1(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotri_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDpotri_rank_1 = hipsolverDpotri_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function function hipsolverDpotri_full_rank(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotri_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDpotri_full_rank = hipsolverDpotri_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCpotri_assumed_rank(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotri_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCpotri_assumed_rank = hipsolverCpotri_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function #else function hipsolverCpotri_rank_0(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotri_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCpotri_rank_0 = hipsolverCpotri_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function function hipsolverCpotri_rank_1(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotri_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCpotri_rank_1 = hipsolverCpotri_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function function hipsolverCpotri_full_rank(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotri_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCpotri_full_rank = hipsolverCpotri_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZpotri_assumed_rank(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotri_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZpotri_assumed_rank = hipsolverZpotri_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function #else function hipsolverZpotri_rank_0(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotri_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZpotri_rank_0 = hipsolverZpotri_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function function hipsolverZpotri_rank_1(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotri_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZpotri_rank_1 = hipsolverZpotri_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function function hipsolverZpotri_full_rank(handle,uplo,n,A,lda,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotri_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZpotri_full_rank = hipsolverZpotri_(handle,uplo,n,c_loc(A),lda,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSpotrs_bufferSize_assumed_rank(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrs_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverSpotrs_bufferSize_assumed_rank = hipsolverSpotrs_bufferSize_(handle,uplo,n,nrhs, & c_loc(A),lda,c_loc(B),ldb,lwork) end function #else function hipsolverSpotrs_bufferSize_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrs_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverSpotrs_bufferSize_rank_0 = hipsolverSpotrs_bufferSize_(handle,uplo,n,nrhs,c_loc(A), & lda,c_loc(B),ldb,lwork) end function function hipsolverSpotrs_bufferSize_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrs_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverSpotrs_bufferSize_rank_1 = hipsolverSpotrs_bufferSize_(handle,uplo,n,nrhs,c_loc(A), & lda,c_loc(B),ldb,lwork) end function function hipsolverSpotrs_bufferSize_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrs_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverSpotrs_bufferSize_full_rank = hipsolverSpotrs_bufferSize_(handle,uplo,n,nrhs, & c_loc(A),lda,c_loc(B),ldb,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDpotrs_bufferSize_assumed_rank(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrs_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverDpotrs_bufferSize_assumed_rank = hipsolverDpotrs_bufferSize_(handle,uplo,n,nrhs, & c_loc(A),lda,c_loc(B),ldb,lwork) end function #else function hipsolverDpotrs_bufferSize_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrs_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverDpotrs_bufferSize_rank_0 = hipsolverDpotrs_bufferSize_(handle,uplo,n,nrhs,c_loc(A), & lda,c_loc(B),ldb,lwork) end function function hipsolverDpotrs_bufferSize_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrs_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverDpotrs_bufferSize_rank_1 = hipsolverDpotrs_bufferSize_(handle,uplo,n,nrhs,c_loc(A), & lda,c_loc(B),ldb,lwork) end function function hipsolverDpotrs_bufferSize_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrs_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverDpotrs_bufferSize_full_rank = hipsolverDpotrs_bufferSize_(handle,uplo,n,nrhs, & c_loc(A),lda,c_loc(B),ldb,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCpotrs_bufferSize_assumed_rank(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrs_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverCpotrs_bufferSize_assumed_rank = hipsolverCpotrs_bufferSize_(handle,uplo,n,nrhs, & c_loc(A),lda,c_loc(B),ldb,lwork) end function #else function hipsolverCpotrs_bufferSize_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrs_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverCpotrs_bufferSize_rank_0 = hipsolverCpotrs_bufferSize_(handle,uplo,n,nrhs,c_loc(A), & lda,c_loc(B),ldb,lwork) end function function hipsolverCpotrs_bufferSize_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrs_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverCpotrs_bufferSize_rank_1 = hipsolverCpotrs_bufferSize_(handle,uplo,n,nrhs,c_loc(A), & lda,c_loc(B),ldb,lwork) end function function hipsolverCpotrs_bufferSize_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrs_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverCpotrs_bufferSize_full_rank = hipsolverCpotrs_bufferSize_(handle,uplo,n,nrhs, & c_loc(A),lda,c_loc(B),ldb,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZpotrs_bufferSize_assumed_rank(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrs_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverZpotrs_bufferSize_assumed_rank = hipsolverZpotrs_bufferSize_(handle,uplo,n,nrhs, & c_loc(A),lda,c_loc(B),ldb,lwork) end function #else function hipsolverZpotrs_bufferSize_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrs_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverZpotrs_bufferSize_rank_0 = hipsolverZpotrs_bufferSize_(handle,uplo,n,nrhs,c_loc(A), & lda,c_loc(B),ldb,lwork) end function function hipsolverZpotrs_bufferSize_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrs_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverZpotrs_bufferSize_rank_1 = hipsolverZpotrs_bufferSize_(handle,uplo,n,nrhs,c_loc(A), & lda,c_loc(B),ldb,lwork) end function function hipsolverZpotrs_bufferSize_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrs_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int) :: lwork ! hipsolverZpotrs_bufferSize_full_rank = hipsolverZpotrs_bufferSize_(handle,uplo,n,nrhs, & c_loc(A),lda,c_loc(B),ldb,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSpotrs_assumed_rank(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrs_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSpotrs_assumed_rank = hipsolverSpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B), & ldb,work,lwork,devInfo) end function #else function hipsolverSpotrs_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrs_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSpotrs_rank_0 = hipsolverSpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,work, & lwork,devInfo) end function function hipsolverSpotrs_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrs_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSpotrs_rank_1 = hipsolverSpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,work, & lwork,devInfo) end function function hipsolverSpotrs_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSpotrs_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSpotrs_full_rank = hipsolverSpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb, & work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDpotrs_assumed_rank(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrs_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDpotrs_assumed_rank = hipsolverDpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B), & ldb,work,lwork,devInfo) end function #else function hipsolverDpotrs_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrs_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDpotrs_rank_0 = hipsolverDpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,work, & lwork,devInfo) end function function hipsolverDpotrs_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrs_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDpotrs_rank_1 = hipsolverDpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,work, & lwork,devInfo) end function function hipsolverDpotrs_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDpotrs_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDpotrs_full_rank = hipsolverDpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb, & work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCpotrs_assumed_rank(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrs_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCpotrs_assumed_rank = hipsolverCpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B), & ldb,work,lwork,devInfo) end function #else function hipsolverCpotrs_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrs_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCpotrs_rank_0 = hipsolverCpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,work, & lwork,devInfo) end function function hipsolverCpotrs_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrs_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCpotrs_rank_1 = hipsolverCpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,work, & lwork,devInfo) end function function hipsolverCpotrs_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCpotrs_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCpotrs_full_rank = hipsolverCpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb, & work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZpotrs_assumed_rank(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrs_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZpotrs_assumed_rank = hipsolverZpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B), & ldb,work,lwork,devInfo) end function #else function hipsolverZpotrs_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrs_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZpotrs_rank_0 = hipsolverZpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,work, & lwork,devInfo) end function function hipsolverZpotrs_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrs_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZpotrs_rank_1 = hipsolverZpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,work, & lwork,devInfo) end function function hipsolverZpotrs_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZpotrs_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZpotrs_full_rank = hipsolverZpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb, & work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSsyevd_bufferSize_assumed_rank(handle,jobz,uplo,n,A,lda,D,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsyevd_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D integer(c_int) :: lwork ! hipsolverSsyevd_bufferSize_assumed_rank = hipsolverSsyevd_bufferSize_(handle,jobz,uplo,n, & c_loc(A),lda,c_loc(D),lwork) end function #else function hipsolverSsyevd_bufferSize_rank_0(handle,jobz,uplo,n,A,lda,D,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsyevd_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: D integer(c_int) :: lwork ! hipsolverSsyevd_bufferSize_rank_0 = hipsolverSsyevd_bufferSize_(handle,jobz,uplo,n,c_loc(A), & lda,c_loc(D),lwork) end function function hipsolverSsyevd_bufferSize_rank_1(handle,jobz,uplo,n,A,lda,D,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsyevd_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D integer(c_int) :: lwork ! hipsolverSsyevd_bufferSize_rank_1 = hipsolverSsyevd_bufferSize_(handle,jobz,uplo,n,c_loc(A), & lda,c_loc(D),lwork) end function function hipsolverSsyevd_bufferSize_full_rank(handle,jobz,uplo,n,A,lda,D,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsyevd_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D integer(c_int) :: lwork ! hipsolverSsyevd_bufferSize_full_rank = hipsolverSsyevd_bufferSize_(handle,jobz,uplo,n, & c_loc(A),lda,c_loc(D),lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDsyevd_bufferSize_assumed_rank(handle,jobz,uplo,n,A,lda,D,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsyevd_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D integer(c_int) :: lwork ! hipsolverDsyevd_bufferSize_assumed_rank = hipsolverDsyevd_bufferSize_(handle,jobz,uplo,n, & c_loc(A),lda,c_loc(D),lwork) end function #else function hipsolverDsyevd_bufferSize_rank_0(handle,jobz,uplo,n,A,lda,D,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsyevd_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: D integer(c_int) :: lwork ! hipsolverDsyevd_bufferSize_rank_0 = hipsolverDsyevd_bufferSize_(handle,jobz,uplo,n,c_loc(A), & lda,c_loc(D),lwork) end function function hipsolverDsyevd_bufferSize_rank_1(handle,jobz,uplo,n,A,lda,D,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsyevd_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D integer(c_int) :: lwork ! hipsolverDsyevd_bufferSize_rank_1 = hipsolverDsyevd_bufferSize_(handle,jobz,uplo,n,c_loc(A), & lda,c_loc(D),lwork) end function function hipsolverDsyevd_bufferSize_full_rank(handle,jobz,uplo,n,A,lda,D,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsyevd_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D integer(c_int) :: lwork ! hipsolverDsyevd_bufferSize_full_rank = hipsolverDsyevd_bufferSize_(handle,jobz,uplo,n, & c_loc(A),lda,c_loc(D),lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCheevd_bufferSize_assumed_rank(handle,jobz,uplo,n,A,lda,D,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCheevd_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D integer(c_int) :: lwork ! hipsolverCheevd_bufferSize_assumed_rank = hipsolverCheevd_bufferSize_(handle,jobz,uplo,n, & c_loc(A),lda,c_loc(D),lwork) end function #else function hipsolverCheevd_bufferSize_rank_0(handle,jobz,uplo,n,A,lda,D,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCheevd_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda real(c_float),target :: D integer(c_int) :: lwork ! hipsolverCheevd_bufferSize_rank_0 = hipsolverCheevd_bufferSize_(handle,jobz,uplo,n,c_loc(A), & lda,c_loc(D),lwork) end function function hipsolverCheevd_bufferSize_rank_1(handle,jobz,uplo,n,A,lda,D,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCheevd_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D integer(c_int) :: lwork ! hipsolverCheevd_bufferSize_rank_1 = hipsolverCheevd_bufferSize_(handle,jobz,uplo,n,c_loc(A), & lda,c_loc(D),lwork) end function function hipsolverCheevd_bufferSize_full_rank(handle,jobz,uplo,n,A,lda,D,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCheevd_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D integer(c_int) :: lwork ! hipsolverCheevd_bufferSize_full_rank = hipsolverCheevd_bufferSize_(handle,jobz,uplo,n, & c_loc(A),lda,c_loc(D),lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZheevd_bufferSize_assumed_rank(handle,jobz,uplo,n,A,lda,D,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZheevd_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D integer(c_int) :: lwork ! hipsolverZheevd_bufferSize_assumed_rank = hipsolverZheevd_bufferSize_(handle,jobz,uplo,n, & c_loc(A),lda,c_loc(D),lwork) end function #else function hipsolverZheevd_bufferSize_rank_0(handle,jobz,uplo,n,A,lda,D,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZheevd_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda real(c_double),target :: D integer(c_int) :: lwork ! hipsolverZheevd_bufferSize_rank_0 = hipsolverZheevd_bufferSize_(handle,jobz,uplo,n,c_loc(A), & lda,c_loc(D),lwork) end function function hipsolverZheevd_bufferSize_rank_1(handle,jobz,uplo,n,A,lda,D,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZheevd_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D integer(c_int) :: lwork ! hipsolverZheevd_bufferSize_rank_1 = hipsolverZheevd_bufferSize_(handle,jobz,uplo,n,c_loc(A), & lda,c_loc(D),lwork) end function function hipsolverZheevd_bufferSize_full_rank(handle,jobz,uplo,n,A,lda,D,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZheevd_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D integer(c_int) :: lwork ! hipsolverZheevd_bufferSize_full_rank = hipsolverZheevd_bufferSize_(handle,jobz,uplo,n, & c_loc(A),lda,c_loc(D),lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSsyevd_assumed_rank(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsyevd_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSsyevd_assumed_rank = hipsolverSsyevd_(handle,jobz,uplo,n,c_loc(A),lda,c_loc(D), & work,lwork,devInfo) end function #else function hipsolverSsyevd_rank_0(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsyevd_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: D type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSsyevd_rank_0 = hipsolverSsyevd_(handle,jobz,uplo,n,c_loc(A),lda,c_loc(D),work, & lwork,devInfo) end function function hipsolverSsyevd_rank_1(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsyevd_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSsyevd_rank_1 = hipsolverSsyevd_(handle,jobz,uplo,n,c_loc(A),lda,c_loc(D),work, & lwork,devInfo) end function function hipsolverSsyevd_full_rank(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsyevd_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSsyevd_full_rank = hipsolverSsyevd_(handle,jobz,uplo,n,c_loc(A),lda,c_loc(D),work, & lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDsyevd_assumed_rank(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsyevd_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDsyevd_assumed_rank = hipsolverDsyevd_(handle,jobz,uplo,n,c_loc(A),lda,c_loc(D), & work,lwork,devInfo) end function #else function hipsolverDsyevd_rank_0(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsyevd_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: D type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDsyevd_rank_0 = hipsolverDsyevd_(handle,jobz,uplo,n,c_loc(A),lda,c_loc(D),work, & lwork,devInfo) end function function hipsolverDsyevd_rank_1(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsyevd_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDsyevd_rank_1 = hipsolverDsyevd_(handle,jobz,uplo,n,c_loc(A),lda,c_loc(D),work, & lwork,devInfo) end function function hipsolverDsyevd_full_rank(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsyevd_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDsyevd_full_rank = hipsolverDsyevd_(handle,jobz,uplo,n,c_loc(A),lda,c_loc(D),work, & lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCheevd_assumed_rank(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCheevd_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCheevd_assumed_rank = hipsolverCheevd_(handle,jobz,uplo,n,c_loc(A),lda,c_loc(D), & work,lwork,devInfo) end function #else function hipsolverCheevd_rank_0(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCheevd_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda real(c_float),target :: D type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCheevd_rank_0 = hipsolverCheevd_(handle,jobz,uplo,n,c_loc(A),lda,c_loc(D),work, & lwork,devInfo) end function function hipsolverCheevd_rank_1(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCheevd_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCheevd_rank_1 = hipsolverCheevd_(handle,jobz,uplo,n,c_loc(A),lda,c_loc(D),work, & lwork,devInfo) end function function hipsolverCheevd_full_rank(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCheevd_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCheevd_full_rank = hipsolverCheevd_(handle,jobz,uplo,n,c_loc(A),lda,c_loc(D),work, & lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZheevd_assumed_rank(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZheevd_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZheevd_assumed_rank = hipsolverZheevd_(handle,jobz,uplo,n,c_loc(A),lda,c_loc(D), & work,lwork,devInfo) end function #else function hipsolverZheevd_rank_0(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZheevd_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda real(c_double),target :: D type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZheevd_rank_0 = hipsolverZheevd_(handle,jobz,uplo,n,c_loc(A),lda,c_loc(D),work, & lwork,devInfo) end function function hipsolverZheevd_rank_1(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZheevd_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZheevd_rank_1 = hipsolverZheevd_(handle,jobz,uplo,n,c_loc(A),lda,c_loc(D),work, & lwork,devInfo) end function function hipsolverZheevd_full_rank(handle,jobz,uplo,n,A,lda,D,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZheevd_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZheevd_full_rank = hipsolverZheevd_(handle,jobz,uplo,n,c_loc(A),lda,c_loc(D),work, & lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSsygvd_bufferSize_assumed_rank(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsygvd_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: W integer(c_int) :: lwork ! hipsolverSsygvd_bufferSize_assumed_rank = hipsolverSsygvd_bufferSize_(handle,itype,jobz, & uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(W),lwork) end function #else function hipsolverSsygvd_bufferSize_rank_0(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsygvd_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: B integer(c_int) :: ldb real(c_float),target :: W integer(c_int) :: lwork ! hipsolverSsygvd_bufferSize_rank_0 = hipsolverSsygvd_bufferSize_(handle,itype,jobz,uplo,n, & c_loc(A),lda,c_loc(B),ldb,c_loc(W),lwork) end function function hipsolverSsygvd_bufferSize_rank_1(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsygvd_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: W integer(c_int) :: lwork ! hipsolverSsygvd_bufferSize_rank_1 = hipsolverSsygvd_bufferSize_(handle,itype,jobz,uplo,n, & c_loc(A),lda,c_loc(B),ldb,c_loc(W),lwork) end function function hipsolverSsygvd_bufferSize_full_rank(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsygvd_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: W integer(c_int) :: lwork ! hipsolverSsygvd_bufferSize_full_rank = hipsolverSsygvd_bufferSize_(handle,itype,jobz,uplo,n, & c_loc(A),lda,c_loc(B),ldb,c_loc(W),lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDsygvd_bufferSize_assumed_rank(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsygvd_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: W integer(c_int) :: lwork ! hipsolverDsygvd_bufferSize_assumed_rank = hipsolverDsygvd_bufferSize_(handle,itype,jobz, & uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(W),lwork) end function #else function hipsolverDsygvd_bufferSize_rank_0(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsygvd_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: B integer(c_int) :: ldb real(c_double),target :: W integer(c_int) :: lwork ! hipsolverDsygvd_bufferSize_rank_0 = hipsolverDsygvd_bufferSize_(handle,itype,jobz,uplo,n, & c_loc(A),lda,c_loc(B),ldb,c_loc(W),lwork) end function function hipsolverDsygvd_bufferSize_rank_1(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsygvd_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: W integer(c_int) :: lwork ! hipsolverDsygvd_bufferSize_rank_1 = hipsolverDsygvd_bufferSize_(handle,itype,jobz,uplo,n, & c_loc(A),lda,c_loc(B),ldb,c_loc(W),lwork) end function function hipsolverDsygvd_bufferSize_full_rank(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsygvd_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: W integer(c_int) :: lwork ! hipsolverDsygvd_bufferSize_full_rank = hipsolverDsygvd_bufferSize_(handle,itype,jobz,uplo,n, & c_loc(A),lda,c_loc(B),ldb,c_loc(W),lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverChegvd_bufferSize_assumed_rank(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChegvd_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: W integer(c_int) :: lwork ! hipsolverChegvd_bufferSize_assumed_rank = hipsolverChegvd_bufferSize_(handle,itype,jobz, & uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(W),lwork) end function #else function hipsolverChegvd_bufferSize_rank_0(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChegvd_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb real(c_float),target :: W integer(c_int) :: lwork ! hipsolverChegvd_bufferSize_rank_0 = hipsolverChegvd_bufferSize_(handle,itype,jobz,uplo,n, & c_loc(A),lda,c_loc(B),ldb,c_loc(W),lwork) end function function hipsolverChegvd_bufferSize_rank_1(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChegvd_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: W integer(c_int) :: lwork ! hipsolverChegvd_bufferSize_rank_1 = hipsolverChegvd_bufferSize_(handle,itype,jobz,uplo,n, & c_loc(A),lda,c_loc(B),ldb,c_loc(W),lwork) end function function hipsolverChegvd_bufferSize_full_rank(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChegvd_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: W integer(c_int) :: lwork ! hipsolverChegvd_bufferSize_full_rank = hipsolverChegvd_bufferSize_(handle,itype,jobz,uplo,n, & c_loc(A),lda,c_loc(B),ldb,c_loc(W),lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZhegvd_bufferSize_assumed_rank(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhegvd_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: W integer(c_int) :: lwork ! hipsolverZhegvd_bufferSize_assumed_rank = hipsolverZhegvd_bufferSize_(handle,itype,jobz, & uplo,n,c_loc(A),lda,c_loc(B),ldb,c_loc(W),lwork) end function #else function hipsolverZhegvd_bufferSize_rank_0(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhegvd_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb real(c_double),target :: W integer(c_int) :: lwork ! hipsolverZhegvd_bufferSize_rank_0 = hipsolverZhegvd_bufferSize_(handle,itype,jobz,uplo,n, & c_loc(A),lda,c_loc(B),ldb,c_loc(W),lwork) end function function hipsolverZhegvd_bufferSize_rank_1(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhegvd_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: W integer(c_int) :: lwork ! hipsolverZhegvd_bufferSize_rank_1 = hipsolverZhegvd_bufferSize_(handle,itype,jobz,uplo,n, & c_loc(A),lda,c_loc(B),ldb,c_loc(W),lwork) end function function hipsolverZhegvd_bufferSize_full_rank(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhegvd_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: W integer(c_int) :: lwork ! hipsolverZhegvd_bufferSize_full_rank = hipsolverZhegvd_bufferSize_(handle,itype,jobz,uplo,n, & c_loc(A),lda,c_loc(B),ldb,c_loc(W),lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSsygvd_assumed_rank(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsygvd_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: W type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSsygvd_assumed_rank = hipsolverSsygvd_(handle,itype,jobz,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(W),work,lwork,devInfo) end function #else function hipsolverSsygvd_rank_0(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsygvd_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: B integer(c_int) :: ldb real(c_float),target :: W type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSsygvd_rank_0 = hipsolverSsygvd_(handle,itype,jobz,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(W),work,lwork,devInfo) end function function hipsolverSsygvd_rank_1(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsygvd_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: W type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSsygvd_rank_1 = hipsolverSsygvd_(handle,itype,jobz,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(W),work,lwork,devInfo) end function function hipsolverSsygvd_full_rank(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsygvd_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: W type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSsygvd_full_rank = hipsolverSsygvd_(handle,itype,jobz,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(W),work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDsygvd_assumed_rank(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsygvd_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: W type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDsygvd_assumed_rank = hipsolverDsygvd_(handle,itype,jobz,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(W),work,lwork,devInfo) end function #else function hipsolverDsygvd_rank_0(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsygvd_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: B integer(c_int) :: ldb real(c_double),target :: W type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDsygvd_rank_0 = hipsolverDsygvd_(handle,itype,jobz,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(W),work,lwork,devInfo) end function function hipsolverDsygvd_rank_1(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsygvd_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: W type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDsygvd_rank_1 = hipsolverDsygvd_(handle,itype,jobz,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(W),work,lwork,devInfo) end function function hipsolverDsygvd_full_rank(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsygvd_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: W type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDsygvd_full_rank = hipsolverDsygvd_(handle,itype,jobz,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(W),work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverChegvd_assumed_rank(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChegvd_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: W type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverChegvd_assumed_rank = hipsolverChegvd_(handle,itype,jobz,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(W),work,lwork,devInfo) end function #else function hipsolverChegvd_rank_0(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChegvd_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb real(c_float),target :: W type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverChegvd_rank_0 = hipsolverChegvd_(handle,itype,jobz,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(W),work,lwork,devInfo) end function function hipsolverChegvd_rank_1(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChegvd_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: W type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverChegvd_rank_1 = hipsolverChegvd_(handle,itype,jobz,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(W),work,lwork,devInfo) end function function hipsolverChegvd_full_rank(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChegvd_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: W type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverChegvd_full_rank = hipsolverChegvd_(handle,itype,jobz,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(W),work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZhegvd_assumed_rank(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhegvd_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: W type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZhegvd_assumed_rank = hipsolverZhegvd_(handle,itype,jobz,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(W),work,lwork,devInfo) end function #else function hipsolverZhegvd_rank_0(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhegvd_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb real(c_double),target :: W type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZhegvd_rank_0 = hipsolverZhegvd_(handle,itype,jobz,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(W),work,lwork,devInfo) end function function hipsolverZhegvd_rank_1(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhegvd_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: W type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZhegvd_rank_1 = hipsolverZhegvd_(handle,itype,jobz,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(W),work,lwork,devInfo) end function function hipsolverZhegvd_full_rank(handle,itype,jobz,uplo,n,A,lda,B,ldb,W,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhegvd_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_EIG_TYPE_1)) :: itype integer(kind(HIPSOLVER_EIG_MODE_NOVECTOR)) :: jobz integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: W type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZhegvd_full_rank = hipsolverZhegvd_(handle,itype,jobz,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(W),work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSsytrd_bufferSize_assumed_rank(handle,uplo,n,A,lda,D,E,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrd_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E real(c_float) :: tau integer(c_int) :: lwork ! hipsolverSsytrd_bufferSize_assumed_rank = hipsolverSsytrd_bufferSize_(handle,uplo,n, & c_loc(A),lda,c_loc(D),c_loc(E),tau,lwork) end function #else function hipsolverSsytrd_bufferSize_rank_0(handle,uplo,n,A,lda,D,E,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrd_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E real(c_float) :: tau integer(c_int) :: lwork ! hipsolverSsytrd_bufferSize_rank_0 = hipsolverSsytrd_bufferSize_(handle,uplo,n,c_loc(A),lda, & c_loc(D),c_loc(E),tau,lwork) end function function hipsolverSsytrd_bufferSize_rank_1(handle,uplo,n,A,lda,D,E,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrd_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float) :: tau integer(c_int) :: lwork ! hipsolverSsytrd_bufferSize_rank_1 = hipsolverSsytrd_bufferSize_(handle,uplo,n,c_loc(A),lda, & c_loc(D),c_loc(E),tau,lwork) end function function hipsolverSsytrd_bufferSize_full_rank(handle,uplo,n,A,lda,D,E,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrd_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float) :: tau integer(c_int) :: lwork ! hipsolverSsytrd_bufferSize_full_rank = hipsolverSsytrd_bufferSize_(handle,uplo,n,c_loc(A), & lda,c_loc(D),c_loc(E),tau,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDsytrd_bufferSize_assumed_rank(handle,uplo,n,A,lda,D,E,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrd_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E real(c_double) :: tau integer(c_int) :: lwork ! hipsolverDsytrd_bufferSize_assumed_rank = hipsolverDsytrd_bufferSize_(handle,uplo,n, & c_loc(A),lda,c_loc(D),c_loc(E),tau,lwork) end function #else function hipsolverDsytrd_bufferSize_rank_0(handle,uplo,n,A,lda,D,E,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrd_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E real(c_double) :: tau integer(c_int) :: lwork ! hipsolverDsytrd_bufferSize_rank_0 = hipsolverDsytrd_bufferSize_(handle,uplo,n,c_loc(A),lda, & c_loc(D),c_loc(E),tau,lwork) end function function hipsolverDsytrd_bufferSize_rank_1(handle,uplo,n,A,lda,D,E,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrd_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double) :: tau integer(c_int) :: lwork ! hipsolverDsytrd_bufferSize_rank_1 = hipsolverDsytrd_bufferSize_(handle,uplo,n,c_loc(A),lda, & c_loc(D),c_loc(E),tau,lwork) end function function hipsolverDsytrd_bufferSize_full_rank(handle,uplo,n,A,lda,D,E,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrd_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double) :: tau integer(c_int) :: lwork ! hipsolverDsytrd_bufferSize_full_rank = hipsolverDsytrd_bufferSize_(handle,uplo,n,c_loc(A), & lda,c_loc(D),c_loc(E),tau,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverChetrd_bufferSize_assumed_rank(handle,uplo,n,A,lda,D,E,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChetrd_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E complex(c_float_complex) :: tau integer(c_int) :: lwork ! hipsolverChetrd_bufferSize_assumed_rank = hipsolverChetrd_bufferSize_(handle,uplo,n, & c_loc(A),lda,c_loc(D),c_loc(E),tau,lwork) end function #else function hipsolverChetrd_bufferSize_rank_0(handle,uplo,n,A,lda,D,E,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChetrd_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E complex(c_float_complex) :: tau integer(c_int) :: lwork ! hipsolverChetrd_bufferSize_rank_0 = hipsolverChetrd_bufferSize_(handle,uplo,n,c_loc(A),lda, & c_loc(D),c_loc(E),tau,lwork) end function function hipsolverChetrd_bufferSize_rank_1(handle,uplo,n,A,lda,D,E,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChetrd_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex) :: tau integer(c_int) :: lwork ! hipsolverChetrd_bufferSize_rank_1 = hipsolverChetrd_bufferSize_(handle,uplo,n,c_loc(A),lda, & c_loc(D),c_loc(E),tau,lwork) end function function hipsolverChetrd_bufferSize_full_rank(handle,uplo,n,A,lda,D,E,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChetrd_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex) :: tau integer(c_int) :: lwork ! hipsolverChetrd_bufferSize_full_rank = hipsolverChetrd_bufferSize_(handle,uplo,n,c_loc(A), & lda,c_loc(D),c_loc(E),tau,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZhetrd_bufferSize_assumed_rank(handle,uplo,n,A,lda,D,E,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhetrd_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E complex(c_double_complex) :: tau integer(c_int) :: lwork ! hipsolverZhetrd_bufferSize_assumed_rank = hipsolverZhetrd_bufferSize_(handle,uplo,n, & c_loc(A),lda,c_loc(D),c_loc(E),tau,lwork) end function #else function hipsolverZhetrd_bufferSize_rank_0(handle,uplo,n,A,lda,D,E,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhetrd_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E complex(c_double_complex) :: tau integer(c_int) :: lwork ! hipsolverZhetrd_bufferSize_rank_0 = hipsolverZhetrd_bufferSize_(handle,uplo,n,c_loc(A),lda, & c_loc(D),c_loc(E),tau,lwork) end function function hipsolverZhetrd_bufferSize_rank_1(handle,uplo,n,A,lda,D,E,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhetrd_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex) :: tau integer(c_int) :: lwork ! hipsolverZhetrd_bufferSize_rank_1 = hipsolverZhetrd_bufferSize_(handle,uplo,n,c_loc(A),lda, & c_loc(D),c_loc(E),tau,lwork) end function function hipsolverZhetrd_bufferSize_full_rank(handle,uplo,n,A,lda,D,E,tau,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhetrd_bufferSize_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex) :: tau integer(c_int) :: lwork ! hipsolverZhetrd_bufferSize_full_rank = hipsolverZhetrd_bufferSize_(handle,uplo,n,c_loc(A), & lda,c_loc(D),c_loc(E),tau,lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSsytrd_assumed_rank(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrd_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSsytrd_assumed_rank = hipsolverSsytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),tau,work,lwork,devInfo) end function #else function hipsolverSsytrd_rank_0(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrd_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSsytrd_rank_0 = hipsolverSsytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau, & work,lwork,devInfo) end function function hipsolverSsytrd_rank_1(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrd_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSsytrd_rank_1 = hipsolverSsytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau, & work,lwork,devInfo) end function function hipsolverSsytrd_full_rank(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrd_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSsytrd_full_rank = hipsolverSsytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & tau,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDsytrd_assumed_rank(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrd_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDsytrd_assumed_rank = hipsolverDsytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),tau,work,lwork,devInfo) end function #else function hipsolverDsytrd_rank_0(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrd_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDsytrd_rank_0 = hipsolverDsytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau, & work,lwork,devInfo) end function function hipsolverDsytrd_rank_1(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrd_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDsytrd_rank_1 = hipsolverDsytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau, & work,lwork,devInfo) end function function hipsolverDsytrd_full_rank(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrd_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDsytrd_full_rank = hipsolverDsytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & tau,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverChetrd_assumed_rank(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChetrd_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverChetrd_assumed_rank = hipsolverChetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),tau,work,lwork,devInfo) end function #else function hipsolverChetrd_rank_0(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChetrd_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverChetrd_rank_0 = hipsolverChetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau, & work,lwork,devInfo) end function function hipsolverChetrd_rank_1(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChetrd_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverChetrd_rank_1 = hipsolverChetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau, & work,lwork,devInfo) end function function hipsolverChetrd_full_rank(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverChetrd_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverChetrd_full_rank = hipsolverChetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & tau,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZhetrd_assumed_rank(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhetrd_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZhetrd_assumed_rank = hipsolverZhetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),tau,work,lwork,devInfo) end function #else function hipsolverZhetrd_rank_0(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhetrd_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZhetrd_rank_0 = hipsolverZhetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau, & work,lwork,devInfo) end function function hipsolverZhetrd_rank_1(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhetrd_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZhetrd_rank_1 = hipsolverZhetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E),tau, & work,lwork,devInfo) end function function hipsolverZhetrd_full_rank(handle,uplo,n,A,lda,D,E,tau,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZhetrd_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex) :: tau type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZhetrd_full_rank = hipsolverZhetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & tau,work,lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSsytrf_bufferSize_assumed_rank(handle,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrf_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSsytrf_bufferSize_assumed_rank = hipsolverSsytrf_bufferSize_(handle,n,c_loc(A),lda, & lwork) end function #else function hipsolverSsytrf_bufferSize_rank_0(handle,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrf_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSsytrf_bufferSize_rank_0 = hipsolverSsytrf_bufferSize_(handle,n,c_loc(A),lda,lwork) end function function hipsolverSsytrf_bufferSize_rank_1(handle,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrf_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSsytrf_bufferSize_rank_1 = hipsolverSsytrf_bufferSize_(handle,n,c_loc(A),lda,lwork) end function function hipsolverSsytrf_bufferSize_full_rank(handle,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrf_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverSsytrf_bufferSize_full_rank = hipsolverSsytrf_bufferSize_(handle,n,c_loc(A),lda, & lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDsytrf_bufferSize_assumed_rank(handle,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrf_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDsytrf_bufferSize_assumed_rank = hipsolverDsytrf_bufferSize_(handle,n,c_loc(A),lda, & lwork) end function #else function hipsolverDsytrf_bufferSize_rank_0(handle,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrf_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDsytrf_bufferSize_rank_0 = hipsolverDsytrf_bufferSize_(handle,n,c_loc(A),lda,lwork) end function function hipsolverDsytrf_bufferSize_rank_1(handle,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrf_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDsytrf_bufferSize_rank_1 = hipsolverDsytrf_bufferSize_(handle,n,c_loc(A),lda,lwork) end function function hipsolverDsytrf_bufferSize_full_rank(handle,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrf_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverDsytrf_bufferSize_full_rank = hipsolverDsytrf_bufferSize_(handle,n,c_loc(A),lda, & lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCsytrf_bufferSize_assumed_rank(handle,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCsytrf_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCsytrf_bufferSize_assumed_rank = hipsolverCsytrf_bufferSize_(handle,n,c_loc(A),lda, & lwork) end function #else function hipsolverCsytrf_bufferSize_rank_0(handle,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCsytrf_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCsytrf_bufferSize_rank_0 = hipsolverCsytrf_bufferSize_(handle,n,c_loc(A),lda,lwork) end function function hipsolverCsytrf_bufferSize_rank_1(handle,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCsytrf_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCsytrf_bufferSize_rank_1 = hipsolverCsytrf_bufferSize_(handle,n,c_loc(A),lda,lwork) end function function hipsolverCsytrf_bufferSize_full_rank(handle,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCsytrf_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverCsytrf_bufferSize_full_rank = hipsolverCsytrf_bufferSize_(handle,n,c_loc(A),lda, & lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZsytrf_bufferSize_assumed_rank(handle,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZsytrf_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZsytrf_bufferSize_assumed_rank = hipsolverZsytrf_bufferSize_(handle,n,c_loc(A),lda, & lwork) end function #else function hipsolverZsytrf_bufferSize_rank_0(handle,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZsytrf_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZsytrf_bufferSize_rank_0 = hipsolverZsytrf_bufferSize_(handle,n,c_loc(A),lda,lwork) end function function hipsolverZsytrf_bufferSize_rank_1(handle,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZsytrf_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZsytrf_bufferSize_rank_1 = hipsolverZsytrf_bufferSize_(handle,n,c_loc(A),lda,lwork) end function function hipsolverZsytrf_bufferSize_full_rank(handle,n,A,lda,lwork) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZsytrf_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: lwork ! hipsolverZsytrf_bufferSize_full_rank = hipsolverZsytrf_bufferSize_(handle,n,c_loc(A),lda, & lwork) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverSsytrf_assumed_rank(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrf_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSsytrf_assumed_rank = hipsolverSsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),work, & lwork,devInfo) end function #else function hipsolverSsytrf_rank_0(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrf_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSsytrf_rank_0 = hipsolverSsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),work,lwork, & devInfo) end function function hipsolverSsytrf_rank_1(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrf_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSsytrf_rank_1 = hipsolverSsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),work,lwork, & devInfo) end function function hipsolverSsytrf_full_rank(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverSsytrf_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverSsytrf_full_rank = hipsolverSsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),work, & lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverDsytrf_assumed_rank(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrf_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDsytrf_assumed_rank = hipsolverDsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),work, & lwork,devInfo) end function #else function hipsolverDsytrf_rank_0(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrf_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDsytrf_rank_0 = hipsolverDsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),work,lwork, & devInfo) end function function hipsolverDsytrf_rank_1(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrf_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDsytrf_rank_1 = hipsolverDsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),work,lwork, & devInfo) end function function hipsolverDsytrf_full_rank(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverDsytrf_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverDsytrf_full_rank = hipsolverDsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),work, & lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverCsytrf_assumed_rank(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCsytrf_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCsytrf_assumed_rank = hipsolverCsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),work, & lwork,devInfo) end function #else function hipsolverCsytrf_rank_0(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCsytrf_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCsytrf_rank_0 = hipsolverCsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),work,lwork, & devInfo) end function function hipsolverCsytrf_rank_1(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCsytrf_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCsytrf_rank_1 = hipsolverCsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),work,lwork, & devInfo) end function function hipsolverCsytrf_full_rank(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverCsytrf_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverCsytrf_full_rank = hipsolverCsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),work, & lwork,devInfo) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsolverZsytrf_assumed_rank(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZsytrf_assumed_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZsytrf_assumed_rank = hipsolverZsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),work, & lwork,devInfo) end function #else function hipsolverZsytrf_rank_0(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZsytrf_rank_0 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZsytrf_rank_0 = hipsolverZsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),work,lwork, & devInfo) end function function hipsolverZsytrf_rank_1(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZsytrf_rank_1 type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZsytrf_rank_1 = hipsolverZsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),work,lwork, & devInfo) end function function hipsolverZsytrf_full_rank(handle,uplo,n,A,lda,ipiv,work,lwork,devInfo) use iso_c_binding use hipfort_hipsolver_enums implicit none integer(kind(HIPSOLVER_STATUS_SUCCESS)) :: hipsolverZsytrf_full_rank type(c_ptr) :: handle integer(kind(HIPSOLVER_FILL_MODE_UPPER)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: work integer(c_int) :: lwork integer(c_int) :: devInfo ! hipsolverZsytrf_full_rank = hipsolverZsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),work, & lwork,devInfo) end function #endif #endif #endif end module hipfort_hipsolver hipfort-rocm-10.0.0/lib/hipfort/hipfort_hipsolver_enums.F90000066400000000000000000000157121524740623400236740ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_hipsolver_enums use, intrinsic :: iso_c_binding implicit none ! hipsolverStatus_t enum, bind(c) enumerator :: HIPSOLVER_STATUS_SUCCESS = 0 enumerator :: HIPSOLVER_STATUS_NOT_INITIALIZED = 1 enumerator :: HIPSOLVER_STATUS_ALLOC_FAILED = 2 enumerator :: HIPSOLVER_STATUS_INVALID_VALUE = 3 #ifdef USE_CUDA_NAMES enumerator :: HIPSOLVER_STATUS_MAPPING_ERROR = 5 #else enumerator :: HIPSOLVER_STATUS_MAPPING_ERROR = 4 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPSOLVER_STATUS_EXECUTION_FAILED = 6 #else enumerator :: HIPSOLVER_STATUS_EXECUTION_FAILED = 5 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPSOLVER_STATUS_INTERNAL_ERROR = 7 #else enumerator :: HIPSOLVER_STATUS_INTERNAL_ERROR = 6 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPSOLVER_STATUS_NOT_SUPPORTED = 9 #else enumerator :: HIPSOLVER_STATUS_NOT_SUPPORTED = 7 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPSOLVER_STATUS_ARCH_MISMATCH = 4 #else enumerator :: HIPSOLVER_STATUS_ARCH_MISMATCH = 8 #endif enumerator :: HIPSOLVER_STATUS_HANDLE_IS_NULLPTR = 9 enumerator :: HIPSOLVER_STATUS_INVALID_ENUM = 10 enumerator :: HIPSOLVER_STATUS_UNKNOWN = 11 #ifdef USE_CUDA_NAMES enumerator :: HIPSOLVER_STATUS_ZERO_PIVOT = 10 #else enumerator :: HIPSOLVER_STATUS_ZERO_PIVOT = 12 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPSOLVER_STATUS_MATRIX_TYPE_NOT_SUPPORTED = 8 #else enumerator :: HIPSOLVER_STATUS_MATRIX_TYPE_NOT_SUPPORTED = 13 #endif end enum ! hipblasOperation_t enum, bind(c) enumerator :: HIPSOLVER_OP_N = 111 enumerator :: HIPSOLVER_OP_T = 112 enumerator :: HIPSOLVER_OP_C = 113 end enum ! hipblasFillMode_t enum, bind(c) enumerator :: HIPSOLVER_FILL_MODE_UPPER = 121 enumerator :: HIPSOLVER_FILL_MODE_LOWER = 122 enumerator :: HIPSOLVER_FILL_MODE_FULL = 123 end enum ! hipblasDiagType_t enum, bind(c) enumerator :: HIPSOLVER_DIAG_NON_UNIT = 131 enumerator :: HIPSOLVER_DIAG_UNIT = 132 end enum ! hipblasSideMode_t enum, bind(c) enumerator :: HIPSOLVER_SIDE_LEFT = 141 enumerator :: HIPSOLVER_SIDE_RIGHT = 142 enumerator :: HIPSOLVER_SIDE_BOTH = 143 end enum ! hipsolverEigMode_t enum, bind(c) #ifdef USE_CUDA_NAMES enumerator :: HIPSOLVER_EIG_MODE_NOVECTOR = 0 #else enumerator :: HIPSOLVER_EIG_MODE_NOVECTOR = 201 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPSOLVER_EIG_MODE_VECTOR = 1 #else enumerator :: HIPSOLVER_EIG_MODE_VECTOR = 202 #endif end enum ! hipsolverEigType_t enum, bind(c) #ifdef USE_CUDA_NAMES enumerator :: HIPSOLVER_EIG_TYPE_1 = 1 #else enumerator :: HIPSOLVER_EIG_TYPE_1 = 211 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPSOLVER_EIG_TYPE_2 = 2 #else enumerator :: HIPSOLVER_EIG_TYPE_2 = 212 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPSOLVER_EIG_TYPE_3 = 3 #else enumerator :: HIPSOLVER_EIG_TYPE_3 = 213 #endif end enum ! hipsolverEigRange_t enum, bind(c) #ifdef USE_CUDA_NAMES enumerator :: HIPSOLVER_EIG_RANGE_ALL = 1001 #else enumerator :: HIPSOLVER_EIG_RANGE_ALL = 221 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPSOLVER_EIG_RANGE_V = 1003 #else enumerator :: HIPSOLVER_EIG_RANGE_V = 222 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPSOLVER_EIG_RANGE_I = 1002 #else enumerator :: HIPSOLVER_EIG_RANGE_I = 223 #endif end enum ! hipsolverDeterministicMode_t enum, bind(c) #ifdef USE_CUDA_NAMES enumerator :: HIPSOLVER_DETERMINISTIC_RESULTS = 1 #else enumerator :: HIPSOLVER_DETERMINISTIC_RESULTS = 241 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPSOLVER_ALLOW_NON_DETERMINISTIC_RESULTS = 2 #else enumerator :: HIPSOLVER_ALLOW_NON_DETERMINISTIC_RESULTS = 242 #endif end enum ! hipsolverAlgMode_t enum, bind(c) #ifdef USE_CUDA_NAMES enumerator :: HIPSOLVER_ALG_0 = 0 #else enumerator :: HIPSOLVER_ALG_0 = 231 #endif #ifdef USE_CUDA_NAMES enumerator :: HIPSOLVER_ALG_1 = 1 #else enumerator :: HIPSOLVER_ALG_1 = 232 #endif end enum ! hipsolverDnFunction_t enum, bind(c) enumerator :: HIPSOLVERDN_GETRF = 0 end enum ! hipsolverRfFactorization_t enum, bind(c) enumerator :: HIPSOLVERRF_FACTORIZATION_ALG0 = 0 enumerator :: HIPSOLVERRF_FACTORIZATION_ALG1 = 1 enumerator :: HIPSOLVERRF_FACTORIZATION_ALG2 = 2 end enum ! hipsolverRfMatrixFormat_t enum, bind(c) enumerator :: HIPSOLVERRF_MATRIX_FORMAT_CSR = 0 enumerator :: HIPSOLVERRF_MATRIX_FORMAT_CSC = 1 end enum ! hipsolverRfNumericBoostReport_t enum, bind(c) enumerator :: HIPSOLVERRF_NUMERIC_BOOST_NOT_USED = 0 enumerator :: HIPSOLVERRF_NUMERIC_BOOST_USED = 1 end enum ! hipsolverRfResetValuesFastMode_t enum, bind(c) enumerator :: HIPSOLVERRF_RESET_VALUES_FAST_MODE_OFF = 0 enumerator :: HIPSOLVERRF_RESET_VALUES_FAST_MODE_ON = 1 end enum ! hipsolverRfTriangularSolve_t enum, bind(c) enumerator :: HIPSOLVERRF_TRIANGULAR_SOLVE_ALG1 = 1 enumerator :: HIPSOLVERRF_TRIANGULAR_SOLVE_ALG2 = 2 enumerator :: HIPSOLVERRF_TRIANGULAR_SOLVE_ALG3 = 3 end enum ! hipsolverRfUnitDiagonal_t enum, bind(c) enumerator :: HIPSOLVERRF_UNIT_DIAGONAL_STORED_L = 0 enumerator :: HIPSOLVERRF_UNIT_DIAGONAL_STORED_U = 1 enumerator :: HIPSOLVERRF_UNIT_DIAGONAL_ASSUMED_L = 2 enumerator :: HIPSOLVERRF_UNIT_DIAGONAL_ASSUMED_U = 3 end enum integer(c_int), parameter :: hipsolverVersionMajor = 3 integer(c_int), parameter :: hipsolverVersionMinor = 6 integer(c_int), parameter :: hipsolverVersionPatch = 0 end module hipfort_hipsolver_enums hipfort-rocm-10.0.0/lib/hipfort/hipfort_hipsparse.F90000066400000000000000000104752401524740623400224570ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_hipsparse use hipfort_hipsparse_enums implicit none !> \ingroup aux_module !> \brief Create a hipSPARSE handle. !> !> \details !> \p hipsparseCreate creates the hipSPARSE library context. It must be !> initialized before any other hipSPARSE API function is invoked and must be passed to !> all subsequent library function calls. The handle should be destroyed at the end !> using hipsparseDestroy(). interface hipsparseCreate #ifdef USE_CUDA_NAMES function hipsparseCreate_(handle) bind(c, name="cusparseCreate") #else function hipsparseCreate_(handle) bind(c, name="hipsparseCreate") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreate_ type(c_ptr) :: handle end function end interface !> \ingroup aux_module !> \brief Destroy a hipSPARSE handle. !> !> \details !> \p hipsparseDestroy destroys the hipSPARSE library context and releases all !> resources used by the hipSPARSE library. interface hipsparseDestroy #ifdef USE_CUDA_NAMES function hipsparseDestroy_(handle) bind(c, name="cusparseDestroy") #else function hipsparseDestroy_(handle) bind(c, name="hipsparseDestroy") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDestroy_ type(c_ptr),value :: handle end function end interface !> \ingroup aux_module !> \brief Return the string representation of a hipSPARSE status's matching backend status enum !> name !> !> \details !> \p hipsparseGetErrorName takes a hipSPARSE status as input and first converts it to the !> matching backend !> status (either \p rocsparse_status or \p cusparseStatus_t). It then returns the string !> representation of this status !> enum name. If the status is not recognized, the function returns "Unrecognized status code". !> !> For example, \p hipsparseGetErrorName( `HIPSPARSE_STATUS_SUCCESS` ) on a system with a !> rocSPARSE backend will !> return \p rocsparse_status_success. On a system with a cuSPARSE backend this function would !> return !> \p CUSPARSE_STATUS_SUCCESS. interface hipsparseGetErrorName #ifdef USE_CUDA_NAMES function hipsparseGetErrorName_(status) bind(c, name="cusparseGetErrorName") #else function hipsparseGetErrorName_(status) bind(c, name="hipsparseGetErrorName") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none type(c_ptr) :: hipsparseGetErrorName_ integer(kind(HIPSPARSE_STATUS_SUCCESS)),value :: status end function end interface !> \ingroup aux_module !> \brief Return the hipSPARSE status's matching backend status description as a string !> !> \details !> \p hipsparseGetErrorString takes a hipSPARSE status as input and first converts it to the !> matching backend !> status (either \p rocsparse_status or \p cusparseStatus_t). It then returns the string !> description of this status. !> If the status is not recognized, the function returns "Unrecognized status code". interface hipsparseGetErrorString #ifdef USE_CUDA_NAMES function hipsparseGetErrorString_(status) bind(c, name="cusparseGetErrorString") #else function hipsparseGetErrorString_(status) bind(c, name="hipsparseGetErrorString") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none type(c_ptr) :: hipsparseGetErrorString_ integer(kind(HIPSPARSE_STATUS_SUCCESS)),value :: status end function end interface !> \ingroup aux_module !> \brief Get the hipSPARSE version. !> !> \details !> \p hipsparseGetVersion gets the hipSPARSE library version number. !> - patch = version % 100 !> - minor = version / 100 % 1000 !> - major = version / 100000 interface hipsparseGetVersion #ifdef USE_CUDA_NAMES function hipsparseGetVersion_(handle,version) bind(c, name="cusparseGetVersion") #else function hipsparseGetVersion_(handle,version) bind(c, name="hipsparseGetVersion") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseGetVersion_ type(c_ptr),value :: handle integer(c_int) :: version end function end interface !> \ingroup aux_module !> \brief Get the hipSPARSE git revision. !> !> \details !> \p hipsparseGetGitRevision gets the hipSPARSE library git commit revision (SHA-1). #ifndef USE_CUDA_NAMES interface hipsparseGetGitRevision function hipsparseGetGitRevision_(handle,rev) bind(c, name="hipsparseGetGitRevision") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseGetGitRevision_ type(c_ptr),value :: handle type(c_ptr),value :: rev end function end interface #endif !> \ingroup aux_module !> \brief Specify the user-defined HIP stream. !> !> \details !> \p hipsparseSetStream specifies the stream to be used by the hipSPARSE library !> context and all subsequent function calls. interface hipsparseSetStream #ifdef USE_CUDA_NAMES function hipsparseSetStream_(handle,streamId) bind(c, name="cusparseSetStream") #else function hipsparseSetStream_(handle,streamId) bind(c, name="hipsparseSetStream") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSetStream_ type(c_ptr),value :: handle type(c_ptr),value :: streamId end function end interface !> \ingroup aux_module !> \brief Get the current stream from the library context. !> !> \details !> \p hipsparseGetStream gets the hipSPARSE library context stream which is currently !> used for all subsequent function calls. interface hipsparseGetStream #ifdef USE_CUDA_NAMES function hipsparseGetStream_(handle,streamId) bind(c, name="cusparseGetStream") #else function hipsparseGetStream_(handle,streamId) bind(c, name="hipsparseGetStream") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseGetStream_ type(c_ptr),value :: handle type(c_ptr) :: streamId end function end interface !> \ingroup aux_module !> \brief Specify the pointer mode. !> !> \details !> \p hipsparseSetPointerMode specifies the pointer mode to be used by the hipSPARSE !> library context and all subsequent function calls. By default, all values are passed !> by reference on the host. Valid pointer modes are `HIPSPARSE_POINTER_MODE_HOST` !> or `HIPSPARSE_POINTER_MODE_DEVICE`. interface hipsparseSetPointerMode #ifdef USE_CUDA_NAMES function hipsparseSetPointerMode_(handle,mode) bind(c, name="cusparseSetPointerMode") #else function hipsparseSetPointerMode_(handle,mode) bind(c, name="hipsparseSetPointerMode") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSetPointerMode_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_POINTER_MODE_HOST)),value :: mode end function end interface !> \ingroup aux_module !> \brief Get the current pointer mode from the library context. !> !> \details !> \p hipsparseGetPointerMode gets the hipSPARSE library context pointer mode which !> is currently used for all subsequent function calls. interface hipsparseGetPointerMode #ifdef USE_CUDA_NAMES function hipsparseGetPointerMode_(handle,mode) bind(c, name="cusparseGetPointerMode") #else function hipsparseGetPointerMode_(handle,mode) bind(c, name="hipsparseGetPointerMode") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseGetPointerMode_ type(c_ptr),value :: handle type(c_ptr),value :: mode end function end interface !> \ingroup aux_module !> \brief Create a matrix descriptor. !> \details !> \p hipsparseCreateMatDescr creates a matrix descriptor. It initializes !> `hipsparseMatrixType_t` to `HIPSPARSE_MATRIX_TYPE_GENERAL` and !> `hipsparseIndexBase_t` to `HIPSPARSE_INDEX_BASE_ZERO`. It should be destroyed !> at the end using hipsparseDestroyMatDescr(). interface hipsparseCreateMatDescr #ifdef USE_CUDA_NAMES function hipsparseCreateMatDescr_(descrA) bind(c, name="cusparseCreateMatDescr") #else function hipsparseCreateMatDescr_(descrA) bind(c, name="hipsparseCreateMatDescr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateMatDescr_ type(c_ptr) :: descrA end function end interface !> \ingroup aux_module !> \brief Destroy a matrix descriptor. !> !> \details !> \p hipsparseDestroyMatDescr destroys a matrix descriptor and releases all !> resources used by the descriptor. interface hipsparseDestroyMatDescr #ifdef USE_CUDA_NAMES function hipsparseDestroyMatDescr_(descrA) bind(c, name="cusparseDestroyMatDescr") #else function hipsparseDestroyMatDescr_(descrA) bind(c, name="hipsparseDestroyMatDescr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDestroyMatDescr_ type(c_ptr),value :: descrA end function end interface !> \ingroup aux_module !> \brief Copy a matrix descriptor. !> \details !> \p hipsparseCopyMatDescr copies a matrix descriptor. Both source and destination !> matrix descriptors must be initialized prior to calling \p hipsparseCopyMatDescr. #ifndef USE_CUDA_NAMES interface hipsparseCopyMatDescr function hipsparseCopyMatDescr_(dest,src) bind(c, name="hipsparseCopyMatDescr") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCopyMatDescr_ type(c_ptr),value :: dest type(c_ptr),value :: src end function end interface #endif !> \ingroup aux_module !> \brief Specify the matrix type of a matrix descriptor. !> !> \details !> \p hipsparseSetMatType sets the matrix type of a matrix descriptor. Valid !> matrix types are `HIPSPARSE_MATRIX_TYPE_GENERAL`, !> `HIPSPARSE_MATRIX_TYPE_SYMMETRIC`, `HIPSPARSE_MATRIX_TYPE_HERMITIAN`, or !> `HIPSPARSE_MATRIX_TYPE_TRIANGULAR`. interface hipsparseSetMatType #ifdef USE_CUDA_NAMES function hipsparseSetMatType_(descrA,myType) bind(c, name="cusparseSetMatType") #else function hipsparseSetMatType_(descrA,myType) bind(c, name="hipsparseSetMatType") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSetMatType_ type(c_ptr),value :: descrA integer(kind(HIPSPARSE_MATRIX_TYPE_GENERAL)),value :: myType end function end interface !> \ingroup aux_module !> \brief Get the matrix type of a matrix descriptor. !> !> \details !> \p hipsparseGetMatType returns the matrix type of a matrix descriptor. interface hipsparseGetMatType #ifdef USE_CUDA_NAMES function hipsparseGetMatType_(descrA) bind(c, name="cusparseGetMatType") #else function hipsparseGetMatType_(descrA) bind(c, name="hipsparseGetMatType") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_MATRIX_TYPE_GENERAL)) :: hipsparseGetMatType_ type(c_ptr),value :: descrA end function end interface !> \ingroup aux_module !> \brief Specify the matrix fill mode of a matrix descriptor. !> !> \details !> \p hipsparseSetMatFillMode sets the matrix fill mode of a matrix descriptor. !> Valid fill modes are `HIPSPARSE_FILL_MODE_LOWER` or !> `HIPSPARSE_FILL_MODE_UPPER`. interface hipsparseSetMatFillMode #ifdef USE_CUDA_NAMES function hipsparseSetMatFillMode_(descrA,fillMode) bind(c, name="cusparseSetMatFillMode") #else function hipsparseSetMatFillMode_(descrA,fillMode) bind(c, name="hipsparseSetMatFillMode") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSetMatFillMode_ type(c_ptr),value :: descrA integer(kind(HIPSPARSE_FILL_MODE_LOWER)),value :: fillMode end function end interface !> \ingroup aux_module !> \brief Get the matrix fill mode of a matrix descriptor. !> !> \details !> \p hipsparseGetMatFillMode returns the matrix fill mode of a matrix descriptor. interface hipsparseGetMatFillMode #ifdef USE_CUDA_NAMES function hipsparseGetMatFillMode_(descrA) bind(c, name="cusparseGetMatFillMode") #else function hipsparseGetMatFillMode_(descrA) bind(c, name="hipsparseGetMatFillMode") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_FILL_MODE_LOWER)) :: hipsparseGetMatFillMode_ type(c_ptr),value :: descrA end function end interface !> \ingroup aux_module !> \brief Specify the matrix diagonal type of a matrix descriptor. !> !> \details !> \p hipsparseSetMatDiagType sets the matrix diagonal type of a matrix !> descriptor. Valid diagonal types are `HIPSPARSE_DIAG_TYPE_UNIT` or !> `HIPSPARSE_DIAG_TYPE_NON_UNIT`. interface hipsparseSetMatDiagType #ifdef USE_CUDA_NAMES function hipsparseSetMatDiagType_(descrA,diagType) bind(c, name="cusparseSetMatDiagType") #else function hipsparseSetMatDiagType_(descrA,diagType) bind(c, name="hipsparseSetMatDiagType") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSetMatDiagType_ type(c_ptr),value :: descrA integer(kind(HIPSPARSE_DIAG_TYPE_NON_UNIT)),value :: diagType end function end interface !> \ingroup aux_module !> \brief Get the matrix diagonal type of a matrix descriptor. !> !> \details !> \p hipsparseGetMatDiagType returns the matrix diagonal type of a matrix !> descriptor. interface hipsparseGetMatDiagType #ifdef USE_CUDA_NAMES function hipsparseGetMatDiagType_(descrA) bind(c, name="cusparseGetMatDiagType") #else function hipsparseGetMatDiagType_(descrA) bind(c, name="hipsparseGetMatDiagType") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_DIAG_TYPE_NON_UNIT)) :: hipsparseGetMatDiagType_ type(c_ptr),value :: descrA end function end interface !> \ingroup aux_module !> \brief Specify the index base of a matrix descriptor. !> !> \details !> \p hipsparseSetMatIndexBase sets the index base of a matrix descriptor. Valid !> options are `HIPSPARSE_INDEX_BASE_ZERO` or `HIPSPARSE_INDEX_BASE_ONE`. interface hipsparseSetMatIndexBase #ifdef USE_CUDA_NAMES function hipsparseSetMatIndexBase_(descrA,base) bind(c, name="cusparseSetMatIndexBase") #else function hipsparseSetMatIndexBase_(descrA,base) bind(c, name="hipsparseSetMatIndexBase") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSetMatIndexBase_ type(c_ptr),value :: descrA integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: base end function end interface !> \ingroup aux_module !> \brief Get the index base of a matrix descriptor. !> !> \details !> \p hipsparseGetMatIndexBase returns the index base of a matrix descriptor. interface hipsparseGetMatIndexBase #ifdef USE_CUDA_NAMES function hipsparseGetMatIndexBase_(descrA) bind(c, name="cusparseGetMatIndexBase") #else function hipsparseGetMatIndexBase_(descrA) bind(c, name="hipsparseGetMatIndexBase") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: hipsparseGetMatIndexBase_ type(c_ptr),value :: descrA end function end interface !> \ingroup aux_module !> \brief Create a \p HYB matrix structure. !> !> \details !> \p hipsparseCreateHybMat creates a structure that holds the matrix in \p HYB !> storage format. It should be destroyed at the end using hipsparseDestroyHybMat(). #ifndef USE_CUDA_NAMES interface hipsparseCreateHybMat function hipsparseCreateHybMat_(hybA) bind(c, name="hipsparseCreateHybMat") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateHybMat_ type(c_ptr) :: hybA end function end interface #endif !> \ingroup aux_module !> \brief Destroy a \p HYB matrix structure. !> !> \details !> \p hipsparseDestroyHybMat destroys a \p HYB structure. #ifndef USE_CUDA_NAMES interface hipsparseDestroyHybMat function hipsparseDestroyHybMat_(hybA) bind(c, name="hipsparseDestroyHybMat") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDestroyHybMat_ type(c_ptr),value :: hybA end function end interface #endif !> \ingroup aux_module !> \brief Create a bsrsv2 info structure. !> !> \details !> \p hipsparseCreateBsrsv2Info creates a structure that holds the bsrsv2 info data !> that is gathered during the analysis routines. It should be destroyed !> at the end using hipsparseDestroyBsrsv2Info(). interface hipsparseCreateBsrsv2Info #ifdef USE_CUDA_NAMES function hipsparseCreateBsrsv2Info_(myInfo) bind(c, name="cusparseCreateBsrsv2Info") #else function hipsparseCreateBsrsv2Info_(myInfo) bind(c, name="hipsparseCreateBsrsv2Info") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateBsrsv2Info_ type(c_ptr) :: myInfo end function end interface !> \ingroup aux_module !> \brief Destroy a bsrsv2 info structure. !> !> \details !> \p hipsparseDestroyBsrsv2Info destroys a bsrsv2 info structure. interface hipsparseDestroyBsrsv2Info #ifdef USE_CUDA_NAMES function hipsparseDestroyBsrsv2Info_(myInfo) bind(c, name="cusparseDestroyBsrsv2Info") #else function hipsparseDestroyBsrsv2Info_(myInfo) bind(c, name="hipsparseDestroyBsrsv2Info") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDestroyBsrsv2Info_ type(c_ptr),value :: myInfo end function end interface !> \ingroup aux_module !> \brief Create a bsrsm2 info structure. !> !> \details !> \p hipsparseCreateBsrsm2Info creates a structure that holds the bsrsm2 info data !> that is gathered during the analysis routines. It should be destroyed !> at the end using hipsparseDestroyBsrsm2Info(). interface hipsparseCreateBsrsm2Info #ifdef USE_CUDA_NAMES function hipsparseCreateBsrsm2Info_(myInfo) bind(c, name="cusparseCreateBsrsm2Info") #else function hipsparseCreateBsrsm2Info_(myInfo) bind(c, name="hipsparseCreateBsrsm2Info") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateBsrsm2Info_ type(c_ptr) :: myInfo end function end interface !> \ingroup aux_module !> \brief Destroy a bsrsm2 info structure. !> !> \details !> \p hipsparseDestroyBsrsm2Info destroys a bsrsm2 info structure. interface hipsparseDestroyBsrsm2Info #ifdef USE_CUDA_NAMES function hipsparseDestroyBsrsm2Info_(myInfo) bind(c, name="cusparseDestroyBsrsm2Info") #else function hipsparseDestroyBsrsm2Info_(myInfo) bind(c, name="hipsparseDestroyBsrsm2Info") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDestroyBsrsm2Info_ type(c_ptr),value :: myInfo end function end interface !> \ingroup aux_module !> \brief Create a bsrilu02 info structure. !> !> \details !> \p hipsparseCreateBsrilu02Info creates a structure that holds the bsrilu02 info data !> that is gathered during the analysis routines. It should be destroyed !> at the end using hipsparseDestroyBsrilu02Info(). interface hipsparseCreateBsrilu02Info #ifdef USE_CUDA_NAMES function hipsparseCreateBsrilu02Info_(myInfo) bind(c, name="cusparseCreateBsrilu02Info") #else function hipsparseCreateBsrilu02Info_(myInfo) bind(c, name="hipsparseCreateBsrilu02Info") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateBsrilu02Info_ type(c_ptr) :: myInfo end function end interface !> \ingroup aux_module !> \brief Destroy a bsrilu02 info structure !> !> \details !> \p hipsparseDestroyBsrilu02Info destroys a bsrilu02 info structure. interface hipsparseDestroyBsrilu02Info #ifdef USE_CUDA_NAMES function hipsparseDestroyBsrilu02Info_(myInfo) bind(c, name="cusparseDestroyBsrilu02Info") #else function hipsparseDestroyBsrilu02Info_(myInfo) bind(c, name="hipsparseDestroyBsrilu02Info") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDestroyBsrilu02Info_ type(c_ptr),value :: myInfo end function end interface !> \ingroup aux_module !> \brief Create a bsric02 info structure. !> !> \details !> \p hipsparseCreateBsric02Info creates a structure that holds the bsric02 info data !> that is gathered during the analysis routines. It should be destroyed !> at the end using hipsparseDestroyBsric02Info(). interface hipsparseCreateBsric02Info #ifdef USE_CUDA_NAMES function hipsparseCreateBsric02Info_(myInfo) bind(c, name="cusparseCreateBsric02Info") #else function hipsparseCreateBsric02Info_(myInfo) bind(c, name="hipsparseCreateBsric02Info") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateBsric02Info_ type(c_ptr) :: myInfo end function end interface !> \ingroup aux_module !> \brief Destroy a bsric02 info structure. !> !> \details !> \p hipsparseDestroyBsric02Info destroys a bsric02 info structure. interface hipsparseDestroyBsric02Info #ifdef USE_CUDA_NAMES function hipsparseDestroyBsric02Info_(myInfo) bind(c, name="cusparseDestroyBsric02Info") #else function hipsparseDestroyBsric02Info_(myInfo) bind(c, name="hipsparseDestroyBsric02Info") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDestroyBsric02Info_ type(c_ptr),value :: myInfo end function end interface !> \ingroup aux_module !> \brief Create a csrsv2 info structure. !> !> \details !> \p hipsparseCreateCsrsv2Info creates a structure that holds the csrsv2 info data !> that is gathered during the analysis routines. It should be destroyed !> at the end using hipsparseDestroyCsrsv2Info(). #ifndef USE_CUDA_NAMES interface hipsparseCreateCsrsv2Info function hipsparseCreateCsrsv2Info_(myInfo) bind(c, name="hipsparseCreateCsrsv2Info") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateCsrsv2Info_ type(c_ptr) :: myInfo end function end interface #endif !> \ingroup aux_module !> \brief Destroy a csrsv2 info structure. !> !> \details !> \p hipsparseDestroyCsrsv2Info destroys a csrsv2 info structure. #ifndef USE_CUDA_NAMES interface hipsparseDestroyCsrsv2Info function hipsparseDestroyCsrsv2Info_(myInfo) bind(c, name="hipsparseDestroyCsrsv2Info") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDestroyCsrsv2Info_ type(c_ptr),value :: myInfo end function end interface #endif !> \ingroup aux_module !> \brief Create a csrsm2 info structure. !> !> \details !> \p hipsparseCreateCsrsm2Info creates a structure that holds the csrsm2 info data !> that is gathered during the analysis routines. It should be destroyed !> at the end using hipsparseDestroyCsrsm2Info(). #ifndef USE_CUDA_NAMES interface hipsparseCreateCsrsm2Info function hipsparseCreateCsrsm2Info_(myInfo) bind(c, name="hipsparseCreateCsrsm2Info") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateCsrsm2Info_ type(c_ptr) :: myInfo end function end interface #endif !> \ingroup aux_module !> \brief Destroy a csrsm2 info structure. !> !> \details !> \p hipsparseDestroyCsrsm2Info destroys a csrsm2 info structure. #ifndef USE_CUDA_NAMES interface hipsparseDestroyCsrsm2Info function hipsparseDestroyCsrsm2Info_(myInfo) bind(c, name="hipsparseDestroyCsrsm2Info") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDestroyCsrsm2Info_ type(c_ptr),value :: myInfo end function end interface #endif !> \ingroup aux_module !> \brief Create a csrilu02 info structure. !> !> \details !> \p hipsparseCreateCsrilu02Info creates a structure that holds the csrilu02 info data !> that is gathered during the analysis routines. It should be destroyed !> at the end using hipsparseDestroyCsrilu02Info(). interface hipsparseCreateCsrilu02Info #ifdef USE_CUDA_NAMES function hipsparseCreateCsrilu02Info_(myInfo) bind(c, name="cusparseCreateCsrilu02Info") #else function hipsparseCreateCsrilu02Info_(myInfo) bind(c, name="hipsparseCreateCsrilu02Info") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateCsrilu02Info_ type(c_ptr) :: myInfo end function end interface !> \ingroup aux_module !> \brief Destroy a csrilu02 info structure. !> !> \details !> \p hipsparseDestroyCsrilu02Info destroys a csrilu02 info structure. interface hipsparseDestroyCsrilu02Info #ifdef USE_CUDA_NAMES function hipsparseDestroyCsrilu02Info_(myInfo) bind(c, name="cusparseDestroyCsrilu02Info") #else function hipsparseDestroyCsrilu02Info_(myInfo) bind(c, name="hipsparseDestroyCsrilu02Info") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDestroyCsrilu02Info_ type(c_ptr),value :: myInfo end function end interface !> \ingroup aux_module !> \brief Create a csric02 info structure. !> !> \details !> \p hipsparseCreateCsric02Info creates a structure that holds the csric02 info data !> that is gathered during the analysis routines. It should be destroyed !> at the end using hipsparseDestroyCsric02Info(). interface hipsparseCreateCsric02Info #ifdef USE_CUDA_NAMES function hipsparseCreateCsric02Info_(myInfo) bind(c, name="cusparseCreateCsric02Info") #else function hipsparseCreateCsric02Info_(myInfo) bind(c, name="hipsparseCreateCsric02Info") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateCsric02Info_ type(c_ptr) :: myInfo end function end interface !> \ingroup aux_module !> \brief Destroy a csric02 info structure. !> !> \details !> \p hipsparseDestroyCsric02Info destroys a csric02 info structure. interface hipsparseDestroyCsric02Info #ifdef USE_CUDA_NAMES function hipsparseDestroyCsric02Info_(myInfo) bind(c, name="cusparseDestroyCsric02Info") #else function hipsparseDestroyCsric02Info_(myInfo) bind(c, name="hipsparseDestroyCsric02Info") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDestroyCsric02Info_ type(c_ptr),value :: myInfo end function end interface !> \ingroup aux_module !> \brief Create a csru2csr info structure. !> !> \details !> \p hipsparseCreateCsru2csrInfo creates a structure that holds the csru2csr info data !> that is gathered during the analysis routines. It should be destroyed !> at the end using hipsparseDestroyCsru2csrInfo(). interface hipsparseCreateCsru2csrInfo #ifdef USE_CUDA_NAMES function hipsparseCreateCsru2csrInfo_(myInfo) bind(c, name="cusparseCreateCsru2csrInfo") #else function hipsparseCreateCsru2csrInfo_(myInfo) bind(c, name="hipsparseCreateCsru2csrInfo") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateCsru2csrInfo_ type(c_ptr) :: myInfo end function end interface !> \ingroup aux_module !> \brief Destroy a csru2csr info structure. !> !> \details !> \p hipsparseDestroyCsru2csrInfo destroys a csru2csr info structure. interface hipsparseDestroyCsru2csrInfo #ifdef USE_CUDA_NAMES function hipsparseDestroyCsru2csrInfo_(myInfo) bind(c, name="cusparseDestroyCsru2csrInfo") #else function hipsparseDestroyCsru2csrInfo_(myInfo) bind(c, name="hipsparseDestroyCsru2csrInfo") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDestroyCsru2csrInfo_ type(c_ptr),value :: myInfo end function end interface !> \ingroup aux_module !> \brief Create a color info structure. !> !> \details !> \p hipsparseCreateColorInfo creates a structure that holds the color info data !> that is gathered during the analysis routines. It should be destroyed !> at the end using hipsparseDestroyColorInfo(). interface hipsparseCreateColorInfo #ifdef USE_CUDA_NAMES function hipsparseCreateColorInfo_(myInfo) bind(c, name="cusparseCreateColorInfo") #else function hipsparseCreateColorInfo_(myInfo) bind(c, name="hipsparseCreateColorInfo") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateColorInfo_ type(c_ptr) :: myInfo end function end interface !> \ingroup aux_module !> \brief Destroy a color info structure. !> !> \details !> \p hipsparseDestroyColorInfo destroys a color info structure. interface hipsparseDestroyColorInfo #ifdef USE_CUDA_NAMES function hipsparseDestroyColorInfo_(myInfo) bind(c, name="cusparseDestroyColorInfo") #else function hipsparseDestroyColorInfo_(myInfo) bind(c, name="hipsparseDestroyColorInfo") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDestroyColorInfo_ type(c_ptr),value :: myInfo end function end interface !> \ingroup aux_module !> \brief Create a csrgemm2 info structure. !> !> \details !> \p hipsparseCreateCsrgemm2Info creates a structure that holds the csrgemm2 info data !> that is gathered during the analysis routines. It should be destroyed !> at the end using hipsparseDestroyCsrgemm2Info(). #ifndef USE_CUDA_NAMES interface hipsparseCreateCsrgemm2Info function hipsparseCreateCsrgemm2Info_(myInfo) bind(c, name="hipsparseCreateCsrgemm2Info") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateCsrgemm2Info_ type(c_ptr) :: myInfo end function end interface #endif !> \ingroup aux_module !> \brief Destroy a csrgemm2 info structure. !> !> \details !> \p hipsparseDestroyCsrgemm2Info destroys a csrgemm2 info structure. #ifndef USE_CUDA_NAMES interface hipsparseDestroyCsrgemm2Info function hipsparseDestroyCsrgemm2Info_(myInfo) bind(c, name="hipsparseDestroyCsrgemm2Info") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDestroyCsrgemm2Info_ type(c_ptr),value :: myInfo end function end interface #endif !> \ingroup aux_module !> \brief Create a prune info structure. !> !> \details !> \p hipsparseCreatePruneInfo creates a structure that holds the prune info data !> that is gathered during the analysis routines. It should be destroyed !> at the end using hipsparseDestroyPruneInfo(). interface hipsparseCreatePruneInfo #ifdef USE_CUDA_NAMES function hipsparseCreatePruneInfo_(myInfo) bind(c, name="cusparseCreatePruneInfo") #else function hipsparseCreatePruneInfo_(myInfo) bind(c, name="hipsparseCreatePruneInfo") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreatePruneInfo_ type(c_ptr) :: myInfo end function end interface !> \ingroup aux_module !> \brief Destroy a prune info structure !> !> \details !> \p hipsparseDestroyPruneInfo destroys a prune info structure. interface hipsparseDestroyPruneInfo #ifdef USE_CUDA_NAMES function hipsparseDestroyPruneInfo_(myInfo) bind(c, name="cusparseDestroyPruneInfo") #else function hipsparseDestroyPruneInfo_(myInfo) bind(c, name="hipsparseDestroyPruneInfo") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDestroyPruneInfo_ type(c_ptr),value :: myInfo end function end interface !> \ingroup level1_module !> \brief Scale a sparse vector and add it to a dense vector. !> !> \details !> \p hipsparseXaxpyi multiplies the sparse vector \f$x\f$ with scalar \f$\alpha\f$ and !> adds the result to the dense vector \f$y\f$, such that !> !> \f[ !> y := y + \alpha \cdot x !> \f] !> !> \code{.c} !> for(i = 0; i < nnz; ++i) !> { !> y[xInd[i]] = y[xInd[i]] + alpha * xVal[i]; !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> If \p nnz is zero, the function returns successfully without modifying \p y. !> Duplicate indices in \p xInd will result in the corresponding values being added !> multiple times to the same location in \p y. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 11.0+) and will be !> removed in CUDA 12.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] nnz - number of non-zero entries of vector \f$x\f$. Must be non-negative. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] xVal - array of \p nnz elements containing the values of \f$x\f$. !> @param[in] xInd - array of \p nnz elements containing the indices of the non-zero !> values of \f$x\f$. !> @param[inout] y - array of values in dense format. Must be pre-allocated with sufficient !> size to accommodate all indices specified in \p xInd. !> @param[in] idxBase - index base. `HIPSPARSE_INDEX_BASE_ZERO` for zero-based indexing or !> `HIPSPARSE_INDEX_BASE_ONE` for one-based indexing. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle is nullptr, \p nnz is negative, !> \p alpha, \p xVal, \p xInd, or \p y is nullptr when \p nnz is greater than zero, !> or \p idxBase is neither `HIPSPARSE_INDEX_BASE_ZERO` nor `HIPSPARSE_INDEX_BASE_ONE`. #ifndef USE_CUDA_NAMES interface hipsparseSaxpyi function hipsparseSaxpyi_(handle,nnz,alpha,xVal,xInd,y,idxBase) bind(c, name="hipsparseSaxpyi") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSaxpyi_ type(c_ptr),value :: handle integer(c_int),value :: nnz real(c_float) :: alpha type(c_ptr),value :: xVal type(c_ptr),value :: xInd type(c_ptr),value :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSaxpyi_assumed_rank #else module procedure & hipsparseSaxpyi_rank_0,& hipsparseSaxpyi_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDaxpyi function hipsparseDaxpyi_(handle,nnz,alpha,xVal,xInd,y,idxBase) bind(c, name="hipsparseDaxpyi") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDaxpyi_ type(c_ptr),value :: handle integer(c_int),value :: nnz real(c_double) :: alpha type(c_ptr),value :: xVal type(c_ptr),value :: xInd type(c_ptr),value :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDaxpyi_assumed_rank #else module procedure & hipsparseDaxpyi_rank_0,& hipsparseDaxpyi_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCaxpyi function hipsparseCaxpyi_(handle,nnz,alpha,xVal,xInd,y,idxBase) bind(c, name="hipsparseCaxpyi") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCaxpyi_ type(c_ptr),value :: handle integer(c_int),value :: nnz complex(c_float_complex) :: alpha type(c_ptr),value :: xVal type(c_ptr),value :: xInd type(c_ptr),value :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCaxpyi_assumed_rank #else module procedure & hipsparseCaxpyi_rank_0,& hipsparseCaxpyi_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZaxpyi function hipsparseZaxpyi_(handle,nnz,alpha,xVal,xInd,y,idxBase) bind(c, name="hipsparseZaxpyi") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZaxpyi_ type(c_ptr),value :: handle integer(c_int),value :: nnz complex(c_double_complex) :: alpha type(c_ptr),value :: xVal type(c_ptr),value :: xInd type(c_ptr),value :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZaxpyi_assumed_rank #else module procedure & hipsparseZaxpyi_rank_0,& hipsparseZaxpyi_rank_1 #endif #endif end interface #endif !> \ingroup level1_module !> \brief Compute the dot product of a complex conjugate sparse vector with a dense !> vector. !> !> \details !> \p hipsparseXdotci computes the dot product of the complex conjugate sparse vector !> \f$x\f$ with the dense vector \f$y\f$, such that !> \f[ !> result := \bar{x}^H y !> \f] !> !> \code{.c} !> result = 0 !> for(i = 0; i < nnz; ++i) !> { !> result += conj(xVal[i]) * y[xInd[i]]; !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> If \p nnz is zero, the function returns successfully with \p result set to zero. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 10.0+) and will be !> removed in CUDA 11.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] nnz - number of non-zero entries of vector \f$x\f$. Must be non-negative. !> @param[in] xVal - array of \p nnz values containing the elements of \f$x\f$. !> @param[in] xInd - array of \p nnz elements containing the indices of the non-zero !> values of \f$x\f$. !> @param[in] y - array of values in dense format. Must be pre-allocated with sufficient !> size to accommodate all indices specified in \p xInd. !> @param[out] myResult - pointer to the result, which can be host or device memory. !> @param[in] idxBase - index base. `HIPSPARSE_INDEX_BASE_ZERO` for zero-based indexing or !> `HIPSPARSE_INDEX_BASE_ONE` for one-based indexing. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle or \p result is nullptr, \p nnz is negative, !> \p xVal, \p xInd, or \p y is nullptr when \p nnz is greater than zero, or \p idxBase !> is neither `HIPSPARSE_INDEX_BASE_ZERO` nor `HIPSPARSE_INDEX_BASE_ONE`. !> \retval HIPSPARSE_STATUS_ALLOC_FAILED the buffer for the dot product reduction !> could not be allocated. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. #ifndef USE_CUDA_NAMES interface hipsparseCdotci function hipsparseCdotci_(handle,nnz,xVal,xInd,y,myResult,idxBase) & bind(c, name="hipsparseCdotci") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCdotci_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: xVal type(c_ptr),value :: xInd type(c_ptr),value :: y type(c_ptr),value :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCdotci_assumed_rank #else module procedure & hipsparseCdotci_rank_0,& hipsparseCdotci_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZdotci function hipsparseZdotci_(handle,nnz,xVal,xInd,y,myResult,idxBase) & bind(c, name="hipsparseZdotci") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZdotci_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: xVal type(c_ptr),value :: xInd type(c_ptr),value :: y type(c_ptr),value :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZdotci_assumed_rank #else module procedure & hipsparseZdotci_rank_0,& hipsparseZdotci_rank_1 #endif #endif end interface #endif !> \ingroup level1_module !> \brief Compute the dot product of a sparse vector with a dense vector. !> !> \details !> \p hipsparseXdoti computes the dot product of the sparse vector \f$x\f$ with the !> dense vector \f$y\f$, such that !> \f[ !> result := y^T x !> \f] !> !> \code{.c} !> result = 0 !> for(i = 0; i < nnz; ++i) !> { !> result += xVal[i] * y[xInd[i]]; !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> If \p nnz is zero, the function returns successfully with \p result set to zero. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 10.0+) and will be !> removed in CUDA 11.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] nnz - number of non-zero entries of vector \f$x\f$. Must be non-negative. !> @param[in] xVal - array of \p nnz values containing the elements of \f$x\f$. !> @param[in] xInd - array of \p nnz elements containing the indices of the non-zero !> values of \f$x\f$. !> @param[in] y - array of values in dense format. Must be pre-allocated with sufficient !> size to accommodate all indices specified in \p xInd. !> @param[out] myResult - pointer to the result, which can be host or device memory. !> @param[in] idxBase - index base. `HIPSPARSE_INDEX_BASE_ZERO` for zero-based indexing or !> `HIPSPARSE_INDEX_BASE_ONE` for one-based indexing. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle or \p result is nullptr, \p nnz is negative, !> \p xVal, \p xInd, or \p y is nullptr when \p nnz is greater than zero, or \p idxBase !> is neither `HIPSPARSE_INDEX_BASE_ZERO` nor `HIPSPARSE_INDEX_BASE_ONE`. !> \retval HIPSPARSE_STATUS_ALLOC_FAILED the buffer for the dot product reduction !> could not be allocated. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. #ifndef USE_CUDA_NAMES interface hipsparseSdoti function hipsparseSdoti_(handle,nnz,xVal,xInd,y,myResult,idxBase) bind(c, name="hipsparseSdoti") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSdoti_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: xVal type(c_ptr),value :: xInd type(c_ptr),value :: y type(c_ptr),value :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSdoti_assumed_rank #else module procedure & hipsparseSdoti_rank_0,& hipsparseSdoti_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDdoti function hipsparseDdoti_(handle,nnz,xVal,xInd,y,myResult,idxBase) bind(c, name="hipsparseDdoti") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDdoti_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: xVal type(c_ptr),value :: xInd type(c_ptr),value :: y type(c_ptr),value :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDdoti_assumed_rank #else module procedure & hipsparseDdoti_rank_0,& hipsparseDdoti_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCdoti function hipsparseCdoti_(handle,nnz,xVal,xInd,y,myResult,idxBase) bind(c, name="hipsparseCdoti") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCdoti_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: xVal type(c_ptr),value :: xInd type(c_ptr),value :: y type(c_ptr),value :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCdoti_assumed_rank #else module procedure & hipsparseCdoti_rank_0,& hipsparseCdoti_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZdoti function hipsparseZdoti_(handle,nnz,xVal,xInd,y,myResult,idxBase) bind(c, name="hipsparseZdoti") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZdoti_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: xVal type(c_ptr),value :: xInd type(c_ptr),value :: y type(c_ptr),value :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZdoti_assumed_rank #else module procedure & hipsparseZdoti_rank_0,& hipsparseZdoti_rank_1 #endif #endif end interface #endif !> \ingroup level1_module !> \brief Gather elements from a dense vector and store them in a sparse vector. !> !> \details !> \p hipsparseXgthr gathers the elements that are listed in \p xInd from the dense !> vector \f$y\f$ and stores them in the sparse vector \f$x\f$. !> !> \code{.c} !> for(i = 0; i < nnz; ++i) !> { !> xVal[i] = y[xInd[i]]; !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> If \p nnz is zero, the function returns successfully without modifying \p xVal. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 11.0+) and will be !> removed in CUDA 12.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] nnz - number of non-zero entries of \f$x\f$. Must be non-negative. !> @param[in] y - array of values in dense format. Must be pre-allocated with sufficient !> size to accommodate all indices specified in \p xInd. !> @param[out] xVal - array of \p nnz elements that will contain the gathered values of \f$x\f$. !> @param[in] xInd - array of \p nnz elements containing the indices of the non-zero !> values of \f$x\f$. !> @param[in] idxBase - index base. `HIPSPARSE_INDEX_BASE_ZERO` for zero-based indexing or !> `HIPSPARSE_INDEX_BASE_ONE` for one-based indexing. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle is nullptr, \p nnz is negative, !> \p y, \p xVal, or \p xInd is nullptr when \p nnz is greater than zero, or \p idxBase !> is neither `HIPSPARSE_INDEX_BASE_ZERO` nor `HIPSPARSE_INDEX_BASE_ONE`. #ifndef USE_CUDA_NAMES interface hipsparseSgthr function hipsparseSgthr_(handle,nnz,y,xVal,xInd,idxBase) bind(c, name="hipsparseSgthr") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgthr_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: y type(c_ptr),value :: xVal type(c_ptr),value :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSgthr_assumed_rank #else module procedure & hipsparseSgthr_rank_0,& hipsparseSgthr_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDgthr function hipsparseDgthr_(handle,nnz,y,xVal,xInd,idxBase) bind(c, name="hipsparseDgthr") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgthr_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: y type(c_ptr),value :: xVal type(c_ptr),value :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDgthr_assumed_rank #else module procedure & hipsparseDgthr_rank_0,& hipsparseDgthr_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCgthr function hipsparseCgthr_(handle,nnz,y,xVal,xInd,idxBase) bind(c, name="hipsparseCgthr") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgthr_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: y type(c_ptr),value :: xVal type(c_ptr),value :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCgthr_assumed_rank #else module procedure & hipsparseCgthr_rank_0,& hipsparseCgthr_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZgthr function hipsparseZgthr_(handle,nnz,y,xVal,xInd,idxBase) bind(c, name="hipsparseZgthr") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgthr_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: y type(c_ptr),value :: xVal type(c_ptr),value :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZgthr_assumed_rank #else module procedure & hipsparseZgthr_rank_0,& hipsparseZgthr_rank_1 #endif #endif end interface #endif !> \ingroup level1_module !> \brief Gather and zero out elements from a dense vector and store them in a sparse !> vector. !> !> \details !> \p hipsparseXgthrz gathers the elements that are listed in \p xInd from the dense !> vector \f$y\f$ and stores them in the sparse vector \f$x\f$. The gathered elements !> in \f$y\f$ are replaced by zero. !> !> \code{.c} !> for(i = 0; i < nnz; ++i) !> { !> xVal[i] = y[xInd[i]]; !> y[xInd[i]] = 0; !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> If \p nnz is zero, the function returns successfully without modifying \p xVal or \p y. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 11.0+) and will be !> removed in CUDA 12.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] nnz - number of non-zero entries of \f$x\f$. Must be non-negative. !> @param[inout] y - array of values in dense format. Must be pre-allocated with sufficient !> size to accommodate all indices specified in \p xInd. Gathered elements !> are set to zero. !> @param[out] xVal - array of \p nnz elements that will contain the gathered values of \f$x\f$. !> @param[in] xInd - array of \p nnz elements containing the indices of the non-zero !> values of \f$x\f$. !> @param[in] idxBase - index base. `HIPSPARSE_INDEX_BASE_ZERO` for zero-based indexing or !> `HIPSPARSE_INDEX_BASE_ONE` for one-based indexing. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle is nullptr, \p nnz is negative, !> \p y, \p xVal, or \p xInd is nullptr when \p nnz is greater than zero, or \p idxBase !> is neither `HIPSPARSE_INDEX_BASE_ZERO` nor `HIPSPARSE_INDEX_BASE_ONE`. #ifndef USE_CUDA_NAMES interface hipsparseSgthrz function hipsparseSgthrz_(handle,nnz,y,xVal,xInd,idxBase) bind(c, name="hipsparseSgthrz") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgthrz_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: y type(c_ptr),value :: xVal type(c_ptr),value :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSgthrz_assumed_rank #else module procedure & hipsparseSgthrz_rank_0,& hipsparseSgthrz_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDgthrz function hipsparseDgthrz_(handle,nnz,y,xVal,xInd,idxBase) bind(c, name="hipsparseDgthrz") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgthrz_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: y type(c_ptr),value :: xVal type(c_ptr),value :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDgthrz_assumed_rank #else module procedure & hipsparseDgthrz_rank_0,& hipsparseDgthrz_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCgthrz function hipsparseCgthrz_(handle,nnz,y,xVal,xInd,idxBase) bind(c, name="hipsparseCgthrz") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgthrz_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: y type(c_ptr),value :: xVal type(c_ptr),value :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCgthrz_assumed_rank #else module procedure & hipsparseCgthrz_rank_0,& hipsparseCgthrz_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZgthrz function hipsparseZgthrz_(handle,nnz,y,xVal,xInd,idxBase) bind(c, name="hipsparseZgthrz") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgthrz_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: y type(c_ptr),value :: xVal type(c_ptr),value :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZgthrz_assumed_rank #else module procedure & hipsparseZgthrz_rank_0,& hipsparseZgthrz_rank_1 #endif #endif end interface #endif !> \ingroup level1_module !> \brief Apply the Givens rotation to a dense and a sparse vector. !> !> \details !> \p hipsparseXroti applies the Givens rotation matrix \f$G\f$ to the sparse vector !> \f$x\f$ and the dense vector \f$y\f$, where !> \f[ !> G = \begin{pmatrix} c & s \\ -s & c \end{pmatrix} !> \f] !> !> \code{.c} !> for(i = 0; i < nnz; ++i) !> { !> x_tmp = xVal[i]; !> y_tmp = y[xInd[i]]; !> !> xVal[i] = c * x_tmp + s * y_tmp; !> y[xInd[i]] = c * y_tmp - s * x_tmp; !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> If \p nnz is zero, the function returns successfully without modifying \p xVal or \p y. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 11.0+) and will be !> removed in CUDA 12.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] nnz - number of non-zero entries of \f$x\f$. Must be non-negative. !> @param[inout] xVal - array of \p nnz elements containing the non-zero values of \f$x\f$. !> @param[in] xInd - array of \p nnz elements containing the indices of the non-zero !> values of \f$x\f$. !> @param[inout] y - array of values in dense format. Must be pre-allocated with sufficient !> size to accommodate all indices specified in \p xInd. !> @param[in] c - pointer to the cosine element of \f$G\f$, which can be on host or device. !> @param[in] s - pointer to the sine element of \f$G\f$, which can be on host or device. !> @param[in] idxBase - index base. `HIPSPARSE_INDEX_BASE_ZERO` for zero-based indexing or !> `HIPSPARSE_INDEX_BASE_ONE` for one-based indexing. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p c, or \p s is nullptr, \p nnz is !> negative, !> \p xVal, \p xInd, or \p y is nullptr when \p nnz is greater than zero, or \p idxBase !> is neither `HIPSPARSE_INDEX_BASE_ZERO` nor `HIPSPARSE_INDEX_BASE_ONE`. #ifndef USE_CUDA_NAMES interface hipsparseSroti function hipsparseSroti_(handle,nnz,xVal,xInd,y,c,s,idxBase) bind(c, name="hipsparseSroti") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSroti_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: xVal type(c_ptr),value :: xInd type(c_ptr),value :: y real(c_float) :: c real(c_float) :: s integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSroti_assumed_rank #else module procedure & hipsparseSroti_rank_0,& hipsparseSroti_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDroti function hipsparseDroti_(handle,nnz,xVal,xInd,y,c,s,idxBase) bind(c, name="hipsparseDroti") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDroti_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: xVal type(c_ptr),value :: xInd type(c_ptr),value :: y real(c_double) :: c real(c_double) :: s integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDroti_assumed_rank #else module procedure & hipsparseDroti_rank_0,& hipsparseDroti_rank_1 #endif #endif end interface #endif !> \ingroup level1_module !> \brief Scatter elements from a dense vector across a sparse vector. !> !> \details !> \p hipsparseXsctr scatters the elements that are listed in \p xInd from the sparse !> vector \f$x\f$ into the dense vector \f$y\f$. Indices of \f$y\f$ that are not listed !> in \p xInd remain unchanged. !> !> \code{.c} !> for(i = 0; i < nnz; ++i) !> { !> y[xInd[i]] = xVal[i]; !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> If \p nnz is zero, the function returns successfully without modifying \p y. !> Duplicate indices in \p xInd will result in the last value being written to \p y. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 11.0+) and will be !> removed in CUDA 12.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] nnz - number of non-zero entries of \f$x\f$. Must be non-negative. !> @param[in] xVal - array of \p nnz elements containing the non-zero values of \f$x\f$. !> @param[in] xInd - array of \p nnz elements containing the indices of the non-zero !> values of \f$x\f$. !> @param[inout] y - array of values in dense format. Must be pre-allocated with sufficient !> size to accommodate all indices specified in \p xInd. !> @param[in] idxBase - index base. `HIPSPARSE_INDEX_BASE_ZERO` for zero-based indexing or !> `HIPSPARSE_INDEX_BASE_ONE` for one-based indexing. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle is nullptr, \p nnz is negative, !> \p xVal, \p xInd, or \p y is nullptr when \p nnz is greater than zero, or \p idxBase !> is neither `HIPSPARSE_INDEX_BASE_ZERO` nor `HIPSPARSE_INDEX_BASE_ONE`. #ifndef USE_CUDA_NAMES interface hipsparseSsctr function hipsparseSsctr_(handle,nnz,xVal,xInd,y,idxBase) bind(c, name="hipsparseSsctr") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSsctr_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: xVal type(c_ptr),value :: xInd type(c_ptr),value :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSsctr_assumed_rank #else module procedure & hipsparseSsctr_rank_0,& hipsparseSsctr_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDsctr function hipsparseDsctr_(handle,nnz,xVal,xInd,y,idxBase) bind(c, name="hipsparseDsctr") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDsctr_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: xVal type(c_ptr),value :: xInd type(c_ptr),value :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDsctr_assumed_rank #else module procedure & hipsparseDsctr_rank_0,& hipsparseDsctr_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCsctr function hipsparseCsctr_(handle,nnz,xVal,xInd,y,idxBase) bind(c, name="hipsparseCsctr") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCsctr_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: xVal type(c_ptr),value :: xInd type(c_ptr),value :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCsctr_assumed_rank #else module procedure & hipsparseCsctr_rank_0,& hipsparseCsctr_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZsctr function hipsparseZsctr_(handle,nnz,xVal,xInd,y,idxBase) bind(c, name="hipsparseZsctr") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZsctr_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: xVal type(c_ptr),value :: xInd type(c_ptr),value :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZsctr_assumed_rank #else module procedure & hipsparseZsctr_rank_0,& hipsparseZsctr_rank_1 #endif #endif end interface #endif !> \ingroup level2_module !> \brief Sparse matrix vector multiplication using the BSR storage format. !> !> \details !> \p hipsparseXbsrmv multiplies the scalar \f$\alpha\f$ with a sparse !> \f$m \times n\f$ matrix, defined in BSR storage format, and the dense vector \f$x\f$ and adds !> the !> result to the dense vector \f$y\f$ that is multiplied by the scalar \f$\beta\f$, such that !> \f[ !> y := \alpha \cdot op(A) \cdot x + \beta \cdot y, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == HIPSPARSE_OPERATION_NON_TRANSPOSE} !> \end{array} !> \right. !> \f] !> and where \f$m = mb \times blockDim\f$ and \f$n= nb \times blockDim\f$. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p transA == `HIPSPARSE_OPERATION_NON_TRANSPOSE` is supported. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - matrix storage of BSR blocks. !> @param[in] transA - matrix operation type. !> @param[in] mb - number of block rows of the sparse BSR matrix. Must be non-negative. !> @param[in] nb - number of block columns of the sparse BSR matrix. Must be non-negative. !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix. Must be non-negative. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descrA - descriptor of the sparse BSR matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] bsrSortedValA - array of \p nnzb blocks of the sparse BSR matrix. !> @param[in] bsrSortedRowPtrA - array of \p mb+1 elements that point to the start of every !> block row of !> the sparse BSR matrix. !> @param[in] bsrSortedColIndA - array of \p nnzb elements containing the block column indices !> of the sparse !> BSR matrix. !> @param[in] blockDim - block dimension of the sparse BSR matrix. Must be positive. !> @param[in] x - array of \p nb*blockDim elements (\f$op(A) = A\f$) or \p mb*blockDim !> elements (\f$op(A) = A^T\f$ or \f$op(A) = A^H\f$). !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] y - array of \p mb*blockDim elements (\f$op(A) = A\f$) or \p nb*blockDim !> elements (\f$op(A) = A^T\f$ or \f$op(A) = A^H\f$). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p descrA, \p alpha, or \p beta is nullptr, !> \p mb, \p nb, or \p nnzb is negative, \p blockDim is less than or equal to zero, or !> \p bsrSortedValA, \p bsrSortedRowPtrA, \p bsrSortedColIndA, \p x, or \p y is nullptr. !> \retval HIPSPARSE_STATUS_ARCH_MISMATCH the device is not supported. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED \p transA is not `HIPSPARSE_OPERATION_NON_TRANSPOSE` !> or `hipsparseMatrixType_t` is not `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseSbsrmv #ifdef USE_CUDA_NAMES function hipsparseSbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) & bind(c, name="cusparseSbsrmv") #else function hipsparseSbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) & bind(c, name="hipsparseSbsrmv") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrmv_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb real(c_float) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: x real(c_float) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSbsrmv_assumed_rank #else module procedure & hipsparseSbsrmv_rank_0,& hipsparseSbsrmv_rank_1 #endif #endif end interface interface hipsparseDbsrmv #ifdef USE_CUDA_NAMES function hipsparseDbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) & bind(c, name="cusparseDbsrmv") #else function hipsparseDbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) & bind(c, name="hipsparseDbsrmv") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrmv_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb real(c_double) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: x real(c_double) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDbsrmv_assumed_rank #else module procedure & hipsparseDbsrmv_rank_0,& hipsparseDbsrmv_rank_1 #endif #endif end interface interface hipsparseCbsrmv #ifdef USE_CUDA_NAMES function hipsparseCbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) & bind(c, name="cusparseCbsrmv") #else function hipsparseCbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) & bind(c, name="hipsparseCbsrmv") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrmv_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb complex(c_float_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: x complex(c_float_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCbsrmv_assumed_rank #else module procedure & hipsparseCbsrmv_rank_0,& hipsparseCbsrmv_rank_1 #endif #endif end interface interface hipsparseZbsrmv #ifdef USE_CUDA_NAMES function hipsparseZbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) & bind(c, name="cusparseZbsrmv") #else function hipsparseZbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) & bind(c, name="hipsparseZbsrmv") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrmv_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb complex(c_double_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: x complex(c_double_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZbsrmv_assumed_rank #else module procedure & hipsparseZbsrmv_rank_0,& hipsparseZbsrmv_rank_1 #endif #endif end interface !> \ingroup level2_module !> \details !> \p hipsparseXbsrsv2_zeroPivot returns `HIPSPARSE_STATUS_ZERO_PIVOT` if either a !> structural or numerical zero has been found during `hipsparseSbsrsv2_analysis` !> "hipsparseXbsrsv2_analysis()" or `hipsparseSbsrsv2_solve` "hipsparseXbsrsv2_solve()" !> computation. The first zero pivot \f$j\f$ at \f$A_{j,j}\f$ is stored in \p position, !> using the same index base as the BSR matrix. !> !> \p position can be in host or device memory. If no zero pivot has been found, !> \p position is set to -1 and `HIPSPARSE_STATUS_SUCCESS` is returned instead. !> !> \note \p hipsparseXbsrsv2_zeroPivot is a blocking function. It might negatively !> influence performance. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 12.0+) and will be !> removed in CUDA 13.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[inout] position - pointer to zero pivot \f$j\f$, can be in host or device memory. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p info, or \p position is nullptr. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_ZERO_PIVOT zero pivot has been found. interface hipsparseXbsrsv2_zeroPivot #ifdef USE_CUDA_NAMES function hipsparseXbsrsv2_zeroPivot_(handle,myInfo,position) & bind(c, name="cusparseXbsrsv2_zeroPivot") #else function hipsparseXbsrsv2_zeroPivot_(handle,myInfo,position) & bind(c, name="hipsparseXbsrsv2_zeroPivot") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXbsrsv2_zeroPivot_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int) :: position end function end interface !> \ingroup level2_module !> \details !> \p hipsparseXbsrsv2_bufferSize returns the size of the temporary storage buffer in bytes !> that is required by `hipsparseSbsrsv2_analysis` "hipsparseXbsrsv2_analysis()" and !> `hipsparseSbsrsv2_solve` "hipsparseXbsrsv2_solve()". The temporary storage buffer must !> be allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - matrix storage of BSR blocks. !> @param[in] transA - matrix operation type. !> @param[in] mb - number of block rows of the sparse BSR matrix. !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix. !> @param[in] descrA - descriptor of the sparse BSR matrix. !> @param[in] bsrSortedValA - array of \p nnzb blocks of the sparse BSR matrix. !> @param[in] bsrSortedRowPtrA - array of \p mb+1 elements that point to the start of every !> block row of !> the sparse BSR matrix. !> @param[in] bsrSortedColIndA - array of \p nnz containing the block column indices of the !> sparse !> BSR matrix. !> @param[in] blockDim - block dimension of the sparse BSR matrix. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseSbsrsv2_analysis` "hipsparseXbsrsv2_analysis()" and !> `hipsparseSbsrsv2_solve` "hipsparseXbsrsv2_solve()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p mb, \p nnzb, \p blockDim, !> \p descr, \p bsrSortedValA, \p bsrSortedRowPtrA, \p bsrSortedColIndA, !> \p info, or \p pBufferSizeInBytes is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> \p transA == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE` or !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseSbsrsv2_bufferSize #ifdef USE_CUDA_NAMES function hipsparseSbsrsv2_bufferSize_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseSbsrsv2_bufferSize") #else function hipsparseSbsrsv2_bufferSize_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseSbsrsv2_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsv2_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSbsrsv2_bufferSize_assumed_rank #else module procedure & hipsparseSbsrsv2_bufferSize_rank_0,& hipsparseSbsrsv2_bufferSize_rank_1 #endif #endif end interface interface hipsparseDbsrsv2_bufferSize #ifdef USE_CUDA_NAMES function hipsparseDbsrsv2_bufferSize_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseDbsrsv2_bufferSize") #else function hipsparseDbsrsv2_bufferSize_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseDbsrsv2_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsv2_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDbsrsv2_bufferSize_assumed_rank #else module procedure & hipsparseDbsrsv2_bufferSize_rank_0,& hipsparseDbsrsv2_bufferSize_rank_1 #endif #endif end interface interface hipsparseCbsrsv2_bufferSize #ifdef USE_CUDA_NAMES function hipsparseCbsrsv2_bufferSize_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseCbsrsv2_bufferSize") #else function hipsparseCbsrsv2_bufferSize_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseCbsrsv2_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsv2_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCbsrsv2_bufferSize_assumed_rank #else module procedure & hipsparseCbsrsv2_bufferSize_rank_0,& hipsparseCbsrsv2_bufferSize_rank_1 #endif #endif end interface interface hipsparseZbsrsv2_bufferSize #ifdef USE_CUDA_NAMES function hipsparseZbsrsv2_bufferSize_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseZbsrsv2_bufferSize") #else function hipsparseZbsrsv2_bufferSize_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseZbsrsv2_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsv2_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZbsrsv2_bufferSize_assumed_rank #else module procedure & hipsparseZbsrsv2_bufferSize_rank_0,& hipsparseZbsrsv2_bufferSize_rank_1 #endif #endif end interface !> \ingroup level2_module !> \details !> \p hipsparseXbsrsv2_bufferSizeExt returns the size of the temporary storage buffer in bytes !> that is required by `hipsparseSbsrsv2_analysis` "hipsparseXbsrsv2_analysis()" and !> `hipsparseSbsrsv2_solve` "hipsparseXbsrsv2_solve()". The temporary storage buffer must be !> allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - matrix storage of BSR blocks. !> @param[in] transA - matrix operation type. !> @param[in] mb - number of block rows of the sparse BSR matrix. !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix. !> @param[in] descrA - descriptor of the sparse BSR matrix. !> @param[in] bsrSortedValA - array of \p nnzb blocks of the sparse BSR matrix. !> @param[in] bsrSortedRowPtrA - array of \p mb+1 elements that point to the start of every !> block row of !> the sparse BSR matrix. !> @param[in] bsrSortedColIndA - array of \p nnz containing the block column indices of the !> sparse !> BSR matrix. !> @param[in] blockDim - block dimension of the sparse BSR matrix. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseSbsrsv2_analysis` "hipsparseXbsrsv2_analysis()" and !> `hipsparseSbsrsv2_solve` "hipsparseXbsrsv2_solve()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p mb, \p nnzb, \p blockDim, !> \p descr, \p bsrSortedValA, \p bsrSortedRowPtrA, \p bsrSortedColIndA, !> \p info, or \p pBufferSizeInBytes is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> \p transA == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE` or !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseSbsrsv2_bufferSizeExt function hipsparseSbsrsv2_bufferSizeExt_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseSbsrsv2_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsv2_bufferSizeExt_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSbsrsv2_bufferSizeExt_assumed_rank #else module procedure & hipsparseSbsrsv2_bufferSizeExt_rank_0,& hipsparseSbsrsv2_bufferSizeExt_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDbsrsv2_bufferSizeExt function hipsparseDbsrsv2_bufferSizeExt_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseDbsrsv2_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsv2_bufferSizeExt_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDbsrsv2_bufferSizeExt_assumed_rank #else module procedure & hipsparseDbsrsv2_bufferSizeExt_rank_0,& hipsparseDbsrsv2_bufferSizeExt_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCbsrsv2_bufferSizeExt function hipsparseCbsrsv2_bufferSizeExt_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseCbsrsv2_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsv2_bufferSizeExt_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCbsrsv2_bufferSizeExt_assumed_rank #else module procedure & hipsparseCbsrsv2_bufferSizeExt_rank_0,& hipsparseCbsrsv2_bufferSizeExt_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZbsrsv2_bufferSizeExt function hipsparseZbsrsv2_bufferSizeExt_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseZbsrsv2_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsv2_bufferSizeExt_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZbsrsv2_bufferSizeExt_assumed_rank #else module procedure & hipsparseZbsrsv2_bufferSizeExt_rank_0,& hipsparseZbsrsv2_bufferSizeExt_rank_1 #endif #endif end interface #endif !> \ingroup level2_module !> \details !> \p hipsparseXbsrsv2_analysis performs the analysis step for `hipsparseSbsrsv2_solve` !> "hipsparseXbsrsv2_solve()". It is expected that this function will be executed only once !> for a given matrix and particular operation type. !> !> \note !> If the matrix sparsity pattern changes, the gathered information will become invalid. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - matrix storage of BSR blocks. !> @param[in] transA - matrix operation type. !> @param[in] mb - number of block rows of the sparse BSR matrix. !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix. !> @param[in] descrA - descriptor of the sparse BSR matrix. !> @param[in] bsrSortedValA - array of \p nnzb blocks of the sparse BSR matrix. !> @param[in] bsrSortedRowPtrA - array of \p mb+1 elements that point to the start of every !> block row of !> the sparse BSR matrix. !> @param[in] bsrSortedColIndA - array of \p nnz containing the block column indices of the !> sparse !> BSR matrix. !> @param[in] blockDim - block dimension of the sparse BSR matrix. !> @param[out] myInfo - structure that holds the information collected during !> the analysis step. !> @param[in] policy - `HIPSPARSE_SOLVE_POLICY_NO_LEVEL` or !> `HIPSPARSE_SOLVE_POLICY_USE_LEVEL`. !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p mb, \p nnzb, \p blockDim, !> \p descrA, \p bsrSortedRowPtrA, \p bsrSortedColIndA, \p info, or !> \p pBuffer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> \p transA == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE` or !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseSbsrsv2_analysis #ifdef USE_CUDA_NAMES function hipsparseSbsrsv2_analysis_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseSbsrsv2_analysis") #else function hipsparseSbsrsv2_analysis_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseSbsrsv2_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsv2_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSbsrsv2_analysis_assumed_rank #else module procedure & hipsparseSbsrsv2_analysis_rank_0,& hipsparseSbsrsv2_analysis_rank_1 #endif #endif end interface interface hipsparseDbsrsv2_analysis #ifdef USE_CUDA_NAMES function hipsparseDbsrsv2_analysis_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseDbsrsv2_analysis") #else function hipsparseDbsrsv2_analysis_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseDbsrsv2_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsv2_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDbsrsv2_analysis_assumed_rank #else module procedure & hipsparseDbsrsv2_analysis_rank_0,& hipsparseDbsrsv2_analysis_rank_1 #endif #endif end interface interface hipsparseCbsrsv2_analysis #ifdef USE_CUDA_NAMES function hipsparseCbsrsv2_analysis_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseCbsrsv2_analysis") #else function hipsparseCbsrsv2_analysis_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseCbsrsv2_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsv2_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCbsrsv2_analysis_assumed_rank #else module procedure & hipsparseCbsrsv2_analysis_rank_0,& hipsparseCbsrsv2_analysis_rank_1 #endif #endif end interface interface hipsparseZbsrsv2_analysis #ifdef USE_CUDA_NAMES function hipsparseZbsrsv2_analysis_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseZbsrsv2_analysis") #else function hipsparseZbsrsv2_analysis_(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseZbsrsv2_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsv2_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZbsrsv2_analysis_assumed_rank #else module procedure & hipsparseZbsrsv2_analysis_rank_0,& hipsparseZbsrsv2_analysis_rank_1 #endif #endif end interface !> \ingroup level2_module !> \brief Sparse triangular solve using the BSR storage format. !> !> \details !> \p hipsparseXbsrsv2_solve solves a sparse triangular linear system of a sparse !> \f$m \times m\f$ matrix, defined in BSR storage format, a dense solution vector !> \f$y\f$ and the right-hand side \f$x\f$ that is multiplied by \f$\alpha\f$, such that !> \f[ !> op(A) \cdot y = \alpha \cdot x, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> A^T, & \text{if trans == HIPSPARSE_OPERATION_TRANSPOSE} !> \end{array} !> \right. !> \f] !> !> Performing the above operation requires three steps. First, the user calls !> `hipsparseSbsrsv2_bufferSize` "hipsparseXbsrsv2_bufferSize()", which will determine the size !> of the required !> temporary storage buffer. The user then allocates this buffer and calls !> `hipsparseSbsrsv2_analysis` "hipsparseXbsrsv2_analysis()", which will perform analysis on the !> sparse matrix !> \f$op(A)\f$. Finally, the user completes the computation by calling \p !> hipsparseXbsrsv2_solve. The buffer size, !> buffer allocation, and analysis only need to be called once for a given sparse matrix !> \f$op(A)\f$, while the !> computation stage can be repeatedly used with different \f$x\f$ and \f$y\f$ vectors. After !> all calls to !> \p hipsparseXbsrsv2_solve are complete, the temporary buffer can be deallocated. !> !> Solving a triangular system involves inverting the diagonal blocks. This means that if the !> sparse matrix is !> missing the diagonal block (referred to as a structural zero) or the diagonal block is not !> invertible (referred !> to as a numerical zero) then a solution is not possible. \p hipsparseXbsrsv2_solve tracks the !> location of the first !> zero pivot (either numerical or structural zero). The zero pivot status can be checked !> calling `hipsparseXbsrsv2_zeroPivot` (). !> If `hipsparseXbsrsv2_zeroPivot` () returns `HIPSPARSE_STATUS_SUCCESS`, then no zero pivot was !> found and therefore !> the matrix does not have a structural or numerical zero. !> !> The user can specify that the sparse matrix should be interpreted as having identity blocks !> on the diagonal by setting the diagonal !> type on the descriptor \p descrA to `HIPSPARSE_DIAG_TYPE_UNIT` using !> `hipsparseSetMatDiagType`. If !> `hipsparseDiagType_t` == `HIPSPARSE_DIAG_TYPE_UNIT`, no zero pivot will be reported, even if !> the diagonal block \f$A_{j,j}\f$ !> for some \f$j\f$ is not invertible. !> !> The sparse CSR matrix passed to \p hipsparseXbsrsv2_solve does not actually have to be a !> triangular matrix. Instead, the !> triangular upper or lower part of the sparse matrix is solved based on `hipsparseFillMode_t` !> set on the descriptor !> \p descrA. If the fill mode is set to `HIPSPARSE_FILL_MODE_LOWER`, then the lower triangular !> matrix is solved. If the !> fill mode is set to `HIPSPARSE_FILL_MODE_UPPER`, then the upper triangular matrix is solved. !> !> \note !> The sparse BSR matrix has to be sorted. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p transA == `HIPSPARSE_OPERATION_NON_TRANSPOSE` and !> \p transA == `HIPSPARSE_OPERATION_TRANSPOSE` is supported. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - matrix storage of BSR blocks. !> @param[in] transA - matrix operation type. !> @param[in] mb - number of block rows of the sparse BSR matrix. !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descrA - descriptor of the sparse BSR matrix. !> @param[in] bsrSortedValA - array of \p nnzb blocks of the sparse BSR matrix. !> @param[in] bsrSortedRowPtrA - array of \p mb+1 elements that point to the start of every !> block row of !> the sparse BSR matrix. !> @param[in] bsrSortedColIndA - array of \p nnz containing the block column indices of the !> sparse !> BSR matrix. !> @param[in] blockDim - block dimension of the sparse BSR matrix. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] f - array of \p m elements, holding the right-hand side. !> @param[out] x - array of \p m elements, holding the solution. !> @param[in] policy - `HIPSPARSE_SOLVE_POLICY_NO_LEVEL` or !> `HIPSPARSE_SOLVE_POLICY_USE_LEVEL`. !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p mb, \p nnzb, \p blockDim, !> \p descrA, \p alpha, \p bsrSortedValA, \p bsrSortedRowPtrA, \p bsrSortedColIndA, !> \p f, or \p x is invalid. !> \retval HIPSPARSE_STATUS_ARCH_MISMATCH the device is not supported. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> \p transA == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE` or !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseSbsrsv2_solve #ifdef USE_CUDA_NAMES function hipsparseSbsrsv2_solve_(handle,dirA,transA,mb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) & bind(c, name="cusparseSbsrsv2_solve") #else function hipsparseSbsrsv2_solve_(handle,dirA,transA,mb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) & bind(c, name="hipsparseSbsrsv2_solve") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsv2_solve_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nnzb real(c_float) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo type(c_ptr),value :: f type(c_ptr),value :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSbsrsv2_solve_assumed_rank #else module procedure & hipsparseSbsrsv2_solve_rank_0,& hipsparseSbsrsv2_solve_rank_1 #endif #endif end interface interface hipsparseDbsrsv2_solve #ifdef USE_CUDA_NAMES function hipsparseDbsrsv2_solve_(handle,dirA,transA,mb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) & bind(c, name="cusparseDbsrsv2_solve") #else function hipsparseDbsrsv2_solve_(handle,dirA,transA,mb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) & bind(c, name="hipsparseDbsrsv2_solve") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsv2_solve_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nnzb real(c_double) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo type(c_ptr),value :: f type(c_ptr),value :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDbsrsv2_solve_assumed_rank #else module procedure & hipsparseDbsrsv2_solve_rank_0,& hipsparseDbsrsv2_solve_rank_1 #endif #endif end interface interface hipsparseCbsrsv2_solve #ifdef USE_CUDA_NAMES function hipsparseCbsrsv2_solve_(handle,dirA,transA,mb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) & bind(c, name="cusparseCbsrsv2_solve") #else function hipsparseCbsrsv2_solve_(handle,dirA,transA,mb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) & bind(c, name="hipsparseCbsrsv2_solve") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsv2_solve_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nnzb complex(c_float_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo type(c_ptr),value :: f type(c_ptr),value :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCbsrsv2_solve_assumed_rank #else module procedure & hipsparseCbsrsv2_solve_rank_0,& hipsparseCbsrsv2_solve_rank_1 #endif #endif end interface interface hipsparseZbsrsv2_solve #ifdef USE_CUDA_NAMES function hipsparseZbsrsv2_solve_(handle,dirA,transA,mb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) & bind(c, name="cusparseZbsrsv2_solve") #else function hipsparseZbsrsv2_solve_(handle,dirA,transA,mb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) & bind(c, name="hipsparseZbsrsv2_solve") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsv2_solve_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: mb integer(c_int),value :: nnzb complex(c_double_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo type(c_ptr),value :: f type(c_ptr),value :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZbsrsv2_solve_assumed_rank #else module procedure & hipsparseZbsrsv2_solve_rank_0,& hipsparseZbsrsv2_solve_rank_1 #endif #endif end interface !> \ingroup level2_module !> \brief Sparse matrix vector multiplication with mask operation using the BSR storage format. !> !> \details !> \p hipsparseXbsrxmv multiplies the scalar \f$\alpha\f$ with a sparse !> \f$(mb \times \text{blockDim}) \times (nb \times \text{blockDim})\f$ !> modified matrix, defined in BSR storage format, and the dense vector \f$x\f$ and adds the !> result to the dense vector \f$y\f$ that is multiplied by the scalar \f$\beta\f$, !> such that !> \f[ !> y := \left( \alpha \cdot op(A) \cdot x + \beta \cdot y \right)\left( \text{mask} \right), !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> A^T, & \text{if trans == HIPSPARSE_OPERATION_TRANSPOSE} \\% !> A^H, & \text{if trans == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} !> \end{array} !> \right. !> \f] !> !> The \f$\text{mask}\f$ is defined as an array of block row indices. !> The input sparse matrix is defined with a modified BSR storage format where the beginning and !> the end of each row !> is defined with two arrays, \p bsrRowPtr and \p bsr_end_ptr (both of size \p mb), rather the !> usual \p bsrRowPtr of size \p mb+1. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p trans == `HIPSPARSE_OPERATION_NON_TRANSPOSE` is supported, !> and \p blockDim == 1 is not supported. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 12.0+) and will be !> removed in CUDA 13.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dir - matrix storage of BSR blocks. !> @param[in] trans - matrix operation type. !> @param[in] sizeOfMask - number of updated block rows of the array \p y. Must be non-negative !> and !> not greater than \p mb. !> @param[in] mb - number of block rows of the sparse BSR matrix. Must be non-negative. !> @param[in] nb - number of block columns of the sparse BSR matrix. Must be non-negative. !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix. Must be non-negative. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr - descriptor of the sparse BSR matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] bsrVal - array of \p nnzb blocks of the sparse BSR matrix. !> @param[in] bsrMaskPtr - array of \p sizeOfMask elements that give the indices of the updated !> block rows. !> @param[in] bsrRowPtr - array of \p mb elements that point to the start of every block row of !> the sparse BSR matrix. !> @param[in] bsrEndPtr - array of \p mb elements that point to the end of every block row of !> the sparse BSR matrix. !> @param[in] bsrColInd - array of \p nnzb elements containing the block column indices of the !> sparse !> BSR matrix. !> @param[in] blockDim - block dimension of the sparse BSR matrix. Must be greater than 1. !> @param[in] x - array of \p nb*blockDim elements (\f$op(A) = A\f$) or \p mb*blockDim !> elements (\f$op(A) = A^T\f$ or \f$op(A) = A^H\f$). !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] y - array of \p mb*blockDim elements (\f$op(A) = A\f$) or \p nb*blockDim !> elements (\f$op(A) = A^T\f$ or \f$op(A) = A^H\f$). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p descr, \p alpha, or \p beta is nullptr, !> \p mb, \p nb, \p nnzb, or \p sizeOfMask is negative, \p sizeOfMask is greater than \p !> mb, !> \p blockDim is less than or equal to 1, or \p bsrVal, \p bsrMaskPtr, \p bsrRowPtr, !> \p bsrEndPtr, \p bsrColInd, \p x, or \p y is nullptr. !> \retval HIPSPARSE_STATUS_ARCH_MISMATCH the device is not supported. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED \p trans is not `HIPSPARSE_OPERATION_NON_TRANSPOSE`, !> or `hipsparseMatrixType_t` is not `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseSbsrxmv #ifdef USE_CUDA_NAMES function hipsparseSbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr,bsrVal, & bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) & bind(c, name="cusparseSbsrxmv") #else function hipsparseSbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr,bsrVal, & bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) & bind(c, name="hipsparseSbsrxmv") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrxmv_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dir integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: trans integer(c_int),value :: sizeOfMask integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb real(c_float) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsrVal type(c_ptr),value :: bsrMaskPtr type(c_ptr),value :: bsrRowPtr type(c_ptr),value :: bsrEndPtr type(c_ptr),value :: bsrColInd integer(c_int),value :: blockDim type(c_ptr),value :: x real(c_float) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSbsrxmv_assumed_rank #else module procedure & hipsparseSbsrxmv_rank_0,& hipsparseSbsrxmv_rank_1 #endif #endif end interface interface hipsparseDbsrxmv #ifdef USE_CUDA_NAMES function hipsparseDbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr,bsrVal, & bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) & bind(c, name="cusparseDbsrxmv") #else function hipsparseDbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr,bsrVal, & bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) & bind(c, name="hipsparseDbsrxmv") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrxmv_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dir integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: trans integer(c_int),value :: sizeOfMask integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb real(c_double) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsrVal type(c_ptr),value :: bsrMaskPtr type(c_ptr),value :: bsrRowPtr type(c_ptr),value :: bsrEndPtr type(c_ptr),value :: bsrColInd integer(c_int),value :: blockDim type(c_ptr),value :: x real(c_double) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDbsrxmv_assumed_rank #else module procedure & hipsparseDbsrxmv_rank_0,& hipsparseDbsrxmv_rank_1 #endif #endif end interface interface hipsparseCbsrxmv #ifdef USE_CUDA_NAMES function hipsparseCbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr,bsrVal, & bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) & bind(c, name="cusparseCbsrxmv") #else function hipsparseCbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr,bsrVal, & bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) & bind(c, name="hipsparseCbsrxmv") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrxmv_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dir integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: trans integer(c_int),value :: sizeOfMask integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb complex(c_float_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsrVal type(c_ptr),value :: bsrMaskPtr type(c_ptr),value :: bsrRowPtr type(c_ptr),value :: bsrEndPtr type(c_ptr),value :: bsrColInd integer(c_int),value :: blockDim type(c_ptr),value :: x complex(c_float_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCbsrxmv_assumed_rank #else module procedure & hipsparseCbsrxmv_rank_0,& hipsparseCbsrxmv_rank_1 #endif #endif end interface interface hipsparseZbsrxmv #ifdef USE_CUDA_NAMES function hipsparseZbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr,bsrVal, & bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) & bind(c, name="cusparseZbsrxmv") #else function hipsparseZbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr,bsrVal, & bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) & bind(c, name="hipsparseZbsrxmv") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrxmv_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dir integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: trans integer(c_int),value :: sizeOfMask integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb complex(c_double_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsrVal type(c_ptr),value :: bsrMaskPtr type(c_ptr),value :: bsrRowPtr type(c_ptr),value :: bsrEndPtr type(c_ptr),value :: bsrColInd integer(c_int),value :: blockDim type(c_ptr),value :: x complex(c_double_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZbsrxmv_assumed_rank #else module procedure & hipsparseZbsrxmv_rank_0,& hipsparseZbsrxmv_rank_1 #endif #endif end interface !> \ingroup level2_module !> \brief Sparse matrix vector multiplication using the CSR storage format. !> !> \details !> \p hipsparseXcsrmv multiplies the scalar \f$\alpha\f$ with a sparse \f$m \times n\f$ !> matrix, defined in CSR storage format, and the dense vector \f$x\f$ and adds the !> result to the dense vector \f$y\f$ that is multiplied by the scalar \f$\beta\f$, !> such that !> \f[ !> y := \alpha \cdot op(A) \cdot x + \beta \cdot y, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if transA == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> A^T, & \text{if transA == HIPSPARSE_OPERATION_TRANSPOSE} \\% !> A^H, & \text{if transA == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} !> \end{array} !> \right. !> \f] !> !> \code{.c} !> for(i = 0; i < m; ++i) !> { !> y[i] = beta * y[i]; !> !> for(j = csrRowPtr[i]; j < csrRowPtr[i + 1]; ++j) !> { !> y[i] = y[i] + alpha * csrVal[j] * x[csrColInd[j]]; !> } !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p transA == `HIPSPARSE_OPERATION_NON_TRANSPOSE` is supported. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 10.0+) and will be !> removed in CUDA 11.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] transA - matrix operation type. !> @param[in] m - number of rows of the sparse CSR matrix. Must be non-negative. !> @param[in] n - number of columns of the sparse CSR matrix. Must be non-negative. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. Must be non-negative. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descrA - descriptor of the sparse CSR matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrSortedValA - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start !> of every row of the sparse CSR matrix. !> @param[in] csrSortedColIndA - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix. !> @param[in] x - array of \p n elements (\f$op(A) == A\f$) or \p m elements !> (\f$op(A) == A^T\f$ or \f$op(A) == A^H\f$). !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] y - array of \p m elements (\f$op(A) == A\f$) or \p n elements !> (\f$op(A) == A^T\f$ or \f$op(A) == A^H\f$). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p descrA, \p alpha, or \p beta is nullptr, !> \p m, \p n, or \p nnz is negative, or \p csrSortedValA, \p csrSortedRowPtrA, !> \p csrSortedColIndA, \p x, or \p y is nullptr. !> \retval HIPSPARSE_STATUS_ARCH_MISMATCH the device is not supported. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED `hipsparseMatrixType_t` is not !> `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseScsrmv function hipsparseScsrmv_(handle,transA,m,n,nnz,alpha,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,x,beta,y) & bind(c, name="hipsparseScsrmv") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrmv_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz real(c_float) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: x real(c_float) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrmv_assumed_rank #else module procedure & hipsparseScsrmv_rank_0,& hipsparseScsrmv_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsrmv function hipsparseDcsrmv_(handle,transA,m,n,nnz,alpha,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,x,beta,y) & bind(c, name="hipsparseDcsrmv") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrmv_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz real(c_double) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: x real(c_double) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrmv_assumed_rank #else module procedure & hipsparseDcsrmv_rank_0,& hipsparseDcsrmv_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsrmv function hipsparseCcsrmv_(handle,transA,m,n,nnz,alpha,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,x,beta,y) & bind(c, name="hipsparseCcsrmv") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrmv_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz complex(c_float_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: x complex(c_float_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrmv_assumed_rank #else module procedure & hipsparseCcsrmv_rank_0,& hipsparseCcsrmv_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsrmv function hipsparseZcsrmv_(handle,transA,m,n,nnz,alpha,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,x,beta,y) & bind(c, name="hipsparseZcsrmv") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrmv_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz complex(c_double_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: x complex(c_double_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrmv_assumed_rank #else module procedure & hipsparseZcsrmv_rank_0,& hipsparseZcsrmv_rank_1 #endif #endif end interface #endif !> \ingroup level2_module !> \details !> \p hipsparseXcsrsv2_zeroPivot returns `HIPSPARSE_STATUS_ZERO_PIVOT` if either a !> structural or numerical zero has been found during `hipsparseScsrsv2_solve()`, !> hipsparseDcsrsv2_solve(), hipsparseCcsrsv2_solve(), or hipsparseZcsrsv2_solve() !> computation. The first zero pivot \f$j\f$ at \f$A_{j,j}\f$ is stored in \p position, !> using same index base as the CSR matrix. !> !> \p position can be in host or device memory. If no zero pivot has been found, !> \p position is set to -1 and `HIPSPARSE_STATUS_SUCCESS` is returned instead. !> !> \note \p hipsparseXcsrsv2_zeroPivot is a blocking function. It might negatively !> influence performance. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 11.0+) and will be !> removed in CUDA 12.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[inout] position - pointer to zero pivot \f$j\f$, which can be in host or device !> memory. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p info, or \p position is nullptr. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_ZERO_PIVOT zero pivot has been found. #ifndef USE_CUDA_NAMES interface hipsparseXcsrsv2_zeroPivot function hipsparseXcsrsv2_zeroPivot_(handle,myInfo,position) & bind(c, name="hipsparseXcsrsv2_zeroPivot") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrsv2_zeroPivot_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int) :: position end function end interface #endif !> \ingroup level2_module !> \details !> \p hipsparseXcsrsv2_bufferSize returns the size of the temporary storage buffer in bytes !> that is required by `hipsparseScsrsv2_analysis` "`hipsparseScsrsv2_analysis()`" and !> `hipsparseScsrsv2_solve` "hipsparseXcsrsv2_solve()". The temporary storage buffer must !> be allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] transA - matrix operation type. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descrA - descriptor of the sparse CSR matrix. !> @param[in] csrSortedValA - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix. !> @param[in] csrSortedColIndA - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseScsrsv2_analysis` "hipsparseXcsrsv2_analysis()" and !> `hipsparseScsrsv2_solve` "hipsparseXcsrsv2_solve()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p nnz, \p descrA, \p csrSortedValA, !> \p csrSortedRowPtrA, \p csrSortedColIndA, \p info, or \p pBufferSizeInBytes is !> invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> \p transA == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE` or !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseScsrsv2_bufferSize function hipsparseScsrsv2_bufferSize_(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseScsrsv2_bufferSize") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsv2_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrsv2_bufferSize_assumed_rank #else module procedure & hipsparseScsrsv2_bufferSize_rank_0,& hipsparseScsrsv2_bufferSize_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsrsv2_bufferSize function hipsparseDcsrsv2_bufferSize_(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseDcsrsv2_bufferSize") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsv2_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrsv2_bufferSize_assumed_rank #else module procedure & hipsparseDcsrsv2_bufferSize_rank_0,& hipsparseDcsrsv2_bufferSize_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsrsv2_bufferSize function hipsparseCcsrsv2_bufferSize_(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseCcsrsv2_bufferSize") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsv2_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrsv2_bufferSize_assumed_rank #else module procedure & hipsparseCcsrsv2_bufferSize_rank_0,& hipsparseCcsrsv2_bufferSize_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsrsv2_bufferSize function hipsparseZcsrsv2_bufferSize_(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseZcsrsv2_bufferSize") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsv2_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrsv2_bufferSize_assumed_rank #else module procedure & hipsparseZcsrsv2_bufferSize_rank_0,& hipsparseZcsrsv2_bufferSize_rank_1 #endif #endif end interface #endif !> \ingroup level2_module !> \details !> \p hipsparseXcsrsv2_bufferSizeExt returns the size of the temporary storage buffer in bytes !> that is required by `hipsparseScsrsv2_analysis` "hipsparseXcsrsv2_analysis()" and !> `hipsparseScsrsv2_solve` "`hipsparseScsrsv2_solve()`". The temporary storage buffer must be !> allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] transA - matrix operation type. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descrA - descriptor of the sparse CSR matrix. !> @param[in] csrSortedValA - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix. !> @param[in] csrSortedColIndA - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseScsrsv2_analysis` "hipsparseXcsrsv2_analysis()" and !> `hipsparseScsrsv2_solve` "hipsparseXcsrsv2_solve()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p nnz, \p descrA, \p csrSortedValA, !> \p csrSortedRowPtrA, \p csrSortedColIndA, \p info, or \p pBufferSizeInBytes is !> invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> \p transA == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE` or !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseScsrsv2_bufferSizeExt function hipsparseScsrsv2_bufferSizeExt_(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseScsrsv2_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsv2_bufferSizeExt_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrsv2_bufferSizeExt_assumed_rank #else module procedure & hipsparseScsrsv2_bufferSizeExt_rank_0,& hipsparseScsrsv2_bufferSizeExt_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsrsv2_bufferSizeExt function hipsparseDcsrsv2_bufferSizeExt_(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseDcsrsv2_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsv2_bufferSizeExt_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrsv2_bufferSizeExt_assumed_rank #else module procedure & hipsparseDcsrsv2_bufferSizeExt_rank_0,& hipsparseDcsrsv2_bufferSizeExt_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsrsv2_bufferSizeExt function hipsparseCcsrsv2_bufferSizeExt_(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseCcsrsv2_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsv2_bufferSizeExt_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrsv2_bufferSizeExt_assumed_rank #else module procedure & hipsparseCcsrsv2_bufferSizeExt_rank_0,& hipsparseCcsrsv2_bufferSizeExt_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsrsv2_bufferSizeExt function hipsparseZcsrsv2_bufferSizeExt_(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseZcsrsv2_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsv2_bufferSizeExt_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrsv2_bufferSizeExt_assumed_rank #else module procedure & hipsparseZcsrsv2_bufferSizeExt_rank_0,& hipsparseZcsrsv2_bufferSizeExt_rank_1 #endif #endif end interface #endif !> \ingroup level2_module !> \details !> \p hipsparseXcsrsv2_analysis performs the analysis step for !> `hipsparseScsrsv2_solve` "hipsparseXcsrsv2_solve()". It is expected that this !> function will be executed only once for a given matrix and particular operation !> type. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] transA - matrix operation type. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descrA - descriptor of the sparse CSR matrix. !> @param[in] csrSortedValA - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix. !> @param[in] csrSortedColIndA - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix. !> @param[out] myInfo - structure that holds the information collected during !> the analysis step. !> @param[in] policy - `HIPSPARSE_SOLVE_POLICY_NO_LEVEL` or !> `HIPSPARSE_SOLVE_POLICY_USE_LEVEL`. !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p nnz, \p descr, !> \p csrSortedRowPtrA, \p csrSortedColIndA, \p info, or \p pBuffer is !> invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> \p transA == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE` or !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseScsrsv2_analysis function hipsparseScsrsv2_analysis_(handle,transA,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseScsrsv2_analysis") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsv2_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrsv2_analysis_assumed_rank #else module procedure & hipsparseScsrsv2_analysis_rank_0,& hipsparseScsrsv2_analysis_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsrsv2_analysis function hipsparseDcsrsv2_analysis_(handle,transA,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseDcsrsv2_analysis") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsv2_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrsv2_analysis_assumed_rank #else module procedure & hipsparseDcsrsv2_analysis_rank_0,& hipsparseDcsrsv2_analysis_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsrsv2_analysis function hipsparseCcsrsv2_analysis_(handle,transA,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseCcsrsv2_analysis") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsv2_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrsv2_analysis_assumed_rank #else module procedure & hipsparseCcsrsv2_analysis_rank_0,& hipsparseCcsrsv2_analysis_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsrsv2_analysis function hipsparseZcsrsv2_analysis_(handle,transA,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseZcsrsv2_analysis") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsv2_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrsv2_analysis_assumed_rank #else module procedure & hipsparseZcsrsv2_analysis_rank_0,& hipsparseZcsrsv2_analysis_rank_1 #endif #endif end interface #endif !> \ingroup level2_module !> \brief Sparse triangular solve using the CSR storage format !> !> \details !> \p hipsparseXcsrsv2_solve solves a sparse triangular linear system of a sparse !> \f$m \times m\f$ matrix, defined in CSR storage format, a dense solution vector !> \f$y\f$, and the right-hand side \f$x\f$ that is multiplied by \f$\alpha\f$, such that !> \f[ !> op(A) \cdot y = \alpha \cdot x, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> A^T, & \text{if trans == HIPSPARSE_OPERATION_TRANSPOSE} \\% !> A^H, & \text{if trans == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} !> \end{array} !> \right. !> \f] !> !> Performing the above operation requires three steps. First, the user calls !> `hipsparseScsrsv2_bufferSize` "hipsparseXcsrsv2_bufferSize()" (or !> `hipsparseScsrsv2_bufferSizeExt` "hipsparseXcsrsv2_bufferSizeExt()") which will determine the !> size of the !> required temporary storage buffer. The user then allocates this buffer and calls !> `hipsparseScsrsv2_analysis` "hipsparseXcsrsv2_analysis()" which will perform analysis on the !> sparse matrix !> \f$op(A)\f$. Finally, the user completes the computation by calling \p !> hipsparseXcsrsv2_solve. The buffer size, !> buffer allocation, and analysis only need to be called once for a given sparse matrix !> \f$op(A)\f$, while the !> computation stage can be repeatedly used with different \f$x\f$ and \f$y\f$ vectors. After !> all calls to !> \p hipsparseXcsrsv2_solve are complete, the temporary buffer can be deallocated. !> !> Solving a triangular system involves division by the diagonal elements. This means that if !> the sparse matrix is !> missing the diagonal entry (referred to as a structural zero) or the diagonal entry is zero !> (referred to as a numerical zero), !> then a division by zero would occur. \p hipsparseXcsrsv2_solve tracks the location of the !> first zero pivot (either numerical !> or structural zero). The zero pivot status can be checked by calling !> `hipsparseXcsrsv2_zeroPivot` (). If !> `hipsparseXcsrsv2_zeroPivot` () returns `HIPSPARSE_STATUS_SUCCESS`, then no zero pivot was !> found and therefore !> the matrix does not have a structural or numerical zero. !> !> The user can specify that the sparse matrix should be interpreted as having ones on the !> diagonal by setting the diagonal type !> on the descriptor \p descrA to `HIPSPARSE_DIAG_TYPE_UNIT` using `hipsparseSetMatDiagType`. If !> `hipsparseDiagType_t` == `HIPSPARSE_DIAG_TYPE_UNIT`, no zero pivot will be reported, even if !> \f$A_{j,j} = 0\f$ for !> some \f$j\f$. !> !> The sparse CSR matrix passed to \p hipsparseXcsrsv2_solve does not actually have to be a !> triangular matrix. Instead, the !> triangular upper or lower part of the sparse matrix is solved based on `hipsparseFillMode_t` !> set on the descriptor !> \p descrA. If the fill mode is set to `HIPSPARSE_FILL_MODE_LOWER`, then the lower triangular !> matrix is solved. If the !> fill mode is set to `HIPSPARSE_FILL_MODE_UPPER`, then the upper triangular matrix is solved. !> !> \note !> The sparse CSR matrix has to be sorted. This can be achieved by calling !> `hipsparseXcsrsort()`. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p transA == `HIPSPARSE_OPERATION_NON_TRANSPOSE` and !> \p transA == `HIPSPARSE_OPERATION_TRANSPOSE` is supported. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] transA - matrix operation type. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descrA - descriptor of the sparse CSR matrix. !> @param[in] csrSortedValA - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start !> of every row of the sparse CSR matrix. !> @param[in] csrSortedColIndA - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] f - array of \p m elements, holding the right-hand side. !> @param[out] x - array of \p m elements, holding the solution. !> @param[in] policy - `HIPSPARSE_SOLVE_POLICY_NO_LEVEL` or !> `HIPSPARSE_SOLVE_POLICY_USE_LEVEL`. !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p nnz, \p descrA, !> \p alpha, \p csrSortedValA, \p csrSortedRowPtrA, \p csrSortedColIndA, !> \p f, or \p x is invalid. !> \retval HIPSPARSE_STATUS_ARCH_MISMATCH the device is not supported. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> \p transA == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE` or !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseScsrsv2_solve function hipsparseScsrsv2_solve_(handle,transA,m,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,f,x,policy,pBuffer) & bind(c, name="hipsparseScsrsv2_solve") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsv2_solve_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: nnz real(c_float) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo type(c_ptr),value :: f type(c_ptr),value :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrsv2_solve_assumed_rank #else module procedure & hipsparseScsrsv2_solve_rank_0,& hipsparseScsrsv2_solve_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsrsv2_solve function hipsparseDcsrsv2_solve_(handle,transA,m,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,f,x,policy,pBuffer) & bind(c, name="hipsparseDcsrsv2_solve") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsv2_solve_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: nnz real(c_double) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo type(c_ptr),value :: f type(c_ptr),value :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrsv2_solve_assumed_rank #else module procedure & hipsparseDcsrsv2_solve_rank_0,& hipsparseDcsrsv2_solve_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsrsv2_solve function hipsparseCcsrsv2_solve_(handle,transA,m,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,f,x,policy,pBuffer) & bind(c, name="hipsparseCcsrsv2_solve") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsv2_solve_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: nnz complex(c_float_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo type(c_ptr),value :: f type(c_ptr),value :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrsv2_solve_assumed_rank #else module procedure & hipsparseCcsrsv2_solve_rank_0,& hipsparseCcsrsv2_solve_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsrsv2_solve function hipsparseZcsrsv2_solve_(handle,transA,m,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,f,x,policy,pBuffer) & bind(c, name="hipsparseZcsrsv2_solve") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsv2_solve_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: nnz complex(c_double_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo type(c_ptr),value :: f type(c_ptr),value :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrsv2_solve_assumed_rank #else module procedure & hipsparseZcsrsv2_solve_rank_0,& hipsparseZcsrsv2_solve_rank_1 #endif #endif end interface #endif !> \ingroup level2_module !> \details !> \p hipsparseXgemvi_bufferSize returns the size of the temporary storage buffer in bytes !> required by `hipsparseSgemvi` "hipsparseXgemvi()". The temporary storage buffer must !> be allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] transA - matrix operation type. !> @param[in] m - number of rows of the dense matrix. !> @param[in] n - number of columns of the dense matrix. !> @param[in] nnz - number of non-zero entries in the sparse vector. !> @param[out] pBufferSizeInBytes - temporary storage buffer size. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p nnz, or !> \p pBufferSizeInBytes is invalid. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> \p transA != `HIPSPARSE_OPERATION_NON_TRANSPOSE` or !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseSgemvi_bufferSize #ifdef USE_CUDA_NAMES function hipsparseSgemvi_bufferSize_(handle,transA,m,n,nnz,pBufferSizeInBytes) & bind(c, name="cusparseSgemvi_bufferSize") #else function hipsparseSgemvi_bufferSize_(handle,transA,m,n,nnz,pBufferSizeInBytes) & bind(c, name="hipsparseSgemvi_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgemvi_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz integer(c_int) :: pBufferSizeInBytes end function end interface interface hipsparseDgemvi_bufferSize #ifdef USE_CUDA_NAMES function hipsparseDgemvi_bufferSize_(handle,transA,m,n,nnz,pBufferSizeInBytes) & bind(c, name="cusparseDgemvi_bufferSize") #else function hipsparseDgemvi_bufferSize_(handle,transA,m,n,nnz,pBufferSizeInBytes) & bind(c, name="hipsparseDgemvi_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgemvi_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz integer(c_int) :: pBufferSizeInBytes end function end interface interface hipsparseCgemvi_bufferSize #ifdef USE_CUDA_NAMES function hipsparseCgemvi_bufferSize_(handle,transA,m,n,nnz,pBufferSizeInBytes) & bind(c, name="cusparseCgemvi_bufferSize") #else function hipsparseCgemvi_bufferSize_(handle,transA,m,n,nnz,pBufferSizeInBytes) & bind(c, name="hipsparseCgemvi_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgemvi_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz integer(c_int) :: pBufferSizeInBytes end function end interface interface hipsparseZgemvi_bufferSize #ifdef USE_CUDA_NAMES function hipsparseZgemvi_bufferSize_(handle,transA,m,n,nnz,pBufferSizeInBytes) & bind(c, name="cusparseZgemvi_bufferSize") #else function hipsparseZgemvi_bufferSize_(handle,transA,m,n,nnz,pBufferSizeInBytes) & bind(c, name="hipsparseZgemvi_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgemvi_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz integer(c_int) :: pBufferSizeInBytes end function end interface !> \ingroup level2_module !> \brief Dense matrix sparse vector multiplication !> !> \details !> \p hipsparseXgemvi multiplies the scalar \f$\alpha\f$ with a dense \f$m \times n\f$ !> matrix \f$A\f$ and the sparse vector \f$x\f$ and adds the result to the dense vector !> \f$y\f$ that is multiplied by the scalar \f$\beta\f$, such that !> \f[ !> y := \alpha \cdot op(A) \cdot x + \beta \cdot y, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if transA == HIPSPARSE_OPERATION_NON_TRANSPOSE} !> \end{array} !> \right. !> \f] !> !> Performing the above operation involves two steps. First, the user calls !> `hipsparseSgemvi_bufferSize` "hipsparseXgemvi_bufferSize()" to determine the size of !> the temporary storage buffer. Next, the user allocates this temporary buffer and passes it to !> \p hipsparseXgemvi to complete the computation. After all calls to \p hipsparseXgemvi are !> complete, the !> temporary storage buffer can be freed. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p transA == `HIPSPARSE_OPERATION_NON_TRANSPOSE` is supported. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] transA - matrix operation type. !> @param[in] m - number of rows of the dense matrix. !> @param[in] n - number of columns of the dense matrix. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] A - pointer to the dense matrix. !> @param[in] lda - leading dimension of the dense matrix. !> @param[in] nnz - number of non-zero entries in the sparse vector. !> @param[in] x - array of \p nnz elements containing the values of the sparse vector. !> @param[in] xInd - array of \p nnz elements containing the indices of the sparse vector. !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] y - array of \p m elements (\f$op(A) == A\f$) or \p n elements !> (\f$op(A) == A^T\f$ or \f$op(A) == A^H\f$). !> @param[in] idxBase - `HIPSPARSE_INDEX_BASE_ZERO` or `HIPSPARSE_INDEX_BASE_ONE`. !> @param[in] pBuffer - temporary storage buffer. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p lda, \p nnz, \p alpha, !> \p A, \p x, \p xInd, \p beta, \p y, or \p pBuffer is invalid. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> \p transA != `HIPSPARSE_OPERATION_NON_TRANSPOSE` or !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseSgemvi #ifdef USE_CUDA_NAMES function hipsparseSgemvi_(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase,pBuffer) & bind(c, name="cusparseSgemvi") #else function hipsparseSgemvi_(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase,pBuffer) & bind(c, name="hipsparseSgemvi") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgemvi_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: nnz type(c_ptr),value :: x type(c_ptr),value :: xInd real(c_float) :: beta type(c_ptr),value :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSgemvi_assumed_rank #else module procedure & hipsparseSgemvi_rank_0,& hipsparseSgemvi_rank_1,& hipsparseSgemvi_full_rank #endif #endif end interface interface hipsparseDgemvi #ifdef USE_CUDA_NAMES function hipsparseDgemvi_(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase,pBuffer) & bind(c, name="cusparseDgemvi") #else function hipsparseDgemvi_(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase,pBuffer) & bind(c, name="hipsparseDgemvi") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgemvi_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: nnz type(c_ptr),value :: x type(c_ptr),value :: xInd real(c_double) :: beta type(c_ptr),value :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDgemvi_assumed_rank #else module procedure & hipsparseDgemvi_rank_0,& hipsparseDgemvi_rank_1,& hipsparseDgemvi_full_rank #endif #endif end interface interface hipsparseCgemvi #ifdef USE_CUDA_NAMES function hipsparseCgemvi_(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase,pBuffer) & bind(c, name="cusparseCgemvi") #else function hipsparseCgemvi_(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase,pBuffer) & bind(c, name="hipsparseCgemvi") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgemvi_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: nnz type(c_ptr),value :: x type(c_ptr),value :: xInd complex(c_float_complex) :: beta type(c_ptr),value :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCgemvi_assumed_rank #else module procedure & hipsparseCgemvi_rank_0,& hipsparseCgemvi_rank_1,& hipsparseCgemvi_full_rank #endif #endif end interface interface hipsparseZgemvi #ifdef USE_CUDA_NAMES function hipsparseZgemvi_(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase,pBuffer) & bind(c, name="cusparseZgemvi") #else function hipsparseZgemvi_(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase,pBuffer) & bind(c, name="hipsparseZgemvi") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgemvi_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: nnz type(c_ptr),value :: x type(c_ptr),value :: xInd complex(c_double_complex) :: beta type(c_ptr),value :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZgemvi_assumed_rank #else module procedure & hipsparseZgemvi_rank_0,& hipsparseZgemvi_rank_1,& hipsparseZgemvi_full_rank #endif #endif end interface !> \ingroup level2_module !> \brief Sparse matrix vector multiplication using the HYB storage format. !> !> \details !> \p hipsparseXhybmv multiplies the scalar \f$\alpha\f$ with a sparse \f$m \times n\f$ !> matrix, defined in HYB storage format, and the dense vector \f$x\f$ and adds the !> result to the dense vector \f$y\f$ that is multiplied by the scalar \f$\beta\f$, !> such that !> \f[ !> y := \alpha \cdot op(A) \cdot x + \beta \cdot y, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if transA == HIPSPARSE_OPERATION_NON_TRANSPOSE} !> \end{array} !> \right. !> \f] !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p transA == `HIPSPARSE_OPERATION_NON_TRANSPOSE` is supported. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 10.0+) and will be !> removed in CUDA 11.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] transA - matrix operation type. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descrA - descriptor of the sparse HYB matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] hybA - matrix in HYB storage format. !> @param[in] x - array of \p n elements (\f$op(A) == A\f$) or \p m elements !> (\f$op(A) == A^T\f$ or \f$op(A) == A^H\f$). !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] y - array of \p m elements (\f$op(A) == A\f$) or \p n elements !> (\f$op(A) == A^T\f$ or \f$op(A) == A^H\f$). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p descrA, \p alpha, \p beta, or \p hybA is !> nullptr, !> or \p x or \p y is nullptr. !> \retval HIPSPARSE_STATUS_ARCH_MISMATCH the device is not supported. !> \retval HIPSPARSE_STATUS_ALLOC_FAILED the buffer could not be allocated. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED \p transA is not `HIPSPARSE_OPERATION_NON_TRANSPOSE` !> or `hipsparseMatrixType_t` is not `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseShybmv function hipsparseShybmv_(handle,transA,alpha,descrA,hybA,x,beta,y) & bind(c, name="hipsparseShybmv") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseShybmv_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA real(c_float) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: hybA type(c_ptr),value :: x real(c_float) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseShybmv_assumed_rank #else module procedure & hipsparseShybmv_rank_0,& hipsparseShybmv_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDhybmv function hipsparseDhybmv_(handle,transA,alpha,descrA,hybA,x,beta,y) & bind(c, name="hipsparseDhybmv") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDhybmv_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA real(c_double) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: hybA type(c_ptr),value :: x real(c_double) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDhybmv_assumed_rank #else module procedure & hipsparseDhybmv_rank_0,& hipsparseDhybmv_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseChybmv function hipsparseChybmv_(handle,transA,alpha,descrA,hybA,x,beta,y) & bind(c, name="hipsparseChybmv") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseChybmv_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA complex(c_float_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: hybA type(c_ptr),value :: x complex(c_float_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseChybmv_assumed_rank #else module procedure & hipsparseChybmv_rank_0,& hipsparseChybmv_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZhybmv function hipsparseZhybmv_(handle,transA,alpha,descrA,hybA,x,beta,y) & bind(c, name="hipsparseZhybmv") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZhybmv_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA complex(c_double_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: hybA type(c_ptr),value :: x complex(c_double_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZhybmv_assumed_rank #else module procedure & hipsparseZhybmv_rank_0,& hipsparseZhybmv_rank_1 #endif #endif end interface #endif !> \ingroup level3_module !> \brief Sparse matrix dense matrix multiplication using the BSR storage format. !> !> \details !> \p hipsparseXbsrmm multiplies the scalar \f$\alpha\f$ with a sparse \f$m \times k\f$ !> matrix \f$A\f$, defined in BSR storage format, and the column-oriented dense \f$k \times n\f$ !> matrix \f$B\f$ and adds the result to the column-oriented dense \f$m \times n\f$ matrix !> \f$C\f$ that !> is multiplied by the scalar \f$\beta\f$, such that !> \f[ !> C := \alpha \cdot op(A) \cdot op(B) + \beta \cdot C, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if transA == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if transB == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> B^T, & \text{if transB == HIPSPARSE_OPERATION_TRANSPOSE} \\% !> \end{array} !> \right. !> \f] !> and where \f$k = blockDim \times kb\f$ and \f$m = blockDim \times mb\f$. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p transA == `HIPSPARSE_OPERATION_NON_TRANSPOSE` is supported. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - the storage format of the blocks. Can be `HIPSPARSE_DIRECTION_ROW` or !> `HIPSPARSE_DIRECTION_COLUMN`. !> @param[in] transA - matrix \f$A\f$ operation type. Currently, only !> `HIPSPARSE_OPERATION_NON_TRANSPOSE` is supported. !> @param[in] transB - matrix \f$B\f$ operation type. Currently, only !> `HIPSPARSE_OPERATION_NON_TRANSPOSE` and `HIPSPARSE_OPERATION_TRANSPOSE` !> are supported. !> @param[in] mb - number of block rows of the sparse BSR matrix \f$A\f$. Must be non-negative. !> @param[in] n - number of columns of the dense matrix \f$op(B)\f$ and \f$C\f$. Must be !> non-negative. !> @param[in] kb - number of block columns of the sparse BSR matrix \f$A\f$. Must be !> non-negative. !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix \f$A\f$. Must be !> non-negative. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descrA - descriptor of the sparse BSR matrix \f$A\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] bsrValA - array of \p nnzb*blockDim*blockDim elements of the sparse BSR matrix !> \f$A\f$. !> @param[in] bsrRowPtrA - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse BSR matrix \f$A\f$. !> @param[in] bsrColIndA - array of \p nnzb elements containing the block column indices of the !> sparse !> BSR matrix \f$A\f$. !> @param[in] blockDim - size of the blocks in the sparse BSR matrix. Must be positive. !> @param[in] B - array of dimension \p ldb*n (\f$op(B) == B\f$), !> \p ldb*k otherwise. !> @param[in] ldb - leading dimension of \f$B\f$, must be at least \f$\max{(1, k)}\f$ (\f$ op(B) !> == B\f$) where \p k=blockDim*kb, !> \f$\max{(1, n)}\f$ otherwise. !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] C - array of dimension \p ldc*n. !> @param[in] ldc - leading dimension of \f$C\f$, must be at least \f$\max{(1, m)}\f$ (\f$ op(A) !> == A\f$) where \p m=blockDim*mb, !> \f$\max{(1, k)}\f$ where \p k=blockDim*kb otherwise. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p descrA, \p alpha, or \p beta is nullptr, !> \p mb, \p n, \p kb, or \p nnzb is negative, \p ldb or \p ldc is invalid, !> \p blockDim is less than or equal to zero, or \p bsrValA, \p bsrRowPtrA, \p !> bsrColIndA, !> \p B, or \p C is nullptr. !> \retval HIPSPARSE_STATUS_ARCH_MISMATCH the device is not supported. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED \p transA is not `HIPSPARSE_OPERATION_NON_TRANSPOSE`, !> \p transB is `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE`, or !> `hipsparseMatrixType_t` is not `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseSbsrmm #ifdef USE_CUDA_NAMES function hipsparseSbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) & bind(c, name="cusparseSbsrmm") #else function hipsparseSbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) & bind(c, name="hipsparseSbsrmm") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrmm_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: mb integer(c_int),value :: n integer(c_int),value :: kb integer(c_int),value :: nnzb real(c_float) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSbsrmm_assumed_rank #else module procedure & hipsparseSbsrmm_rank_0,& hipsparseSbsrmm_rank_1,& hipsparseSbsrmm_full_rank #endif #endif end interface interface hipsparseDbsrmm #ifdef USE_CUDA_NAMES function hipsparseDbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) & bind(c, name="cusparseDbsrmm") #else function hipsparseDbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) & bind(c, name="hipsparseDbsrmm") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrmm_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: mb integer(c_int),value :: n integer(c_int),value :: kb integer(c_int),value :: nnzb real(c_double) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDbsrmm_assumed_rank #else module procedure & hipsparseDbsrmm_rank_0,& hipsparseDbsrmm_rank_1,& hipsparseDbsrmm_full_rank #endif #endif end interface interface hipsparseCbsrmm #ifdef USE_CUDA_NAMES function hipsparseCbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) & bind(c, name="cusparseCbsrmm") #else function hipsparseCbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) & bind(c, name="hipsparseCbsrmm") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrmm_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: mb integer(c_int),value :: n integer(c_int),value :: kb integer(c_int),value :: nnzb complex(c_float_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCbsrmm_assumed_rank #else module procedure & hipsparseCbsrmm_rank_0,& hipsparseCbsrmm_rank_1,& hipsparseCbsrmm_full_rank #endif #endif end interface interface hipsparseZbsrmm #ifdef USE_CUDA_NAMES function hipsparseZbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) & bind(c, name="cusparseZbsrmm") #else function hipsparseZbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) & bind(c, name="hipsparseZbsrmm") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrmm_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: mb integer(c_int),value :: n integer(c_int),value :: kb integer(c_int),value :: nnzb complex(c_double_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZbsrmm_assumed_rank #else module procedure & hipsparseZbsrmm_rank_0,& hipsparseZbsrmm_rank_1,& hipsparseZbsrmm_full_rank #endif #endif end interface !> \ingroup level3_module !> \details !> \p hipsparseXbsrsm2_zeroPivot returns `HIPSPARSE_STATUS_ZERO_PIVOT` if either a !> structural or numerical zero has been found during `hipsparseSbsrsm2_analysis` !> "hipsparseXbsrsm2_analysis()" !> or `hipsparseSbsrsm2_solve` "hipsparseXbsrsm2_solve()" computation. The first zero pivot !> \f$j\f$ at \f$A_{j,j}\f$ !> is stored in \p position, using the same index base as the BSR matrix. !> !> \p position can be in host or device memory. If no zero pivot has been found, !> \p position is set to -1 and `HIPSPARSE_STATUS_SUCCESS` is returned instead. !> !> \note \p hipsparseXbsrsm2_zeroPivot is a blocking function. It might negatively !> influence performance. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 12.0+) and will be !> removed in CUDA 13.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[inout] position - pointer to zero pivot \f$j\f$, which can be in host or device !> memory. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p info, or \p position is nullptr. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_ZERO_PIVOT zero pivot has been found. interface hipsparseXbsrsm2_zeroPivot #ifdef USE_CUDA_NAMES function hipsparseXbsrsm2_zeroPivot_(handle,myInfo,position) & bind(c, name="cusparseXbsrsm2_zeroPivot") #else function hipsparseXbsrsm2_zeroPivot_(handle,myInfo,position) & bind(c, name="hipsparseXbsrsm2_zeroPivot") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXbsrsm2_zeroPivot_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int) :: position end function end interface !> \ingroup level3_module !> \details !> \p hipsparseXbsrsm2_buffer_size returns the size of the temporary storage buffer in bytes !> that is required by `hipsparseSbsrsm2_analysis` "hipsparseXbsrsm2_analysis()" and !> `hipsparseSbsrsm2_solve` "hipsparseXbsrsm2_solve()". The temporary storage buffer must !> be allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - matrix storage of BSR blocks. !> @param[in] transA - matrix \f$A\f$ operation type. !> @param[in] transX - matrix \f$X\f$ operation type. !> @param[in] mb - number of block rows of the sparse BSR matrix \f$A\f$. !> @param[in] nrhs - number of columns of the dense matrix \f$op(X)\f$. !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix \f$A\f$. !> @param[in] descrA - descriptor of the sparse BSR matrix \f$A\f$. !> @param[in] bsrSortedValA - array of \p nnzb blocks of the sparse BSR matrix. !> @param[in] bsrSortedRowPtrA - array of \p mb+1 elements that point to the start of every !> block row of !> the sparse BSR matrix. !> @param[in] bsrSortedColIndA - array of \p nnzb containing the block column indices of the !> sparse !> BSR matrix. !> @param[in] blockDim - block dimension of the sparse BSR matrix. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseSbsrsm2_analysis` "hipsparseXbsrsm2_analysis()" and !> `hipsparseSbsrsm2_solve` "hipsparseXbsrsm2_solve()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p mb, \p nrhs, \p nnzb, \p blockDim, !> \p descrA, \p bsrSortedValA, \p bsrSortedRowPtrA, \p bsrSortedColIndA, \p info, !> or !> \p pBufferSizeInBytes is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> \p transA == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE`, !> \p transX == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE`, or !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseSbsrsm2_bufferSize #ifdef USE_CUDA_NAMES function hipsparseSbsrsm2_bufferSize_(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseSbsrsm2_bufferSize") #else function hipsparseSbsrsm2_bufferSize_(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseSbsrsm2_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsm2_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transX integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSbsrsm2_bufferSize_assumed_rank #else module procedure & hipsparseSbsrsm2_bufferSize_rank_0,& hipsparseSbsrsm2_bufferSize_rank_1 #endif #endif end interface interface hipsparseDbsrsm2_bufferSize #ifdef USE_CUDA_NAMES function hipsparseDbsrsm2_bufferSize_(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseDbsrsm2_bufferSize") #else function hipsparseDbsrsm2_bufferSize_(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseDbsrsm2_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsm2_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transX integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDbsrsm2_bufferSize_assumed_rank #else module procedure & hipsparseDbsrsm2_bufferSize_rank_0,& hipsparseDbsrsm2_bufferSize_rank_1 #endif #endif end interface interface hipsparseCbsrsm2_bufferSize #ifdef USE_CUDA_NAMES function hipsparseCbsrsm2_bufferSize_(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseCbsrsm2_bufferSize") #else function hipsparseCbsrsm2_bufferSize_(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseCbsrsm2_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsm2_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transX integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCbsrsm2_bufferSize_assumed_rank #else module procedure & hipsparseCbsrsm2_bufferSize_rank_0,& hipsparseCbsrsm2_bufferSize_rank_1 #endif #endif end interface interface hipsparseZbsrsm2_bufferSize #ifdef USE_CUDA_NAMES function hipsparseZbsrsm2_bufferSize_(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseZbsrsm2_bufferSize") #else function hipsparseZbsrsm2_bufferSize_(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseZbsrsm2_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsm2_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transX integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZbsrsm2_bufferSize_assumed_rank #else module procedure & hipsparseZbsrsm2_bufferSize_rank_0,& hipsparseZbsrsm2_bufferSize_rank_1 #endif #endif end interface !> \ingroup level3_module !> \brief Sparse triangular system solve using the BSR storage format. !> !> \details !> \p hipsparseXbsrsm2_analysis performs the analysis step for `hipsparseSbsrsm2_solve` !> "hipsparseXbsrsm2_solve()". It is expected that this function will be executed only once !> for a given matrix and particular operation type. !> !> \note !> If the matrix sparsity pattern changes, the gathered information will become invalid. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - matrix storage of BSR blocks. !> @param[in] transA - matrix \f$A\f$ operation type. !> @param[in] transX - matrix \f$X\f$ operation type. !> @param[in] mb - number of block rows of the sparse BSR matrix \f$A\f$. !> @param[in] nrhs - number of columns of the dense matrix \f$op(X)\f$. !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix \f$A\f$. !> @param[in] descrA - descriptor of the sparse BSR matrix \f$A\f$. !> @param[in] bsrSortedValA - array of \p nnzb blocks of the sparse BSR matrix \f$A\f$. !> @param[in] bsrSortedRowPtrA - array of \p mb+1 elements that point to the start of every !> block row of !> the sparse BSR matrix \f$A\f$. !> @param[in] bsrSortedColIndA - array of \p nnzb containing the block column indices of the !> sparse !> BSR matrix \f$A\f$. !> @param[in] blockDim - block dimension of the sparse BSR matrix \f$A\f$. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[in] policy - `HIPSPARSE_SOLVE_POLICY_NO_LEVEL` or !> `HIPSPARSE_SOLVE_POLICY_USE_LEVEL`. !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p mb, \p nrhs, \p nnzb, !> \p blockDim, \p descrA, \p bsrSortedValA, \p bsrSortedRowPtrA, !> \p bsrSortedColIndA, \p info, or \p pBuffer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> \p transA == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE`, !> \p transX == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE`, or !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseSbsrsm2_analysis #ifdef USE_CUDA_NAMES function hipsparseSbsrsm2_analysis_(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseSbsrsm2_analysis") #else function hipsparseSbsrsm2_analysis_(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseSbsrsm2_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsm2_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transX integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSbsrsm2_analysis_assumed_rank #else module procedure & hipsparseSbsrsm2_analysis_rank_0,& hipsparseSbsrsm2_analysis_rank_1 #endif #endif end interface interface hipsparseDbsrsm2_analysis #ifdef USE_CUDA_NAMES function hipsparseDbsrsm2_analysis_(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseDbsrsm2_analysis") #else function hipsparseDbsrsm2_analysis_(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseDbsrsm2_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsm2_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transX integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDbsrsm2_analysis_assumed_rank #else module procedure & hipsparseDbsrsm2_analysis_rank_0,& hipsparseDbsrsm2_analysis_rank_1 #endif #endif end interface interface hipsparseCbsrsm2_analysis #ifdef USE_CUDA_NAMES function hipsparseCbsrsm2_analysis_(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseCbsrsm2_analysis") #else function hipsparseCbsrsm2_analysis_(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseCbsrsm2_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsm2_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transX integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCbsrsm2_analysis_assumed_rank #else module procedure & hipsparseCbsrsm2_analysis_rank_0,& hipsparseCbsrsm2_analysis_rank_1 #endif #endif end interface interface hipsparseZbsrsm2_analysis #ifdef USE_CUDA_NAMES function hipsparseZbsrsm2_analysis_(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseZbsrsm2_analysis") #else function hipsparseZbsrsm2_analysis_(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseZbsrsm2_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsm2_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transX integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZbsrsm2_analysis_assumed_rank #else module procedure & hipsparseZbsrsm2_analysis_rank_0,& hipsparseZbsrsm2_analysis_rank_1 #endif #endif end interface !> \ingroup level3_module !> \brief Sparse triangular system solve using the BSR storage format. !> !> \details !> \p hipsparseXbsrsm2_solve solves a sparse triangular linear system of a sparse !> \f$m \times m\f$ matrix, defined in BSR storage format, a column-oriented dense solution !> matrix !> \f$X\f$ and the column-oriented dense right-hand side matrix \f$B\f$ that is multiplied by !> \f$\alpha\f$, !> such that !> \f[ !> op(A) \cdot op(X) = \alpha \cdot op(B), !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if transA == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> A^T, & \text{if transA == HIPSPARSE_OPERATION_TRANSPOSE} \\% !> A^H, & \text{if transA == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} !> \end{array} !> \right. !> \f] !> , !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if transX == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> B^T, & \text{if transX == HIPSPARSE_OPERATION_TRANSPOSE} \\% !> B^H, & \text{if transX == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(X) = \left\{ !> \begin{array}{ll} !> X, & \text{if transX == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> X^T, & \text{if transX == HIPSPARSE_OPERATION_TRANSPOSE} \\% !> X^H, & \text{if transX == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} !> \end{array} !> \right. !> \f] !> and where \f$m = blockDim \times mb\f$. !> !> Note that, as indicated above, the operation type of both \f$op(B)\f$ and \f$op(X)\f$ is !> specified by the !> \p transX parameter and that the operation type of \f$B\f$ and \f$X\f$ must match. For !> example, if \f$op(B)=B\f$, then !> \f$op(X)=X\f$. Likewise, if \f$op(B)=B^T\f$, then \f$op(X)=X^T\f$. !> !> Given that the sparse matrix \f$A\f$ is a square matrix, its size is \f$m \times m\f$ !> regardless of !> whether \f$A\f$ is transposed or not. The size of the column-oriented dense matrices \f$B\f$ !> and \f$X\f$ !> depends on the value of \p transX: !> !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> ldb \times nrhs, \text{ } ldb ≥ m, & \text{if transX == !> HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> ldb \times m, \text{ } ldb ≥ nrhs, & \text{if transX == !> HIPSPARSE_OPERATION_TRANSPOSE} \\% !> ldb \times m, \text{ } ldb ≥ nrhs, & \text{if transX == !> HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(X) = \left\{ !> \begin{array}{ll} !> ldb \times nrhs, \text{ } ldb ≥ m, & \text{if transX == !> HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> ldb \times m, \text{ } ldb ≥ nrhs, & \text{if transX == !> HIPSPARSE_OPERATION_TRANSPOSE} \\% !> ldb \times m, \text{ } ldb ≥ nrhs, & \text{if transX == !> HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} !> \end{array} !> \right. !> \f] !> !> \p hipsparseXbsrsm2_solve requires a user-allocated temporary buffer. Its size is returned by !> `hipsparseSbsrsm2_bufferSize` "hipsparseXbsrsm2_bufferSize()". The size of the required !> buffer is larger !> when \p transA equals `HIPSPARSE_OPERATION_TRANSPOSE` or !> `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE` and !> when \p transX is `HIPSPARSE_OPERATION_NON_TRANSPOSE`. The subsequent solve will also be !> faster when \f$A\f$ is !> non-transposed and \f$B\f$ is transposed (or conjugate transposed). For example, instead of !> solving: !> !> \f[ !> \left[ !> \begin{array}{c | c} !> \begin{array}{c c} !> a_{00} & a_{01} \\% !> a_{10} & a_{11} !> \end{array} & !> \begin{array}{c c} !> 0 & 0 \\% !> 0 & 0 !> \end{array} \\% !> \hline !> \begin{array}{c c} !> a_{20} & a_{21} \\% !> a_{30} & a_{31} !> \end{array} & !> \begin{array}{c c} !> a_{22} & a_{23} \\% !> a_{32} & a_{33} !> \end{array} \\% !> \end{array} !> \right] !> \cdot !> \begin{bmatrix} !> x_{00} & x_{01} \\% !> x_{10} & x_{11} \\% !> x_{20} & x_{21} \\% !> x_{30} & x_{31} \\% !> \end{bmatrix} !> = !> \begin{bmatrix} !> b_{00} & b_{01} \\% !> b_{10} & b_{11} \\% !> b_{20} & b_{21} \\% !> b_{30} & b_{31} \\% !> \end{bmatrix} !> \f] !> !> Consider solving: !> !> \f[ !> \left[ !> \begin{array}{c | c} !> \begin{array}{c c} !> a_{00} & a_{01} \\% !> a_{10} & a_{11} !> \end{array} & !> \begin{array}{c c} !> 0 & 0 \\% !> 0 & 0 !> \end{array} \\% !> \hline !> \begin{array}{c c} !> a_{20} & a_{21} \\% !> a_{30} & a_{31} !> \end{array} & !> \begin{array}{c c} !> a_{22} & a_{23} \\% !> a_{32} & a_{33} !> \end{array} \\% !> \end{array} !> \right] !> \cdot !> \begin{bmatrix} !> x_{00} & x_{10} & x_{20} & x_{30} \\% !> x_{01} & x_{11} & x_{21} & x_{31} !> \end{bmatrix}^{T} !> = !> \begin{bmatrix} !> b_{00} & b_{10} & b_{20} & b_{30} \\% !> b_{01} & b_{11} & b_{21} & b_{31} !> \end{bmatrix}^{T} !> \f] !> !> After the temporary storage buffer has been allocated, analysis meta data is required. It can !> be obtained !> by hipsparseSbsrsm2_analysis "hipsparseXbsrsm2_analysis()". The triangular solve is completed !> by calling !> \p hipsparseXbsrsm2_solve, and after all solves are performed, the temporary storage buffer !> allocated by the !> user can be freed. !> !> Solving a triangular system involves inverting the diagonal blocks. This means that if the !> sparse matrix is !> missing the diagonal block (referred to as a structural zero) or the diagonal block is not !> invertible (referred !> to as a numerical zero), then a solution is not possible. \p hipsparseXbsrsm2_solve tracks !> the location of the first !> zero pivot (either numerical or structural zero). The zero pivot status can be checked by !> calling `hipsparseXbsrsm2_zeroPivot` (). !> If `hipsparseXbsrsm2_zeroPivot` () returns `HIPSPARSE_STATUS_SUCCESS`, then no zero pivot was !> found and therefore !> the matrix does not have a structural or numerical zero. !> !> The user can specify that the sparse matrix should be interpreted as having identity blocks !> on the diagonal by setting the diagonal !> type on the descriptor \p descrA to `HIPSPARSE_DIAG_TYPE_UNIT` using !> `hipsparseSetMatDiagType`. If !> `hipsparseDiagType_t` == `HIPSPARSE_DIAG_TYPE_UNIT`, no zero pivot will be reported, even if !> the diagonal block \f$A_{j,j}\f$ !> for some \f$j\f$ is not invertible. !> !> The sparse CSR matrix passed to \p hipsparseXbsrsm2_solve does not actually have to be a !> triangular matrix. Instead, the !> triangular upper or lower part of the sparse matrix is solved based on `hipsparseFillMode_t` !> set on the descriptor !> \p descrA. If the fill mode is set to `HIPSPARSE_FILL_MODE_LOWER`, then the lower triangular !> matrix is solved. If the !> fill mode is set to `HIPSPARSE_FILL_MODE_UPPER`, then the upper triangular matrix is solved. !> !> \note !> The sparse BSR matrix has to be sorted. !> !> \note !> Operation type of B and X must match if \f$op(B)=B, op(X)=X\f$. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p transA != `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE` and !> \p transX != `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE` is supported. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - matrix storage of BSR blocks. !> @param[in] transA - matrix \f$A\f$ operation type. !> @param[in] transX - matrix \f$X\f$ operation type. !> @param[in] mb - number of block rows of the sparse BSR matrix \f$A\f$. !> @param[in] nrhs - number of columns of the dense matrix \f$op(X)\f$. !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix \f$A\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descrA - descriptor of the sparse BSR matrix \f$A\f$. !> @param[in] bsrSortedValA - array of \p nnzb blocks of the sparse BSR matrix. !> @param[in] bsrSortedRowPtrA - array of \p mb+1 elements that point to the start of every !> block row of !> the sparse BSR matrix. !> @param[in] bsrSortedColIndA - array of \p nnzb containing the block column indices of the !> sparse !> BSR matrix. !> @param[in] blockDim - block dimension of the sparse BSR matrix. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] B - rhs matrix B with leading dimension \p ldb. !> @param[in] ldb - leading dimension of rhs matrix \f$B\f$. !> @param[out] X - solution matrix X with leading dimension \p ldx. !> @param[in] ldx - leading dimension of solution matrix \f$X\f$. !> @param[in] policy - `HIPSPARSE_SOLVE_POLICY_NO_LEVEL` or `HIPSPARSE_SOLVE_POLICY_USE_LEVEL`. !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p mb, \p nrhs, \p nnzb, \p blockDim, !> \p alpha, \p descrA, \p bsrSortedValA, \p bsrSortedRowPtrA, \p bsrSortedColIndA, !> \p B, \p X \p info, or \p pBuffer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> \p transA == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE`, !> \p transX == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE` or !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseSbsrsm2_solve #ifdef USE_CUDA_NAMES function hipsparseSbsrsm2_solve_(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy, & pBuffer) & bind(c, name="cusparseSbsrsm2_solve") #else function hipsparseSbsrsm2_solve_(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy, & pBuffer) & bind(c, name="hipsparseSbsrsm2_solve") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsm2_solve_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transX integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb real(c_float) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSbsrsm2_solve_assumed_rank #else module procedure & hipsparseSbsrsm2_solve_rank_0,& hipsparseSbsrsm2_solve_rank_1,& hipsparseSbsrsm2_solve_full_rank #endif #endif end interface interface hipsparseDbsrsm2_solve #ifdef USE_CUDA_NAMES function hipsparseDbsrsm2_solve_(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy, & pBuffer) & bind(c, name="cusparseDbsrsm2_solve") #else function hipsparseDbsrsm2_solve_(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy, & pBuffer) & bind(c, name="hipsparseDbsrsm2_solve") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsm2_solve_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transX integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb real(c_double) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDbsrsm2_solve_assumed_rank #else module procedure & hipsparseDbsrsm2_solve_rank_0,& hipsparseDbsrsm2_solve_rank_1,& hipsparseDbsrsm2_solve_full_rank #endif #endif end interface interface hipsparseCbsrsm2_solve #ifdef USE_CUDA_NAMES function hipsparseCbsrsm2_solve_(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy, & pBuffer) & bind(c, name="cusparseCbsrsm2_solve") #else function hipsparseCbsrsm2_solve_(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy, & pBuffer) & bind(c, name="hipsparseCbsrsm2_solve") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsm2_solve_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transX integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb complex(c_float_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCbsrsm2_solve_assumed_rank #else module procedure & hipsparseCbsrsm2_solve_rank_0,& hipsparseCbsrsm2_solve_rank_1,& hipsparseCbsrsm2_solve_full_rank #endif #endif end interface interface hipsparseZbsrsm2_solve #ifdef USE_CUDA_NAMES function hipsparseZbsrsm2_solve_(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy, & pBuffer) & bind(c, name="cusparseZbsrsm2_solve") #else function hipsparseZbsrsm2_solve_(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy, & pBuffer) & bind(c, name="hipsparseZbsrsm2_solve") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsm2_solve_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transX integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb complex(c_double_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZbsrsm2_solve_assumed_rank #else module procedure & hipsparseZbsrsm2_solve_rank_0,& hipsparseZbsrsm2_solve_rank_1,& hipsparseZbsrsm2_solve_full_rank #endif #endif end interface !> \ingroup level3_module !> \brief Sparse matrix dense matrix multiplication using the CSR storage format. !> !> \details !> \p hipsparseXcsrmm multiplies the scalar \f$\alpha\f$ with a sparse \f$m \times k\f$ !> matrix \f$A\f$, defined in CSR storage format, and the column-oriented dense \f$k \times n\f$ !> matrix \f$B\f$ and adds the result to the column-oriented dense \f$m \times n\f$ matrix !> \f$C\f$ that !> is multiplied by the scalar \f$\beta\f$, such that !> \f[ !> C := \alpha \cdot op(A) \cdot B + \beta \cdot C, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if transA == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> A^T, & \text{if transA == HIPSPARSE_OPERATION_TRANSPOSE} \\% !> A^H, & \text{if transA == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} !> \end{array} !> \right. !> \f] !> !> \code{.c} !> for(i = 0; i < ldc; ++i) !> { !> for(j = 0; j < n; ++j) !> { !> C[i][j] = beta * C[i][j]; !> !> for(k = csrRowPtr[i]; k < csrRowPtr[i + 1]; ++k) !> { !> C[i][j] += alpha * csrVal[k] * B[csrColInd[k]][j]; !> } !> } !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 10.0+) and will be !> removed in CUDA 11.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] transA - matrix \f$A\f$ operation type. !> @param[in] m - number of rows of the sparse CSR matrix \f$A\f$. Must be non-negative. !> @param[in] n - number of columns of the dense matrix \f$op(B)\f$ and \f$C\f$. Must be !> non-negative. !> @param[in] k - number of columns of the sparse CSR matrix \f$A\f$. Must be non-negative. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix \f$A\f$. Must be !> non-negative. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descrA - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrSortedValA - array of \p nnz elements of the sparse CSR matrix \f$A\f$. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix \f$A\f$. !> @param[in] csrSortedColIndA - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix \f$A\f$. !> @param[in] B - array of dimension \p ldb*n (\f$op(B) == B\f$), !> \p ldb*k otherwise. !> @param[in] ldb - leading dimension of \f$B\f$, must be at least \f$\max{(1, k)}\f$ !> (\f$op(B) == B\f$), \f$\max{(1, n)}\f$ otherwise. !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] C - array of dimension \p ldc*n. !> @param[in] ldc - leading dimension of \f$C\f$, must be at least \f$\max{(1, m)}\f$ !> (\f$op(A) == A\f$), \f$\max{(1, k)}\f$ otherwise. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p descrA, \p alpha, or \p beta is nullptr, !> \p m, \p n, \p k, or \p nnz is negative, \p ldb or \p ldc is invalid, or !> \p csrSortedValA, \p csrSortedRowPtrA, \p csrSortedColIndA, \p B, or \p C is nullptr. !> \retval HIPSPARSE_STATUS_ARCH_MISMATCH the device is not supported. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED `hipsparseMatrixType_t` is not !> `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseScsrmm function hipsparseScsrmm_(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,B,ldb,beta,C,ldc) & bind(c, name="hipsparseScsrmm") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrmm_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz real(c_float) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrmm_assumed_rank #else module procedure & hipsparseScsrmm_rank_0,& hipsparseScsrmm_rank_1,& hipsparseScsrmm_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsrmm function hipsparseDcsrmm_(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,B,ldb,beta,C,ldc) & bind(c, name="hipsparseDcsrmm") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrmm_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz real(c_double) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrmm_assumed_rank #else module procedure & hipsparseDcsrmm_rank_0,& hipsparseDcsrmm_rank_1,& hipsparseDcsrmm_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsrmm function hipsparseCcsrmm_(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,B,ldb,beta,C,ldc) & bind(c, name="hipsparseCcsrmm") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrmm_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz complex(c_float_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrmm_assumed_rank #else module procedure & hipsparseCcsrmm_rank_0,& hipsparseCcsrmm_rank_1,& hipsparseCcsrmm_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsrmm function hipsparseZcsrmm_(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,B,ldb,beta,C,ldc) & bind(c, name="hipsparseZcsrmm") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrmm_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz complex(c_double_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrmm_assumed_rank #else module procedure & hipsparseZcsrmm_rank_0,& hipsparseZcsrmm_rank_1,& hipsparseZcsrmm_full_rank #endif #endif end interface #endif !> \ingroup level3_module !> \brief Sparse matrix dense matrix multiplication using the CSR storage format. !> !> \details !> \p hipsparseXcsrmm2 multiplies the scalar \f$\alpha\f$ with a sparse \f$m \times k\f$ !> matrix \f$A\f$, defined in CSR storage format, and the column-oriented dense \f$k \times n\f$ !> matrix \f$B\f$ and adds the result to the column-oriented dense \f$m \times n\f$ matrix !> \f$C\f$ that !> is multiplied by the scalar \f$\beta\f$, such that !> \f[ !> C := \alpha \cdot op(A) \cdot op(B) + \beta \cdot C, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if transA == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> A^T, & \text{if transA == HIPSPARSE_OPERATION_TRANSPOSE} \\% !> A^H, & \text{if transA == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if transB == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> B^T, & \text{if transB == HIPSPARSE_OPERATION_TRANSPOSE} \\% !> B^H, & \text{if transB == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} !> \end{array} !> \right. !> \f] !> !> \code{.c} !> for(i = 0; i < ldc; ++i) !> { !> for(j = 0; j < n; ++j) !> { !> C[i][j] = beta * C[i][j]; !> !> for(k = csrRowPtr[i]; k < csrRowPtr[i + 1]; ++k) !> { !> C[i][j] += alpha * csrVal[k] * B[csrColInd[k]][j]; !> } !> } !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] transA - matrix \f$A\f$ operation type. !> @param[in] transB - matrix \f$B\f$ operation type. !> @param[in] m - number of rows of the sparse CSR matrix \f$A\f$. !> @param[in] n - number of columns of the dense matrix \f$op(B)\f$ and \f$C\f$. !> @param[in] k - number of columns of the sparse CSR matrix \f$A\f$. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descrA - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrSortedValA - array of \p nnz elements of the sparse CSR matrix \f$A\f$. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix \f$A\f$. !> @param[in] csrSortedColIndA - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix \f$A\f$. !> @param[in] B - array of dimension \p ldb*n (\f$op(B) == B\f$), !> \p ldb*k otherwise. !> @param[in] ldb - leading dimension of \f$B\f$. Must be at least \f$\max{(1, k)}\f$ !> (\f$op(B) == B\f$), \f$\max{(1, n)}\f$ otherwise. !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] C - array of dimension \p ldc*n. !> @param[in] ldc - leading dimension of \f$C\f$. Must be at least \f$\max{(1, m)}\f$ !> (\f$op(A) == A\f$), \f$\max{(1, k)}\f$ otherwise. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p k, \p nnz, \p ldb, \p ldc, !> \p descrA, \p alpha, \p csrSortedValA, \p csrSortedRowPtrA, \p csrSortedColIndA, !> \p B, \p beta, or \p C is invalid. !> \retval HIPSPARSE_STATUS_ARCH_MISMATCH the device is not supported. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseScsrmm2 function hipsparseScsrmm2_(handle,transA,transB,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) & bind(c, name="hipsparseScsrmm2") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrmm2_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz real(c_float) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrmm2_assumed_rank #else module procedure & hipsparseScsrmm2_rank_0,& hipsparseScsrmm2_rank_1,& hipsparseScsrmm2_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsrmm2 function hipsparseDcsrmm2_(handle,transA,transB,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) & bind(c, name="hipsparseDcsrmm2") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrmm2_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz real(c_double) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrmm2_assumed_rank #else module procedure & hipsparseDcsrmm2_rank_0,& hipsparseDcsrmm2_rank_1,& hipsparseDcsrmm2_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsrmm2 function hipsparseCcsrmm2_(handle,transA,transB,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) & bind(c, name="hipsparseCcsrmm2") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrmm2_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz complex(c_float_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrmm2_assumed_rank #else module procedure & hipsparseCcsrmm2_rank_0,& hipsparseCcsrmm2_rank_1,& hipsparseCcsrmm2_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsrmm2 function hipsparseZcsrmm2_(handle,transA,transB,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) & bind(c, name="hipsparseZcsrmm2") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrmm2_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz complex(c_double_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrmm2_assumed_rank #else module procedure & hipsparseZcsrmm2_rank_0,& hipsparseZcsrmm2_rank_1,& hipsparseZcsrmm2_full_rank #endif #endif end interface #endif !> \ingroup level3_module !> \details !> \p hipsparseXcsrsm2_zeroPivot returns `HIPSPARSE_STATUS_ZERO_PIVOT` if either a !> structural or numerical zero has been found during `hipsparseScsrsm2_analysis` !> "hipsparseXcsrsm2_analysis()" or `hipsparseScsrsm2_solve` "hipsparseXcsrsm2_solve()" !> computation. The first zero pivot \f$j\f$ at \f$A_{j,j}\f$ is stored in \p position, !> using the same index base as the CSR matrix. !> !> \p position can be in host or device memory. If no zero pivot has been found, !> \p position is set to -1 and `HIPSPARSE_STATUS_SUCCESS` is returned instead. !> !> \note \p hipsparseXcsrsm2_zeroPivot is a blocking function. It might negatively !> influence performance. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 11.0+) and will be !> removed in CUDA 12.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[inout] position - pointer to zero pivot \f$j\f$, which can be in host or device !> memory. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p info, or \p position is nullptr. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_ZERO_PIVOT zero pivot has been found. #ifndef USE_CUDA_NAMES interface hipsparseXcsrsm2_zeroPivot function hipsparseXcsrsm2_zeroPivot_(handle,myInfo,position) & bind(c, name="hipsparseXcsrsm2_zeroPivot") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrsm2_zeroPivot_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int) :: position end function end interface #endif !> \ingroup level3_module !> \details !> \p hipsparseXcsrsm2_bufferSizeExt returns the size of the temporary storage buffer !> in bytes that is required by `hipsparseScsrsm2_analysis` "hipsparseXcsrsm2_analysis()" !> and `hipsparseScsrsm2_solve` "hipsparseXcsrsm2_solve()". The temporary storage buffer !> must be allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] algo - algorithm to use. !> @param[in] transA - matrix \f$A\f$ operation type. !> @param[in] transB - matrix \f$B\f$ operation type. !> @param[in] m - number of rows of the sparse CSR matrix \f$A\f$. !> @param[in] nrhs - number of columns of the dense matrix \f$op(B)\f$. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descrA - descriptor of the sparse CSR matrix \f$A\f$. !> @param[in] csrSortedValA - array of \p nnz elements of the sparse CSR matrix \f$A\f$. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix \f$A\f$. !> @param[in] csrSortedColIndA - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix \f$A\f$. !> @param[in] B - array of \p m \f$\times\f$ \p nrhs elements of the rhs matrix \f$B\f$. !> @param[in] ldb - leading dimension of rhs matrix \f$B\f$. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] policy - `HIPSPARSE_SOLVE_POLICY_NO_LEVEL` or !> `HIPSPARSE_SOLVE_POLICY_USE_LEVEL`. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseScsrsm2_analysis` "hipsparseXcsrsm2_analysis()" and !> `hipsparseScsrsm2_solve` "hipsparseXcsrsm2_solve()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p nrhs, \p nnz, \p alpha, !> \p descrA, \p csrSortedValA, \p csrSortedRowPtrA, \p csrSortedColIndA, \p B, !> \p info, or \p pBufferSizeInBytes is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> \p transA == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE`, !> \p transB == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE`, or !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseScsrsm2_bufferSizeExt function hipsparseScsrsm2_bufferSizeExt_(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBufferSizeInBytes) & bind(c, name="hipsparseScsrsm2_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsm2_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz type(c_ptr),value :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrsm2_bufferSizeExt_assumed_rank #else module procedure & hipsparseScsrsm2_bufferSizeExt_rank_0,& hipsparseScsrsm2_bufferSizeExt_rank_1,& hipsparseScsrsm2_bufferSizeExt_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsrsm2_bufferSizeExt function hipsparseDcsrsm2_bufferSizeExt_(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBufferSizeInBytes) & bind(c, name="hipsparseDcsrsm2_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsm2_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz type(c_ptr),value :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrsm2_bufferSizeExt_assumed_rank #else module procedure & hipsparseDcsrsm2_bufferSizeExt_rank_0,& hipsparseDcsrsm2_bufferSizeExt_rank_1,& hipsparseDcsrsm2_bufferSizeExt_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsrsm2_bufferSizeExt function hipsparseCcsrsm2_bufferSizeExt_(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBufferSizeInBytes) & bind(c, name="hipsparseCcsrsm2_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsm2_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz type(c_ptr),value :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrsm2_bufferSizeExt_assumed_rank #else module procedure & hipsparseCcsrsm2_bufferSizeExt_rank_0,& hipsparseCcsrsm2_bufferSizeExt_rank_1,& hipsparseCcsrsm2_bufferSizeExt_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsrsm2_bufferSizeExt function hipsparseZcsrsm2_bufferSizeExt_(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBufferSizeInBytes) & bind(c, name="hipsparseZcsrsm2_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsm2_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz type(c_ptr),value :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrsm2_bufferSizeExt_assumed_rank #else module procedure & hipsparseZcsrsm2_bufferSizeExt_rank_0,& hipsparseZcsrsm2_bufferSizeExt_rank_1,& hipsparseZcsrsm2_bufferSizeExt_full_rank #endif #endif end interface #endif !> \ingroup level3_module !> \details !> \p hipsparseXcsrsm2_analysis performs the analysis step for `hipsparseScsrsm2_solve` !> "hipsparseXcsrsm2_solve()". It is expected that this function will be executed only once !> for a given matrix and particular operation type. !> !> \note !> If the matrix sparsity pattern changes, the gathered information will become invalid. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] algo - algorithm to use. !> @param[in] transA - matrix \f$A\f$ operation type. !> @param[in] transB - matrix \f$B\f$ operation type. !> @param[in] m - number of rows of the sparse CSR matrix \f$A\f$. !> @param[in] nrhs - number of columns of the dense matrix \f$op(B)\f$. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descrA - descriptor of the sparse CSR matrix \f$A\f$. !> @param[in] csrSortedValA - array of \p nnz elements of the sparse CSR matrix \f$A\f$. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix \f$A\f$. !> @param[in] csrSortedColIndA - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix \f$A\f$. !> @param[in] B - array of \p m \f$\times\f$ \p nrhs elements of the rhs matrix \f$B\f$. !> @param[in] ldb - leading dimension of rhs matrix \f$B\f$. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[in] policy - `HIPSPARSE_SOLVE_POLICY_NO_LEVEL` or !> `HIPSPARSE_SOLVE_POLICY_USE_LEVEL`. !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p nrhs, \p nnz, \p alpha, !> \p descrA, \p csrSortedValA, \p csrSortedRowPtrA, \p csrSortedColIndA, \p B, !> \p info, or \p pBuffer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> \p transA == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE`, !> \p transB == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE`, or !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseScsrsm2_analysis function hipsparseScsrsm2_analysis_(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) & bind(c, name="hipsparseScsrsm2_analysis") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsm2_analysis_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz real(c_float) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrsm2_analysis_assumed_rank #else module procedure & hipsparseScsrsm2_analysis_rank_0,& hipsparseScsrsm2_analysis_rank_1,& hipsparseScsrsm2_analysis_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsrsm2_analysis function hipsparseDcsrsm2_analysis_(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) & bind(c, name="hipsparseDcsrsm2_analysis") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsm2_analysis_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz real(c_double) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrsm2_analysis_assumed_rank #else module procedure & hipsparseDcsrsm2_analysis_rank_0,& hipsparseDcsrsm2_analysis_rank_1,& hipsparseDcsrsm2_analysis_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsrsm2_analysis function hipsparseCcsrsm2_analysis_(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) & bind(c, name="hipsparseCcsrsm2_analysis") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsm2_analysis_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz complex(c_float_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrsm2_analysis_assumed_rank #else module procedure & hipsparseCcsrsm2_analysis_rank_0,& hipsparseCcsrsm2_analysis_rank_1,& hipsparseCcsrsm2_analysis_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsrsm2_analysis function hipsparseZcsrsm2_analysis_(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) & bind(c, name="hipsparseZcsrsm2_analysis") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsm2_analysis_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz complex(c_double_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrsm2_analysis_assumed_rank #else module procedure & hipsparseZcsrsm2_analysis_rank_0,& hipsparseZcsrsm2_analysis_rank_1,& hipsparseZcsrsm2_analysis_full_rank #endif #endif end interface #endif !> \ingroup level3_module !> \brief Sparse triangular system solve using the CSR storage format !> !> \details !> \p hipsparseXcsrsm2_solve solves a sparse triangular linear system of a sparse !> \f$m \times m\f$ matrix, defined in CSR storage format, a column-oriented dense solution !> matrix !> \f$X\f$, and the column-oriented dense right-hand side matrix \f$B\f$ that is multiplied by !> \f$\alpha\f$, such that !> \f[ !> op(A) \cdot op(X) = \alpha \cdot op(B), !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if transA == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> A^T, & \text{if transA == HIPSPARSE_OPERATION_TRANSPOSE} \\% !> A^H, & \text{if transA == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} !> \end{array} !> \right. !> \f] !> , !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if transB == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> B^T, & \text{if transB == HIPSPARSE_OPERATION_TRANSPOSE} \\% !> B^H, & \text{if transB == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(X) = \left\{ !> \begin{array}{ll} !> X, & \text{if transB == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> X^T, & \text{if transB == HIPSPARSE_OPERATION_TRANSPOSE} \\% !> X^H, & \text{if transB == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} !> \end{array} !> \right. !> \f] !> !> The solution is performed in-place, meaning that the matrix \f$B\f$ is overwritten with the !> solution !> \f$X\f$ after calling \p hipsparseXcsrsm2_solve. Given that the sparse matrix \f$A\f$ is a !> square matrix, its !> size is \f$m \times m\f$ regardless of whether \f$A\f$ is transposed or not. The size of the !> column-oriented dense !> matrices \f$B\f$ and \f$X\f$ depend on the value of \p transB !> !> \f[ !> op(B)/op(X) = \left\{ !> \begin{array}{ll} !> ldb \times nrhs, \text{ } ldb ≥ m, & \text{if transB == !> HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> ldb \times m, \text{ } ldb ≥ nrhs, & \text{if transB == !> HIPSPARSE_OPERATION_TRANSPOSE} \\% !> ldb \times m, \text{ } ldb ≥ nrhs, & \text{if transB == !> HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} !> \end{array} !> \right. !> \f] !> !> \p hipsparseXcsrsm2_solve requires a user-allocated temporary buffer. Its size is returned by !> `hipsparseScsrsm2_bufferSizeExt` "hipsparseXcsrsm2_bufferSizeExt()". The size of the required !> buffer is !> larger when \p transA equals `HIPSPARSE_OPERATION_TRANSPOSE` or !> `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE` !> and when \p transB is `HIPSPARSE_OPERATION_NON_TRANSPOSE`. The subsequent solve will also be !> faster when \f$A\f$ !> is non-transposed and \f$B\f$ is transposed (or conjugate transposed). For example, instead !> of solving: !> !> \f[ !> \begin{bmatrix} !> a_{00} & 0 & 0 \\% !> a_{10} & a_{11} & 0 \\% !> a_{20} & a_{21} & a_{22} \\% !> \end{bmatrix} !> \cdot !> \begin{bmatrix} !> x_{00} & x_{01} \\% !> x_{10} & x_{11} \\% !> x_{20} & x_{21} \\% !> \end{bmatrix} !> = !> \begin{bmatrix} !> b_{00} & b_{01} \\% !> b_{10} & b_{11} \\% !> b_{20} & b_{21} \\% !> \end{bmatrix} !> \f] !> !> Consider solving: !> !> \f[ !> \begin{bmatrix} !> a_{00} & 0 & 0 \\% !> a_{10} & a_{11} & 0 \\% !> a_{20} & a_{21} & a_{22} !> \end{bmatrix} !> \cdot !> \begin{bmatrix} !> x_{00} & x_{10} & x_{20} \\% !> x_{01} & x_{11} & x_{21} !> \end{bmatrix}^{T} !> = !> \begin{bmatrix} !> b_{00} & b_{10} & b_{20} \\% !> b_{01} & b_{11} & b_{21} !> \end{bmatrix}^{T} !> \f] !> !> After the temporary storage buffer has been allocated, analysis meta data is required. It can !> be obtained by !> `hipsparseScsrsm2_analysis` "hipsparseXcsrsm2_analysis()". The triangular solve is completed !> by calling !> \p hipsparseXcsrsm2_solve. After all solves are performed, the temporary storage buffer !> allocated by the !> user can be freed. !> !> Solving a triangular system involves division by the diagonal elements. This means that if !> the sparse matrix is !> missing the diagonal entry (referred to as a structural zero) or the diagonal entry is zero !> (referred to as a numerical zero), !> then a division by zero would occur. \p hipsparseXcsrsm2_solve tracks the location of the !> first zero pivot (either numerical !> or structural zero). The zero pivot status can be checked by calling !> `hipsparseXcsrsm2_zeroPivot` (). If !> `hipsparseXcsrsm2_zeroPivot` () returns `HIPSPARSE_STATUS_SUCCESS`, then no zero pivot was !> found and therefore !> the matrix does not have a structural or numerical zero. !> !> The user can specify that the sparse matrix should be interpreted as having ones on the !> diagonal by setting the diagonal type !> on the descriptor \p descrA to `HIPSPARSE_DIAG_TYPE_UNIT` using `hipsparseSetMatDiagType`. If !> `hipsparseDiagType_t` == `HIPSPARSE_DIAG_TYPE_UNIT`, no zero pivot will be reported, even if !> \f$A_{j,j} = 0\f$ for !> some \f$j\f$. !> !> The sparse CSR matrix passed to \p hipsparseXcsrsm2_solve does not actually have to be a !> triangular matrix. Instead, the !> triangular upper or lower part of the sparse matrix is solved based on the !> `hipsparseFillMode_t` setting on the descriptor !> \p descrA. If the fill mode is set to `HIPSPARSE_FILL_MODE_LOWER`, then the lower triangular !> matrix is solved. If the !> fill mode is set to `HIPSPARSE_FILL_MODE_UPPER`, then the upper triangular matrix is solved. !> !> \note !> The sparse CSR matrix has to be sorted. This can be achieved by calling !> `hipsparseXcsrsort()`. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p transA != `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE` and !> \p transB != `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE` is supported. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] algo - algorithm to use. !> @param[in] transA - matrix \f$A\f$ operation type. !> @param[in] transB - matrix \f$B\f$ operation type. !> @param[in] m - number of rows of the sparse CSR matrix \f$A\f$. !> @param[in] nrhs - number of columns of the dense matrix \f$op(B)\f$. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descrA - descriptor of the sparse CSR matrix \f$A\f$. !> @param[in] csrSortedValA - array of \p nnz elements of the sparse CSR matrix \f$A\f$. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix \f$A\f$. !> @param[in] csrSortedColIndA - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix \f$A\f$. !> @param[inout] B - array of \p m \f$\times\f$ \p nrhs elements of the rhs matrix \f$B\f$. !> @param[in] ldb - leading dimension of rhs matrix \f$B\f$. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] policy - `HIPSPARSE_SOLVE_POLICY_NO_LEVEL` or !> `HIPSPARSE_SOLVE_POLICY_USE_LEVEL`. !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p nrhs, \p nnz, \p alpha, !> \p descrA, \p csrSortedValA, \p csrSortedRowPtrA, \p csrSortedColIndA, \p B, !> \p info, or \p pBuffer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> \p transA == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE`, !> \p transB == `HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE`, or !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseScsrsm2_solve function hipsparseScsrsm2_solve_(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) & bind(c, name="hipsparseScsrsm2_solve") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsm2_solve_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz real(c_float) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrsm2_solve_assumed_rank #else module procedure & hipsparseScsrsm2_solve_rank_0,& hipsparseScsrsm2_solve_rank_1,& hipsparseScsrsm2_solve_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsrsm2_solve function hipsparseDcsrsm2_solve_(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) & bind(c, name="hipsparseDcsrsm2_solve") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsm2_solve_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz real(c_double) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrsm2_solve_assumed_rank #else module procedure & hipsparseDcsrsm2_solve_rank_0,& hipsparseDcsrsm2_solve_rank_1,& hipsparseDcsrsm2_solve_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsrsm2_solve function hipsparseCcsrsm2_solve_(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) & bind(c, name="hipsparseCcsrsm2_solve") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsm2_solve_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz complex(c_float_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrsm2_solve_assumed_rank #else module procedure & hipsparseCcsrsm2_solve_rank_0,& hipsparseCcsrsm2_solve_rank_1,& hipsparseCcsrsm2_solve_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsrsm2_solve function hipsparseZcsrsm2_solve_(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) & bind(c, name="hipsparseZcsrsm2_solve") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsm2_solve_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz complex(c_double_complex) :: alpha type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrsm2_solve_assumed_rank #else module procedure & hipsparseZcsrsm2_solve_rank_0,& hipsparseZcsrsm2_solve_rank_1,& hipsparseZcsrsm2_solve_full_rank #endif #endif end interface #endif !> \ingroup level3_module !> \brief Dense matrix sparse matrix multiplication using the CSC storage format. !> !> \details !> \p hipsparseXgemmi multiplies the scalar \f$\alpha\f$ with a dense column-oriented \f$m !> \times k\f$ !> matrix \f$A\f$ and the sparse \f$k \times n\f$ matrix \f$B\f$, defined in CSC !> storage format, and adds the result to the dense column-oriented \f$m \times n\f$ matrix !> \f$C\f$ that !> is multiplied by the scalar \f$\beta\f$, such that !> \f[ !> C := \alpha \cdot A \cdot B + \beta \cdot C !> \f] !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 11.0+) and will be !> removed in CUDA 12.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the dense matrix \f$A\f$. Must be non-negative. !> @param[in] n - number of columns of the sparse CSC matrix \f$op(B)\f$ and \f$C\f$. Must be !> non-negative. !> @param[in] k - number of columns of the dense matrix \f$A\f$. Must be non-negative. !> @param[in] nnz - number of non-zero entries of the sparse CSC matrix \f$B\f$. Must be !> non-negative. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] A - array of dimension \f$lda \times k\f$ (\f$op(A) == A\f$) or !> \f$lda \times m\f$ (\f$op(A) == A^T\f$ or \f$op(A) == A^H\f$). !> @param[in] lda - leading dimension of \f$A\f$, must be at least \f$m\f$ !> (\f$op(A) == A\f$) or \f$k\f$ (\f$op(A) == A^T\f$ or !> \f$op(A) == A^H\f$). !> @param[in] cscValB - array of \p nnz elements of the sparse CSC matrix \f$B\f$. !> @param[in] cscColPtrB - array of \p n+1 elements that point to the start of every column of !> the !> sparse CSC matrix \f$B\f$. !> @param[in] cscRowIndB - array of \p nnz elements containing the column indices of the sparse !> CSC !> matrix \f$B\f$. !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] C - array of dimension \f$ldc \times n\f$ that holds the values of \f$C\f$. !> @param[in] ldc - leading dimension of \f$C\f$, must be at least \f$m\f$. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p alpha or \p beta is nullptr, !> \p m, \p n, \p k, or \p nnz is negative, \p lda or \p ldc is invalid, or !> \p A, \p cscValB, \p cscColPtrB, \p cscRowIndB, or \p C is nullptr. #ifndef USE_CUDA_NAMES interface hipsparseSgemmi function hipsparseSgemmi_(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB,cscRowIndB,beta,C, & ldc) & bind(c, name="hipsparseSgemmi") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgemmi_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: cscValB type(c_ptr),value :: cscColPtrB type(c_ptr),value :: cscRowIndB real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSgemmi_assumed_rank #else module procedure & hipsparseSgemmi_rank_0,& hipsparseSgemmi_rank_1,& hipsparseSgemmi_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDgemmi function hipsparseDgemmi_(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB,cscRowIndB,beta,C, & ldc) & bind(c, name="hipsparseDgemmi") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgemmi_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: cscValB type(c_ptr),value :: cscColPtrB type(c_ptr),value :: cscRowIndB real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDgemmi_assumed_rank #else module procedure & hipsparseDgemmi_rank_0,& hipsparseDgemmi_rank_1,& hipsparseDgemmi_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCgemmi function hipsparseCgemmi_(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB,cscRowIndB,beta,C, & ldc) & bind(c, name="hipsparseCgemmi") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgemmi_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: cscValB type(c_ptr),value :: cscColPtrB type(c_ptr),value :: cscRowIndB complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCgemmi_assumed_rank #else module procedure & hipsparseCgemmi_rank_0,& hipsparseCgemmi_rank_1,& hipsparseCgemmi_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZgemmi function hipsparseZgemmi_(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB,cscRowIndB,beta,C, & ldc) & bind(c, name="hipsparseZgemmi") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgemmi_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: cscValB type(c_ptr),value :: cscColPtrB type(c_ptr),value :: cscRowIndB complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZgemmi_assumed_rank #else module procedure & hipsparseZgemmi_rank_0,& hipsparseZgemmi_rank_1,& hipsparseZgemmi_full_rank #endif #endif end interface #endif !> \ingroup extra_module !> \details !> \p hipsparseXcsrgeamNnz computes the total CSR non-zero elements and the CSR row !> offsets that point to the start of every row of the sparse CSR matrix of the !> resulting matrix \f$C\f$. It is assumed that \p csrRowPtrC has been allocated with !> size \p m+1. The desired index base in the output CSR matrix is set in the !> `hipsparseMatDescr_t`. See `hipsparseSetMatIndexBase`(). !> !> For a full code example, see `hipsparseScsrgeam`(). !> !> \note !> As indicated, \p nnzTotalDevHostPtr can point to either host or device memory. This is !> controlled !> by setting the pointer mode. See `hipsparseSetPointerMode`(). !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> !> \deprecated !> This function is deprecated and will be removed in a future release. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrices \f$A\f$, \f$B\f$, and \f$C\f$. Must !> be non-negative. !> @param[in] n - number of columns of the sparse CSR matrices \f$A\f$, \f$B\f$, and \f$C\f$. !> Must be non-negative. !> @param[in] descrA - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzA - number of non-zero entries of the sparse CSR matrix \f$A\f$. Must be !> non-negative. !> @param[in] csrRowPtrA - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix \f$A\f$. !> @param[in] csrColIndA - array of \p nnzA elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] descrB - descriptor of the sparse CSR matrix \f$B\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzB - number of non-zero entries of the sparse CSR matrix \f$B\f$. Must be !> non-negative. !> @param[in] csrRowPtrB - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix \f$B\f$. !> @param[in] csrColIndB - array of \p nnzB elements containing the column indices of the !> sparse CSR matrix \f$B\f$. !> @param[in] descrC - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[out] csrRowPtrC - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix \f$C\f$. !> @param[out] nnzTotalDevHostPtr - pointer to the number of non-zero entries of the sparse CSR !> matrix \f$C\f$. \p nnzTotalDevHostPtr can be a host or device pointer. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p descrA, \p descrB, or \p descrC is !> nullptr, !> \p m, \p n, \p nnzA, or \p nnzB is negative, or \p csrRowPtrA, \p csrColIndA, \p !> csrRowPtrB, !> \p csrColIndB, \p csrRowPtrC, or \p nnzTotalDevHostPtr is nullptr. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED `hipsparseMatrixType_t` is not !> `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseXcsrgeamNnz function hipsparseXcsrgeamNnz_(handle,m,n,descrA,nnzA,csrRowPtrA,csrColIndA,descrB,nnzB, & csrRowPtrB,csrColIndB,descrC,csrRowPtrC,nnzTotalDevHostPtr) & bind(c, name="hipsparseXcsrgeamNnz") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrgeamNnz_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrRowPtrB type(c_ptr),value :: csrColIndB type(c_ptr),value :: descrC type(c_ptr),value :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseXcsrgeamNnz_assumed_rank #else module procedure & hipsparseXcsrgeamNnz_rank_0,& hipsparseXcsrgeamNnz_rank_1 #endif #endif end interface #endif !> \ingroup extra_module !> \brief Sparse matrix sparse matrix addition using the CSR storage format. !> !> \details !> \p hipsparseXcsrgeam multiplies the scalar \f$\alpha\f$ with the sparse !> \f$m \times n\f$ matrix \f$A\f$, defined in CSR storage format, multiplies the !> scalar \f$\beta\f$ with the sparse \f$m \times n\f$ matrix \f$B\f$, defined in CSR !> storage format, and adds both resulting matrices to obtain the sparse !> \f$m \times n\f$ matrix \f$C\f$, defined in CSR storage format, such that !> \f[ !> C := \alpha \cdot A + \beta \cdot B. !> \f] !> !> This computation involves a multi-step process. First, the user must allocate \p csrRowPtrC !> to have size \p m+1. The user then calls `hipsparseXcsrgeamNnz`, which fills in the \p !> csrRowPtrC !> array and computes the total number of non-zeros in \f$C\f$, \p nnzC. The user then allocates !> both !> arrays \p csrColIndC and \p csrValC to have size \p nnzC and calls \p hipsparseXcsrgeam to !> complete !> the computation. The desired index base in the output CSR matrix \f$C\f$ is set in the !> `hipsparseMatDescr_t` \p descrC. See `hipsparseSetMatIndexBase`(). !> !> \note Both scalars \f$\alpha\f$ and \f$beta\f$ have to be valid. !> \note Currently, only `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> \note This function is non-blocking and executed asynchronously with respect to the !> host. It can return before the actual computation has finished. !> !> \deprecated !> This function is deprecated and will be removed in a future release. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrices \f$A\f$, \f$B\f$, and \f$C\f$. !> @param[in] n - number of columns of the sparse CSR matrices \f$A\f$, \f$B\f$, and \f$C\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descrA - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzA - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] csrValA - array of \p nnzA elements of the sparse CSR matrix \f$A\f$. !> @param[in] csrRowPtrA - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix \f$A\f$. !> @param[in] csrColIndA - array of \p nnzA elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] beta - scalar \f$\beta\f$. !> @param[in] descrB - descriptor of the sparse CSR matrix \f$B\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzB - number of non-zero entries of the sparse CSR matrix \f$B\f$. !> @param[in] csrValB - array of \p nnzB elements of the sparse CSR matrix \f$B\f$. !> @param[in] csrRowPtrB - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix \f$B\f$. !> @param[in] csrColIndB - array of \p nnzB elements containing the column indices of the !> sparse CSR matrix \f$B\f$. !> @param[in] descrC - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[out] csrValC - array of elements of the sparse CSR matrix \f$C\f$. !> @param[in] csrRowPtrC - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix \f$C\f$. !> @param[out] csrColIndC - array of elements containing the column indices of the !> sparse CSR matrix \f$C\f$. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p nnzA, \p nnzB, !> \p alpha, \p descrA, \p csrValA, \p csrRowPtrA, \p csrColIndA, \p beta, !> \p descrB, \p csrValB, \p csrRowPtrB, \p csrColIndB, \p descrC, \p csrValC, !> \p csrRowPtrC, or \p csrColIndC is invalid. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseScsrgeam function hipsparseScsrgeam_(handle,m,n,alpha,descrA,nnzA,csrValA,csrRowPtrA,csrColIndA,beta, & descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="hipsparseScsrgeam") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgeam_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA real(c_float) :: beta type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrValB type(c_ptr),value :: csrRowPtrB type(c_ptr),value :: csrColIndB type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrgeam_assumed_rank #else module procedure & hipsparseScsrgeam_rank_0,& hipsparseScsrgeam_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsrgeam function hipsparseDcsrgeam_(handle,m,n,alpha,descrA,nnzA,csrValA,csrRowPtrA,csrColIndA,beta, & descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="hipsparseDcsrgeam") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgeam_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA real(c_double) :: beta type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrValB type(c_ptr),value :: csrRowPtrB type(c_ptr),value :: csrColIndB type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrgeam_assumed_rank #else module procedure & hipsparseDcsrgeam_rank_0,& hipsparseDcsrgeam_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsrgeam function hipsparseCcsrgeam_(handle,m,n,alpha,descrA,nnzA,csrValA,csrRowPtrA,csrColIndA,beta, & descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="hipsparseCcsrgeam") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgeam_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA complex(c_float_complex) :: beta type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrValB type(c_ptr),value :: csrRowPtrB type(c_ptr),value :: csrColIndB type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrgeam_assumed_rank #else module procedure & hipsparseCcsrgeam_rank_0,& hipsparseCcsrgeam_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsrgeam function hipsparseZcsrgeam_(handle,m,n,alpha,descrA,nnzA,csrValA,csrRowPtrA,csrColIndA,beta, & descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="hipsparseZcsrgeam") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgeam_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA complex(c_double_complex) :: beta type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrValB type(c_ptr),value :: csrRowPtrB type(c_ptr),value :: csrColIndB type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrgeam_assumed_rank #else module procedure & hipsparseZcsrgeam_rank_0,& hipsparseZcsrgeam_rank_1 #endif #endif end interface #endif !> \ingroup extra_module !> \details !> \p hipsparseXcsrgeam2_bufferSizeExt returns the size of the temporary storage buffer !> in bytes that is required by `hipsparseXcsrgeam2Nnz`() and `hipsparseScsrgeam2` !> "hipsparseXcsrgeam2()". The temporary storage buffer must be allocated by the user. !> !> \note !> Currently, only `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrices \f$A\f$, \f$B\f$, and \f$C\f$. !> @param[in] n - number of columns of the sparse CSR matrices \f$A\f$, \f$B\f$, and \f$C\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descrA - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzA - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] csrSortedValA - array of \p nnzA elements of the sparse CSR matrix \f$A\f$. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix \f$A\f$. !> @param[in] csrSortedColIndA - array of \p nnzA elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] beta - scalar \f$\beta\f$. !> @param[in] descrB - descriptor of the sparse CSR matrix \f$B\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzB - number of non-zero entries of the sparse CSR matrix \f$B\f$. !> @param[in] csrSortedValB - array of \p nnzB elements of the sparse CSR matrix \f$B\f$. !> @param[in] csrSortedRowPtrB - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix \f$B\f$. !> @param[in] csrSortedColIndB - array of \p nnzB elements containing the column indices of the !> sparse CSR matrix \f$B\f$. !> @param[in] descrC - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[out] csrSortedValC - array of elements of the sparse CSR matrix \f$C\f$. !> @param[in] csrSortedRowPtrC - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix \f$C\f$. !> @param[out] csrSortedColIndC - array of elements containing the column indices of the !> sparse CSR matrix \f$C\f$. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseXcsrgeam2Nnz()` and `hipsparseScsrgeam2` "hipsparseXcsrgeam2()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p nnzA, \p nnzB, !> \p alpha, \p descrA, \p csrSortedValA, \p csrSortedRowPtrA, \p csrSortedColIndA, !> \p beta, \p descrB, \p csrSortedValB, \p csrSortedRowPtrB, \p csrSortedColIndB, !> \p descrC, \p csrSortedValC, \p csrSortedRowPtrC, \p csrSortedColIndC, or !> \p pBufferSizeInBytes is invalid. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseScsrgeam2_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseScsrgeam2_bufferSizeExt_(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC, & pBufferSizeInBytes) & bind(c, name="cusparseScsrgeam2_bufferSizeExt") #else function hipsparseScsrgeam2_bufferSizeExt_(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC, & pBufferSizeInBytes) & bind(c, name="hipsparseScsrgeam2_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgeam2_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA real(c_float) :: beta type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrSortedValB type(c_ptr),value :: csrSortedRowPtrB type(c_ptr),value :: csrSortedColIndB type(c_ptr),value :: descrC type(c_ptr),value :: csrSortedValC type(c_ptr),value :: csrSortedRowPtrC type(c_ptr),value :: csrSortedColIndC integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrgeam2_bufferSizeExt_assumed_rank #else module procedure & hipsparseScsrgeam2_bufferSizeExt_rank_0,& hipsparseScsrgeam2_bufferSizeExt_rank_1 #endif #endif end interface interface hipsparseDcsrgeam2_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseDcsrgeam2_bufferSizeExt_(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC, & pBufferSizeInBytes) & bind(c, name="cusparseDcsrgeam2_bufferSizeExt") #else function hipsparseDcsrgeam2_bufferSizeExt_(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC, & pBufferSizeInBytes) & bind(c, name="hipsparseDcsrgeam2_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgeam2_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA real(c_double) :: beta type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrSortedValB type(c_ptr),value :: csrSortedRowPtrB type(c_ptr),value :: csrSortedColIndB type(c_ptr),value :: descrC type(c_ptr),value :: csrSortedValC type(c_ptr),value :: csrSortedRowPtrC type(c_ptr),value :: csrSortedColIndC integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrgeam2_bufferSizeExt_assumed_rank #else module procedure & hipsparseDcsrgeam2_bufferSizeExt_rank_0,& hipsparseDcsrgeam2_bufferSizeExt_rank_1 #endif #endif end interface interface hipsparseCcsrgeam2_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseCcsrgeam2_bufferSizeExt_(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC, & pBufferSizeInBytes) & bind(c, name="cusparseCcsrgeam2_bufferSizeExt") #else function hipsparseCcsrgeam2_bufferSizeExt_(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC, & pBufferSizeInBytes) & bind(c, name="hipsparseCcsrgeam2_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgeam2_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA complex(c_float_complex) :: beta type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrSortedValB type(c_ptr),value :: csrSortedRowPtrB type(c_ptr),value :: csrSortedColIndB type(c_ptr),value :: descrC type(c_ptr),value :: csrSortedValC type(c_ptr),value :: csrSortedRowPtrC type(c_ptr),value :: csrSortedColIndC integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrgeam2_bufferSizeExt_assumed_rank #else module procedure & hipsparseCcsrgeam2_bufferSizeExt_rank_0,& hipsparseCcsrgeam2_bufferSizeExt_rank_1 #endif #endif end interface interface hipsparseZcsrgeam2_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseZcsrgeam2_bufferSizeExt_(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC, & pBufferSizeInBytes) & bind(c, name="cusparseZcsrgeam2_bufferSizeExt") #else function hipsparseZcsrgeam2_bufferSizeExt_(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC, & pBufferSizeInBytes) & bind(c, name="hipsparseZcsrgeam2_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgeam2_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA complex(c_double_complex) :: beta type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrSortedValB type(c_ptr),value :: csrSortedRowPtrB type(c_ptr),value :: csrSortedColIndB type(c_ptr),value :: descrC type(c_ptr),value :: csrSortedValC type(c_ptr),value :: csrSortedRowPtrC type(c_ptr),value :: csrSortedColIndC integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrgeam2_bufferSizeExt_assumed_rank #else module procedure & hipsparseZcsrgeam2_bufferSizeExt_rank_0,& hipsparseZcsrgeam2_bufferSizeExt_rank_1 #endif #endif end interface !> \ingroup extra_module !> \details !> \p hipsparseXcsrgeam2Nnz computes the total CSR non-zero elements and the CSR row !> offsets that point to the start of every row of the sparse CSR matrix of the !> resulting matrix \f$C\f$. It is assumed that \p csrRowPtrC has been allocated with !> size \p m+1. The required buffer size can be obtained by !> `hipsparseScsrgeam2_bufferSizeExt` "hipsparseXcsrgeam2_bufferSizeExt()". The !> desired index base in the output CSR matrix \f$C\f$ is set in the `hipsparseMatDescr_t` !> \p descrC. See `hipsparseSetMatIndexBase`(). !> !> \note !> As indicated, \p nnzTotalDevHostPtr can point to either host or device memory. This is !> controlled !> by setting the pointer mode. See `hipsparseSetPointerMode`(). !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> \note !> Currently, only `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrices \f$A\f$, \f$B\f$, and \f$C\f$. !> @param[in] n - number of columns of the sparse CSR matrices \f$A\f$, \f$B\f$, and \f$C\f$. !> @param[in] descrA - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzA - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix \f$A\f$. !> @param[in] csrSortedColIndA - array of \p nnzA elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] descrB - descriptor of the sparse CSR matrix \f$B\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzB - number of non-zero entries of the sparse CSR matrix \f$B\f$. !> @param[in] csrSortedRowPtrB - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix \f$B\f$. !> @param[in] csrSortedColIndB - array of \p nnzB elements containing the column indices of the !> sparse CSR matrix \f$B\f$. !> @param[in] descrC - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrSortedRowPtrC - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix \f$C\f$. !> @param[out] nnzTotalDevHostPtr - pointer to the number of non-zero entries of the sparse CSR !> matrix \f$C\f$. \p nnzTotalDevHostPtr can be a host or device pointer. !> @param[in] workspace - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p nnzA, \p nnzB, !> \p descrA, \p csrSortedRowPtrA, \p csrSortedColIndA, \p descrB, \p csrSortedRowPtrB, !> \p csrSortedColIndB, \p descrC, \p csrSortedRowPtrC, or \p nnzTotalDevHostPtr is !> invalid. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseXcsrgeam2Nnz #ifdef USE_CUDA_NAMES function hipsparseXcsrgeam2Nnz_(handle,m,n,descrA,nnzA,csrSortedRowPtrA,csrSortedColIndA, & descrB,nnzB,csrSortedRowPtrB,csrSortedColIndB,descrC,csrSortedRowPtrC,nnzTotalDevHostPtr, & workspace) & bind(c, name="cusparseXcsrgeam2Nnz") #else function hipsparseXcsrgeam2Nnz_(handle,m,n,descrA,nnzA,csrSortedRowPtrA,csrSortedColIndA, & descrB,nnzB,csrSortedRowPtrB,csrSortedColIndB,descrC,csrSortedRowPtrC,nnzTotalDevHostPtr, & workspace) & bind(c, name="hipsparseXcsrgeam2Nnz") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrgeam2Nnz_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrSortedRowPtrB type(c_ptr),value :: csrSortedColIndB type(c_ptr),value :: descrC type(c_ptr),value :: csrSortedRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr),value :: workspace end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseXcsrgeam2Nnz_assumed_rank #else module procedure & hipsparseXcsrgeam2Nnz_rank_0,& hipsparseXcsrgeam2Nnz_rank_1 #endif #endif end interface !> \ingroup extra_module !> \brief Sparse matrix sparse matrix addition using the CSR storage format. !> !> \details !> \p hipsparseXcsrgeam2 multiplies the scalar \f$\alpha\f$ with the sparse !> \f$m \times n\f$ matrix \f$A\f$, defined in CSR storage format, multiplies the !> scalar \f$\beta\f$ with the sparse \f$m \times n\f$ matrix \f$B\f$, defined in CSR !> storage format, and adds both resulting matrices to obtain the sparse !> \f$m \times n\f$ matrix \f$C\f$, defined in CSR storage format, such that !> \f[ !> C := \alpha \cdot A + \beta \cdot B. !> \f] !> !> This computation involves a multi-step process. First, the user must call !> `hipsparseScsrgeam2_bufferSizeExt` "hipsparseXcsrgeam2_bufferSizeExt()" to determine the !> required user allocated temporary buffer size. The user then allocates this buffer and also !> allocates !> \p csrRowPtrC to have size \p m+1. Both the temporary storage buffer and \p csrRowPtrC array !> are then !> passed to `hipsparseXcsrgeam2Nnz`, which fills in the \p csrRowPtrC array and computes the !> total !> number of non-zeros in \f$C\f$, \p nnzC. The user then allocates both arrays \p csrColIndC !> and \p csrValC to have !> size \p nnzC and calls \p hipsparseXcsrgeam2 to complete the computation. The desired index !> base in !> the output CSR matrix \f$C\f$ is set in the `hipsparseMatDescr_t` \p descrC. See !> `hipsparseSetMatIndexBase` (). !> !> \note Both scalars \f$\alpha\f$ and \f$beta\f$ have to be valid. !> \note Currently, only `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> \note This function is non-blocking and executed asynchronously with respect to the !> host. It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrices \f$A\f$, \f$B\f$, and \f$C\f$. !> @param[in] n - number of columns of the sparse CSR matrices \f$A\f$, \f$B\f$, and \f$C\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descrA - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzA - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] csrSortedValA - array of \p nnzA elements of the sparse CSR matrix \f$A\f$. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix \f$A\f$. !> @param[in] csrSortedColIndA - array of \p nnzA elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] beta - scalar \f$\beta\f$. !> @param[in] descrB - descriptor of the sparse CSR matrix \f$B\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzB - number of non-zero entries of the sparse CSR matrix \f$B\f$. !> @param[in] csrSortedValB - array of \p nnzB elements of the sparse CSR matrix \f$B\f$. !> @param[in] csrSortedRowPtrB - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix \f$B\f$. !> @param[in] csrSortedColIndB - array of \p nnzB elements containing the column indices of the !> sparse CSR matrix \f$B\f$. !> @param[in] descrC - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[out] csrSortedValC - array of elements of the sparse CSR matrix \f$C\f$. !> @param[in] csrSortedRowPtrC - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix \f$C\f$. !> @param[out] csrSortedColIndC - array of elements containing the column indices of the !> sparse CSR matrix \f$C\f$. !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p nnzA, \p nnzB, !> \p alpha, \p descrA, \p csrSortedValA, \p csrSortedRowPtrA, \p csrSortedColIndA, \p !> beta, !> \p descrB, \p csrSortedValB, \p csrSortedRowPtrB, \p csrSortedColIndB, \p descrC, \p !> csrSortedValC, !> \p csrSortedRowPtrC, \p csrSortedColIndC, or \p pBuffer is invalid. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseScsrgeam2 #ifdef USE_CUDA_NAMES function hipsparseScsrgeam2_(handle,m,n,alpha,descrA,nnzA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB,csrSortedColIndB,descrC, & csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) & bind(c, name="cusparseScsrgeam2") #else function hipsparseScsrgeam2_(handle,m,n,alpha,descrA,nnzA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB,csrSortedColIndB,descrC, & csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) & bind(c, name="hipsparseScsrgeam2") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgeam2_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA real(c_float) :: beta type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrSortedValB type(c_ptr),value :: csrSortedRowPtrB type(c_ptr),value :: csrSortedColIndB type(c_ptr),value :: descrC type(c_ptr),value :: csrSortedValC type(c_ptr),value :: csrSortedRowPtrC type(c_ptr),value :: csrSortedColIndC type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrgeam2_assumed_rank #else module procedure & hipsparseScsrgeam2_rank_0,& hipsparseScsrgeam2_rank_1 #endif #endif end interface interface hipsparseDcsrgeam2 #ifdef USE_CUDA_NAMES function hipsparseDcsrgeam2_(handle,m,n,alpha,descrA,nnzA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB,csrSortedColIndB,descrC, & csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) & bind(c, name="cusparseDcsrgeam2") #else function hipsparseDcsrgeam2_(handle,m,n,alpha,descrA,nnzA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB,csrSortedColIndB,descrC, & csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) & bind(c, name="hipsparseDcsrgeam2") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgeam2_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA real(c_double) :: beta type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrSortedValB type(c_ptr),value :: csrSortedRowPtrB type(c_ptr),value :: csrSortedColIndB type(c_ptr),value :: descrC type(c_ptr),value :: csrSortedValC type(c_ptr),value :: csrSortedRowPtrC type(c_ptr),value :: csrSortedColIndC type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrgeam2_assumed_rank #else module procedure & hipsparseDcsrgeam2_rank_0,& hipsparseDcsrgeam2_rank_1 #endif #endif end interface interface hipsparseCcsrgeam2 #ifdef USE_CUDA_NAMES function hipsparseCcsrgeam2_(handle,m,n,alpha,descrA,nnzA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB,csrSortedColIndB,descrC, & csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) & bind(c, name="cusparseCcsrgeam2") #else function hipsparseCcsrgeam2_(handle,m,n,alpha,descrA,nnzA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB,csrSortedColIndB,descrC, & csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) & bind(c, name="hipsparseCcsrgeam2") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgeam2_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA complex(c_float_complex) :: beta type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrSortedValB type(c_ptr),value :: csrSortedRowPtrB type(c_ptr),value :: csrSortedColIndB type(c_ptr),value :: descrC type(c_ptr),value :: csrSortedValC type(c_ptr),value :: csrSortedRowPtrC type(c_ptr),value :: csrSortedColIndC type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrgeam2_assumed_rank #else module procedure & hipsparseCcsrgeam2_rank_0,& hipsparseCcsrgeam2_rank_1 #endif #endif end interface interface hipsparseZcsrgeam2 #ifdef USE_CUDA_NAMES function hipsparseZcsrgeam2_(handle,m,n,alpha,descrA,nnzA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB,csrSortedColIndB,descrC, & csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) & bind(c, name="cusparseZcsrgeam2") #else function hipsparseZcsrgeam2_(handle,m,n,alpha,descrA,nnzA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB,csrSortedColIndB,descrC, & csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) & bind(c, name="hipsparseZcsrgeam2") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgeam2_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA complex(c_double_complex) :: beta type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrSortedValB type(c_ptr),value :: csrSortedRowPtrB type(c_ptr),value :: csrSortedColIndB type(c_ptr),value :: descrC type(c_ptr),value :: csrSortedValC type(c_ptr),value :: csrSortedRowPtrC type(c_ptr),value :: csrSortedColIndC type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrgeam2_assumed_rank #else module procedure & hipsparseZcsrgeam2_rank_0,& hipsparseZcsrgeam2_rank_1 #endif #endif end interface !> \ingroup extra_module !> \details !> \p hipsparseXcsrgemmNnz computes the total CSR non-zero elements and the CSR row !> offsets that point to the start of every row of the sparse CSR matrix of the !> resulting multiplied matrix \f$C\f$. It is assumed that \p csrRowPtrC has been allocated !> with size \p m+1. The desired index base in the output CSR matrix \f$C\f$ is set in the !> `hipsparseMatDescr_t` \p descrC. See `hipsparseSetMatIndexBase`(). !> !> \note !> As indicated, \p nnzTotalDevHostPtr can point to either host or device memory. This is !> controlled !> by setting the pointer mode. See `hipsparseSetPointerMode`(). !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> For matrix products with more than 8192 intermediate products per !> row, an additional temporary storage buffer is allocated by the algorithm. !> !> \note !> Currently, only \p transA == \p transB == `HIPSPARSE_OPERATION_NON_TRANSPOSE` is !> supported. !> !> \note !> Currently, only `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 10.0+) and will be !> removed in CUDA 11.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] transA - matrix \f$A\f$ operation type. !> @param[in] transB - matrix \f$B\f$ operation type. !> @param[in] m - number of rows of the sparse CSR matrix \f$op(A)\f$ and \f$C\f$. Must be !> non-negative. !> @param[in] n - number of columns of the sparse CSR matrix \f$op(B)\f$ and !> \f$C\f$. Must be non-negative. !> @param[in] k - number of columns of the sparse CSR matrix \f$op(A)\f$ and number of !> rows of the sparse CSR matrix \f$op(B)\f$. Must be non-negative. !> @param[in] descrA - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzA - number of non-zero entries of the sparse CSR matrix \f$A\f$. Must be !> non-negative. !> @param[in] csrRowPtrA - array of \p m+1 elements (\f$op(A) == A\f$, \p k+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(A)\f$. !> @param[in] csrColIndA - array of \p nnzA elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] descrB - descriptor of the sparse CSR matrix \f$B\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzB - number of non-zero entries of the sparse CSR matrix \f$B\f$. Must be !> non-negative. !> @param[in] csrRowPtrB - array of \p k+1 elements (\f$op(B) == B\f$, \p m+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(B)\f$. !> @param[in] csrColIndB - array of \p nnzB elements containing the column indices of the !> sparse CSR matrix \f$B\f$. !> @param[in] descrC - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrRowPtrC - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix \f$C\f$. !> @param[inout] nnzTotalDevHostPtr - pointer to the number of non-zero entries of the sparse !> CSR !> matrix \f$C\f$. \p nnzTotalDevHostPtr can be a host or device pointer. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p descrA, \p descrB, or \p descrC is !> nullptr, !> \p m, \p n, \p k, \p nnzA, or \p nnzB is negative, or \p csrRowPtrA, \p csrColIndA, !> \p csrRowPtrB, \p csrColIndB, \p csrRowPtrC, or \p nnzTotalDevHostPtr is nullptr. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED \p transA is not `HIPSPARSE_OPERATION_NON_TRANSPOSE`, !> \p transB is not `HIPSPARSE_OPERATION_NON_TRANSPOSE`, or !> `hipsparseMatrixType_t` is not `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseXcsrgemmNnz function hipsparseXcsrgemmNnz_(handle,transA,transB,m,n,k,descrA,nnzA,csrRowPtrA,csrColIndA, & descrB,nnzB,csrRowPtrB,csrColIndB,descrC,csrRowPtrC,nnzTotalDevHostPtr) & bind(c, name="hipsparseXcsrgemmNnz") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrgemmNnz_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrRowPtrB type(c_ptr),value :: csrColIndB type(c_ptr),value :: descrC type(c_ptr),value :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseXcsrgemmNnz_assumed_rank #else module procedure & hipsparseXcsrgemmNnz_rank_0,& hipsparseXcsrgemmNnz_rank_1 #endif #endif end interface #endif !> \ingroup extra_module !> \brief Sparse matrix and sparse matrix multiplication using the CSR storage format. !> !> \details !> \p hipsparseXcsrgemm multiplies the sparse \f$m \times k\f$ matrix \f$op(A)\f$, defined in !> CSR storage format, with the sparse \f$k \times n\f$ matrix \f$op(B)\f$, defined in CSR !> storage format, and stores the result in the sparse \f$m \times n\f$ matrix \f$C\f$, !> defined in CSR storage format, such that !> \f[ !> C := op(A) \cdot op(B), !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if transA == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> A^T, & \text{if transA == HIPSPARSE_OPERATION_TRANSPOSE} \\% !> A^H, & \text{if transA == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if transB == HIPSPARSE_OPERATION_NON_TRANSPOSE} \\% !> B^T, & \text{if transB == HIPSPARSE_OPERATION_TRANSPOSE} \\% !> B^H, & \text{if transB == HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE} !> \end{array} !> \right. !> \f] !> !> This computation involves a multi-step process. First, the user must allocate \p csrRowPtrC !> to have size \p m+1. The user then calls `hipsparseXcsrgemmNnz`, which fills in the \p !> csrRowPtrC !> array and computes the total number of non-zeros in C, \p nnzC. The user then allocates both !> arrays \p csrColIndC and \p csrValC to have size \p nnzC and calls \p hipsparseXcsrgemm to !> complete !> the computation. The desired index base in the output CSR matrix C is set in the !> `hipsparseMatDescr_t` \p descrC. See `hipsparseSetMatIndexBase`(). !> !> \note Currently, only \p transA == `HIPSPARSE_OPERATION_NON_TRANSPOSE` is supported. !> \note Currently, only \p transB == `HIPSPARSE_OPERATION_NON_TRANSPOSE` is supported. !> \note Currently, only `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> \note This function is non-blocking and executed asynchronously with respect to the !> host. It can return before the actual computation has finished. !> \note For matrix products with more than 4096 non-zero entries per !> row, an additional temporary storage buffer is allocated by the algorithm. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] transA - matrix \f$A\f$ operation type. !> @param[in] transB - matrix \f$B\f$ operation type. !> @param[in] m - number of rows of the sparse CSR matrix \f$op(A)\f$ and \f$C\f$. !> @param[in] n - number of columns of the sparse CSR matrix \f$op(B)\f$ and !> \f$C\f$. !> @param[in] k - number of columns of the sparse CSR matrix \f$op(A)\f$ and number of !> rows of the sparse CSR matrix \f$op(B)\f$. !> @param[in] descrA - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzA - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] csrValA - array of \p nnzA elements of the sparse CSR matrix \f$A\f$. !> @param[in] csrRowPtrA - array of \p m+1 elements (\f$op(A) == A\f$, \p k+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(A)\f$. !> @param[in] csrColIndA - array of \p nnzA elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] descrB - descriptor of the sparse CSR matrix \f$B\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzB - number of non-zero entries of the sparse CSR matrix \f$B\f$. !> @param[in] csrValB - array of \p nnzB elements of the sparse CSR matrix \f$B\f$. !> @param[in] csrRowPtrB - array of \p k+1 elements (\f$op(B) == B\f$, \p m+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(B)\f$. !> @param[in] csrColIndB - array of \p nnzB elements containing the column indices of the !> sparse CSR matrix \f$B\f$. !> @param[in] descrC - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[out] csrValC - array of \p nnzC elements of the sparse CSR matrix \f$C\f$. !> @param[in] csrRowPtrC - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix \f$C\f$. !> @param[out] csrColIndC - array of \p nnzC elements containing the column indices of the !> sparse CSR matrix \f$C\f$. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p k, \p nnzA, \p nnzB, !> \p descrA, \p csrValA, \p csrRowPtrA, \p csrColIndA, \p descrB, \p csrValB, !> \p csrRowPtrB, \p csrColIndB, \p descrC, \p csrValC, \p csrRowPtrC, or \p csrColIndC !> is invalid. !> \retval HIPSPARSE_STATUS_ALLOC_FAILED additional buffer for long rows could not be !> allocated. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> \p transA != `HIPSPARSE_OPERATION_NON_TRANSPOSE`, !> \p transB != `HIPSPARSE_OPERATION_NON_TRANSPOSE`, or !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseScsrgemm function hipsparseScsrgemm_(handle,transA,transB,m,n,k,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="hipsparseScsrgemm") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgemm_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrValB type(c_ptr),value :: csrRowPtrB type(c_ptr),value :: csrColIndB type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrgemm_assumed_rank #else module procedure & hipsparseScsrgemm_rank_0,& hipsparseScsrgemm_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsrgemm function hipsparseDcsrgemm_(handle,transA,transB,m,n,k,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="hipsparseDcsrgemm") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgemm_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrValB type(c_ptr),value :: csrRowPtrB type(c_ptr),value :: csrColIndB type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrgemm_assumed_rank #else module procedure & hipsparseDcsrgemm_rank_0,& hipsparseDcsrgemm_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsrgemm function hipsparseCcsrgemm_(handle,transA,transB,m,n,k,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="hipsparseCcsrgemm") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgemm_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrValB type(c_ptr),value :: csrRowPtrB type(c_ptr),value :: csrColIndB type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrgemm_assumed_rank #else module procedure & hipsparseCcsrgemm_rank_0,& hipsparseCcsrgemm_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsrgemm function hipsparseZcsrgemm_(handle,transA,transB,m,n,k,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="hipsparseZcsrgemm") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgemm_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrValB type(c_ptr),value :: csrRowPtrB type(c_ptr),value :: csrColIndB type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrgemm_assumed_rank #else module procedure & hipsparseZcsrgemm_rank_0,& hipsparseZcsrgemm_rank_1 #endif #endif end interface #endif !> \ingroup extra_module !> \details !> \p hipsparseXcsrgemm2_bufferSizeExt returns the size of the temporary storage buffer !> in bytes that is required by `hipsparseXcsrgemm2Nnz`() and `hipsparseScsrgemm2` !> "hipsparseXcsrgemm2()". The temporary storage buffer must be allocated by the user. !> !> \note !> For matrix products with more than 4096 non-zero entries per row, !> an additional temporary storage buffer is allocated by the algorithm. !> !> \note !> For matrix products with more than 8192 intermediate products per !> row, an additional temporary storage buffer is allocated by the algorithm. !> !> \note !> Currently, only `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix \f$op(A)\f$ and \f$C\f$. !> @param[in] n - number of columns of the sparse CSR matrix \f$op(B)\f$ and !> \f$C\f$. !> @param[in] k - number of columns of the sparse CSR matrix \f$op(A)\f$ and number of !> rows of the sparse CSR matrix \f$op(B)\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descrA - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzA - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] csrRowPtrA - array of \p m+1 elements (\f$op(A) == A\f$, \p k+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(A)\f$. !> @param[in] csrColIndA - array of \p nnzA elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] descrB - descriptor of the sparse CSR matrix \f$B\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzB - number of non-zero entries of the sparse CSR matrix \f$B\f$. !> @param[in] csrRowPtrB - array of \p k+1 elements (\f$op(B) == B\f$, \p m+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(B)\f$. !> @param[in] csrColIndB - array of \p nnzB elements containing the column indices of the !> sparse CSR matrix \f$B\f$. !> @param[in] beta - scalar \f$\beta\f$. !> @param[in] descrD - descriptor of the sparse CSR matrix \f$D\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzD - number of non-zero entries of the sparse CSR matrix \f$D\f$. !> @param[in] csrRowPtrD - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix \f$D\f$. !> @param[in] csrColIndD - array of \p nnzD elements containing the column indices of the sparse !> CSR matrix \f$D\f$. !> @param[inout] myInfo - structure that holds meta data for the sparse CSR matrix \f$C\f$. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseXcsrgemm2Nnz()`, `hipsparseScsrgemm2()`, hipsparseDcsrgemm2(), !> hipsparseCcsrgemm2(), and hipsparseZcsrgemm2(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p k, \p nnzA, \p nnzB, \p !> nnz_D, !> \p alpha, \p beta, \p descrA, \p csrRowPtrA, \p csrColIndA, \p descrB, \p csrRowPtrB, !> \p csrColIndB, \p descrD, \p csrRowPtrD, \p csrColIndD, \p info, or \p !> pBufferSizeInBytes !> is invalid. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseScsrgemm2_bufferSizeExt function hipsparseScsrgemm2_bufferSizeExt_(handle,m,n,k,alpha,descrA,nnzA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrRowPtrD,csrColIndD, & myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseScsrgemm2_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgemm2_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrRowPtrB type(c_ptr),value :: csrColIndB real(c_float) :: beta type(c_ptr),value :: descrD integer(c_int),value :: nnzD type(c_ptr),value :: csrRowPtrD type(c_ptr),value :: csrColIndD type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrgemm2_bufferSizeExt_assumed_rank #else module procedure & hipsparseScsrgemm2_bufferSizeExt_rank_0,& hipsparseScsrgemm2_bufferSizeExt_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsrgemm2_bufferSizeExt function hipsparseDcsrgemm2_bufferSizeExt_(handle,m,n,k,alpha,descrA,nnzA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrRowPtrD,csrColIndD, & myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseDcsrgemm2_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgemm2_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrRowPtrB type(c_ptr),value :: csrColIndB real(c_double) :: beta type(c_ptr),value :: descrD integer(c_int),value :: nnzD type(c_ptr),value :: csrRowPtrD type(c_ptr),value :: csrColIndD type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrgemm2_bufferSizeExt_assumed_rank #else module procedure & hipsparseDcsrgemm2_bufferSizeExt_rank_0,& hipsparseDcsrgemm2_bufferSizeExt_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsrgemm2_bufferSizeExt function hipsparseCcsrgemm2_bufferSizeExt_(handle,m,n,k,alpha,descrA,nnzA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrRowPtrD,csrColIndD, & myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseCcsrgemm2_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgemm2_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrRowPtrB type(c_ptr),value :: csrColIndB complex(c_float_complex) :: beta type(c_ptr),value :: descrD integer(c_int),value :: nnzD type(c_ptr),value :: csrRowPtrD type(c_ptr),value :: csrColIndD type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrgemm2_bufferSizeExt_assumed_rank #else module procedure & hipsparseCcsrgemm2_bufferSizeExt_rank_0,& hipsparseCcsrgemm2_bufferSizeExt_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsrgemm2_bufferSizeExt function hipsparseZcsrgemm2_bufferSizeExt_(handle,m,n,k,alpha,descrA,nnzA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrRowPtrD,csrColIndD, & myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseZcsrgemm2_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgemm2_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrRowPtrB type(c_ptr),value :: csrColIndB complex(c_double_complex) :: beta type(c_ptr),value :: descrD integer(c_int),value :: nnzD type(c_ptr),value :: csrRowPtrD type(c_ptr),value :: csrColIndD type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrgemm2_bufferSizeExt_assumed_rank #else module procedure & hipsparseZcsrgemm2_bufferSizeExt_rank_0,& hipsparseZcsrgemm2_bufferSizeExt_rank_1 #endif #endif end interface #endif !> \ingroup extra_module !> \details !> \p hipsparseXcsrgemm2Nnz computes the total CSR non-zero elements and the CSR row !> offsets that point to the start of every row of the sparse CSR matrix of the !> resulting multiplied matrix \f$C\f$. It is assumed that \p csrRowPtrC has been allocated !> with size \p m+1. The required buffer size can be obtained by !> `hipsparseScsrgemm2_bufferSizeExt` "hipsparseXcsrgemm2_bufferSizeExt()". The desired !> index base in the output CSR matrix \f$C\f$ is set in the `hipsparseMatDescr_t` \p descrC. !> See `hipsparseSetMatIndexBase`(). !> !> \note !> As indicated, \p nnzTotalDevHostPtr can point to either host or device memory. This is !> controlled !> by setting the pointer mode. See `hipsparseSetPointerMode`(). !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> For matrix products with more than 8192 intermediate products per !> row, an additional temporary storage buffer is allocated by the algorithm. !> !> \note !> Currently, only `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix \f$op(A)\f$ and \f$C\f$. !> @param[in] n - number of columns of the sparse CSR matrix \f$op(B)\f$ and !> \f$C\f$. !> @param[in] k - number of columns of the sparse CSR matrix \f$op(A)\f$ and number of !> rows of the sparse CSR matrix \f$op(B)\f$. !> @param[in] descrA - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzA - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] csrRowPtrA - array of \p m+1 elements (\f$op(A) == A\f$, \p k+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(A)\f$. !> @param[in] csrColIndA - array of \p nnzA elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] descrB - descriptor of the sparse CSR matrix \f$B\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzB - number of non-zero entries of the sparse CSR matrix \f$B\f$. !> @param[in] csrRowPtrB - array of \p k+1 elements (\f$op(B) == B\f$, \p m+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(B)\f$. !> @param[in] csrColIndB - array of \p nnzB elements containing the column indices of the !> sparse CSR matrix \f$B\f$. !> @param[in] descrD - descriptor of the sparse CSR matrix \f$D\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzD - number of non-zero entries of the sparse CSR matrix \f$D\f$. !> @param[in] csrRowPtrD - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix \f$D\f$. !> @param[in] csrColIndD - array of \p nnzD elements containing the column indices of the sparse !> CSR matrix \f$D\f$. !> @param[in] descrC - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[out] csrRowPtrC - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix \f$C\f$. !> @param[out] nnzTotalDevHostPtr - pointer to the number of non-zero entries of the sparse CSR !> matrix \f$C\f$. !> @param[in] myInfo - structure that holds meta data for the sparse CSR matrix \f$C\f$. !> @param[in] pBuffer - temporary storage buffer allocated by the user. The size is returned !> by `hipsparseScsrgemm2_bufferSizeExt()`, hipsparseDcsrgemm2_bufferSizeExt(), !> hipsparseZcsrgemm2_bufferSizeExt(), or hipsparseZcsrgemm2_bufferSizeExt(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p k, \p nnzA, \p nnzB, \p !> nnzD, !> \p descrA, \p csrRowPtrA, \p csrColIndA, \p descrB, \p csrRowPtrB, \p csrColIndB, !> \p descrD, \p csrRowPtrD, \p csrColIndD, \p descrC, \p csrRowPtrC, \p !> nnzTotalDevHostPtr, !> \p info, or \p pBuffer is invalid. !> \retval HIPSPARSE_STATUS_ALLOC_FAILED additional buffer for long rows could not be !> allocated. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseXcsrgemm2Nnz function hipsparseXcsrgemm2Nnz_(handle,m,n,k,descrA,nnzA,csrRowPtrA,csrColIndA,descrB,nnzB, & csrRowPtrB,csrColIndB,descrD,nnzD,csrRowPtrD,csrColIndD,descrC,csrRowPtrC, & nnzTotalDevHostPtr,myInfo,pBuffer) & bind(c, name="hipsparseXcsrgemm2Nnz") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrgemm2Nnz_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrRowPtrB type(c_ptr),value :: csrColIndB type(c_ptr),value :: descrD integer(c_int),value :: nnzD type(c_ptr),value :: csrRowPtrD type(c_ptr),value :: csrColIndD type(c_ptr),value :: descrC type(c_ptr),value :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr),value :: myInfo type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseXcsrgemm2Nnz_assumed_rank #else module procedure & hipsparseXcsrgemm2Nnz_rank_0,& hipsparseXcsrgemm2Nnz_rank_1 #endif #endif end interface #endif !> \ingroup extra_module !> \brief Sparse matrix and sparse matrix multiplication using CSR storage format !> !> \details !> \p hipsparseXcsrgemm2 multiplies the scalar \f$\alpha\f$ with the sparse !> \f$m \times k\f$ matrix \f$A\f$, defined in CSR storage format, and the sparse !> \f$k \times n\f$ matrix \f$B\f$, defined in CSR storage format, and adds the result !> to the sparse \f$m \times n\f$ matrix \f$D\f$ that is multiplied by \f$\beta\f$. The !> final result is stored in the sparse \f$m \times n\f$ matrix \f$C\f$, defined in CSR !> storage format, such !> that !> \f[ !> C := \alpha \cdot A \cdot B + \beta \cdot D !> \f] !> !> This computation involves a multi-step process. First, the user must call !> `hipsparseScsrgemm2_bufferSizeExt` "hipsparseXcsrgemm2_bufferSizeExt()" to !> determine the required user-allocated temporary buffer size. The user then allocates this !> buffer and also allocates \p csrRowPtrC to have size \p m+1. Both the temporary storage !> buffer and \p csrRowPtrC array are then passed to `hipsparseXcsrgemm2Nnz`, which fills !> in the \p csrRowPtrC array and computes the total number of nonzeros in \f$C\f$, \p nnzC. !> The user then allocates both arrays \p csrColIndC and \p csrValC to have size \p nnzC and !> calls \p hipsparseXcsrgemm2 to complete the computation. The desired index base in the output !> CSR matrix \f$C\f$ is set in the `hipsparseMatDescr_t` \p descrC. See !> `hipsparseSetMatIndexBase` (). !> !> \note If \f$\alpha == 0\f$, then \f$C = \beta \cdot D\f$ will be computed. !> \note If \f$\beta == 0\f$, then \f$C = \alpha \cdot A \cdot B\f$ will be computed. !> \note \f$\alpha == beta == 0\f$ is invalid. !> \note Currently, only `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> \note This function is non-blocking and executed asynchronously with respect to the !> host. It can return before the actual computation has finished. !> \note For matrix products with more than 4096 non-zero entries per !> row, an additional temporary storage buffer is allocated by the algorithm. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix \f$op(A)\f$ and \f$C\f$. !> @param[in] n - number of columns of the sparse CSR matrix \f$op(B)\f$ and !> \f$C\f$. !> @param[in] k - number of columns of the sparse CSR matrix \f$op(A)\f$ and number of !> rows of the sparse CSR matrix \f$op(B)\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descrA - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzA - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] csrValA - array of \p nnzA elements of the sparse CSR matrix \f$A\f$. !> @param[in] csrRowPtrA - array of \p m+1 elements (\f$op(A) == A\f$, \p k+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(A)\f$. !> @param[in] csrColIndA - array of \p nnzA elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] descrB - descriptor of the sparse CSR matrix \f$B\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzB - number of non-zero entries of the sparse CSR matrix \f$B\f$. !> @param[in] csrValB - array of \p nnzB elements of the sparse CSR matrix \f$B\f$. !> @param[in] csrRowPtrB - array of \p k+1 elements (\f$op(B) == B\f$, \p m+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(B)\f$. !> @param[in] csrColIndB - array of \p nnzB elements containing the column indices of the !> sparse CSR matrix \f$B\f$. !> @param[in] beta - scalar \f$\beta\f$. !> @param[in] descrD - descriptor of the sparse CSR matrix \f$D\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] nnzD - number of non-zero entries of the sparse CSR matrix \f$D\f$. !> @param[in] csrValD - array of \p nnzD elements of the sparse CSR matrix \f$D\f$. !> @param[in] csrRowPtrD - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix \f$D\f$. !> @param[in] csrColIndD - array of \p nnzD elements containing the column indices of the !> sparse CSR matrix \f$D\f$. !> @param[in] descrC - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[out] csrValC - array of \p nnzC elements of the sparse CSR matrix \f$C\f$. !> @param[in] csrRowPtrC - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix \f$C\f$. !> @param[out] csrColIndC - array of \p nnzC elements containing the column indices of the !> sparse CSR matrix \f$C\f$. !> @param[in] myInfo - structure that holds meta data for the sparse CSR matrix \f$C\f$. !> @param[in] pBuffer - temporary storage buffer allocated by the user. The size is returned !> by `hipsparseScsrgemm2_bufferSizeExt()`, hipsparseDcsrgemm2_bufferSizeExt(), !> hipsparseCcsrgemm2_bufferSizeExt(), or hipsparseZcsrgemm2_bufferSizeExt(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p k, \p nnzA, \p nnzB, !> \p nnzD, \p alpha, \p beta, \p descrA, \p csrValA, \p csrRowPtrA, \p csrColIndA, !> \p descrB, \p csrValB, \p csrRowPtrB, \p csrColIndB, \p descrD, \p csrValD, !> \p csrRowPtrD, \p csrColIndD, \p csrValC, \p csrRowPtrC, \p csrColIndC, \p info, !> or \p pBuffer is invalid. !> \retval HIPSPARSE_STATUS_ALLOC_FAILED additional buffer for long rows could not be !> allocated. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseScsrgemm2 function hipsparseScsrgemm2_(handle,m,n,k,alpha,descrA,nnzA,csrValA,csrRowPtrA,csrColIndA, & descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrValD,csrRowPtrD,csrColIndD, & descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,pBuffer) & bind(c, name="hipsparseScsrgemm2") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgemm2_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrValB type(c_ptr),value :: csrRowPtrB type(c_ptr),value :: csrColIndB real(c_float) :: beta type(c_ptr),value :: descrD integer(c_int),value :: nnzD type(c_ptr),value :: csrValD type(c_ptr),value :: csrRowPtrD type(c_ptr),value :: csrColIndD type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC type(c_ptr),value :: myInfo type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrgemm2_assumed_rank #else module procedure & hipsparseScsrgemm2_rank_0,& hipsparseScsrgemm2_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsrgemm2 function hipsparseDcsrgemm2_(handle,m,n,k,alpha,descrA,nnzA,csrValA,csrRowPtrA,csrColIndA, & descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrValD,csrRowPtrD,csrColIndD, & descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,pBuffer) & bind(c, name="hipsparseDcsrgemm2") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgemm2_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrValB type(c_ptr),value :: csrRowPtrB type(c_ptr),value :: csrColIndB real(c_double) :: beta type(c_ptr),value :: descrD integer(c_int),value :: nnzD type(c_ptr),value :: csrValD type(c_ptr),value :: csrRowPtrD type(c_ptr),value :: csrColIndD type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC type(c_ptr),value :: myInfo type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrgemm2_assumed_rank #else module procedure & hipsparseDcsrgemm2_rank_0,& hipsparseDcsrgemm2_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsrgemm2 function hipsparseCcsrgemm2_(handle,m,n,k,alpha,descrA,nnzA,csrValA,csrRowPtrA,csrColIndA, & descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrValD,csrRowPtrD,csrColIndD, & descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,pBuffer) & bind(c, name="hipsparseCcsrgemm2") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgemm2_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrValB type(c_ptr),value :: csrRowPtrB type(c_ptr),value :: csrColIndB complex(c_float_complex) :: beta type(c_ptr),value :: descrD integer(c_int),value :: nnzD type(c_ptr),value :: csrValD type(c_ptr),value :: csrRowPtrD type(c_ptr),value :: csrColIndD type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC type(c_ptr),value :: myInfo type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrgemm2_assumed_rank #else module procedure & hipsparseCcsrgemm2_rank_0,& hipsparseCcsrgemm2_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsrgemm2 function hipsparseZcsrgemm2_(handle,m,n,k,alpha,descrA,nnzA,csrValA,csrRowPtrA,csrColIndA, & descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrValD,csrRowPtrD,csrColIndD, & descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,pBuffer) & bind(c, name="hipsparseZcsrgemm2") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgemm2_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: descrA integer(c_int),value :: nnzA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: descrB integer(c_int),value :: nnzB type(c_ptr),value :: csrValB type(c_ptr),value :: csrRowPtrB type(c_ptr),value :: csrColIndB complex(c_double_complex) :: beta type(c_ptr),value :: descrD integer(c_int),value :: nnzD type(c_ptr),value :: csrValD type(c_ptr),value :: csrRowPtrD type(c_ptr),value :: csrColIndD type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC type(c_ptr),value :: myInfo type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrgemm2_assumed_rank #else module procedure & hipsparseZcsrgemm2_rank_0,& hipsparseZcsrgemm2_rank_1 #endif #endif end interface #endif !> \ingroup precond_module !> \details !> \p hipsparseXbsric02_zeroPivot returns `HIPSPARSE_STATUS_ZERO_PIVOT` if either a !> structural or numerical zero has been found during `hipsparseSbsric02_analysis` !> "hipsparseXbsric02_analysis()" or `hipsparseSbsric02` "hipsparseXbsric02()" computation. !> The first zero pivot \f$j\f$ at \f$A_{j,j}\f$ is stored in \p position, using the same index !> base as the BSR matrix. !> !> \p position can be in host or device memory. If no zero pivot has been found, !> \p position is set to -1 and `HIPSPARSE_STATUS_SUCCESS` is returned instead. !> !> \note !> If a zero pivot is found, \p position=j means that either the diagonal block \p A(j,j) !> is missing (structural zero) or the diagonal block \p A(j,j) is not positive definite !> (numerical zero). !> !> \note \p hipsparseXbsric02_zeroPivot is a blocking function. It might negatively influence !> performance. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 12.0+) and will be !> removed in CUDA 13.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[inout] position - pointer to zero pivot \f$j\f$, which can be in host or device !> memory. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p info, or \p position is nullptr. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_ZERO_PIVOT zero pivot has been found. interface hipsparseXbsric02_zeroPivot #ifdef USE_CUDA_NAMES function hipsparseXbsric02_zeroPivot_(handle,myInfo,position) & bind(c, name="cusparseXbsric02_zeroPivot") #else function hipsparseXbsric02_zeroPivot_(handle,myInfo,position) & bind(c, name="hipsparseXbsric02_zeroPivot") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXbsric02_zeroPivot_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int) :: position end function end interface !> \ingroup precond_module !> \details !> \p hipsparseXbsric02_bufferSize returns the size of the temporary storage buffer !> in bytes that is required by `hipsparseSbsric02_analysis` "hipsparseXbsric02_analysis()" !> and `hipsparseSbsric02` "hipsparseXbsric02()". The temporary storage buffer must be !> allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - direction that specifies whether to count non-zero elements by !> `HIPSPARSE_DIRECTION_ROW` !> or by `HIPSPARSE_DIRECTION_COLUMN`. !> @param[in] mb - number of block rows in the sparse BSR matrix. Must be non-negative. !> @param[in] nnzb - number of non-zero block entries of the sparse BSR matrix. Must be !> non-negative. !> @param[in] descrA - descriptor of the sparse BSR matrix. !> @param[in] bsrValA - array of length \p nnzb*blockDim*blockDim containing the values of the !> sparse BSR matrix. !> @param[in] bsrRowPtrA - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse BSR matrix. !> @param[in] bsrColIndA - array of \p nnzb elements containing the block column indices of the !> sparse BSR matrix. !> @param[in] blockDim - the block dimension of the BSR matrix. Must be positive, which is !> between 1 and m where \p m=mb*blockDim. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseSbsric02_analysis()`, hipsparseDbsric02_analysis(), !> hipsparseCbsric02_analysis(), hipsparseZbsric02_analysis(), !> `hipsparseSbsric02()`, hipsparseDbsric02(), hipsparseCbsric02(), !> and hipsparseZbsric02(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p descrA, \p bsrValA, \p bsrRowPtrA, !> \p bsrColIndA, \p info, or \p pBufferSizeInBytes is nullptr, \p mb, or \p nnzb is !> negative, !> or \p blockDim is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED `hipsparseMatrixType_t` != !> `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseSbsric02_bufferSize #ifdef USE_CUDA_NAMES function hipsparseSbsric02_bufferSize_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseSbsric02_bufferSize") #else function hipsparseSbsric02_bufferSize_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseSbsric02_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsric02_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSbsric02_bufferSize_assumed_rank #else module procedure & hipsparseSbsric02_bufferSize_rank_0,& hipsparseSbsric02_bufferSize_rank_1 #endif #endif end interface interface hipsparseDbsric02_bufferSize #ifdef USE_CUDA_NAMES function hipsparseDbsric02_bufferSize_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseDbsric02_bufferSize") #else function hipsparseDbsric02_bufferSize_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseDbsric02_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsric02_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDbsric02_bufferSize_assumed_rank #else module procedure & hipsparseDbsric02_bufferSize_rank_0,& hipsparseDbsric02_bufferSize_rank_1 #endif #endif end interface interface hipsparseCbsric02_bufferSize #ifdef USE_CUDA_NAMES function hipsparseCbsric02_bufferSize_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseCbsric02_bufferSize") #else function hipsparseCbsric02_bufferSize_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseCbsric02_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsric02_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCbsric02_bufferSize_assumed_rank #else module procedure & hipsparseCbsric02_bufferSize_rank_0,& hipsparseCbsric02_bufferSize_rank_1 #endif #endif end interface interface hipsparseZbsric02_bufferSize #ifdef USE_CUDA_NAMES function hipsparseZbsric02_bufferSize_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseZbsric02_bufferSize") #else function hipsparseZbsric02_bufferSize_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseZbsric02_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsric02_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZbsric02_bufferSize_assumed_rank #else module procedure & hipsparseZbsric02_bufferSize_rank_0,& hipsparseZbsric02_bufferSize_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p hipsparseXbsric02_analysis performs the analysis step for `hipsparseSbsric02` !> "hipsparseXbsric02()". It is expected that this function will be executed only once !> for a given matrix and particular operation type. !> !> \note !> If the matrix sparsity pattern changes, the gathered information will become invalid. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - direction that specifies whether to count non-zero elements by !> `HIPSPARSE_DIRECTION_ROW` or by !> `HIPSPARSE_DIRECTION_COLUMN`. !> @param[in] mb - number of block rows in the sparse BSR matrix. !> @param[in] nnzb - number of non-zero block entries of the sparse BSR matrix. !> @param[in] descrA - descriptor of the sparse BSR matrix. !> @param[in] bsrValA - array of length \p nnzb*blockDim*blockDim containing the values of the !> sparse BSR matrix. !> @param[in] bsrRowPtrA - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse BSR matrix. !> @param[in] bsrColIndA - array of \p nnzb elements containing the block column indices of the !> sparse BSR matrix. !> @param[in] blockDim - the block dimension of the BSR matrix, which is between 1 and m where !> \p m=mb*blockDim. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[in] policy - `HIPSPARSE_SOLVE_POLICY_NO_LEVEL` or `HIPSPARSE_SOLVE_POLICY_USE_LEVEL`. !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p mb, \p nnzb, \p blockDim, \p descrA, !> \p bsrValA, \p bsrRowPtrA, \p bsrColIndA, \p info, or \p pBuffer pointer is !> invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseSbsric02_analysis #ifdef USE_CUDA_NAMES function hipsparseSbsric02_analysis_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseSbsric02_analysis") #else function hipsparseSbsric02_analysis_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseSbsric02_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsric02_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSbsric02_analysis_assumed_rank #else module procedure & hipsparseSbsric02_analysis_rank_0,& hipsparseSbsric02_analysis_rank_1 #endif #endif end interface interface hipsparseDbsric02_analysis #ifdef USE_CUDA_NAMES function hipsparseDbsric02_analysis_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseDbsric02_analysis") #else function hipsparseDbsric02_analysis_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseDbsric02_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsric02_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDbsric02_analysis_assumed_rank #else module procedure & hipsparseDbsric02_analysis_rank_0,& hipsparseDbsric02_analysis_rank_1 #endif #endif end interface interface hipsparseCbsric02_analysis #ifdef USE_CUDA_NAMES function hipsparseCbsric02_analysis_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseCbsric02_analysis") #else function hipsparseCbsric02_analysis_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseCbsric02_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsric02_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCbsric02_analysis_assumed_rank #else module procedure & hipsparseCbsric02_analysis_rank_0,& hipsparseCbsric02_analysis_rank_1 #endif #endif end interface interface hipsparseZbsric02_analysis #ifdef USE_CUDA_NAMES function hipsparseZbsric02_analysis_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseZbsric02_analysis") #else function hipsparseZbsric02_analysis_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseZbsric02_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsric02_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZbsric02_analysis_assumed_rank #else module procedure & hipsparseZbsric02_analysis_rank_0,& hipsparseZbsric02_analysis_rank_1 #endif #endif end interface !> \ingroup precond_module !> \brief Incomplete Cholesky factorization with 0 fill-ins and no pivoting using the BSR !> storage format. !> !> \details !> \p hipsparseXbsric02 computes the incomplete Cholesky factorization with 0 fill-ins !> and no pivoting of a sparse \f$mb \times mb\f$ BSR matrix \f$A\f$, such that !> \f[ !> A \approx LL^T !> \f] !> !> Computing the above incomplete Cholesky factorization requires three steps to complete. !> First, !> the user determines the size of the required temporary storage buffer by calling !> `hipsparseSbsric02_bufferSize` "hipsparseXbsric02_bufferSize()". After this buffer size has !> been determined, !> the user allocates the buffer and passes it to `hipsparseSbsric02_analysis` !> "hipsparseXbsric02_analysis()". !> This will perform analysis on the sparsity pattern of the matrix. Finally, the user calls \p !> hipsparseXbsric02 !> to perform the actual factorization. The calculation of the buffer size and the analysis of !> the sparse matrix !> only need to be performed once for a given sparsity pattern, while the factorization can be !> repeatedly applied !> to multiple matrices having the same sparsity pattern. After all calls to \p !> hipsparseXbsric02 are complete, !> the temporary buffer can be deallocated. !> !> \p hipsparseXbsric02 requires a user-allocated temporary buffer. Its size is returned !> by `hipsparseSbsric02_bufferSize` "hipsparseXbsric02_bufferSize()". Furthermore, !> analysis meta data is required. It can be obtained by `hipsparseSbsric02_analysis` !> "hipsparseXbsric02_analysis()". \p hipsparseXbsric02 reports the first zero pivot !> (either numerical or structural zero). The zero pivot status can be obtained by calling !> `hipsparseXbsric02_zeroPivot`(). !> !> \p hipsparseXbsric02 reports the first zero pivot (either numerical or structural zero). !> The zero pivot status can be obtained by calling `hipsparseXbsric02_zeroPivot`(). !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - direction that specifies whether to count non-zero elements by !> `HIPSPARSE_DIRECTION_ROW` or by !> `HIPSPARSE_DIRECTION_COLUMN`. !> @param[in] mb - number of block rows in the sparse BSR matrix. !> @param[in] nnzb - number of non-zero block entries of the sparse BSR matrix. !> @param[in] descrA - descriptor of the sparse BSR matrix. !> @param[inout] bsrValA - array of length \p nnzb*blockDim*blockDim containing the values of !> the sparse BSR matrix. !> @param[in] bsrRowPtrA - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse BSR matrix. !> @param[in] bsrColIndA - array of \p nnzb elements containing the block column indices of the !> sparse BSR matrix. !> @param[in] blockDim - the block dimension of the BSR matrix, which is between 1 and m where !> \p m=mb*blockDim. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] policy - `HIPSPARSE_SOLVE_POLICY_NO_LEVEL` or `HIPSPARSE_SOLVE_POLICY_USE_LEVEL`. !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p mb, \p nnzb, \p blockDim, \p descrA, !> \p bsrValA, \p bsrRowPtrA, or \p bsrColIndA pointer is invalid. !> \retval HIPSPARSE_STATUS_ARCH_MISMATCH the device is not supported. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseSbsric02 #ifdef USE_CUDA_NAMES function hipsparseSbsric02_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA,blockDim, & myInfo,policy,pBuffer) & bind(c, name="cusparseSbsric02") #else function hipsparseSbsric02_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA,blockDim, & myInfo,policy,pBuffer) & bind(c, name="hipsparseSbsric02") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsric02_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSbsric02_assumed_rank #else module procedure & hipsparseSbsric02_rank_0,& hipsparseSbsric02_rank_1 #endif #endif end interface interface hipsparseDbsric02 #ifdef USE_CUDA_NAMES function hipsparseDbsric02_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA,blockDim, & myInfo,policy,pBuffer) & bind(c, name="cusparseDbsric02") #else function hipsparseDbsric02_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA,blockDim, & myInfo,policy,pBuffer) & bind(c, name="hipsparseDbsric02") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsric02_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDbsric02_assumed_rank #else module procedure & hipsparseDbsric02_rank_0,& hipsparseDbsric02_rank_1 #endif #endif end interface interface hipsparseCbsric02 #ifdef USE_CUDA_NAMES function hipsparseCbsric02_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA,blockDim, & myInfo,policy,pBuffer) & bind(c, name="cusparseCbsric02") #else function hipsparseCbsric02_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA,blockDim, & myInfo,policy,pBuffer) & bind(c, name="hipsparseCbsric02") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsric02_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCbsric02_assumed_rank #else module procedure & hipsparseCbsric02_rank_0,& hipsparseCbsric02_rank_1 #endif #endif end interface interface hipsparseZbsric02 #ifdef USE_CUDA_NAMES function hipsparseZbsric02_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA,blockDim, & myInfo,policy,pBuffer) & bind(c, name="cusparseZbsric02") #else function hipsparseZbsric02_(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA,blockDim, & myInfo,policy,pBuffer) & bind(c, name="hipsparseZbsric02") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsric02_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZbsric02_assumed_rank #else module procedure & hipsparseZbsric02_rank_0,& hipsparseZbsric02_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p hipsparseXbsrilu02_zeroPivot returns `HIPSPARSE_STATUS_ZERO_PIVOT` if either a !> structural or numerical zero has been found during `hipsparseSbsrilu02_analysis` !> "hipsparseXbsrilu02_analysis()" or `hipsparseSbsrilu02` "hipsparseXbsrilu02()" !> computation. The first zero pivot \f$j\f$ at \f$A_{j,j}\f$ is stored in \p position, !> using the same index base as the BSR matrix. !> !> \p position can be in host or device memory. If no zero pivot has been found, !> \p position is set to -1 and `HIPSPARSE_STATUS_SUCCESS` is returned instead. !> !> \note !> If a zero pivot is found, \p position \f$=j\f$ means that either the diagonal block !> \f$A_{j,j}\f$ is missing (structural zero) or the diagonal block \f$A_{j,j}\f$ is not !> invertible (numerical zero). !> !> \note \p hipsparseXbsrilu02_zeroPivot is a blocking function. It might negatively influence !> performance. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 12.0+) and will be !> removed in CUDA 13.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[inout] position - pointer to zero pivot \f$j\f$, which can be in host or device !> memory. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p info, or \p position is nullptr. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_ZERO_PIVOT zero pivot has been found. interface hipsparseXbsrilu02_zeroPivot #ifdef USE_CUDA_NAMES function hipsparseXbsrilu02_zeroPivot_(handle,myInfo,position) & bind(c, name="cusparseXbsrilu02_zeroPivot") #else function hipsparseXbsrilu02_zeroPivot_(handle,myInfo,position) & bind(c, name="hipsparseXbsrilu02_zeroPivot") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXbsrilu02_zeroPivot_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int) :: position end function end interface !> \ingroup precond_module !> \details !> \p hipsparseXbsrilu02_numericBoost enables the user to replace a numerical value in !> an incomplete LU factorization. \p tol is used to determine whether a numerical value !> is replaced by \p boost_val, such that \f$A_{j,j} = \text{boost_val}\f$ if !> \f$\text{tol} ≥ \left|A_{j,j}\right|\f$. !> !> \note The boost value is enabled by setting \p enable_boost to 1 or disabled by !> setting \p enable_boost to 0. !> !> \note \p tol and \p boost_val can be in host or device memory. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 12.0+) and will be !> removed in CUDA 13.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] enable_boost - enable/disable numeric boost. !> @param[in] tol - tolerance to determine whether a numerical value is replaced or not. !> @param[in] boost_val - boost value to replace a numerical value. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p info, \p tol, or \p boost_val is !> nullptr. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseSbsrilu02_numericBoost #ifdef USE_CUDA_NAMES function hipsparseSbsrilu02_numericBoost_(handle,myInfo,enable_boost,tol,boost_val) & bind(c, name="cusparseSbsrilu02_numericBoost") #else function hipsparseSbsrilu02_numericBoost_(handle,myInfo,enable_boost,tol,boost_val) & bind(c, name="hipsparseSbsrilu02_numericBoost") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrilu02_numericBoost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_double) :: tol real(c_float) :: boost_val end function end interface interface hipsparseDbsrilu02_numericBoost #ifdef USE_CUDA_NAMES function hipsparseDbsrilu02_numericBoost_(handle,myInfo,enable_boost,tol,boost_val) & bind(c, name="cusparseDbsrilu02_numericBoost") #else function hipsparseDbsrilu02_numericBoost_(handle,myInfo,enable_boost,tol,boost_val) & bind(c, name="hipsparseDbsrilu02_numericBoost") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrilu02_numericBoost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_double) :: tol real(c_double) :: boost_val end function end interface interface hipsparseCbsrilu02_numericBoost #ifdef USE_CUDA_NAMES function hipsparseCbsrilu02_numericBoost_(handle,myInfo,enable_boost,tol,boost_val) & bind(c, name="cusparseCbsrilu02_numericBoost") #else function hipsparseCbsrilu02_numericBoost_(handle,myInfo,enable_boost,tol,boost_val) & bind(c, name="hipsparseCbsrilu02_numericBoost") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrilu02_numericBoost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_double) :: tol complex(c_float_complex) :: boost_val end function end interface interface hipsparseZbsrilu02_numericBoost #ifdef USE_CUDA_NAMES function hipsparseZbsrilu02_numericBoost_(handle,myInfo,enable_boost,tol,boost_val) & bind(c, name="cusparseZbsrilu02_numericBoost") #else function hipsparseZbsrilu02_numericBoost_(handle,myInfo,enable_boost,tol,boost_val) & bind(c, name="hipsparseZbsrilu02_numericBoost") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrilu02_numericBoost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_double) :: tol complex(c_double_complex) :: boost_val end function end interface !> \ingroup precond_module !> \details !> \p hipsparseXbsrilu02_bufferSize returns the size of the temporary storage buffer !> in bytes that is required by `hipsparseSbsrilu02_analysis` "hipsparseXbsrilu02_analysis()" !> and `hipsparseSbsrilu02` "hipsparseXbsrilu02()". The temporary storage buffer must be !> allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - direction that specifies whether to count non-zero elements by !> `HIPSPARSE_DIRECTION_ROW` !> or by `HIPSPARSE_DIRECTION_COLUMN`. !> @param[in] mb - number of block rows in the sparse BSR matrix. !> @param[in] nnzb - number of non-zero block entries of the sparse BSR matrix. !> @param[in] descrA - descriptor of the sparse BSR matrix. !> @param[in] bsrSortedValA - array of length \p nnzb*blockDim*blockDim containing the values of !> the sparse BSR matrix. !> @param[in] bsrSortedRowPtrA - array of \p mb+1 elements that point to the start of every !> block row of the !> sparse BSR matrix. !> @param[in] bsrSortedColIndA - array of \p nnzb elements containing the block column indices !> of the sparse BSR matrix. !> @param[in] blockDim - the block dimension of the BSR matrix, which is between 1 and m where !> \p m=mb*blockDim. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseSbsrilu02_analysis()`, hipsparseDbsrilu02_analysis(), !> hipsparseCbsrilu02_analysis(), hipsparseZbsrilu02_analysis(), !> `hipsparseSbsrilu02()`, hipsparseDbsrilu02(), hipsparseCbsrilu02(), !> and hipsparseZbsrilu02(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p mb, \p nnzb, \p blockDim, \p descrA, !> \p bsrSortedValA, \p bsrSortedRowPtrA, \p bsrSortedColIndA, \p info, or !> \p pBufferSizeInBytes pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseSbsrilu02_bufferSize #ifdef USE_CUDA_NAMES function hipsparseSbsrilu02_bufferSize_(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseSbsrilu02_bufferSize") #else function hipsparseSbsrilu02_bufferSize_(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseSbsrilu02_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrilu02_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSbsrilu02_bufferSize_assumed_rank #else module procedure & hipsparseSbsrilu02_bufferSize_rank_0,& hipsparseSbsrilu02_bufferSize_rank_1 #endif #endif end interface interface hipsparseDbsrilu02_bufferSize #ifdef USE_CUDA_NAMES function hipsparseDbsrilu02_bufferSize_(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseDbsrilu02_bufferSize") #else function hipsparseDbsrilu02_bufferSize_(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseDbsrilu02_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrilu02_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDbsrilu02_bufferSize_assumed_rank #else module procedure & hipsparseDbsrilu02_bufferSize_rank_0,& hipsparseDbsrilu02_bufferSize_rank_1 #endif #endif end interface interface hipsparseCbsrilu02_bufferSize #ifdef USE_CUDA_NAMES function hipsparseCbsrilu02_bufferSize_(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseCbsrilu02_bufferSize") #else function hipsparseCbsrilu02_bufferSize_(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseCbsrilu02_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrilu02_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCbsrilu02_bufferSize_assumed_rank #else module procedure & hipsparseCbsrilu02_bufferSize_rank_0,& hipsparseCbsrilu02_bufferSize_rank_1 #endif #endif end interface interface hipsparseZbsrilu02_bufferSize #ifdef USE_CUDA_NAMES function hipsparseZbsrilu02_bufferSize_(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseZbsrilu02_bufferSize") #else function hipsparseZbsrilu02_bufferSize_(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseZbsrilu02_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrilu02_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZbsrilu02_bufferSize_assumed_rank #else module procedure & hipsparseZbsrilu02_bufferSize_rank_0,& hipsparseZbsrilu02_bufferSize_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p hipsparseXbsrilu02_analysis performs the analysis step for `hipsparseSbsrilu02` !> "hipsparseXbsrilu02()". It is expected that this function will be executed only once !> for a given matrix. !> !> \note !> If the matrix sparsity pattern changes, the gathered information will become invalid. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - direction that specified whether to count non-zero elements by !> `HIPSPARSE_DIRECTION_ROW` or by `HIPSPARSE_DIRECTION_COLUMN`. !> @param[in] mb - number of block rows in the sparse BSR matrix. !> @param[in] nnzb - number of non-zero block entries of the sparse BSR matrix. !> @param[in] descrA - descriptor of the sparse BSR matrix. !> @param[in] bsrSortedValA - array of length \p nnzb*blockDim*blockDim containing the values of !> the sparse BSR matrix. !> @param[in] bsrSortedRowPtrA - array of \p mb+1 elements that point to the start of every !> block row of the !> sparse BSR matrix. !> @param[in] bsrSortedColIndA - array of \p nnzb elements containing the block column indices !> of the sparse BSR matrix. !> @param[in] blockDim - the block dimension of the BSR matrix, which is between 1 and m where !> \p m=mb*blockDim. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[in] policy - `HIPSPARSE_SOLVE_POLICY_NO_LEVEL` or `HIPSPARSE_SOLVE_POLICY_USE_LEVEL`. !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p mb, \p nnzb, \p blockDim, \p descrA, !> \p bsrSortedValA, \p bsrSortedRowPtrA, \p bsrSortedColIndA, \p info, or \p !> pBuffer pointer !> is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseSbsrilu02_analysis #ifdef USE_CUDA_NAMES function hipsparseSbsrilu02_analysis_(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseSbsrilu02_analysis") #else function hipsparseSbsrilu02_analysis_(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseSbsrilu02_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrilu02_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSbsrilu02_analysis_assumed_rank #else module procedure & hipsparseSbsrilu02_analysis_rank_0,& hipsparseSbsrilu02_analysis_rank_1 #endif #endif end interface interface hipsparseDbsrilu02_analysis #ifdef USE_CUDA_NAMES function hipsparseDbsrilu02_analysis_(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseDbsrilu02_analysis") #else function hipsparseDbsrilu02_analysis_(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseDbsrilu02_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrilu02_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDbsrilu02_analysis_assumed_rank #else module procedure & hipsparseDbsrilu02_analysis_rank_0,& hipsparseDbsrilu02_analysis_rank_1 #endif #endif end interface interface hipsparseCbsrilu02_analysis #ifdef USE_CUDA_NAMES function hipsparseCbsrilu02_analysis_(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseCbsrilu02_analysis") #else function hipsparseCbsrilu02_analysis_(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseCbsrilu02_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrilu02_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCbsrilu02_analysis_assumed_rank #else module procedure & hipsparseCbsrilu02_analysis_rank_0,& hipsparseCbsrilu02_analysis_rank_1 #endif #endif end interface interface hipsparseZbsrilu02_analysis #ifdef USE_CUDA_NAMES function hipsparseZbsrilu02_analysis_(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseZbsrilu02_analysis") #else function hipsparseZbsrilu02_analysis_(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseZbsrilu02_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrilu02_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZbsrilu02_analysis_assumed_rank #else module procedure & hipsparseZbsrilu02_analysis_rank_0,& hipsparseZbsrilu02_analysis_rank_1 #endif #endif end interface !> \ingroup precond_module !> \brief Incomplete LU factorization with 0 fill-ins and no pivoting using the BSR storage !> format. !> !> \details !> \p hipsparseXbsrilu02 computes the incomplete LU factorization with 0 fill-ins and no !> pivoting of a sparse \f$mb \times mb\f$ BSR matrix \f$A\f$, such that !> \f[ !> A \approx LU !> \f] !> !> Computing the above incomplete LU factorization requires three steps to complete. First, !> the user determines the size of the required temporary storage buffer by calling !> `hipsparseSbsrilu02_bufferSize` "hipsparseXbsrilu02_bufferSize()". After this buffer size !> has been determined, the user allocates the buffer and passes it to !> `hipsparseSbsrilu02_analysis` "hipsparseXbsrilu02_analysis()". This will perform analysis on !> the sparsity pattern of the matrix. Finally, the user calls \p hipsparseXbsrilu02 to perform !> the !> actual factorization. The calculation of the buffer size and the analysis of the sparse !> matrix !> only need to be performed once for a given sparsity pattern, while the factorization can be !> repeatedly applied to multiple matrices having the same sparsity pattern. After all calls to !> `hipsparseSbsrilu02` "hipsparseXbsrilu02()" are complete, the temporary buffer can be !> deallocated. !> !> \p hipsparseXbsrilu02 reports the first zero pivot (either numerical or structural zero). !> The zero pivot status can be obtained by calling `hipsparseXbsrilu02_zeroPivot`(). !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - direction that specified whether to count non-zero elements by !> `HIPSPARSE_DIRECTION_ROW` or by `HIPSPARSE_DIRECTION_COLUMN`. !> @param[in] mb - number of block rows in the sparse BSR matrix. !> @param[in] nnzb - number of non-zero block entries of the sparse BSR matrix. !> @param[in] descrA - descriptor of the sparse BSR matrix. !> @param[inout] bsrSortedValA_valM - array of length \p nnzb*blockDim*blockDim containing the !> values of the sparse BSR matrix. !> @param[in] bsrSortedRowPtrA - array of \p mb+1 elements that point to the start of every !> block row of the !> sparse BSR matrix. !> @param[in] bsrSortedColIndA - array of \p nnzb elements containing the block column indices !> of the sparse BSR matrix. !> @param[in] blockDim - the block dimension of the BSR matrix, which is between 1 and m where !> \p m=mb*blockDim. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] policy - `HIPSPARSE_SOLVE_POLICY_NO_LEVEL` or `HIPSPARSE_SOLVE_POLICY_USE_LEVEL`. !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p mb, \p nnzb, \p blockDim, \p descrA, !> \p bsrSortedValA_valM, \p bsrSortedRowPtrA, or \p bsrSortedColIndA pointer is !> invalid. !> \retval HIPSPARSE_STATUS_ARCH_MISMATCH the device is not supported. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseSbsrilu02 #ifdef USE_CUDA_NAMES function hipsparseSbsrilu02_(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM,bsrSortedRowPtrA, & bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseSbsrilu02") #else function hipsparseSbsrilu02_(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM,bsrSortedRowPtrA, & bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseSbsrilu02") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrilu02_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA_valM type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSbsrilu02_assumed_rank #else module procedure & hipsparseSbsrilu02_rank_0,& hipsparseSbsrilu02_rank_1 #endif #endif end interface interface hipsparseDbsrilu02 #ifdef USE_CUDA_NAMES function hipsparseDbsrilu02_(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM,bsrSortedRowPtrA, & bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseDbsrilu02") #else function hipsparseDbsrilu02_(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM,bsrSortedRowPtrA, & bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseDbsrilu02") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrilu02_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA_valM type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDbsrilu02_assumed_rank #else module procedure & hipsparseDbsrilu02_rank_0,& hipsparseDbsrilu02_rank_1 #endif #endif end interface interface hipsparseCbsrilu02 #ifdef USE_CUDA_NAMES function hipsparseCbsrilu02_(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM,bsrSortedRowPtrA, & bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseCbsrilu02") #else function hipsparseCbsrilu02_(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM,bsrSortedRowPtrA, & bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseCbsrilu02") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrilu02_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA_valM type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCbsrilu02_assumed_rank #else module procedure & hipsparseCbsrilu02_rank_0,& hipsparseCbsrilu02_rank_1 #endif #endif end interface interface hipsparseZbsrilu02 #ifdef USE_CUDA_NAMES function hipsparseZbsrilu02_(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM,bsrSortedRowPtrA, & bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="cusparseZbsrilu02") #else function hipsparseZbsrilu02_(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM,bsrSortedRowPtrA, & bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) & bind(c, name="hipsparseZbsrilu02") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrilu02_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrSortedValA_valM type(c_ptr),value :: bsrSortedRowPtrA type(c_ptr),value :: bsrSortedColIndA integer(c_int),value :: blockDim type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZbsrilu02_assumed_rank #else module procedure & hipsparseZbsrilu02_rank_0,& hipsparseZbsrilu02_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p hipsparseXcsric02_zeroPivot returns `HIPSPARSE_STATUS_ZERO_PIVOT` if either a !> structural or numerical zero has been found during `hipsparseScsric02_analysis` !> "hipsparseXcsric02_analysis()" or `hipsparseScsric02` "hipsparseXcsric02()" !> computation. The first zero pivot \f$j\f$ at \f$A_{j,j}\f$ is stored in \p position, !> using the same index base as the CSR matrix. !> !> \p position can be in host or device memory. If no zero pivot has been found, !> \p position is set to -1 and `HIPSPARSE_STATUS_SUCCESS` is returned instead. !> !> \note \p hipsparseXcsric02_zeroPivot is a blocking function. It might negatively influence !> performance. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 12.0+) and will be !> removed in CUDA 13.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[inout] position - pointer to zero pivot \f$j\f$, which can be in host or device !> memory. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p info, or \p position is nullptr. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_ZERO_PIVOT zero pivot has been found. interface hipsparseXcsric02_zeroPivot #ifdef USE_CUDA_NAMES function hipsparseXcsric02_zeroPivot_(handle,myInfo,position) & bind(c, name="cusparseXcsric02_zeroPivot") #else function hipsparseXcsric02_zeroPivot_(handle,myInfo,position) & bind(c, name="hipsparseXcsric02_zeroPivot") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsric02_zeroPivot_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int) :: position end function end interface !> \ingroup precond_module !> \details !> \p hipsparseXcsric02_bufferSize returns the size of the temporary storage buffer in bytes !> that is required by `hipsparseScsric02_analysis` "hipsparseXcsric02_analysis()" and !> `hipsparseScsric02` "hipsparseXcsric02()". The temporary storage buffer must be allocated !> by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descrA - descriptor of the sparse CSR matrix. !> @param[in] csrSortedValA - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix. !> @param[in] csrSortedColIndA - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseScsric02_analysis` "hipsparseXcsric02_analysis()" and !> `hipsparseScsric02` "hipsparseXcsric02()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p nnz, \p descrA, \p csrSortedValA, !> \p csrSortedRowPtrA, \p csrSortedColIndA, \p info, or \p pBufferSizeInBytes !> pointer is !> invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseScsric02_bufferSize #ifdef USE_CUDA_NAMES function hipsparseScsric02_bufferSize_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseScsric02_bufferSize") #else function hipsparseScsric02_bufferSize_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseScsric02_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsric02_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsric02_bufferSize_assumed_rank #else module procedure & hipsparseScsric02_bufferSize_rank_0,& hipsparseScsric02_bufferSize_rank_1 #endif #endif end interface interface hipsparseDcsric02_bufferSize #ifdef USE_CUDA_NAMES function hipsparseDcsric02_bufferSize_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseDcsric02_bufferSize") #else function hipsparseDcsric02_bufferSize_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseDcsric02_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsric02_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsric02_bufferSize_assumed_rank #else module procedure & hipsparseDcsric02_bufferSize_rank_0,& hipsparseDcsric02_bufferSize_rank_1 #endif #endif end interface interface hipsparseCcsric02_bufferSize #ifdef USE_CUDA_NAMES function hipsparseCcsric02_bufferSize_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseCcsric02_bufferSize") #else function hipsparseCcsric02_bufferSize_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseCcsric02_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsric02_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsric02_bufferSize_assumed_rank #else module procedure & hipsparseCcsric02_bufferSize_rank_0,& hipsparseCcsric02_bufferSize_rank_1 #endif #endif end interface interface hipsparseZcsric02_bufferSize #ifdef USE_CUDA_NAMES function hipsparseZcsric02_bufferSize_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseZcsric02_bufferSize") #else function hipsparseZcsric02_bufferSize_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseZcsric02_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsric02_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsric02_bufferSize_assumed_rank #else module procedure & hipsparseZcsric02_bufferSize_rank_0,& hipsparseZcsric02_bufferSize_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p hipsparseXcsric02_bufferSizeExt returns the size of the temporary storage buffer !> in bytes that is required by `hipsparseScsric02_analysis` "hipsparseXcsric02_analysis()" !> and `hipsparseScsric02` "hipsparseXcsric02()". The temporary storage buffer must be !> allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descrA - descriptor of the sparse CSR matrix. !> @param[in] csrSortedValA - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix. !> @param[in] csrSortedColIndA - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseScsric02_analysis` "hipsparseXcsric02_analysis()" and !> `hipsparseScsric02` "hipsparseXcsric02()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p nnz, \p descrA, \p csrSortedValA, !> \p csrSortedRowPtrA, \p csrSortedColIndA, \p info, or \p pBufferSizeInBytes !> pointer is !> invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseScsric02_bufferSizeExt function hipsparseScsric02_bufferSizeExt_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseScsric02_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsric02_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsric02_bufferSizeExt_assumed_rank #else module procedure & hipsparseScsric02_bufferSizeExt_rank_0,& hipsparseScsric02_bufferSizeExt_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsric02_bufferSizeExt function hipsparseDcsric02_bufferSizeExt_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseDcsric02_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsric02_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsric02_bufferSizeExt_assumed_rank #else module procedure & hipsparseDcsric02_bufferSizeExt_rank_0,& hipsparseDcsric02_bufferSizeExt_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsric02_bufferSizeExt function hipsparseCcsric02_bufferSizeExt_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseCcsric02_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsric02_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsric02_bufferSizeExt_assumed_rank #else module procedure & hipsparseCcsric02_bufferSizeExt_rank_0,& hipsparseCcsric02_bufferSizeExt_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsric02_bufferSizeExt function hipsparseZcsric02_bufferSizeExt_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseZcsric02_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsric02_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsric02_bufferSizeExt_assumed_rank #else module procedure & hipsparseZcsric02_bufferSizeExt_rank_0,& hipsparseZcsric02_bufferSizeExt_rank_1 #endif #endif end interface #endif !> \ingroup precond_module !> \details !> \p hipsparseXcsric02_analysis performs the analysis step for `hipsparseScsric02` !> "hipsparseXcsric02()". !> !> \note !> If the matrix sparsity pattern changes, the gathered information will become invalid. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descrA - descriptor of the sparse CSR matrix. !> @param[in] csrSortedValA - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix. !> @param[in] csrSortedColIndA - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix. !> @param[out] myInfo - structure that holds the information collected during !> the analysis step. !> @param[in] policy - `HIPSPARSE_SOLVE_POLICY_NO_LEVEL` or `HIPSPARSE_SOLVE_POLICY_USE_LEVEL`. !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p nnz, \p descrA, \p csrSortedValA, !> \p csrSortedRowPtrA, \p csrSortedColIndA, \p info, or \p pBuffer pointer is !> invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseScsric02_analysis #ifdef USE_CUDA_NAMES function hipsparseScsric02_analysis_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="cusparseScsric02_analysis") #else function hipsparseScsric02_analysis_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseScsric02_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsric02_analysis_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsric02_analysis_assumed_rank #else module procedure & hipsparseScsric02_analysis_rank_0,& hipsparseScsric02_analysis_rank_1 #endif #endif end interface interface hipsparseDcsric02_analysis #ifdef USE_CUDA_NAMES function hipsparseDcsric02_analysis_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="cusparseDcsric02_analysis") #else function hipsparseDcsric02_analysis_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseDcsric02_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsric02_analysis_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsric02_analysis_assumed_rank #else module procedure & hipsparseDcsric02_analysis_rank_0,& hipsparseDcsric02_analysis_rank_1 #endif #endif end interface interface hipsparseCcsric02_analysis #ifdef USE_CUDA_NAMES function hipsparseCcsric02_analysis_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="cusparseCcsric02_analysis") #else function hipsparseCcsric02_analysis_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseCcsric02_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsric02_analysis_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsric02_analysis_assumed_rank #else module procedure & hipsparseCcsric02_analysis_rank_0,& hipsparseCcsric02_analysis_rank_1 #endif #endif end interface interface hipsparseZcsric02_analysis #ifdef USE_CUDA_NAMES function hipsparseZcsric02_analysis_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="cusparseZcsric02_analysis") #else function hipsparseZcsric02_analysis_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseZcsric02_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsric02_analysis_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsric02_analysis_assumed_rank #else module procedure & hipsparseZcsric02_analysis_rank_0,& hipsparseZcsric02_analysis_rank_1 #endif #endif end interface !> \ingroup precond_module !> \brief Incomplete Cholesky factorization with 0 fill-ins and no pivoting using the CSR !> storage format. !> !> \details !> \p hipsparseXcsric02 computes the incomplete Cholesky factorization with 0 fill-ins !> and no pivoting of a sparse \f$m \times m\f$ CSR matrix \f$A\f$, such that !> \f[ !> A \approx LL^T !> \f] !> where the lower triangular matrix \f$L\f$ is computed using: !> \f[ !> L_{ij} = \left\{ !> \begin{array}{ll} !> \sqrt{A_{jj} - \sum_{k=0}^{j-1}(L_{jk})^{2}}, & \text{if i == j} \\% !> \frac{1}{L_{jj}}(A_{jj} - \sum_{k=0}^{j-1}L_{ik} \times L_{jk}), & \text{if i > j} !> \end{array} !> \right. !> \f] !> for each entry found in the CSR matrix \f$A\f$. !> !> Computing the above incomplete Cholesky factorization requires three steps to complete. !> First, !> the user determines the size of the required temporary storage buffer by calling !> `hipsparseScsric02_bufferSize` "hipsparseXcsric02_bufferSize()". After this buffer size has !> been determined, !> the user allocates the buffer and passes it to `hipsparseScsric02_analysis` !> "hipsparseXcsric02_analysis()". !> This will perform analysis on the sparsity pattern of the matrix. Finally, the user calls \p !> hipsparseScsric02, !> \p hipsparseDcsric02, \p hipsparseCcsric02, or \p hipsparseZcsric02 to perform the actual !> factorization. The calculation !> of the buffer size and the analysis of the sparse matrix only need to be performed once for a !> given sparsity pattern, !> while the factorization can be repeatedly applied to multiple matrices having the same !> sparsity pattern. After all calls !> to `hipsparseScsric02` "hipsparseXcsric02()" are complete, the temporary buffer can be !> deallocated. !> !> When computing the Cholesky factorization, it is possible that \f$L_{jj} == 0\f$, which would !> result in a division by zero. !> This could occur from either \f$A_{jj}\f$ not existing in the sparse CSR matrix (referred to !> as a structural zero) or because !> \f$A_{jj} - \sum_{k=0}^{j-1}(L_{jk})^{2} == 0\f$ (referred to as a numerical zero). For !> example, running the Cholesky !> factorization on the following matrix: !> \f[ !> \begin{bmatrix} !> 2 & 1 & 0 \\% !> 1 & 2 & 1 \\% !> 0 & 1 & 2 !> \end{bmatrix} !> \f] !> results in a successful Cholesky factorization, however running with the matrix: !> \f[ !> \begin{bmatrix} !> 2 & 1 & 0 \\% !> 1 & 1/2 & 1 \\% !> 0 & 1 & 2 !> \end{bmatrix} !> \f] !> results in a numerical zero because: !> \f[ !> \begin{array}{ll} !> L_{00} &= \sqrt{2} \\% !> L_{10} &= \frac{1}{\sqrt{2}} \\% !> L_{11} &= \sqrt{\frac{1}{2} - (\frac{1}{\sqrt{2}})^2} !> &= 0 !> \end{array} !> \f] !> The user can detect the presence of a structural zero by calling !> `hipsparseXcsric02_zeroPivot` () after !> `hipsparseScsric02_analysis` "hipsparseXcsric02_analysis()" and/or the presence of a !> structural or !> numerical zero by calling `hipsparseXcsric02_zeroPivot` () after `hipsparseScsric02` !> "hipsparseXcsric02()": !> \code{.c} !> hipsparseDcsric02(handle, !> m, !> nnz, !> descrM, !> csrVal, !> csrRowPtr, !> csrColInd, !> info, !> HIPSPARSE_SOLVE_POLICY_USE_LEVEL, !> buffer); !> !> // Check for zero pivot !> if(CUSPARSE_STATUS_ZERO_PIVOT == hipsparseXcsric02_zeroPivot(handle, info, &position)) !> { !> printf("L has structural and/or numerical zero at L(%d,%d)", position, position); !> } !> \endcode !> In both cases, `hipsparseXcsric02_zeroPivot` () will report the first zero pivot (either !> numerical or structural) !> found. See the full example below. The user can also set the diagonal type to be \f$1\f$ !> using `hipsparseSetMatDiagType` (), !> which will interpret the matrix \f$A\f$ as having ones on its diagonal (even if no non-zero !> exists in the sparsity pattern). !> !> \p hipsparseXcsric02 computes the Cholesky factorization inplace meaning that the values !> array \p csrSortedValA_valM of the \f$A\f$ !> matrix is overwritten with the \f$L\f$ matrix stored in the lower triangular part of \f$A\f$: !> !> \f[ !> \begin{align} !> \begin{bmatrix} !> a_{00} & a_{01} & a_{02} \\% !> a_{10} & a_{11} & a_{12} \\% !> a_{20} & a_{21} & a_{22} !> \end{bmatrix} !> \rightarrow !> \begin{bmatrix} !> l_{00} & a_{01} & a_{02} \\% !> l_{10} & l_{11} & a_{12} \\% !> l_{20} & l_{21} & l_{22} !> \end{bmatrix} !> \end{align} !> \f] !> The row pointer array \p csrSortedRowPtrA and the column indices array \p csrSortedColIndA !> remain the same for \f$A\f$ and the !> output as the incomplete factorization does not generate new non-zeros in the output which do !> not already exist in \f$A\f$. !> !> The performance of computing Cholesky factorization with hipSPARSE greatly depends on the !> sparsity pattern !> the the matrix \f$A\f$, because this is what determines the amount of parallelism available. !> !> \note !> The sparse CSR matrix has to be sorted. This can be achieved by calling !> `hipsparseXcsrsort`(). !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descrA - descriptor of the sparse CSR matrix. !> @param[inout] csrSortedValA_valM - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start !> of every row of the sparse CSR matrix. !> @param[in] csrSortedColIndA - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] policy - `HIPSPARSE_SOLVE_POLICY_NO_LEVEL` or `HIPSPARSE_SOLVE_POLICY_USE_LEVEL`. !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p nnz, \p descrA, \p !> csrSortedValA_valM, !> \p csrSortedRowPtrA, or \p csrSortedColIndA pointer is invalid. !> \retval HIPSPARSE_STATUS_ARCH_MISMATCH the device is not supported. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseScsric02 #ifdef USE_CUDA_NAMES function hipsparseScsric02_(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="cusparseScsric02") #else function hipsparseScsric02_(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseScsric02") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsric02_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA_valM type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsric02_assumed_rank #else module procedure & hipsparseScsric02_rank_0,& hipsparseScsric02_rank_1 #endif #endif end interface interface hipsparseDcsric02 #ifdef USE_CUDA_NAMES function hipsparseDcsric02_(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="cusparseDcsric02") #else function hipsparseDcsric02_(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseDcsric02") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsric02_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA_valM type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsric02_assumed_rank #else module procedure & hipsparseDcsric02_rank_0,& hipsparseDcsric02_rank_1 #endif #endif end interface interface hipsparseCcsric02 #ifdef USE_CUDA_NAMES function hipsparseCcsric02_(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="cusparseCcsric02") #else function hipsparseCcsric02_(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseCcsric02") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsric02_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA_valM type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsric02_assumed_rank #else module procedure & hipsparseCcsric02_rank_0,& hipsparseCcsric02_rank_1 #endif #endif end interface interface hipsparseZcsric02 #ifdef USE_CUDA_NAMES function hipsparseZcsric02_(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="cusparseZcsric02") #else function hipsparseZcsric02_(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseZcsric02") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsric02_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA_valM type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsric02_assumed_rank #else module procedure & hipsparseZcsric02_rank_0,& hipsparseZcsric02_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p hipsparseXcsrilu02_zeroPivot returns `HIPSPARSE_STATUS_ZERO_PIVOT` if either a !> structural or numerical zero has been found during `hipsparseScsrilu02` !> "hipsparseXcsrilu02()" !> computation. The first zero pivot \f$j\f$ at \f$A_{j,j}\f$ is stored in \p position, using !> the same !> index base as the CSR matrix. !> !> \p position can be in host or device memory. If no zero pivot has been found, !> \p position is set to -1 and `HIPSPARSE_STATUS_SUCCESS` is returned instead. !> !> \note \p hipsparseXcsrilu02_zeroPivot is a blocking function. It might negatively influence !> performance. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 12.0+) and will be !> removed in CUDA 13.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[inout] position - pointer to zero pivot \f$j\f$, which can be in host or device !> memory. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p info, or \p position is nullptr. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_ZERO_PIVOT zero pivot has been found. interface hipsparseXcsrilu02_zeroPivot #ifdef USE_CUDA_NAMES function hipsparseXcsrilu02_zeroPivot_(handle,myInfo,position) & bind(c, name="cusparseXcsrilu02_zeroPivot") #else function hipsparseXcsrilu02_zeroPivot_(handle,myInfo,position) & bind(c, name="hipsparseXcsrilu02_zeroPivot") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrilu02_zeroPivot_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int) :: position end function end interface !> \ingroup precond_module !> \details !> \p hipsparseXcsrilu02_numericBoost enables the user to replace a numerical value in !> an incomplete LU factorization. \p tol is used to determine whether a numerical value !> is replaced by \p boost_val, such that \f$A_{j,j} = \text{boost_val}\f$ if !> \f$\text{tol} ≥ \left|A_{j,j}\right|\f$. !> !> \note The boost value is enabled by setting \p enable_boost to 1 or disabled by !> setting \p enable_boost to 0. !> !> \note \p tol and \p boost_val can be in host or device memory. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 12.0+) and will be !> removed in CUDA 13.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] enable_boost - enable/disable numeric boost. !> @param[in] tol - tolerance to determine whether a numerical value is replaced or not. !> @param[in] boost_val - boost value to replace a numerical value. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p info, \p tol, or \p boost_val is !> nullptr. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseScsrilu02_numericBoost #ifdef USE_CUDA_NAMES function hipsparseScsrilu02_numericBoost_(handle,myInfo,enable_boost,tol,boost_val) & bind(c, name="cusparseScsrilu02_numericBoost") #else function hipsparseScsrilu02_numericBoost_(handle,myInfo,enable_boost,tol,boost_val) & bind(c, name="hipsparseScsrilu02_numericBoost") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrilu02_numericBoost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_double) :: tol real(c_float) :: boost_val end function end interface interface hipsparseDcsrilu02_numericBoost #ifdef USE_CUDA_NAMES function hipsparseDcsrilu02_numericBoost_(handle,myInfo,enable_boost,tol,boost_val) & bind(c, name="cusparseDcsrilu02_numericBoost") #else function hipsparseDcsrilu02_numericBoost_(handle,myInfo,enable_boost,tol,boost_val) & bind(c, name="hipsparseDcsrilu02_numericBoost") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrilu02_numericBoost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_double) :: tol real(c_double) :: boost_val end function end interface interface hipsparseCcsrilu02_numericBoost #ifdef USE_CUDA_NAMES function hipsparseCcsrilu02_numericBoost_(handle,myInfo,enable_boost,tol,boost_val) & bind(c, name="cusparseCcsrilu02_numericBoost") #else function hipsparseCcsrilu02_numericBoost_(handle,myInfo,enable_boost,tol,boost_val) & bind(c, name="hipsparseCcsrilu02_numericBoost") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrilu02_numericBoost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_double) :: tol complex(c_float_complex) :: boost_val end function end interface interface hipsparseZcsrilu02_numericBoost #ifdef USE_CUDA_NAMES function hipsparseZcsrilu02_numericBoost_(handle,myInfo,enable_boost,tol,boost_val) & bind(c, name="cusparseZcsrilu02_numericBoost") #else function hipsparseZcsrilu02_numericBoost_(handle,myInfo,enable_boost,tol,boost_val) & bind(c, name="hipsparseZcsrilu02_numericBoost") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrilu02_numericBoost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_double) :: tol complex(c_double_complex) :: boost_val end function end interface !> \ingroup precond_module !> \details !> \p hipsparseXcsrilu02_bufferSize returns the size of the temporary storage buffer !> in bytes that is required by `hipsparseScsrilu02_analysis` "hipsparseXcsrilu02_analysis()" !> and `hipsparseScsrilu02` "hipsparseXcsrilu02()". The temporary storage buffer !> must be allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descrA - descriptor of the sparse CSR matrix. !> @param[in] csrSortedValA - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix. !> @param[in] csrSortedColIndA - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseScsrilu02_analysis` "hipsparseXcsrilu02_analysis()" and !> `hipsparseScsrilu02` "hipsparseXcsrilu02()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p nnz, \p descrA, \p csrSortedValA, !> \p csrSortedRowPtrA, \p csrSortedColIndA, \p info, or \p pBufferSizeInBytes !> pointer !> is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseScsrilu02_bufferSize #ifdef USE_CUDA_NAMES function hipsparseScsrilu02_bufferSize_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseScsrilu02_bufferSize") #else function hipsparseScsrilu02_bufferSize_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseScsrilu02_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrilu02_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrilu02_bufferSize_assumed_rank #else module procedure & hipsparseScsrilu02_bufferSize_rank_0,& hipsparseScsrilu02_bufferSize_rank_1 #endif #endif end interface interface hipsparseDcsrilu02_bufferSize #ifdef USE_CUDA_NAMES function hipsparseDcsrilu02_bufferSize_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseDcsrilu02_bufferSize") #else function hipsparseDcsrilu02_bufferSize_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseDcsrilu02_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrilu02_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrilu02_bufferSize_assumed_rank #else module procedure & hipsparseDcsrilu02_bufferSize_rank_0,& hipsparseDcsrilu02_bufferSize_rank_1 #endif #endif end interface interface hipsparseCcsrilu02_bufferSize #ifdef USE_CUDA_NAMES function hipsparseCcsrilu02_bufferSize_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseCcsrilu02_bufferSize") #else function hipsparseCcsrilu02_bufferSize_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseCcsrilu02_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrilu02_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrilu02_bufferSize_assumed_rank #else module procedure & hipsparseCcsrilu02_bufferSize_rank_0,& hipsparseCcsrilu02_bufferSize_rank_1 #endif #endif end interface interface hipsparseZcsrilu02_bufferSize #ifdef USE_CUDA_NAMES function hipsparseZcsrilu02_bufferSize_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseZcsrilu02_bufferSize") #else function hipsparseZcsrilu02_bufferSize_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseZcsrilu02_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrilu02_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrilu02_bufferSize_assumed_rank #else module procedure & hipsparseZcsrilu02_bufferSize_rank_0,& hipsparseZcsrilu02_bufferSize_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p hipsparseXcsrilu02_bufferSizeExt returns the size of the temporary storage buffer !> in bytes that is required by `hipsparseScsrilu02_analysis` "hipsparseXcsrilu02_analysis()" !> and `hipsparseScsrilu02` "hipsparseXcsrilu02()". The temporary storage buffer !> must be allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descrA - descriptor of the sparse CSR matrix. !> @param[in] csrSortedValA - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix. !> @param[in] csrSortedColIndA - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseScsrilu02_analysis` "hipsparseXcsrilu02_analysis()" and !> `hipsparseScsrilu02` "hipsparseXcsrilu02()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p nnz, \p descrA, \p csrSortedValA, !> \p csrSortedRowPtrA, \p csrSortedColIndA, \p info, or \p pBufferSizeInBytes !> pointer !> is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. #ifndef USE_CUDA_NAMES interface hipsparseScsrilu02_bufferSizeExt function hipsparseScsrilu02_bufferSizeExt_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseScsrilu02_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrilu02_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrilu02_bufferSizeExt_assumed_rank #else module procedure & hipsparseScsrilu02_bufferSizeExt_rank_0,& hipsparseScsrilu02_bufferSizeExt_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsrilu02_bufferSizeExt function hipsparseDcsrilu02_bufferSizeExt_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseDcsrilu02_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrilu02_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrilu02_bufferSizeExt_assumed_rank #else module procedure & hipsparseDcsrilu02_bufferSizeExt_rank_0,& hipsparseDcsrilu02_bufferSizeExt_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsrilu02_bufferSizeExt function hipsparseCcsrilu02_bufferSizeExt_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseCcsrilu02_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrilu02_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrilu02_bufferSizeExt_assumed_rank #else module procedure & hipsparseCcsrilu02_bufferSizeExt_rank_0,& hipsparseCcsrilu02_bufferSizeExt_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsrilu02_bufferSizeExt function hipsparseZcsrilu02_bufferSizeExt_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseZcsrilu02_bufferSizeExt") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrilu02_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrilu02_bufferSizeExt_assumed_rank #else module procedure & hipsparseZcsrilu02_bufferSizeExt_rank_0,& hipsparseZcsrilu02_bufferSizeExt_rank_1 #endif #endif end interface #endif !> \ingroup precond_module !> \details !> \p hipsparseXcsrilu02_analysis performs the analysis step for `hipsparseScsrilu02` !> "hipsparseXcsrilu02()". It is expected that this function will be executed only once for !> a given matrix and particular operation type. !> !> \note !> If the matrix sparsity pattern changes, the gathered information will become invalid. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descrA - descriptor of the sparse CSR matrix. !> @param[in] csrSortedValA - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix. !> @param[in] csrSortedColIndA - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix. !> @param[out] myInfo - structure that holds the information collected during !> the analysis step. !> @param[in] policy - `HIPSPARSE_SOLVE_POLICY_NO_LEVEL` or `HIPSPARSE_SOLVE_POLICY_USE_LEVEL`. !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p nnz, \p descrA, \p csrSortedValA, !> \p csrSortedRowPtrA, \p csrSortedColIndA, \p info, or \p pBuffer pointer is !> invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseScsrilu02_analysis #ifdef USE_CUDA_NAMES function hipsparseScsrilu02_analysis_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="cusparseScsrilu02_analysis") #else function hipsparseScsrilu02_analysis_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseScsrilu02_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrilu02_analysis_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrilu02_analysis_assumed_rank #else module procedure & hipsparseScsrilu02_analysis_rank_0,& hipsparseScsrilu02_analysis_rank_1 #endif #endif end interface interface hipsparseDcsrilu02_analysis #ifdef USE_CUDA_NAMES function hipsparseDcsrilu02_analysis_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="cusparseDcsrilu02_analysis") #else function hipsparseDcsrilu02_analysis_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseDcsrilu02_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrilu02_analysis_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrilu02_analysis_assumed_rank #else module procedure & hipsparseDcsrilu02_analysis_rank_0,& hipsparseDcsrilu02_analysis_rank_1 #endif #endif end interface interface hipsparseCcsrilu02_analysis #ifdef USE_CUDA_NAMES function hipsparseCcsrilu02_analysis_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="cusparseCcsrilu02_analysis") #else function hipsparseCcsrilu02_analysis_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseCcsrilu02_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrilu02_analysis_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrilu02_analysis_assumed_rank #else module procedure & hipsparseCcsrilu02_analysis_rank_0,& hipsparseCcsrilu02_analysis_rank_1 #endif #endif end interface interface hipsparseZcsrilu02_analysis #ifdef USE_CUDA_NAMES function hipsparseZcsrilu02_analysis_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="cusparseZcsrilu02_analysis") #else function hipsparseZcsrilu02_analysis_(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseZcsrilu02_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrilu02_analysis_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrilu02_analysis_assumed_rank #else module procedure & hipsparseZcsrilu02_analysis_rank_0,& hipsparseZcsrilu02_analysis_rank_1 #endif #endif end interface !> \ingroup precond_module !> \brief Incomplete LU factorization with 0 fill-ins and no pivoting using the CSR !> storage format. !> !> \details !> \p hipsparseXcsrilu02 computes the incomplete LU factorization with 0 fill-ins and no !> pivoting of a sparse \f$m \times m\f$ CSR matrix \f$A\f$, such that !> \f[ !> A \approx LU !> \f] !> where the lower triangular matrix \f$L\f$ and the upper triangular matrix \f$U\f$ are !> computed using: !> \f[ !> \begin{array}{ll} !> L_{ij} = \frac{1}{U_{jj}}(A_{ij} - \sum_{k=0}^{j-1}L_{ik} \times U_{kj}), & \text{if i !> > j} \\% !> U_{ij} = (A_{ij} - \sum_{k=0}^{j-1}L_{ik} \times U_{kj}), & \text{if i <= j} !> \end{array} !> \f] !> for each entry found in the CSR matrix \f$A\f$. !> !> Computing the above incomplete \f$LU\f$ factorization requires three steps to complete. !> First, !> the user determines the size of the required temporary storage buffer by calling !> `hipsparseScsrilu02_bufferSize` "hipsparseXcsrilu02_bufferSize()". After this buffer size has !> been determined, !> the user allocates the buffer and passes it to `hipsparseScsrilu02_analysis` !> "hipsparseXcsrilu02_analysis()". !> This will perform analysis on the sparsity pattern of the matrix. Finally, the user calls \p !> hipsparseScsrilu02, !> \p hipsparseDcsrilu02, \p hipsparseCcsrilu02, or \p hipsparseZcsrilu02 to perform the actual !> factorization. The calculation !> of the buffer size and the analysis of the sparse matrix only need to be performed once for a !> given sparsity pattern, !> while the factorization can be repeatedly applied to multiple matrices having the same !> sparsity pattern. After all calls !> to `hipsparseScsrilu02` "hipsparseXcsrilu02()" are complete, the temporary buffer can be !> deallocated. !> !> When computing the \f$LU\f$ factorization, it is possible that \f$U_{jj} == 0\f$ which would !> result in a division by zero. !> This could occur from either \f$A_{jj}\f$ not existing in the sparse CSR matrix (referred to !> as a structural zero) or because !> \f$A_{ij} - \sum_{k=0}^{j-1}L_{ik} \times U_{kj} == 0\f$ (referred to as a numerical zero). !> For example, running the !> \f$LU\f$ factorization on the following matrix: !> \f[ !> \begin{bmatrix} !> 2 & 1 & 0 \\% !> 1 & 2 & 1 \\% !> 0 & 1 & 2 !> \end{bmatrix} !> \f] !> results in a successful \f$LU\f$ factorization. However, running with the matrix: !> \f[ !> \begin{bmatrix} !> 2 & 1 & 0 \\% !> 1 & 1/2 & 1 \\% !> 0 & 1 & 2 !> \end{bmatrix} !> \f] !> results in a numerical zero because: !> \f[ !> \begin{array}{ll} !> U_{00} &= 2 \\% !> U_{01} &= 1 \\% !> L_{10} &= \frac{1}{2} \\% !> U_{11} &= \frac{1}{2} - \frac{1}{2} !> &= 0 !> \end{array} !> \f] !> The user can detect the presence of a structural zero by calling !> `hipsparseXcsrilu02_zeroPivot` () after !> `hipsparseScsrilu02_analysis` "hipsparseXcsrilu02_analysis()" and/or the presence of a !> structural or !> numerical zero by calling `hipsparseXcsrilu02_zeroPivot` () after `hipsparseScsrilu02` !> "hipsparseXcsrilu02()". !> In both cases, `hipsparseXcsrilu02_zeroPivot` () will report the first zero pivot (either !> numerical or structural) !> found. See the example below. The user can also set the diagonal type to be \f$1\f$ using !> `hipsparseSetMatDiagType` (), !> which will interpret the matrix \f$A\f$ as having ones on its diagonal (even if no nonzero !> exists in the sparsity pattern). !> !> \p hipsparseXcsrilu02 computes the \f$LU\f$ factorization inplace, meaning that the values !> array \p csrSortedValA_valM of the \f$A\f$ !> matrix is overwritten with the \f$L\f$ matrix stored in the strictly lower triangular part of !> \f$A\f$ and the \f$U\f$ matrix !> stored in the upper part of \f$A\f$: !> !> \f[ !> \begin{align} !> \begin{bmatrix} !> a_{00} & a_{01} & a_{02} \\% !> a_{10} & a_{11} & a_{12} \\% !> a_{20} & a_{21} & a_{22} !> \end{bmatrix} !> \rightarrow !> \begin{bmatrix} !> u_{00} & u_{01} & u_{02} \\% !> l_{10} & u_{11} & u_{12} \\% !> l_{20} & l_{21} & u_{22} !> \end{bmatrix} !> \end{align} !> \f] !> The row pointer array \p csrSortedRowPtrA and the column indices array \p csrSortedColIndA !> remain the same for \f$A\f$ and \f$LU\f$ as !> the incomplete factorization does not generate new non-zeros in \f$LU\f$ which do not already !> exist in \f$A\f$. !> !> The performance of computing \f$LU\f$ factorization with hipSPARSE greatly depends on the !> sparsity pattern !> of the matrix \f$A\f$, because this is what determines the amount of parallelism available. !> !> \note !> The sparse CSR matrix has to be sorted. This can be achieved by calling !> `hipsparseXcsrsort`(). !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descrA - descriptor of the sparse CSR matrix. !> @param[inout] csrSortedValA_valM - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start !> of every row of the sparse CSR matrix. !> @param[in] csrSortedColIndA - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] policy - `HIPSPARSE_SOLVE_POLICY_NO_LEVEL` or `HIPSPARSE_SOLVE_POLICY_USE_LEVEL`. !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p nnz, \p descrA, \p !> csrSortedValA_valM, !> \p csrSortedRowPtrA, or \p csrSortedColIndA pointer is invalid. !> \retval HIPSPARSE_STATUS_ARCH_MISMATCH the device is not supported. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseScsrilu02 #ifdef USE_CUDA_NAMES function hipsparseScsrilu02_(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="cusparseScsrilu02") #else function hipsparseScsrilu02_(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseScsrilu02") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrilu02_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA_valM type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrilu02_assumed_rank #else module procedure & hipsparseScsrilu02_rank_0,& hipsparseScsrilu02_rank_1 #endif #endif end interface interface hipsparseDcsrilu02 #ifdef USE_CUDA_NAMES function hipsparseDcsrilu02_(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="cusparseDcsrilu02") #else function hipsparseDcsrilu02_(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseDcsrilu02") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrilu02_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA_valM type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrilu02_assumed_rank #else module procedure & hipsparseDcsrilu02_rank_0,& hipsparseDcsrilu02_rank_1 #endif #endif end interface interface hipsparseCcsrilu02 #ifdef USE_CUDA_NAMES function hipsparseCcsrilu02_(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="cusparseCcsrilu02") #else function hipsparseCcsrilu02_(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseCcsrilu02") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrilu02_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA_valM type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrilu02_assumed_rank #else module procedure & hipsparseCcsrilu02_rank_0,& hipsparseCcsrilu02_rank_1 #endif #endif end interface interface hipsparseZcsrilu02 #ifdef USE_CUDA_NAMES function hipsparseZcsrilu02_(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="cusparseZcsrilu02") #else function hipsparseZcsrilu02_(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) & bind(c, name="hipsparseZcsrilu02") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrilu02_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA_valM type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)),value :: policy type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrilu02_assumed_rank #else module procedure & hipsparseZcsrilu02_rank_0,& hipsparseZcsrilu02_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p hipsparseXgpsvInterleavedBatch_bufferSizeExt returns the size of the temporary storage !> buffer in bytes that is required by `hipsparseSgpsvInterleavedBatch` !> "hipsparseXgpsvInterleavedBatch()". !> The temporary storage buffer must be allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] algo - algorithm to solve the linear system. !> @param[in] m - size of the pentadiagonal linear system. !> @param[in] ds - lower diagonal (distance 2) of the pentadiagonal system. The first two !> entries !> must be zero. !> @param[in] dl - lower diagonal of the pentadiagonal system. The first entry must be zero. !> @param[in] d - main diagonal of the pentadiagonal system. !> @param[in] du - upper diagonal of the pentadiagonal system. The last entry must be zero. !> @param[in] dw - upper diagonal (distance 2) of the pentadiagonal system. The last two entries !> must be zero. !> @param[in] x - Dense array of right-hand sides with dimension \p batchCount by \p m. !> @param[in] batchCount - The number of systems to solve. !> @param[out] pBufferSizeInBytes - Number of bytes of the temporary storage buffer required. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p alg, \p batchCount, \p ds, \p dl, !> \p d, \p du, \p dw, \p x, or \p pBufferSizeInBytes pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseSgpsvInterleavedBatch_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseSgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,ds,dl,d,du,dw,x, & batchCount,pBufferSizeInBytes) & bind(c, name="cusparseSgpsvInterleavedBatch_bufferSizeExt") #else function hipsparseSgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,ds,dl,d,du,dw,x, & batchCount,pBufferSizeInBytes) & bind(c, name="hipsparseSgpsvInterleavedBatch_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgpsvInterleavedBatch_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(c_int),value :: m type(c_ptr),value :: ds type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: dw type(c_ptr),value :: x integer(c_int),value :: batchCount integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSgpsvInterleavedBatch_bufferSizeExt_assumed_rank #else module procedure & hipsparseSgpsvInterleavedBatch_bufferSizeExt_rank_0,& hipsparseSgpsvInterleavedBatch_bufferSizeExt_rank_1 #endif #endif end interface interface hipsparseDgpsvInterleavedBatch_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseDgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,ds,dl,d,du,dw,x, & batchCount,pBufferSizeInBytes) & bind(c, name="cusparseDgpsvInterleavedBatch_bufferSizeExt") #else function hipsparseDgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,ds,dl,d,du,dw,x, & batchCount,pBufferSizeInBytes) & bind(c, name="hipsparseDgpsvInterleavedBatch_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgpsvInterleavedBatch_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(c_int),value :: m type(c_ptr),value :: ds type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: dw type(c_ptr),value :: x integer(c_int),value :: batchCount integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDgpsvInterleavedBatch_bufferSizeExt_assumed_rank #else module procedure & hipsparseDgpsvInterleavedBatch_bufferSizeExt_rank_0,& hipsparseDgpsvInterleavedBatch_bufferSizeExt_rank_1 #endif #endif end interface interface hipsparseCgpsvInterleavedBatch_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseCgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,ds,dl,d,du,dw,x, & batchCount,pBufferSizeInBytes) & bind(c, name="cusparseCgpsvInterleavedBatch_bufferSizeExt") #else function hipsparseCgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,ds,dl,d,du,dw,x, & batchCount,pBufferSizeInBytes) & bind(c, name="hipsparseCgpsvInterleavedBatch_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgpsvInterleavedBatch_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(c_int),value :: m type(c_ptr),value :: ds type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: dw type(c_ptr),value :: x integer(c_int),value :: batchCount integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCgpsvInterleavedBatch_bufferSizeExt_assumed_rank #else module procedure & hipsparseCgpsvInterleavedBatch_bufferSizeExt_rank_0,& hipsparseCgpsvInterleavedBatch_bufferSizeExt_rank_1 #endif #endif end interface interface hipsparseZgpsvInterleavedBatch_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseZgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,ds,dl,d,du,dw,x, & batchCount,pBufferSizeInBytes) & bind(c, name="cusparseZgpsvInterleavedBatch_bufferSizeExt") #else function hipsparseZgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,ds,dl,d,du,dw,x, & batchCount,pBufferSizeInBytes) & bind(c, name="hipsparseZgpsvInterleavedBatch_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgpsvInterleavedBatch_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(c_int),value :: m type(c_ptr),value :: ds type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: dw type(c_ptr),value :: x integer(c_int),value :: batchCount integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZgpsvInterleavedBatch_bufferSizeExt_assumed_rank #else module procedure & hipsparseZgpsvInterleavedBatch_bufferSizeExt_rank_0,& hipsparseZgpsvInterleavedBatch_bufferSizeExt_rank_1 #endif #endif end interface !> \ingroup precond_module !> \brief Interleaved batch pentadiagonal solver !> !> \details !> \p hipsparseXgpsvInterleavedBatch solves a batch of pentadiagonal linear systems !> \f[ !> P^{i}*x^{i} = x^{i} !> \f] !> where for each batch \f$i=0\ldots\f$ \p batchCount, \f$P^{i}\f$ is a sparse pentadiagonal !> matrix and !> \f$x^{i}\f$ is a dense right-hand side vector. All of the pentadiagonal matrices, !> \f$P^{i}\f$, are !> packed in an interleaved fashion into five vectors: \p ds for the lowest diagonals, \p dl for !> the lower !> diagonals, \p d for the main diagonals, \p du for the upper diagonals, and \p dw for the !> highest digaonals. !> See below for a description of the interleaved memory pattern. !> !> Solving the batched pentadiagonal system involves two steps. First, the user calls !> `hipsparseSgpsvInterleavedBatch_bufferSizeExt` !> "`hipsparseSgpsvInterleavedBatch_bufferSizeExt()`" !> to determine the size of the required temporary storage buffer. Once determined, the user !> allocates !> this buffer and passes it to `hipsparseSgpsvInterleavedBatch` !> "hipsparseXgpsvInterleavedBatch()" !> to perform the actual solve. The \f$x^{i}\f$ vectors, which initially stores the right-hand !> side values, are !> overwritten with the solution after the call to !> `hipsparseSgpsvInterleavedBatch` "hipsparseXgpsvInterleavedBatch()". !> !> Unlike the strided batch routines, which write each batch matrix one after the other in !> memory, the interleaved !> routines write the batch matrices such that each element from each matrix is written !> consecutively one after !> the other. For example, consider the following batch matrices: !> !> \f[ !> \begin{bmatrix} !> t^{0}_{00} & t^{0}_{01} & t^{0}_{02} \\% !> t^{0}_{10} & t^{0}_{11} & t^{0}_{12} \\% !> t^{0}_{20} & t^{0}_{21} & t^{0}_{22} !> \end{bmatrix} !> \begin{bmatrix} !> t^{1}_{00} & t^{1}_{01} & t^{1}_{02} \\% !> t^{1}_{10} & t^{1}_{11} & t^{1}_{12} \\% !> t^{1}_{20} & t^{1}_{21} & t^{1}_{22} !> \end{bmatrix} !> \begin{bmatrix} !> t^{2}_{00} & t^{2}_{01} & t^{2}_{02} \\% !> t^{2}_{10} & t^{2}_{11} & t^{2}_{12} \\% !> t^{2}_{20} & t^{2}_{21} & t^{2}_{22} !> \end{bmatrix} !> \f] !> !> In interleaved format, the highest, higher, lowest, lower, and diagonal arrays would look !> like: !> \f[ !> \begin{align} !> \text{lowest} &= \begin{bmatrix} 0 & 0 & 0 & 0 & 0 & 0 & t^{0}_{20} & t^{1}_{20} & !> t^{2}_{20} \end{bmatrix} \\% !> \text{lower} &= \begin{bmatrix} 0 & 0 & 0 & t^{0}_{10} & t^{1}_{10} & t^{1}_{10} & !> t^{0}_{21} & t^{1}_{21} & t^{2}_{21} \end{bmatrix} \\% !> \text{diagonal} &= \begin{bmatrix} t^{0}_{00} & t^{1}_{00} & t^{2}_{00} & t^{0}_{11} & !> t^{1}_{11} & t^{2}_{11} & t^{0}_{22} & t^{1}_{22} & t^{2}_{22} \end{bmatrix} \\% !> \text{higher} &= \begin{bmatrix} t^{0}_{01} & t^{1}_{01} & t^{2}_{01} & t^{0}_{12} & !> t^{1}_{12} & t^{2}_{12} & 0 & 0 & 0 \end{bmatrix} \\% !> \text{highest} &= \begin{bmatrix} t^{0}_{02} & t^{1}_{02} & t^{2}_{02} & 0 & 0 & 0 & 0 & 0 !> & 0 \end{bmatrix} \\% !> \end{align} !> \f] !> For the lowest array, the first \p 2*batchCount entries are zero, and for the lower array, !> the first \p batchCount entries are zero. !> For the upper array, the last \p batchCount entries are zero, and for the highest array, the !> last \p 2*batchCount entries are zero. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] algo - algorithm to solve the linear system. !> @param[in] m - size of the pentadiagonal linear system. !> @param[inout] ds - lower diagonal (distance 2) of the pentadiagonal system. The first two !> entries !> must be zero. !> @param[inout] dl - lower diagonal of the pentadiagonal system. The first entry must be zero. !> @param[inout] d - main diagonal of the pentadiagonal system. !> @param[inout] du - upper diagonal of the pentadiagonal system. The last entry must be zero. !> @param[inout] dw - upper diagonal (distance 2) of the pentadiagonal system. The last two !> entries !> must be zero. !> @param[inout] x - Dense array of right-hand-sides with dimension \p batchCount by \p m. !> @param[in] batchCount - The number of systems to solve. !> @param[in] pBuffer - Temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p alg, \p batchCount, \p ds, !> \p dl, \p d, \p du, \p dw, \p x, or \p pBuffer pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseSgpsvInterleavedBatch #ifdef USE_CUDA_NAMES function hipsparseSgpsvInterleavedBatch_(handle,algo,m,ds,dl,d,du,dw,x,batchCount,pBuffer) & bind(c, name="cusparseSgpsvInterleavedBatch") #else function hipsparseSgpsvInterleavedBatch_(handle,algo,m,ds,dl,d,du,dw,x,batchCount,pBuffer) & bind(c, name="hipsparseSgpsvInterleavedBatch") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgpsvInterleavedBatch_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(c_int),value :: m type(c_ptr),value :: ds type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: dw type(c_ptr),value :: x integer(c_int),value :: batchCount type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSgpsvInterleavedBatch_assumed_rank #else module procedure & hipsparseSgpsvInterleavedBatch_rank_0,& hipsparseSgpsvInterleavedBatch_rank_1 #endif #endif end interface interface hipsparseDgpsvInterleavedBatch #ifdef USE_CUDA_NAMES function hipsparseDgpsvInterleavedBatch_(handle,algo,m,ds,dl,d,du,dw,x,batchCount,pBuffer) & bind(c, name="cusparseDgpsvInterleavedBatch") #else function hipsparseDgpsvInterleavedBatch_(handle,algo,m,ds,dl,d,du,dw,x,batchCount,pBuffer) & bind(c, name="hipsparseDgpsvInterleavedBatch") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgpsvInterleavedBatch_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(c_int),value :: m type(c_ptr),value :: ds type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: dw type(c_ptr),value :: x integer(c_int),value :: batchCount type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDgpsvInterleavedBatch_assumed_rank #else module procedure & hipsparseDgpsvInterleavedBatch_rank_0,& hipsparseDgpsvInterleavedBatch_rank_1 #endif #endif end interface interface hipsparseCgpsvInterleavedBatch #ifdef USE_CUDA_NAMES function hipsparseCgpsvInterleavedBatch_(handle,algo,m,ds,dl,d,du,dw,x,batchCount,pBuffer) & bind(c, name="cusparseCgpsvInterleavedBatch") #else function hipsparseCgpsvInterleavedBatch_(handle,algo,m,ds,dl,d,du,dw,x,batchCount,pBuffer) & bind(c, name="hipsparseCgpsvInterleavedBatch") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgpsvInterleavedBatch_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(c_int),value :: m type(c_ptr),value :: ds type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: dw type(c_ptr),value :: x integer(c_int),value :: batchCount type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCgpsvInterleavedBatch_assumed_rank #else module procedure & hipsparseCgpsvInterleavedBatch_rank_0,& hipsparseCgpsvInterleavedBatch_rank_1 #endif #endif end interface interface hipsparseZgpsvInterleavedBatch #ifdef USE_CUDA_NAMES function hipsparseZgpsvInterleavedBatch_(handle,algo,m,ds,dl,d,du,dw,x,batchCount,pBuffer) & bind(c, name="cusparseZgpsvInterleavedBatch") #else function hipsparseZgpsvInterleavedBatch_(handle,algo,m,ds,dl,d,du,dw,x,batchCount,pBuffer) & bind(c, name="hipsparseZgpsvInterleavedBatch") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgpsvInterleavedBatch_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(c_int),value :: m type(c_ptr),value :: ds type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: dw type(c_ptr),value :: x integer(c_int),value :: batchCount type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZgpsvInterleavedBatch_assumed_rank #else module procedure & hipsparseZgpsvInterleavedBatch_rank_0,& hipsparseZgpsvInterleavedBatch_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p hipsparseSgtsv2_bufferSizeExt returns the size of the temporary storage buffer !> that is required by `hipsparseSgtsv2` "hipsparseXgtsv2()". The temporary !> storage buffer must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - size of the tridiagonal linear system. Must be at least 2. !> @param[in] n - number of columns in the dense matrix B. Must be non-negative. !> @param[in] dl - lower diagonal of the tridiagonal system. The first entry must be zero. !> @param[in] d - main diagonal of the tridiagonal system. !> @param[in] du - upper diagonal of the tridiagonal system. The last entry must be zero. !> @param[in] B - dense matrix of size ( \p ldb, \p n ). !> @param[in] ldb - leading dimension of B. Must satisfy \p ldb >= max(1, m). !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseSgtsv2` "hipsparseXgtsv2()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p dl, \p d, \p du, \p B, or !> \p pBufferSizeInBytes is nullptr, \p m is less than 2, \p n is negative, !> or \p ldb is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseSgtsv2_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseSgtsv2_bufferSizeExt_(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) & bind(c, name="cusparseSgtsv2_bufferSizeExt") #else function hipsparseSgtsv2_bufferSizeExt_(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) & bind(c, name="hipsparseSgtsv2_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSgtsv2_bufferSizeExt_assumed_rank #else module procedure & hipsparseSgtsv2_bufferSizeExt_rank_0,& hipsparseSgtsv2_bufferSizeExt_rank_1,& hipsparseSgtsv2_bufferSizeExt_full_rank #endif #endif end interface interface hipsparseDgtsv2_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseDgtsv2_bufferSizeExt_(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) & bind(c, name="cusparseDgtsv2_bufferSizeExt") #else function hipsparseDgtsv2_bufferSizeExt_(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) & bind(c, name="hipsparseDgtsv2_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDgtsv2_bufferSizeExt_assumed_rank #else module procedure & hipsparseDgtsv2_bufferSizeExt_rank_0,& hipsparseDgtsv2_bufferSizeExt_rank_1,& hipsparseDgtsv2_bufferSizeExt_full_rank #endif #endif end interface interface hipsparseCgtsv2_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseCgtsv2_bufferSizeExt_(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) & bind(c, name="cusparseCgtsv2_bufferSizeExt") #else function hipsparseCgtsv2_bufferSizeExt_(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) & bind(c, name="hipsparseCgtsv2_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCgtsv2_bufferSizeExt_assumed_rank #else module procedure & hipsparseCgtsv2_bufferSizeExt_rank_0,& hipsparseCgtsv2_bufferSizeExt_rank_1,& hipsparseCgtsv2_bufferSizeExt_full_rank #endif #endif end interface interface hipsparseZgtsv2_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseZgtsv2_bufferSizeExt_(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) & bind(c, name="cusparseZgtsv2_bufferSizeExt") #else function hipsparseZgtsv2_bufferSizeExt_(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) & bind(c, name="hipsparseZgtsv2_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZgtsv2_bufferSizeExt_assumed_rank #else module procedure & hipsparseZgtsv2_bufferSizeExt_rank_0,& hipsparseZgtsv2_bufferSizeExt_rank_1,& hipsparseZgtsv2_bufferSizeExt_full_rank #endif #endif end interface !> \ingroup precond_module !> \brief Tridiagonal solver with pivoting !> !> \details !> \p hipsparseXgtsv2 solves a tridiagonal system for multiple right-hand sides using pivoting !> \f[ !> T*B = B !> \f] !> where \f$T\f$ is a sparse tridiagonal matrix and \f$B\f$ is a dense \f$ldb \times n\f$ matrix !> storing the !> right-hand side vectors in column order. The tridiagonal matrix \f$T\f$ is defined by three !> vectors: \p dl !> for the lower diagonal, \p d for the main diagonal, and \p du for the upper diagonal. !> !> Solving the tridiagonal system involves two steps. First, the user calls !> `hipsparseSgtsv2_bufferSizeExt` "hipsparseXgtsv2_bufferSizeExt()" to determine the size of !> the required !> temporary storage buffer. After this is determined, the user allocates the buffer and passes !> it to !> `hipsparseSgtsv2` "hipsparseXgtsv2()" to perform the actual solve. The \f$B\f$ dense matrix, !> which initially !> stores the \p n right-hand side vectors, is overwritten with the \p n solution vectors after !> the call to !> `hipsparseSgtsv2` "hipsparseXgtsv2()". !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - size of the tridiagonal linear system (must be >= 2). !> @param[in] n - number of columns in the dense matrix B. !> @param[in] dl - lower diagonal of the tridiagonal system. The first entry must be zero. !> @param[in] d - main diagonal of the tridiagonal system. !> @param[in] du - upper diagonal of the tridiagonal system. The last entry must be zero. !> @param[inout] B - Dense matrix of size ( \p ldb, \p n ). !> @param[in] ldb - Leading dimension of B. Must satisfy \p ldb >= max(1, m). !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p ldb, \p dl, \p d, !> \p du, \p B, or \p pBuffer pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseSgtsv2 #ifdef USE_CUDA_NAMES function hipsparseSgtsv2_(handle,m,n,dl,d,du,B,ldb,pBuffer) bind(c, name="cusparseSgtsv2") #else function hipsparseSgtsv2_(handle,m,n,dl,d,du,B,ldb,pBuffer) bind(c, name="hipsparseSgtsv2") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSgtsv2_assumed_rank #else module procedure & hipsparseSgtsv2_rank_0,& hipsparseSgtsv2_rank_1,& hipsparseSgtsv2_full_rank #endif #endif end interface interface hipsparseDgtsv2 #ifdef USE_CUDA_NAMES function hipsparseDgtsv2_(handle,m,n,dl,d,du,B,ldb,pBuffer) bind(c, name="cusparseDgtsv2") #else function hipsparseDgtsv2_(handle,m,n,dl,d,du,B,ldb,pBuffer) bind(c, name="hipsparseDgtsv2") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDgtsv2_assumed_rank #else module procedure & hipsparseDgtsv2_rank_0,& hipsparseDgtsv2_rank_1,& hipsparseDgtsv2_full_rank #endif #endif end interface interface hipsparseCgtsv2 #ifdef USE_CUDA_NAMES function hipsparseCgtsv2_(handle,m,n,dl,d,du,B,ldb,pBuffer) bind(c, name="cusparseCgtsv2") #else function hipsparseCgtsv2_(handle,m,n,dl,d,du,B,ldb,pBuffer) bind(c, name="hipsparseCgtsv2") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCgtsv2_assumed_rank #else module procedure & hipsparseCgtsv2_rank_0,& hipsparseCgtsv2_rank_1,& hipsparseCgtsv2_full_rank #endif #endif end interface interface hipsparseZgtsv2 #ifdef USE_CUDA_NAMES function hipsparseZgtsv2_(handle,m,n,dl,d,du,B,ldb,pBuffer) bind(c, name="cusparseZgtsv2") #else function hipsparseZgtsv2_(handle,m,n,dl,d,du,B,ldb,pBuffer) bind(c, name="hipsparseZgtsv2") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZgtsv2_assumed_rank #else module procedure & hipsparseZgtsv2_rank_0,& hipsparseZgtsv2_rank_1,& hipsparseZgtsv2_full_rank #endif #endif end interface !> \ingroup precond_module !> \details !> \p hipsparseXgtsvInterleavedBatch_bufferSizeExt returns the size of the temporary storage !> buffer in bytes that is required by `hipsparseSgtsvInterleavedBatch` !> "hipsparseXgtsvInterleavedBatch()". !> The temporary storage buffer must be allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] algo - Algorithm to use when solving tridiagonal systems. Options are Thomas ( \p !> algo=0 ), !> LU ( \p algo=1 ), or QR ( \p algo=2 ). The Thomas algorithm is the fastest !> but is not !> stable, while LU and QR are slower but are stable. !> @param[in] m - size of the tridiagonal linear system. !> @param[in] dl - lower diagonal of the tridiagonal system. The first element of the lower !> diagonal must be zero. !> @param[in] d - main diagonal of the tridiagonal system. !> @param[in] du - upper diagonal of the tridiagonal system. The last element of the upper !> diagonal must be zero. !> @param[inout] x - Dense array of right-hand sides with dimension \p batchCount by \p m. !> @param[in] batchCount - The number of systems to solve. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseSgtsvInterleavedBatch` "`hipsparseSgtsvInterleavedBatch()`". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p batchCount, \p dl, \p d, \p du, !> \p x, or \p pBufferSizeInBytes pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseSgtsvInterleavedBatch_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseSgtsvInterleavedBatch_bufferSizeExt_(handle,algo,m,dl,d,du,x,batchCount, & pBufferSizeInBytes) & bind(c, name="cusparseSgtsvInterleavedBatch_bufferSizeExt") #else function hipsparseSgtsvInterleavedBatch_bufferSizeExt_(handle,algo,m,dl,d,du,x,batchCount, & pBufferSizeInBytes) & bind(c, name="hipsparseSgtsvInterleavedBatch_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsvInterleavedBatch_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batchCount integer(c_size_t) :: pBufferSizeInBytes end function end interface interface hipsparseDgtsvInterleavedBatch_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseDgtsvInterleavedBatch_bufferSizeExt_(handle,algo,m,dl,d,du,x,batchCount, & pBufferSizeInBytes) & bind(c, name="cusparseDgtsvInterleavedBatch_bufferSizeExt") #else function hipsparseDgtsvInterleavedBatch_bufferSizeExt_(handle,algo,m,dl,d,du,x,batchCount, & pBufferSizeInBytes) & bind(c, name="hipsparseDgtsvInterleavedBatch_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsvInterleavedBatch_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batchCount integer(c_size_t) :: pBufferSizeInBytes end function end interface interface hipsparseCgtsvInterleavedBatch_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseCgtsvInterleavedBatch_bufferSizeExt_(handle,algo,m,dl,d,du,x,batchCount, & pBufferSizeInBytes) & bind(c, name="cusparseCgtsvInterleavedBatch_bufferSizeExt") #else function hipsparseCgtsvInterleavedBatch_bufferSizeExt_(handle,algo,m,dl,d,du,x,batchCount, & pBufferSizeInBytes) & bind(c, name="hipsparseCgtsvInterleavedBatch_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsvInterleavedBatch_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batchCount integer(c_size_t) :: pBufferSizeInBytes end function end interface interface hipsparseZgtsvInterleavedBatch_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseZgtsvInterleavedBatch_bufferSizeExt_(handle,algo,m,dl,d,du,x,batchCount, & pBufferSizeInBytes) & bind(c, name="cusparseZgtsvInterleavedBatch_bufferSizeExt") #else function hipsparseZgtsvInterleavedBatch_bufferSizeExt_(handle,algo,m,dl,d,du,x,batchCount, & pBufferSizeInBytes) & bind(c, name="hipsparseZgtsvInterleavedBatch_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsvInterleavedBatch_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batchCount integer(c_size_t) :: pBufferSizeInBytes end function end interface !> \ingroup precond_module !> \brief Interleaved batch tridiagonal solver. !> !> \details !> \p hipsparseXgtsvInterleavedBatch solves a batched tridiagonal linear system !> \f[ !> T^{i}*x^{i} = x^{i} !> \f] !> where for each batch \f$i=0\ldots\f$ \p batchCount, \f$T^{i}\f$ is a sparse tridiagonal !> matrix and !> \f$x^{i}\f$ is a dense right-hand side vector. All of the tridiagonal matrices, \f$T^{i}\f$, !> are !> packed in an interleaved fashion into three vectors: \p dl for the lower diagonals, \p d for !> the main !> diagonals, and \p du for the upper diagonals. See below for a description of the interleaved !> memory pattern. !> !> Solving the batched tridiagonal system involves two steps. First, the user calls !> `hipsparseSgtsvInterleavedBatch_bufferSizeExt` !> "hipsparseXgtsvInterleavedBatch_bufferSizeExt()" !> to determine the size of the required temporary storage buffer. Once determined, the user !> allocates !> this buffer and passes it to `hipsparseSgtsvInterleavedBatch` !> "hipsparseXgtsvInterleavedBatch()" !> to perform the actual solve. The \f$x^{i}\f$ vectors, which initially stores the right-hand !> side values, are !> overwritten with the solution after the call to !> `hipsparseSgtsvInterleavedBatch` "hipsparseXgtsvInterleavedBatch()". !> !> The user can specify different algorithms for \p hipsparseXgtsvInterleavedBatch !> to use. Options are Thomas ( \p algo=0 ), !> LU ( \p algo=1 ), or QR ( \p algo=2 ). !> !> Unlike the strided batch routines, which write each batch matrix one after the other in !> memory, the interleaved !> routines write the batch matrices such that each element from each matrix is written !> consecutively one after !> the other. For example, consider the following batch matrices: !> !> \f[ !> \begin{bmatrix} !> t^{0}_{00} & t^{0}_{01} & 0 \\% !> t^{0}_{10} & t^{0}_{11} & t^{0}_{12} \\% !> 0 & t^{0}_{21} & t^{0}_{22} !> \end{bmatrix} !> \begin{bmatrix} !> t^{1}_{00} & t^{1}_{01} & 0 \\% !> t^{1}_{10} & t^{1}_{11} & t^{1}_{12} \\% !> 0 & t^{1}_{21} & t^{1}_{22} !> \end{bmatrix} !> \begin{bmatrix} !> t^{2}_{00} & t^{2}_{01} & 0 \\% !> t^{2}_{10} & t^{2}_{11} & t^{2}_{12} \\% !> 0 & t^{2}_{21} & t^{2}_{22} !> \end{bmatrix} !> \f] !> !> In interleaved format, the upper, lower, and diagonal arrays would look like: !> \f[ !> \begin{align} !> \text{lower} &= \begin{bmatrix} 0 & 0 & 0 & t^{0}_{10} & t^{1}_{10} & t^{1}_{10} & !> t^{0}_{21} & t^{1}_{21} & t^{2}_{21} \end{bmatrix} \\% !> \text{diagonal} &= \begin{bmatrix} t^{0}_{00} & t^{1}_{00} & t^{2}_{00} & t^{0}_{11} & !> t^{1}_{11} & t^{2}_{11} & t^{0}_{22} & t^{1}_{22} & t^{2}_{22} \end{bmatrix} \\% !> \text{upper} &= \begin{bmatrix} t^{0}_{01} & t^{1}_{01} & t^{2}_{01} & t^{0}_{12} & !> t^{1}_{12} & t^{2}_{12} & 0 & 0 & 0 \end{bmatrix} \\% !> \end{align} !> \f] !> For the lower array, the first \p batchCount entries are zero, and for the upper array, the !> last \p batchCount !> entries are zero. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] algo - Algorithm to use when solving tridiagonal systems. Options are Thomas ( \p !> algo=0 ), !> LU ( \p algo=1 ), or QR ( \p algo=2 ). The Thomas algorithm is the fastest but is !> not !> stable, while LU and QR are slower but are stable. !> @param[in] m - size of the tridiagonal linear system. !> @param[inout] dl - lower diagonal of the tridiagonal system. The first element of the lower !> diagonal must be zero. !> @param[inout] d - main diagonal of the tridiagonal system. !> @param[inout] du - upper diagonal of the tridiagonal system. The last element of the upper !> diagonal must be zero. !> @param[inout] x - Dense array of right-hand sides with dimension \p batchCount by \p m. !> @param[in] batchCount - The number of systems to solve. !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p batchCount, \p dl, \p d, !> \p du, \p x, or \p pBuffer pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseSgtsvInterleavedBatch #ifdef USE_CUDA_NAMES function hipsparseSgtsvInterleavedBatch_(handle,algo,m,dl,d,du,x,batchCount,pBuffer) & bind(c, name="cusparseSgtsvInterleavedBatch") #else function hipsparseSgtsvInterleavedBatch_(handle,algo,m,dl,d,du,x,batchCount,pBuffer) & bind(c, name="hipsparseSgtsvInterleavedBatch") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsvInterleavedBatch_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batchCount type(c_ptr),value :: pBuffer end function end interface interface hipsparseDgtsvInterleavedBatch #ifdef USE_CUDA_NAMES function hipsparseDgtsvInterleavedBatch_(handle,algo,m,dl,d,du,x,batchCount,pBuffer) & bind(c, name="cusparseDgtsvInterleavedBatch") #else function hipsparseDgtsvInterleavedBatch_(handle,algo,m,dl,d,du,x,batchCount,pBuffer) & bind(c, name="hipsparseDgtsvInterleavedBatch") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsvInterleavedBatch_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batchCount type(c_ptr),value :: pBuffer end function end interface interface hipsparseCgtsvInterleavedBatch #ifdef USE_CUDA_NAMES function hipsparseCgtsvInterleavedBatch_(handle,algo,m,dl,d,du,x,batchCount,pBuffer) & bind(c, name="cusparseCgtsvInterleavedBatch") #else function hipsparseCgtsvInterleavedBatch_(handle,algo,m,dl,d,du,x,batchCount,pBuffer) & bind(c, name="hipsparseCgtsvInterleavedBatch") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsvInterleavedBatch_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batchCount type(c_ptr),value :: pBuffer end function end interface interface hipsparseZgtsvInterleavedBatch #ifdef USE_CUDA_NAMES function hipsparseZgtsvInterleavedBatch_(handle,algo,m,dl,d,du,x,batchCount,pBuffer) & bind(c, name="cusparseZgtsvInterleavedBatch") #else function hipsparseZgtsvInterleavedBatch_(handle,algo,m,dl,d,du,x,batchCount,pBuffer) & bind(c, name="hipsparseZgtsvInterleavedBatch") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsvInterleavedBatch_ type(c_ptr),value :: handle integer(c_int),value :: algo integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batchCount type(c_ptr),value :: pBuffer end function end interface !> \ingroup precond_module !> \details !> \p hipsparseXgtsv2_nopivot_bufferSizeExt returns the size of the temporary storage !> buffer in bytes that is required by `hipsparseSgtsv2_nopivot` "hipsparseXgtsv2_nopivot()". !> The temporary storage buffer must be allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - size of the tridiagonal linear system. Must be >= 2. !> @param[in] n - number of columns in the dense matrix B. Must be non-negative. !> @param[in] dl - lower diagonal of the tridiagonal system. The first entry must be zero. !> @param[in] d - main diagonal of the tridiagonal system. !> @param[in] du - upper diagonal of the tridiagonal system. The last entry must be zero. !> @param[in] B - Dense matrix of size ( \p ldb, \p n ). !> @param[in] ldb - Leading dimension of B. Must satisfy \p ldb >= max(1, m). !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseSgtsv2_nopivot` "hipsparseXgtsv2_nopivot()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p dl, \p d, \p du, \p B, or !> \p pBufferSizeInBytes is nullptr, \p m is less than 2, \p n is negative, !> or \p ldb is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseSgtsv2_nopivot_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseSgtsv2_nopivot_bufferSizeExt_(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) & bind(c, name="cusparseSgtsv2_nopivot_bufferSizeExt") #else function hipsparseSgtsv2_nopivot_bufferSizeExt_(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) & bind(c, name="hipsparseSgtsv2_nopivot_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_nopivot_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSgtsv2_nopivot_bufferSizeExt_assumed_rank #else module procedure & hipsparseSgtsv2_nopivot_bufferSizeExt_rank_0,& hipsparseSgtsv2_nopivot_bufferSizeExt_rank_1,& hipsparseSgtsv2_nopivot_bufferSizeExt_full_rank #endif #endif end interface interface hipsparseDgtsv2_nopivot_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseDgtsv2_nopivot_bufferSizeExt_(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) & bind(c, name="cusparseDgtsv2_nopivot_bufferSizeExt") #else function hipsparseDgtsv2_nopivot_bufferSizeExt_(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) & bind(c, name="hipsparseDgtsv2_nopivot_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_nopivot_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDgtsv2_nopivot_bufferSizeExt_assumed_rank #else module procedure & hipsparseDgtsv2_nopivot_bufferSizeExt_rank_0,& hipsparseDgtsv2_nopivot_bufferSizeExt_rank_1,& hipsparseDgtsv2_nopivot_bufferSizeExt_full_rank #endif #endif end interface interface hipsparseCgtsv2_nopivot_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseCgtsv2_nopivot_bufferSizeExt_(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) & bind(c, name="cusparseCgtsv2_nopivot_bufferSizeExt") #else function hipsparseCgtsv2_nopivot_bufferSizeExt_(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) & bind(c, name="hipsparseCgtsv2_nopivot_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_nopivot_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCgtsv2_nopivot_bufferSizeExt_assumed_rank #else module procedure & hipsparseCgtsv2_nopivot_bufferSizeExt_rank_0,& hipsparseCgtsv2_nopivot_bufferSizeExt_rank_1,& hipsparseCgtsv2_nopivot_bufferSizeExt_full_rank #endif #endif end interface interface hipsparseZgtsv2_nopivot_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseZgtsv2_nopivot_bufferSizeExt_(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) & bind(c, name="cusparseZgtsv2_nopivot_bufferSizeExt") #else function hipsparseZgtsv2_nopivot_bufferSizeExt_(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) & bind(c, name="hipsparseZgtsv2_nopivot_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_nopivot_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZgtsv2_nopivot_bufferSizeExt_assumed_rank #else module procedure & hipsparseZgtsv2_nopivot_bufferSizeExt_rank_0,& hipsparseZgtsv2_nopivot_bufferSizeExt_rank_1,& hipsparseZgtsv2_nopivot_bufferSizeExt_full_rank #endif #endif end interface !> \ingroup precond_module !> \brief Tridiagonal solver (no pivoting) !> !> \details !> \p hipsparseXgtsv2_nopivot solves a tridiagonal linear system for multiple right-hand sides !> without pivoting !> \f[ !> T*B = B !> \f] !> where \f$T\f$ is a sparse tridiagonal matrix and \f$B\f$ is a dense \f$ldb \times n\f$ matrix !> storing the !> right-hand side vectors in column order. The tridiagonal matrix \f$T\f$ is defined by three !> vectors: \p dl !> for the lower diagonal, \p d for the main diagonal, and \p du for the upper diagonal. !> !> Solving the tridiagonal system with multiple right-hand sides without pivoting involves two !> steps. First, !> the user calls `hipsparseSgtsv2_nopivot_bufferSizeExt` !> "hipsparseXgtsv2_nopivot_bufferSizeExt()" !> to determine the size of the required temporary storage buffer. Once determined, the user !> allocates this !> buffer and passes it to `hipsparseSgtsv2_nopivot` "hipsparseXgtsv2_nopivot()" to perform the !> actual !> solve. The \f$B\f$ dense matrix, which initially stores the \p n right-hand side vectors, is !> overwritten !> with the \p n solution vectors after the call to `hipsparseSgtsv2_nopivot` !> "hipsparseXgtsv2_nopivot()". !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - size of the tridiagonal linear system (must be >= 2). !> @param[in] n - number of columns in the dense matrix B. !> @param[in] dl - lower diagonal of the tridiagonal system. The first entry must be zero. !> @param[in] d - main diagonal of the tridiagonal system. !> @param[in] du - upper diagonal of the tridiagonal system. The last entry must be zero. !> @param[inout] B - Dense matrix of size ( \p ldb, \p n ). !> @param[in] ldb - Leading dimension of B. Must satisfy \p ldb >= max(1, m). !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p ldb, \p dl, \p d, !> \p du, \p B, or \p pBuffer pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseSgtsv2_nopivot #ifdef USE_CUDA_NAMES function hipsparseSgtsv2_nopivot_(handle,m,n,dl,d,du,B,ldb,pBuffer) & bind(c, name="cusparseSgtsv2_nopivot") #else function hipsparseSgtsv2_nopivot_(handle,m,n,dl,d,du,B,ldb,pBuffer) & bind(c, name="hipsparseSgtsv2_nopivot") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_nopivot_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSgtsv2_nopivot_assumed_rank #else module procedure & hipsparseSgtsv2_nopivot_rank_0,& hipsparseSgtsv2_nopivot_rank_1,& hipsparseSgtsv2_nopivot_full_rank #endif #endif end interface interface hipsparseDgtsv2_nopivot #ifdef USE_CUDA_NAMES function hipsparseDgtsv2_nopivot_(handle,m,n,dl,d,du,B,ldb,pBuffer) & bind(c, name="cusparseDgtsv2_nopivot") #else function hipsparseDgtsv2_nopivot_(handle,m,n,dl,d,du,B,ldb,pBuffer) & bind(c, name="hipsparseDgtsv2_nopivot") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_nopivot_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDgtsv2_nopivot_assumed_rank #else module procedure & hipsparseDgtsv2_nopivot_rank_0,& hipsparseDgtsv2_nopivot_rank_1,& hipsparseDgtsv2_nopivot_full_rank #endif #endif end interface interface hipsparseCgtsv2_nopivot #ifdef USE_CUDA_NAMES function hipsparseCgtsv2_nopivot_(handle,m,n,dl,d,du,B,ldb,pBuffer) & bind(c, name="cusparseCgtsv2_nopivot") #else function hipsparseCgtsv2_nopivot_(handle,m,n,dl,d,du,B,ldb,pBuffer) & bind(c, name="hipsparseCgtsv2_nopivot") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_nopivot_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCgtsv2_nopivot_assumed_rank #else module procedure & hipsparseCgtsv2_nopivot_rank_0,& hipsparseCgtsv2_nopivot_rank_1,& hipsparseCgtsv2_nopivot_full_rank #endif #endif end interface interface hipsparseZgtsv2_nopivot #ifdef USE_CUDA_NAMES function hipsparseZgtsv2_nopivot_(handle,m,n,dl,d,du,B,ldb,pBuffer) & bind(c, name="cusparseZgtsv2_nopivot") #else function hipsparseZgtsv2_nopivot_(handle,m,n,dl,d,du,B,ldb,pBuffer) & bind(c, name="hipsparseZgtsv2_nopivot") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_nopivot_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZgtsv2_nopivot_assumed_rank #else module procedure & hipsparseZgtsv2_nopivot_rank_0,& hipsparseZgtsv2_nopivot_rank_1,& hipsparseZgtsv2_nopivot_full_rank #endif #endif end interface !> \ingroup precond_module !> \details !> \p hipsparseXgtsv2StridedBatch_bufferSizeExt returns the size of the temporary storage !> buffer in bytes that is required by `hipsparseSgtsv2StridedBatch` !> "hipsparseXgtsv2StridedBatch()". !> The temporary storage buffer must be allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - size of the tridiagonal linear system. !> @param[in] dl - lower diagonal of the tridiagonal system where the ith system lower diagonal !> starts at !> \p dl+batchStride*i. !> @param[in] d - main diagonal of the tridiagonal system where the ith system diagonal starts !> at !> \p d+batchStride*i. !> @param[in] du - upper diagonal of the tridiagonal system where the ith system upper diagonal !> starts at !> \p du+batchStride*i. !> @param[inout] x - Dense array of right-hand sides where the ith right-hand side starts at \p !> x+batchStride*i. !> @param[in] batchCount - The number of systems to solve. !> @param[in] batchStride - The number of elements that separate each system, which must satisfy !> \p batchStride >= m. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseSgtsv2StridedBatch` "hipsparseXgtsv2StridedBatch()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p batchCount, \p batchStride, \p dl, !> \p d, \p du, \p x, or \p pBufferSizeInBytes pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseSgtsv2StridedBatch_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseSgtsv2StridedBatch_bufferSizeExt_(handle,m,dl,d,du,x,batchCount,batchStride, & pBufferSizeInBytes) & bind(c, name="cusparseSgtsv2StridedBatch_bufferSizeExt") #else function hipsparseSgtsv2StridedBatch_bufferSizeExt_(handle,m,dl,d,du,x,batchCount,batchStride, & pBufferSizeInBytes) & bind(c, name="hipsparseSgtsv2StridedBatch_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2StridedBatch_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batchCount integer(c_int),value :: batchStride integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSgtsv2StridedBatch_bufferSizeExt_assumed_rank #else module procedure & hipsparseSgtsv2StridedBatch_bufferSizeExt_rank_0,& hipsparseSgtsv2StridedBatch_bufferSizeExt_rank_1 #endif #endif end interface interface hipsparseDgtsv2StridedBatch_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseDgtsv2StridedBatch_bufferSizeExt_(handle,m,dl,d,du,x,batchCount,batchStride, & pBufferSizeInBytes) & bind(c, name="cusparseDgtsv2StridedBatch_bufferSizeExt") #else function hipsparseDgtsv2StridedBatch_bufferSizeExt_(handle,m,dl,d,du,x,batchCount,batchStride, & pBufferSizeInBytes) & bind(c, name="hipsparseDgtsv2StridedBatch_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2StridedBatch_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batchCount integer(c_int),value :: batchStride integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDgtsv2StridedBatch_bufferSizeExt_assumed_rank #else module procedure & hipsparseDgtsv2StridedBatch_bufferSizeExt_rank_0,& hipsparseDgtsv2StridedBatch_bufferSizeExt_rank_1 #endif #endif end interface interface hipsparseCgtsv2StridedBatch_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseCgtsv2StridedBatch_bufferSizeExt_(handle,m,dl,d,du,x,batchCount,batchStride, & pBufferSizeInBytes) & bind(c, name="cusparseCgtsv2StridedBatch_bufferSizeExt") #else function hipsparseCgtsv2StridedBatch_bufferSizeExt_(handle,m,dl,d,du,x,batchCount,batchStride, & pBufferSizeInBytes) & bind(c, name="hipsparseCgtsv2StridedBatch_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2StridedBatch_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batchCount integer(c_int),value :: batchStride integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCgtsv2StridedBatch_bufferSizeExt_assumed_rank #else module procedure & hipsparseCgtsv2StridedBatch_bufferSizeExt_rank_0,& hipsparseCgtsv2StridedBatch_bufferSizeExt_rank_1 #endif #endif end interface interface hipsparseZgtsv2StridedBatch_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseZgtsv2StridedBatch_bufferSizeExt_(handle,m,dl,d,du,x,batchCount,batchStride, & pBufferSizeInBytes) & bind(c, name="cusparseZgtsv2StridedBatch_bufferSizeExt") #else function hipsparseZgtsv2StridedBatch_bufferSizeExt_(handle,m,dl,d,du,x,batchCount,batchStride, & pBufferSizeInBytes) & bind(c, name="hipsparseZgtsv2StridedBatch_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2StridedBatch_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batchCount integer(c_int),value :: batchStride integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZgtsv2StridedBatch_bufferSizeExt_assumed_rank #else module procedure & hipsparseZgtsv2StridedBatch_bufferSizeExt_rank_0,& hipsparseZgtsv2StridedBatch_bufferSizeExt_rank_1 #endif #endif end interface !> \ingroup precond_module !> \brief Strided batch tridiagonal solver (no pivoting). !> !> \details !> \p hipsparseXgtsv2StridedBatch solves a batched tridiagonal linear system !> \f[ !> T^{i}*x^{i} = x^{i} !> \f] !> where for each batch \f$i=0\ldots\f$ \p batchCount, \f$T^{i}\f$ is a sparse tridiagonal !> matrix and !> \f$x^{i}\f$ is a dense right-hand side vector. All of the tridiagonal matrices, \f$T^{i}\f$, !> are !> packed one after the other into three vectors: \p dl for the lower diagonals, \p d for the !> main !> diagonals, and \p du for the upper diagonals. See below for a description of the strided !> memory pattern. !> !> Solving the batched tridiagonal system involves two steps. First, the user calls !> `hipsparseSgtsv2StridedBatch_bufferSizeExt` "hipsparseXgtsv2StridedBatch_bufferSizeExt()" !> to determine the size of the required temporary storage buffer. After this is determined, the !> user allocates !> this buffer and passes it to `hipsparseSgtsv2StridedBatch` "hipsparseXgtsv2StridedBatch()" !> to perform the actual solve. The \f$x^{i}\f$ vectors, which initially stores the right-hand !> side values, are !> overwritten with the solution after the call to !> `hipsparseSgtsv2StridedBatch` "hipsparseXgtsv2StridedBatch()". !> !> The strided batch routines write each batch matrix one after the other in memory. For !> example, consider !> the following batch matrices: !> !> \f[ !> \begin{bmatrix} !> t^{0}_{00} & t^{0}_{01} & 0 \\% !> t^{0}_{10} & t^{0}_{11} & t^{0}_{12} \\% !> 0 & t^{0}_{21} & t^{0}_{22} !> \end{bmatrix} !> \begin{bmatrix} !> t^{1}_{00} & t^{1}_{01} & 0 \\% !> t^{1}_{10} & t^{1}_{11} & t^{1}_{12} \\% !> 0 & t^{1}_{21} & t^{1}_{22} !> \end{bmatrix} !> \begin{bmatrix} !> t^{2}_{00} & t^{2}_{01} & 0 \\% !> t^{2}_{10} & t^{2}_{11} & t^{2}_{12} \\% !> 0 & t^{2}_{21} & t^{2}_{22} !> \end{bmatrix} !> \f] !> !> In strided format, the upper, lower, and diagonal arrays would look like: !> \f[ !> \begin{align} !> \text{lower} &= \begin{bmatrix} 0 & t^{0}_{10} & t^{0}_{21} & 0 & t^{1}_{10} & t^{1}_{21} & !> 0 & t^{2}_{10} & t^{2}_{21} \end{bmatrix} \\% !> \text{diagonal} &= \begin{bmatrix} t^{0}_{00} & t^{0}_{11} & t^{0}_{22} & t^{1}_{00} & !> t^{1}_{11} & t^{1}_{22} & t^{2}_{00} & t^{2}_{11} & t^{2}_{22} \end{bmatrix} \\% !> \text{upper} &= \begin{bmatrix} t^{0}_{01} & t^{0}_{12} & 0 & t^{1}_{01} & t^{1}_{12} & 0 & !> t^{2}_{01} & t^{2}_{12} & 0 \end{bmatrix} \\% !> \end{align} !> \f] !> For the lower array, for each batch \p i, the \p i*batchStride entries are zero, and for the !> upper array, the !> \p i*batchStride+batchStride-1 entries are zero. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - size of the tridiagonal linear system (must be >= 2). !> @param[in] dl - lower diagonal of the tridiagonal system. The first entry must be zero. !> @param[in] d - main diagonal of the tridiagonal system. !> @param[in] du - upper diagonal of the tridiagonal system. The last entry must be zero. !> @param[inout] x - Dense array of right-hand sides where the ith right-hand side starts at \p !> x+batchStride*i. !> @param[in] batchCount - The number of systems to solve. !> @param[in] batchStride - The number of elements that separate each system, which must satisfy !> \p batchStride >= m. !> @param[in] pBuffer - temporary storage buffer allocated by the user. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p batchCount, \p batchStride, \p dl, !> \p d, !> \p du, \p x, or \p pBuffer pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseSgtsv2StridedBatch #ifdef USE_CUDA_NAMES function hipsparseSgtsv2StridedBatch_(handle,m,dl,d,du,x,batchCount,batchStride,pBuffer) & bind(c, name="cusparseSgtsv2StridedBatch") #else function hipsparseSgtsv2StridedBatch_(handle,m,dl,d,du,x,batchCount,batchStride,pBuffer) & bind(c, name="hipsparseSgtsv2StridedBatch") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2StridedBatch_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batchCount integer(c_int),value :: batchStride type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSgtsv2StridedBatch_assumed_rank #else module procedure & hipsparseSgtsv2StridedBatch_rank_0,& hipsparseSgtsv2StridedBatch_rank_1 #endif #endif end interface interface hipsparseDgtsv2StridedBatch #ifdef USE_CUDA_NAMES function hipsparseDgtsv2StridedBatch_(handle,m,dl,d,du,x,batchCount,batchStride,pBuffer) & bind(c, name="cusparseDgtsv2StridedBatch") #else function hipsparseDgtsv2StridedBatch_(handle,m,dl,d,du,x,batchCount,batchStride,pBuffer) & bind(c, name="hipsparseDgtsv2StridedBatch") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2StridedBatch_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batchCount integer(c_int),value :: batchStride type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDgtsv2StridedBatch_assumed_rank #else module procedure & hipsparseDgtsv2StridedBatch_rank_0,& hipsparseDgtsv2StridedBatch_rank_1 #endif #endif end interface interface hipsparseCgtsv2StridedBatch #ifdef USE_CUDA_NAMES function hipsparseCgtsv2StridedBatch_(handle,m,dl,d,du,x,batchCount,batchStride,pBuffer) & bind(c, name="cusparseCgtsv2StridedBatch") #else function hipsparseCgtsv2StridedBatch_(handle,m,dl,d,du,x,batchCount,batchStride,pBuffer) & bind(c, name="hipsparseCgtsv2StridedBatch") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2StridedBatch_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batchCount integer(c_int),value :: batchStride type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCgtsv2StridedBatch_assumed_rank #else module procedure & hipsparseCgtsv2StridedBatch_rank_0,& hipsparseCgtsv2StridedBatch_rank_1 #endif #endif end interface interface hipsparseZgtsv2StridedBatch #ifdef USE_CUDA_NAMES function hipsparseZgtsv2StridedBatch_(handle,m,dl,d,du,x,batchCount,batchStride,pBuffer) & bind(c, name="cusparseZgtsv2StridedBatch") #else function hipsparseZgtsv2StridedBatch_(handle,m,dl,d,du,x,batchCount,batchStride,pBuffer) & bind(c, name="hipsparseZgtsv2StridedBatch") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2StridedBatch_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batchCount integer(c_int),value :: batchStride type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZgtsv2StridedBatch_assumed_rank #else module procedure & hipsparseZgtsv2StridedBatch_rank_0,& hipsparseZgtsv2StridedBatch_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse BSR matrix into a sparse CSR matrix. !> !> \details !> \p hipsparseXbsr2csr converts a BSR matrix into a CSR matrix. It is assumed !> that \p csrValC, \p csrColIndC, and \p csrRowPtrC are allocated. Allocation size !> for \p csrRowPtrC is computed by the number of block rows multiplied by the block !> dimension plus one. Allocation for \p csrValC and \p csrColInd is computed by !> the number of blocks in the BSR matrix multiplied by the block dimension squared. !> !> For example, given the BSR matrix using block dimension 2: !> \f[ !> \left[ !> \begin{array}{c | c} !> \begin{array}{c c} !> 1 & 0 \\% !> 3 & 4 !> \end{array} & !> \begin{array}{c c} !> 0 & 2 \\% !> 0 & 0 !> \end{array} \\% !> \hline !> \begin{array}{c c} !> 5 & 0 \\% !> 1 & 2 !> \end{array} & !> \begin{array}{c c} !> 6 & 7 \\% !> 3 & 4 !> \end{array} \\% !> \end{array} !> \right] !> \f] !> !> The resulting CSR matrix row pointer, column indices, and values arrays are: !> \f[ !> \begin{align} !> \text{csrRowPtrC} &= \begin{bmatrix} 0 & 4 & 8 & 12 & 16 \end{bmatrix} \\% !> \text{csrColIndC} &= \begin{bmatrix} 0 & 1 & 2 & 3 & 0 & 1 & 2 & 3 & 0 & 1 & 2 & 3 & 0 & 1 !> & 2 & 3 \end{bmatrix} \\% !> \text{csrValC} &= \begin{bmatrix} 1 & 0 & 0 & 2 & 3 & 4 & 0 & 0 & 5 & 0 & 6 & 7 & 1 & 2 & 3 !> & 4 \end{bmatrix} \\% !> \end{align} !> \f] !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - the storage format of the blocks, `HIPSPARSE_DIRECTION_ROW` or !> `HIPSPARSE_DIRECTION_COLUMN`. !> @param[in] mb - number of block rows in the sparse BSR matrix, which must be non-negative. !> @param[in] nb - number of block columns in the sparse BSR matrix, which must be non-negative. !> @param[in] descrA - descriptor of the sparse BSR matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] bsrValA - array of \p nnzb*blockDim*blockDim containing the values of the sparse !> BSR matrix. !> @param[in] bsrRowPtrA - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse BSR matrix. !> @param[in] bsrColIndA - array of \p nnzb elements containing the block column indices of the !> sparse BSR matrix. !> @param[in] blockDim - size of the blocks in the sparse BSR matrix. Must be positive. !> @param[in] descrC - descriptor of the sparse CSR matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[out] csrValC - array of \p nnzb*blockDim*blockDim elements containing the values of !> the sparse CSR matrix. !> @param[out] csrRowPtrC - array of \p m+1 where \p m=mb*blockDim elements that point to the !> start of every row of the !> sparse CSR matrix. !> @param[out] csrColIndC - array of \p nnzb*blockDim*blockDim elements containing the column !> indices of the sparse CSR matrix. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p descrA, \p descrC, \p bsrValA, !> \p bsrRowPtrA, \p bsrColIndA, \p csrValC, \p csrRowPtrC, or \p csrColIndC is nullptr, !> \p mb or \p nb is negative, or \p blockDim is invalid. interface hipsparseSbsr2csr #ifdef USE_CUDA_NAMES function hipsparseSbsr2csr_(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA,blockDim, & descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="cusparseSbsr2csr") #else function hipsparseSbsr2csr_(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA,blockDim, & descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="hipsparseSbsr2csr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsr2csr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSbsr2csr_assumed_rank #else module procedure & hipsparseSbsr2csr_rank_0,& hipsparseSbsr2csr_rank_1 #endif #endif end interface interface hipsparseDbsr2csr #ifdef USE_CUDA_NAMES function hipsparseDbsr2csr_(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA,blockDim, & descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="cusparseDbsr2csr") #else function hipsparseDbsr2csr_(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA,blockDim, & descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="hipsparseDbsr2csr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsr2csr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDbsr2csr_assumed_rank #else module procedure & hipsparseDbsr2csr_rank_0,& hipsparseDbsr2csr_rank_1 #endif #endif end interface interface hipsparseCbsr2csr #ifdef USE_CUDA_NAMES function hipsparseCbsr2csr_(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA,blockDim, & descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="cusparseCbsr2csr") #else function hipsparseCbsr2csr_(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA,blockDim, & descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="hipsparseCbsr2csr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsr2csr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCbsr2csr_assumed_rank #else module procedure & hipsparseCbsr2csr_rank_0,& hipsparseCbsr2csr_rank_1 #endif #endif end interface interface hipsparseZbsr2csr #ifdef USE_CUDA_NAMES function hipsparseZbsr2csr_(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA,blockDim, & descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="cusparseZbsr2csr") #else function hipsparseZbsr2csr_(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA,blockDim, & descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="hipsparseZbsr2csr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsr2csr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZbsr2csr_assumed_rank #else module procedure & hipsparseZbsr2csr_rank_0,& hipsparseZbsr2csr_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse COO matrix into a sparse CSR matrix. !> !> \details !> \p hipsparseXcoo2csr converts the COO array containing the row indices into a !> CSR array of row offsets that point to the start of every row. !> It is assumed that the COO row index array is sorted and that all arrays have been allocated !> prior to calling \p hipsparseXcoo2csr. !> !> For example, given the COO row indices array: !> \f[ !> \begin{align} !> \text{cooRowInd} &= \begin{bmatrix} 0 & 0 & 1 & 2 & 2 & 4 & 4 & 4 \end{bmatrix} !> \end{align} !> \f] !> !> the resulting CSR row pointer array after calling \p hipsparseXcoo2csr is: !> \f[ !> \begin{align} !> \text{csrRowPtr} &= \begin{bmatrix} 0 & 2 & 3 & 5 & 8 \end{bmatrix} !> \end{align} !> \f] !> !> \note This function can also be used to convert a COO array containing the column indices !> into !> a CSC array of column offsets that point to the start of every column. In this case, it is !> assumed that the COO column index array is sorted instead. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] cooRowInd - array of \p nnz elements containing the row indices of the sparse COO !> matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. Must be non-negative. !> @param[in] m - number of rows of the sparse CSR matrix. Must be non-negative. !> @param[out] csrRowPtr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] idxBase - index base. `HIPSPARSE_INDEX_BASE_ZERO` for zero-based indexing or !> `HIPSPARSE_INDEX_BASE_ONE` for one-based indexing. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle is nullptr, \p m or \p nnz is negative, !> \p cooRowInd or \p csrRowPtr is nullptr when \p nnz is greater than zero, or !> \p idxBase is neither `HIPSPARSE_INDEX_BASE_ZERO` nor `HIPSPARSE_INDEX_BASE_ONE`. interface hipsparseXcoo2csr #ifdef USE_CUDA_NAMES function hipsparseXcoo2csr_(handle,cooRowInd,nnz,m,csrRowPtr,idxBase) & bind(c, name="cusparseXcoo2csr") #else function hipsparseXcoo2csr_(handle,cooRowInd,nnz,m,csrRowPtr,idxBase) & bind(c, name="hipsparseXcoo2csr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcoo2csr_ type(c_ptr),value :: handle type(c_ptr),value :: cooRowInd integer(c_int),value :: nnz integer(c_int),value :: m type(c_ptr),value :: csrRowPtr integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseXcoo2csr_assumed_rank #else module procedure & hipsparseXcoo2csr_rank_0,& hipsparseXcoo2csr_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Sort a sparse COO matrix. !> !> \details !> \p hipsparseXcoosort_bufferSizeExt returns the size of the temporary storage buffer !> in bytes required by `hipsparseXcoosortByRow`() and `hipsparseXcoosortByColumn`(). !> The temporary storage buffer must be allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse COO matrix. !> @param[in] n - number of columns of the sparse COO matrix. !> @param[in] nnz - number of non-zero entries of the sparse COO matrix. !> @param[in] cooRows - array of \p nnz elements containing the row indices of the sparse !> COO matrix. !> @param[in] cooCols - array of \p nnz elements containing the column indices of the sparse !> COO matrix. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseXcoosortByRow()` and `hipsparseXcoosortByColumn()`. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p nnz, \p cooRows, !> \p cooCols, or \p pBufferSizeInBytes pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseXcoosort_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseXcoosort_bufferSizeExt_(handle,m,n,nnz,cooRows,cooCols,pBufferSizeInBytes) & bind(c, name="cusparseXcoosort_bufferSizeExt") #else function hipsparseXcoosort_bufferSizeExt_(handle,m,n,nnz,cooRows,cooCols,pBufferSizeInBytes) & bind(c, name="hipsparseXcoosort_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcoosort_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: cooRows type(c_ptr),value :: cooCols integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseXcoosort_bufferSizeExt_assumed_rank #else module procedure & hipsparseXcoosort_bufferSizeExt_rank_0,& hipsparseXcoosort_bufferSizeExt_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Sort a sparse COO matrix by row. !> !> \details !> \p hipsparseXcoosortByRow sorts a matrix in COO format by row. The sorted !> permutation vector \p P can be used to obtain sorted \p cooVal array. In this !> case, \p P must be initialized as the identity permutation. See !> `hipsparseCreateIdentityPermutation`(). To apply the permutation vector to the COO !> values, see `hipsparseSgthr` "hipsparseXgthr()". !> !> \p hipsparseXcoosortByRow requires an extra temporary storage buffer that must be !> allocated by the user. The storage buffer size can be determined by !> `hipsparseXcoosort_bufferSizeExt`(). !> !> \note !> \p P can be \p NULL if a sorted permutation vector is not required. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse COO matrix. !> @param[in] n - number of columns of the sparse COO matrix. !> @param[in] nnz - number of non-zero entries of the sparse COO matrix. !> @param[inout] cooRows - array of \p nnz elements containing the row indices of the sparse !> COO matrix. !> @param[inout] cooCols - array of \p nnz elements containing the column indices of the sparse !> COO matrix. !> @param[inout] P - array of \p nnz integers containing the unsorted map indices. Can be !> \p NULL. !> @param[in] pBuffer - temporary storage buffer allocated by the user. The size is returned by !> `hipsparseXcoosort_bufferSizeExt`(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p nnz, \p cooRows, !> \p cooCols, or \p pBuffer pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseXcoosortByRow #ifdef USE_CUDA_NAMES function hipsparseXcoosortByRow_(handle,m,n,nnz,cooRows,cooCols,P,pBuffer) & bind(c, name="cusparseXcoosortByRow") #else function hipsparseXcoosortByRow_(handle,m,n,nnz,cooRows,cooCols,P,pBuffer) & bind(c, name="hipsparseXcoosortByRow") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcoosortByRow_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: cooRows type(c_ptr),value :: cooCols type(c_ptr),value :: P type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseXcoosortByRow_assumed_rank #else module procedure & hipsparseXcoosortByRow_rank_0,& hipsparseXcoosortByRow_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Sort a sparse COO matrix by column. !> !> \details !> \p hipsparseXcoosortByColumn sorts a matrix in COO format by column. The sorted !> permutation vector \p P can be used to obtain the sorted \p cooVal array. In this !> case, \p P must be initialized as the identity permutation. See !> `hipsparseCreateIdentityPermutation`(). To apply the permutation vector to the COO !> values, see `hipsparseSgthr` "hipsparseXgthr()". !> !> \p hipsparseXcoosortByColumn requires an extra temporary storage buffer that must be !> allocated by the user. The storage buffer size can be determined by !> `hipsparseXcoosort_bufferSizeExt`(). !> !> \note !> \p P can be \p NULL if a sorted permutation vector is not required. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse COO matrix. !> @param[in] n - number of columns of the sparse COO matrix. !> @param[in] nnz - number of non-zero entries of the sparse COO matrix. !> @param[inout] cooRows - array of \p nnz elements containing the row indices of the sparse !> COO matrix. !> @param[inout] cooCols - array of \p nnz elements containing the column indices of the sparse !> COO matrix. !> @param[inout] P - array of \p nnz integers containing the unsorted map indices. Can be !> \p NULL. !> @param[in] pBuffer - temporary storage buffer allocated by the user. The size is returned by !> `hipsparseXcoosort_bufferSizeExt`(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p nnz, \p cooRows, !> \p cooCols, or \p pBuffer pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseXcoosortByColumn #ifdef USE_CUDA_NAMES function hipsparseXcoosortByColumn_(handle,m,n,nnz,cooRows,cooCols,P,pBuffer) & bind(c, name="cusparseXcoosortByColumn") #else function hipsparseXcoosortByColumn_(handle,m,n,nnz,cooRows,cooCols,P,pBuffer) & bind(c, name="hipsparseXcoosortByColumn") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcoosortByColumn_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: cooRows type(c_ptr),value :: cooCols type(c_ptr),value :: P type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseXcoosortByColumn_assumed_rank #else module procedure & hipsparseXcoosortByColumn_rank_0,& hipsparseXcoosortByColumn_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Create the identity map. !> !> \details !> \p hipsparseCreateIdentityPermutation stores the identity map in \p p, such that !> \f$p = 0:1:(n-1)\f$. !> !> \code{.c} !> for(i = 0; i < n; ++i) !> { !> p[i] = i; !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPASRE library context queue. !> @param[in] n - size of the map \p p. !> @param[out] p - array of \p n integers containing the map. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p n, or \p p pointer is invalid. interface hipsparseCreateIdentityPermutation #ifdef USE_CUDA_NAMES function hipsparseCreateIdentityPermutation_(handle,n,p) & bind(c, name="cusparseCreateIdentityPermutation") #else function hipsparseCreateIdentityPermutation_(handle,n,p) & bind(c, name="hipsparseCreateIdentityPermutation") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateIdentityPermutation_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: p end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCreateIdentityPermutation_assumed_rank #else module procedure & hipsparseCreateIdentityPermutation_rank_0,& hipsparseCreateIdentityPermutation_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief !> \p hipsparseXcsc2dense functions convert the sparse matrix in CSC format into a dense matrix. !> !> \details !> Given the input CSC matrix of size \p mxn, the routine writes the matrix to the dense array !> \p A such !> that \p A has leading dimension \p ld and is column ordered. This means that \p A has size \p !> ldxn where !> \p ld>=m. All the parameters are assumed to have been preallocated by the user. If the input !> CSC matrix !> has index base of one, it must be set in the `hipsparseMatDescr_t`. See !> `hipsparseSetMatIndexBase` () !> prior to calling \p hipsparseXcsc2dense. !> !> For example, consider the sparse CSC matrix: !> \f[ !> \begin{align} !> \text{cscRowInd} &= \begin{bmatrix} 0 & 1 & 2 & 1 & 2 & 0 & 2 \end{bmatrix} \\% !> \text{cscColPtr} &= \begin{bmatrix} 0 & 3 & 4 & 5 & 7 \end{bmatrix} \\% !> \text{cscVal} &= \begin{bmatrix} 1 & 3 & 5 & 4 & 6 & 2 & 7 \end{bmatrix} \\% !> \end{align} !> \f] !> !> \p hipsparseXcsc2dense is used to convert to the dense matrix: !> \f[ !> \begin{bmatrix} !> 1 & 0 & 0 & 2 \\% !> 3 & 4 & 0 & 0 \\% !> 5 & 0 & 6 & 7 !> \end{bmatrix} !> \f] !> !> where the values in the \p A array are column ordered: !> \f[ !> \text{A} &= \begin{bmatrix} 1 & 3 & 5 & 0 & 4 & 0 & 0 & 0 & 6 & 2 & 0 & 7 \end{bmatrix} \\% !> \f] !> !> \note !> This function is executed asynchronously with respect to the host and can return control to !> the application !> on the host before the entire result is ready. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 11.0+) and will be !> removed in CUDA 12.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the dense matrix \p A. Must be non-negative. !> @param[in] n - number of columns of the dense matrix \p A. Must be non-negative. !> @param[in] descr - the descriptor of the dense matrix \p A. The supported matrix type is !> `HIPSPARSE_MATRIX_TYPE_GENERAL` and !> any valid value of the `hipsparseIndexBase_t`. !> @param[in] cscVal - array of nnz ( = \p cscColPtr[n] - \p cscColPtr[0] ) non-zero elements of !> matrix \p A. !> @param[in] cscRowInd - integer array of nnz ( = \p cscColPtr[n] - \p cscColPtr[0] ) column !> indices of the non-zero elements of matrix \p A. !> @param[in] cscColPtr - integer array of \p n+1 elements that contains the start of every !> column and the end of the last column plus one. !> @param[out] A - array of dimensions (\p ld, \p n). !> @param[in] ld - leading dimension of dense array \p A. Must be at least \p m. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p descr, \p cscVal, \p cscColPtr, !> \p cscRowInd, or \p A is nullptr, \p m or \p n is negative, or \p ld is invalid. #ifndef USE_CUDA_NAMES interface hipsparseScsc2dense function hipsparseScsc2dense_(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) & bind(c, name="hipsparseScsc2dense") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsc2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: cscVal type(c_ptr),value :: cscRowInd type(c_ptr),value :: cscColPtr type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsc2dense_assumed_rank #else module procedure & hipsparseScsc2dense_rank_0,& hipsparseScsc2dense_rank_1,& hipsparseScsc2dense_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsc2dense function hipsparseDcsc2dense_(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) & bind(c, name="hipsparseDcsc2dense") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsc2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: cscVal type(c_ptr),value :: cscRowInd type(c_ptr),value :: cscColPtr type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsc2dense_assumed_rank #else module procedure & hipsparseDcsc2dense_rank_0,& hipsparseDcsc2dense_rank_1,& hipsparseDcsc2dense_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsc2dense function hipsparseCcsc2dense_(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) & bind(c, name="hipsparseCcsc2dense") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsc2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: cscVal type(c_ptr),value :: cscRowInd type(c_ptr),value :: cscColPtr type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsc2dense_assumed_rank #else module procedure & hipsparseCcsc2dense_rank_0,& hipsparseCcsc2dense_rank_1,& hipsparseCcsc2dense_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsc2dense function hipsparseZcsc2dense_(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) & bind(c, name="hipsparseZcsc2dense") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsc2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: cscVal type(c_ptr),value :: cscRowInd type(c_ptr),value :: cscColPtr type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsc2dense_assumed_rank #else module procedure & hipsparseZcsc2dense_rank_0,& hipsparseZcsc2dense_rank_1,& hipsparseZcsc2dense_full_rank #endif #endif end interface #endif !> \ingroup conv_module !> \brief Sort a sparse CSC matrix. !> !> \details !> \p hipsparseXcscsort_bufferSizeExt returns the size of the temporary storage buffer !> in bytes required by `hipsparseXcscsort()`. The temporary storage buffer must be !> allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSC matrix. !> @param[in] n - number of columns of the sparse CSC matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSC matrix. !> @param[in] cscColPtr - array of \p n+1 elements that point to the start of every column of !> the sparse CSC matrix. !> @param[in] cscRowInd - array of \p nnz elements containing the row indices of the sparse !> CSC matrix. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseXcscsort`(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p nnz, \p cscColPtr, \p !> cscRowInd, or !> \p pBufferSizeInBytes pointer is invalid. interface hipsparseXcscsort_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseXcscsort_bufferSizeExt_(handle,m,n,nnz,cscColPtr,cscRowInd, & pBufferSizeInBytes) & bind(c, name="cusparseXcscsort_bufferSizeExt") #else function hipsparseXcscsort_bufferSizeExt_(handle,m,n,nnz,cscColPtr,cscRowInd, & pBufferSizeInBytes) & bind(c, name="hipsparseXcscsort_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcscsort_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: cscColPtr type(c_ptr),value :: cscRowInd integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseXcscsort_bufferSizeExt_assumed_rank #else module procedure & hipsparseXcscsort_bufferSizeExt_rank_0,& hipsparseXcscsort_bufferSizeExt_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Sort a sparse CSC matrix !> !> \details !> \p hipsparseXcscsort sorts a matrix in CSC format. The sorted permutation vector !> \p P can be used to obtain sorted \p cscVal array. In this case, \p P must be !> initialized as the identity permutation. See `hipsparseCreateIdentityPermutation`(). To !> apply the permutation vector to the CSC values, see `hipsparseSgthr` !> "hipsparseXgthr()". !> !> \p hipsparseXcscsort requires extra temporary storage buffer that must be allocated by !> the user. The storage buffer size can be determined by `hipsparseXcscsort_bufferSizeExt`(). !> !> \note !> \p P can be \p NULL if a sorted permutation vector is not required. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSC matrix. !> @param[in] n - number of columns of the sparse CSC matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSC matrix. !> @param[in] descrA - descriptor of the sparse CSC matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] cscColPtr - array of \p n+1 elements that point to the start of every column of !> the sparse CSC matrix. !> @param[inout] cscRowInd - array of \p nnz elements containing the row indices of the sparse !> CSC matrix. !> @param[inout] P - array of \p nnz integers containing the unsorted map indices. Can be !> \p NULL. !> @param[in] pBuffer - temporary storage buffer allocated by the user. The size is returned by !> `hipsparseXcscsort_bufferSizeExt`(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p nnz, \p descrA, \p !> cscColPtr, !> \p cscRowInd, or \p pBuffer pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseXcscsort #ifdef USE_CUDA_NAMES function hipsparseXcscsort_(handle,m,n,nnz,descrA,cscColPtr,cscRowInd,P,pBuffer) & bind(c, name="cusparseXcscsort") #else function hipsparseXcscsort_(handle,m,n,nnz,descrA,cscColPtr,cscRowInd,P,pBuffer) & bind(c, name="hipsparseXcscsort") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcscsort_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: cscColPtr type(c_ptr),value :: cscRowInd type(c_ptr),value :: P type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseXcscsort_assumed_rank #else module procedure & hipsparseXcscsort_rank_0,& hipsparseXcscsort_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief !> This function computes the number of non-zero block columns per row and the total number of !> non-zero blocks in a sparse !> BSR matrix, given a sparse CSR matrix as input. !> !> \details !> Consider the matrix: !> \f[ !> \begin{bmatrix} !> 1 & 0 & 0 & 2 \\% !> 3 & 4 & 0 & 0 \\% !> 5 & 0 & 6 & 7 \\% !> 1 & 2 & 3 & 4 !> \end{bmatrix} !> \f] !> !> stored as a sparse CSR matrix. This function computes both the BSR row pointer array as well !> as the total number !> of non-zero blocks that results when converting the CSR matrix to the BSR format. Assuming a !> block dimension of 2, !> the above matrix, after conversion to the BSR format, looks like: !> !> \f[ !> \left[ !> \begin{array}{c | c} !> \begin{array}{c c} !> 1 & 0 \\% !> 3 & 4 !> \end{array} & !> \begin{array}{c c} !> 0 & 2 \\% !> 0 & 0 !> \end{array} \\% !> \hline !> \begin{array}{c c} !> 5 & 0 \\% !> 1 & 2 !> \end{array} & !> \begin{array}{c c} !> 6 & 7 \\% !> 3 & 4 !> \end{array} \\% !> \end{array} !> \right] !> \f] !> !> and the resulting BSR row pointer array and total non-zero blocks after \p !> hipsparseXcsr2bsrNnz has been called !> looks like: !> !> \f[ !> \begin{align} !> \text{bsrRowPtrC} &= \begin{bmatrix} 0 & 2 & 4 \end{bmatrix} \\% !> \text{bsrNnzb} &= 4 !> \end{align} !> \f] !> !> In general, when converting a CSR matrix of size \p m x \p n to a BSR matrix, the resulting !> BSR matrix will have size !> \p mb x \p nb where \p mb and \p nb equal: !> !> \f[ !> \begin{align} !> \text{mb} &= \text{(m - 1) / blockDim + 1} \\% !> \text{nb} &= \text{(n - 1) / blockDim + 1} !> \end{align} !> \f] !> !> In particular, it can be the case that \p blockDim does not divide evenly into \p m and/or \p !> n. In these cases, the !> CSR matrix is expanded in size to fit full BSR blocks. For example, using the original CSR !> matrix and block !> dimension 3 instead of 2, the function \p hipsparseXcsr2bsrNnz computes the BSR row pointer !> array and total number of !> non-zero blocks for the BSR matrix: !> !> \f[ !> \left[ !> \begin{array}{c | c} !> \begin{array}{c c c} !> 1 & 0 & 0 \\% !> 3 & 4 & 0 \\% !> 5 & 0 & 6 !> \end{array} & !> \begin{array}{c c c} !> 2 & 0 & 0 \\% !> 0 & 0 & 0 \\% !> 7 & 0 & 0 !> \end{array} \\% !> \hline !> \begin{array}{c c c} !> 1 & 2 & 3 \\% !> 0 & 0 & 0 \\% !> 0 & 0 & 0 !> \end{array} & !> \begin{array}{c c c} !> 4 & 0 & 0 \\% !> 0 & 0 & 0 \\% !> 0 & 0 & 0 !> \end{array} \\% !> \end{array} !> \right] !> \f] !> !> See hipsparseScsr2bsr() for a full code example. !> !> \note !> The routine supports asynchronous execution if the pointer mode is set to device. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - direction that specifies whether to count non-zero elements by !> `HIPSPARSE_DIRECTION_ROW` or by !> `HIPSPARSE_DIRECTION_COLUMN`. !> @param[in] m - number of rows of the sparse CSR matrix. Must be non-negative. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] descrA - descriptor of the sparse CSR matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrRowPtrA - integer array containing \p m+1 elements that points to the start of !> each row of the CSR matrix. !> @param[in] csrColIndA - integer array of the column indices for each non-zero element in the !> CSR matrix. !> @param[in] blockDim - the block dimension of the BSR matrix, which is between \f$1\f$ and !> \f$\min(m, n)\f$. !> @param[in] descrC - descriptor of the sparse BSR matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[out] bsrRowPtrC - integer array containing \p mb+1 elements that point to the start of !> each block row of the BSR matrix. !> @param[out] bsrNnzb - total number of non-zero elements in device or host memory. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p blockDim, \p csrRowPtrA, \p !> csrColIndA, !> \p bsrRowPtrC, or \p bsrNnzb pointer is invalid. interface hipsparseXcsr2bsrNnz #ifdef USE_CUDA_NAMES function hipsparseXcsr2bsrNnz_(handle,dirA,m,n,descrA,csrRowPtrA,csrColIndA,blockDim,descrC, & bsrRowPtrC,bsrNnzb) & bind(c, name="cusparseXcsr2bsrNnz") #else function hipsparseXcsr2bsrNnz_(handle,dirA,m,n,descrA,csrRowPtrA,csrColIndA,blockDim,descrC, & bsrRowPtrC,bsrNnzb) & bind(c, name="hipsparseXcsr2bsrNnz") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsr2bsrNnz_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descrA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: descrC type(c_ptr),value :: bsrRowPtrC type(c_ptr),value :: bsrNnzb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseXcsr2bsrNnz_assumed_rank #else module procedure & hipsparseXcsr2bsrNnz_rank_0,& hipsparseXcsr2bsrNnz_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse CSR matrix into a sparse BSR matrix. !> !> \details !> \p hipsparseXcsr2bsr completes the conversion of a CSR matrix into a BSR matrix. !> It is assumed that \p bsrValC, \p bsrColIndC, and \p bsrRowPtrC are allocated. The !> allocation size for \p bsrRowPtr is computed as \p mb+1, where \p mb is the number of !> block rows in the BSR matrix defined as: !> !> \f[ !> \begin{align} !> \text{mb} &= \text{(m - 1) / blockDim + 1} !> \end{align} !> \f] !> !> The allocation size for \p bsrColIndC, that is, \p bsrNnzb, is computed using !> `hipsparseXcsr2bsrNnz`(), which also fills the \p bsrRowPtrC array. The allocation size !> for \p bsrValC is then equal to: !> !> \f[ !> \text{bsrNnzb * blockDim * blockDim} !> \f] !> !> For example, given the CSR matrix: !> \f[ !> \begin{bmatrix} !> 1 & 0 & 0 & 2 \\% !> 3 & 4 & 0 & 0 \\% !> 5 & 0 & 6 & 7 \\% !> 1 & 2 & 3 & 4 !> \end{bmatrix} !> \f] !> !> The resulting BSR matrix using block dimension 2 would look like: !> \f[ !> \left[ !> \begin{array}{c | c} !> \begin{array}{c c} !> 1 & 0 \\% !> 3 & 4 !> \end{array} & !> \begin{array}{c c} !> 0 & 2 \\% !> 0 & 0 !> \end{array} \\% !> \hline !> \begin{array}{c c} !> 5 & 0 \\% !> 1 & 2 !> \end{array} & !> \begin{array}{c c} !> 6 & 7 \\% !> 3 & 4 !> \end{array} \\% !> \end{array} !> \right] !> \f] !> !> The call to `hipsparseXcsr2bsrNnz` results in the BSR row pointer array: !> \f[ !> \begin{align} !> \text{bsrRowPtrC} &= \begin{bmatrix} 0 & 2 & 4 \end{bmatrix} \\% !> \end{align} !> \f] !> !> and the call to \p hipsparseXcsr2bsr completes the conversion resulting in the BSR column !> indices and values arrays: !> \f[ !> \begin{align} !> \text{bsrColIndC} &= \begin{bmatrix} 0 & 1 & 0 & 1 \end{bmatrix} \\% !> \text{bsrValC} &= \begin{bmatrix} 1 & 0 & 3 & 4 & 0 & 2 & 0 & 0 & 5 & 0 & 1 & 2 & 6 & 7 & 3 !> & 4 \end{bmatrix} \\% !> \end{align} !> \f] !> !> The \p dirA parameter determines the order of the BSR block values. The example above uses !> row order. Using column ordering !> would result instead in the BSR values array: !> !> \f[ !> \text{bsrValC} &= \begin{bmatrix} 1 & 3 & 0 & 4 & 0 & 0 & 2 & 0 & 5 & 1 & 0 & 2 & 6 & 3 & 7 !> & 4 \end{bmatrix} \\% !> \f] !> !> \note !> \p hipsparseXcsr2bsr requires extra temporary storage that is allocated internally if !> \p blockDim > 16. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - the storage format of the blocks, `HIPSPARSE_DIRECTION_ROW` or !> `HIPSPARSE_DIRECTION_COLUMN`. !> @param[in] m - number of rows in the sparse CSR matrix. !> @param[in] n - number of columns in the sparse CSR matrix. !> @param[in] descrA - descriptor of the sparse CSR matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrValA - array of \p nnz elements containing the values of the sparse CSR matrix. !> @param[in] csrRowPtrA - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csrColIndA - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[in] blockDim - size of the blocks in the sparse BSR matrix. !> @param[in] descrC - descriptor of the sparse BSR matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[out] bsrValC - array of \p nnzb*blockDim*blockDim containing the values of the sparse !> BSR matrix. !> @param[out] bsrRowPtrC - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse BSR matrix. !> @param[out] bsrColIndC - array of \p nnzb elements containing the block column indices of the !> sparse BSR matrix. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p blockDim, \p bsrValC, \p !> bsrRowPtrC, !> \p bsrColIndC, \p csrValA, \p csrRowPtrA, or \p csrColIndA pointer is invalid. interface hipsparseScsr2bsr #ifdef USE_CUDA_NAMES function hipsparseScsr2bsr_(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA,blockDim, & descrC,bsrValC,bsrRowPtrC,bsrColIndC) & bind(c, name="cusparseScsr2bsr") #else function hipsparseScsr2bsr_(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA,blockDim, & descrC,bsrValC,bsrRowPtrC,bsrColIndC) & bind(c, name="hipsparseScsr2bsr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2bsr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: descrC type(c_ptr),value :: bsrValC type(c_ptr),value :: bsrRowPtrC type(c_ptr),value :: bsrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsr2bsr_assumed_rank #else module procedure & hipsparseScsr2bsr_rank_0,& hipsparseScsr2bsr_rank_1 #endif #endif end interface interface hipsparseDcsr2bsr #ifdef USE_CUDA_NAMES function hipsparseDcsr2bsr_(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA,blockDim, & descrC,bsrValC,bsrRowPtrC,bsrColIndC) & bind(c, name="cusparseDcsr2bsr") #else function hipsparseDcsr2bsr_(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA,blockDim, & descrC,bsrValC,bsrRowPtrC,bsrColIndC) & bind(c, name="hipsparseDcsr2bsr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2bsr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: descrC type(c_ptr),value :: bsrValC type(c_ptr),value :: bsrRowPtrC type(c_ptr),value :: bsrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsr2bsr_assumed_rank #else module procedure & hipsparseDcsr2bsr_rank_0,& hipsparseDcsr2bsr_rank_1 #endif #endif end interface interface hipsparseCcsr2bsr #ifdef USE_CUDA_NAMES function hipsparseCcsr2bsr_(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA,blockDim, & descrC,bsrValC,bsrRowPtrC,bsrColIndC) & bind(c, name="cusparseCcsr2bsr") #else function hipsparseCcsr2bsr_(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA,blockDim, & descrC,bsrValC,bsrRowPtrC,bsrColIndC) & bind(c, name="hipsparseCcsr2bsr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2bsr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: descrC type(c_ptr),value :: bsrValC type(c_ptr),value :: bsrRowPtrC type(c_ptr),value :: bsrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsr2bsr_assumed_rank #else module procedure & hipsparseCcsr2bsr_rank_0,& hipsparseCcsr2bsr_rank_1 #endif #endif end interface interface hipsparseZcsr2bsr #ifdef USE_CUDA_NAMES function hipsparseZcsr2bsr_(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA,blockDim, & descrC,bsrValC,bsrRowPtrC,bsrColIndC) & bind(c, name="cusparseZcsr2bsr") #else function hipsparseZcsr2bsr_(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA,blockDim, & descrC,bsrValC,bsrRowPtrC,bsrColIndC) & bind(c, name="hipsparseZcsr2bsr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2bsr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA integer(c_int),value :: blockDim type(c_ptr),value :: descrC type(c_ptr),value :: bsrValC type(c_ptr),value :: bsrRowPtrC type(c_ptr),value :: bsrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsr2bsr_assumed_rank #else module procedure & hipsparseZcsr2bsr_rank_0,& hipsparseZcsr2bsr_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse CSR matrix into a sparse COO matrix. !> !> \details !> \p hipsparseXcsr2coo converts the CSR array containing the row offsets that point !> to the start of every row into a COO array of row indices. All arrays are assumed !> to be allocated by the user prior to calling \p hipsparseXcsr2coo. !> !> For example, given the CSR row pointer array (assuming zero index base): !> \f[ !> \begin{align} !> \text{csrRowPtr} &= \begin{bmatrix} 0 & 1 & 3 & 4 \end{bmatrix} !> \end{align} !> \f] !> !> Calling \p hipsparseXcsr2coo results in the COO row indices array: !> \f[ !> \begin{align} !> \text{cooRowInd} &= \begin{bmatrix} 0 & 1 & 1 & 2 \end{bmatrix} !> \end{align} !> \f] !> !> \note !> This function can also be used to convert a CSC array containing the column offsets into a !> COO !> array of column indices. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] csrRowPtr - array of \p m+1 elements that point to the start of every row !> of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. Must be non-negative. !> @param[in] m - number of rows of the sparse CSR matrix. Must be non-negative. !> @param[out] cooRowInd - array of \p nnz elements containing the row indices of the sparse COO !> matrix. !> @param[in] idxBase - index base. `HIPSPARSE_INDEX_BASE_ZERO` for zero-based indexing or !> `HIPSPARSE_INDEX_BASE_ONE` for one-based indexing. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle is nullptr, \p m or, \p nnz is negative, !> \p csrRowPtr or \p cooRowInd is nullptr when \p nnz is greater than zero, or !> \p idxBase is neither `HIPSPARSE_INDEX_BASE_ZERO` nor `HIPSPARSE_INDEX_BASE_ONE`. !> \retval HIPSPARSE_STATUS_ARCH_MISMATCH the device is not supported. interface hipsparseXcsr2coo #ifdef USE_CUDA_NAMES function hipsparseXcsr2coo_(handle,csrRowPtr,nnz,m,cooRowInd,idxBase) & bind(c, name="cusparseXcsr2coo") #else function hipsparseXcsr2coo_(handle,csrRowPtr,nnz,m,cooRowInd,idxBase) & bind(c, name="hipsparseXcsr2coo") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsr2coo_ type(c_ptr),value :: handle type(c_ptr),value :: csrRowPtr integer(c_int),value :: nnz integer(c_int),value :: m type(c_ptr),value :: cooRowInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseXcsr2coo_assumed_rank #else module procedure & hipsparseXcsr2coo_rank_0,& hipsparseXcsr2coo_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse CSR matrix into a sparse CSC matrix. !> !> \details !> \p hipsparseXcsr2csc converts a CSR matrix into a CSC matrix. \p hipsparseXcsr2csc !> can also be used to convert a CSC matrix into a CSR matrix. \p copyValues decides !> whether \p cscSortedVal is being filled during conversion (`HIPSPARSE_ACTION_NUMERIC`) !> or not (`HIPSPARSE_ACTION_SYMBOLIC`). !> !> For example given the matrix: !> \f[ !> \begin{bmatrix} !> 1 & 0 & 0 & 2 \\% !> 3 & 4 & 0 & 0 \\% !> 5 & 0 & 6 & 7 !> \end{bmatrix} !> \f] !> !> Represented using the sparse CSR format as: !> \f[ !> \begin{align} !> \text{csrSortedRowPtr} &= \begin{bmatrix} 0 & 2 & 4 & 7 \end{bmatrix} \\% !> \text{csrSortedColInd} &= \begin{bmatrix} 0 & 3 & 0 & 1 & 0 & 2 & 3 \end{bmatrix} \\% !> \text{csrSortedVal} &= \begin{bmatrix} 1 & 2 & 3 & 4 & 5 & 6 & 7 \end{bmatrix} !> \end{align} !> \f] !> !> this function converts it to the sparse CSC format: !> \f[ !> \begin{align} !> \text{cscSortedRowInd} &= \begin{bmatrix} 0 & 1 & 2 & 1 & 2 & 0 & 2 \end{bmatrix} \\% !> \text{cscSortedColPtr} &= \begin{bmatrix} 0 & 3 & 4 & 5 & 7 \end{bmatrix} \\% !> \text{cscSortedVal} &= \begin{bmatrix} 1 & 3 & 5 & 4 & 6 & 2 & 7 \end{bmatrix} !> \end{align} !> \f] !> !> The CSC arrays \p cscSortedRowInd, \p cscSortedColPtr, and \p cscSortedVal must be allocated !> by the !> user prior to calling \p hipsparseXcsr2csc(). !> !> \note !> The resulting matrix can also be seen as the transpose of the input matrix. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 10.0+) and will be !> removed in CUDA 11.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix, which must be non-negative. !> @param[in] n - number of columns of the sparse CSR matrix, which must be non-negative. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix, which must be !> non-negative. !> @param[in] csrSortedVal - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csrSortedRowPtr - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix. !> @param[in] csrSortedColInd - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix. !> @param[out] cscSortedVal - array of \p nnz elements of the sparse CSC matrix. !> @param[out] cscSortedRowInd - array of \p nnz elements containing the row indices of the !> sparse CSC !> matrix. !> @param[out] cscSortedColPtr - array of \p n+1 elements that point to the start of every !> column of the !> sparse CSC matrix. !> @param[in] copyValues - `HIPSPARSE_ACTION_SYMBOLIC` or `HIPSPARSE_ACTION_NUMERIC`. !> @param[in] idxBase - index base. `HIPSPARSE_INDEX_BASE_ZERO` for zero-based indexing or !> `HIPSPARSE_INDEX_BASE_ONE` for one-based indexing. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle is nullptr, \p m, \p n, or \p nnz is !> negative, !> \p csrSortedVal, \p csrSortedRowPtr, \p csrSortedColInd, \p cscSortedVal, \p !> cscSortedRowInd, !> or \p cscSortedColPtr is nullptr when \p nnz is greater than zero, \p copyValues is !> neither !> `HIPSPARSE_ACTION_SYMBOLIC` nor `HIPSPARSE_ACTION_NUMERIC`, or \p idxBase is neither !> `HIPSPARSE_INDEX_BASE_ZERO` nor `HIPSPARSE_INDEX_BASE_ONE`. !> \retval HIPSPARSE_STATUS_ARCH_MISMATCH the device is not supported. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. #ifndef USE_CUDA_NAMES interface hipsparseScsr2csc function hipsparseScsr2csc_(handle,m,n,nnz,csrSortedVal,csrSortedRowPtr,csrSortedColInd, & cscSortedVal,cscSortedRowInd,cscSortedColPtr,copyValues,idxBase) & bind(c, name="hipsparseScsr2csc") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csrSortedVal type(c_ptr),value :: csrSortedRowPtr type(c_ptr),value :: csrSortedColInd type(c_ptr),value :: cscSortedVal type(c_ptr),value :: cscSortedRowInd type(c_ptr),value :: cscSortedColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)),value :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsr2csc_assumed_rank #else module procedure & hipsparseScsr2csc_rank_0,& hipsparseScsr2csc_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsr2csc function hipsparseDcsr2csc_(handle,m,n,nnz,csrSortedVal,csrSortedRowPtr,csrSortedColInd, & cscSortedVal,cscSortedRowInd,cscSortedColPtr,copyValues,idxBase) & bind(c, name="hipsparseDcsr2csc") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csrSortedVal type(c_ptr),value :: csrSortedRowPtr type(c_ptr),value :: csrSortedColInd type(c_ptr),value :: cscSortedVal type(c_ptr),value :: cscSortedRowInd type(c_ptr),value :: cscSortedColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)),value :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsr2csc_assumed_rank #else module procedure & hipsparseDcsr2csc_rank_0,& hipsparseDcsr2csc_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsr2csc function hipsparseCcsr2csc_(handle,m,n,nnz,csrSortedVal,csrSortedRowPtr,csrSortedColInd, & cscSortedVal,cscSortedRowInd,cscSortedColPtr,copyValues,idxBase) & bind(c, name="hipsparseCcsr2csc") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csrSortedVal type(c_ptr),value :: csrSortedRowPtr type(c_ptr),value :: csrSortedColInd type(c_ptr),value :: cscSortedVal type(c_ptr),value :: cscSortedRowInd type(c_ptr),value :: cscSortedColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)),value :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsr2csc_assumed_rank #else module procedure & hipsparseCcsr2csc_rank_0,& hipsparseCcsr2csc_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsr2csc function hipsparseZcsr2csc_(handle,m,n,nnz,csrSortedVal,csrSortedRowPtr,csrSortedColInd, & cscSortedVal,cscSortedRowInd,cscSortedColPtr,copyValues,idxBase) & bind(c, name="hipsparseZcsr2csc") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csrSortedVal type(c_ptr),value :: csrSortedRowPtr type(c_ptr),value :: csrSortedColInd type(c_ptr),value :: cscSortedVal type(c_ptr),value :: cscSortedRowInd type(c_ptr),value :: cscSortedColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)),value :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsr2csc_assumed_rank #else module procedure & hipsparseZcsr2csc_rank_0,& hipsparseZcsr2csc_rank_1 #endif #endif end interface #endif !> \ingroup conv_module !> \brief This function computes the size of the user-allocated temporary storage buffer used !> when converting a sparse CSR matrix into a sparse CSC matrix. !> !> \details !> \p hipsparseCsr2cscEx2_bufferSize calculates the required user allocated temporary buffer !> needed !> by `hipsparseCsr2cscEx2` to convert a CSR matrix into a CSC matrix. `hipsparseCsr2cscEx2` !> can also be used to convert a CSC matrix into a CSR matrix. \p copyValues decides !> whether \p cscVal is being filled during conversion (`HIPSPARSE_ACTION_NUMERIC`) !> or not (`HIPSPARSE_ACTION_SYMBOLIC`). !> !> \note !> The resulting matrix can also be seen as the transpose of the input matrix. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] csrVal - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csrRowPtr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csrColInd - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[in] cscVal - array of \p nnz elements of the sparse CSC matrix. !> @param[in] cscColPtr - array of \p n+1 elements that point to the start of every column of !> the !> sparse CSC matrix. !> @param[in] cscRowInd - array of \p nnz elements containing the row indices of the sparse !> CSC matrix. !> @param[in] valType - The data type of the values arrays \p csrVal and \p cscVal. Can be !> HIP_R_32F, !> HIP_R_64F, HIP_C_32F, or HIP_C_64F. !> @param[in] copyValues - `HIPSPARSE_ACTION_SYMBOLIC` or `HIPSPARSE_ACTION_NUMERIC`. !> @param[in] idxBase - `HIPSPARSE_INDEX_BASE_ZERO` or `HIPSPARSE_INDEX_BASE_ONE`. !> @param[in] alg - HIPSPARSE_CSR2CSC_ALG_DEFAULT, HIPSPARSE_CSR2CSC_ALG1, or !> HIPSPARSE_CSR2CSC_ALG2. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseCsr2cscEx2()`. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p nnz, \p csrRowPtr, \p !> csrColInd, or !> \p pBufferSizeInBytes pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseCsr2cscEx2_bufferSize #ifdef USE_CUDA_NAMES function hipsparseCsr2cscEx2_bufferSize_(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd,cscVal, & cscColPtr,cscRowInd,valType,copyValues,idxBase,alg,pBufferSizeInBytes) & bind(c, name="cusparseCsr2cscEx2_bufferSize") #else function hipsparseCsr2cscEx2_bufferSize_(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd,cscVal, & cscColPtr,cscRowInd,valType,copyValues,idxBase,alg,pBufferSizeInBytes) & bind(c, name="hipsparseCsr2cscEx2_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCsr2cscEx2_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: cscVal type(c_ptr),value :: cscColPtr type(c_ptr),value :: cscRowInd integer(kind(HIP_R_32F)),value :: valType integer(kind(HIPSPARSE_ACTION_SYMBOLIC)),value :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase integer(kind(HIPSPARSE_CSR2CSC_ALG_DEFAULT)),value :: alg integer(c_size_t) :: pBufferSizeInBytes end function end interface !> \ingroup conv_module !> \brief Convert a sparse CSR matrix into a sparse CSC matrix. !> !> \details !> \p hipsparseCsr2cscEx2 converts a CSR matrix into a CSC matrix. \p hipsparseCsr2cscEx2 !> can also be used to convert a CSC matrix into a CSR matrix. \p copyValues decides !> whether \p cscVal is being filled during conversion (`HIPSPARSE_ACTION_NUMERIC`) !> or not (`HIPSPARSE_ACTION_SYMBOLIC`). !> !> \note !> The resulting matrix can also be seen as the transpose of the input matrix. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] csrVal - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csrRowPtr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csrColInd - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[in] cscVal - array of \p nnz elements of the sparse CSC matrix. !> @param[in] cscColPtr - array of \p n+1 elements that point to the start of every column of !> the !> sparse CSC matrix. !> @param[in] cscRowInd - array of \p nnz elements containing the row indices of the sparse !> CSC matrix. !> @param[in] valType - The data type of the values arrays \p csrVal and \p cscVal. Can be !> HIP_R_32F, !> HIP_R_64F, HIP_C_32F, or HIP_C_64F. !> @param[in] copyValues - `HIPSPARSE_ACTION_SYMBOLIC` or `HIPSPARSE_ACTION_NUMERIC`. !> @param[in] idxBase - `HIPSPARSE_INDEX_BASE_ZERO` or `HIPSPARSE_INDEX_BASE_ONE`. !> @param[in] alg - HIPSPARSE_CSR2CSC_ALG_DEFAULT, HIPSPARSE_CSR2CSC_ALG1 or !> HIPSPARSE_CSR2CSC_ALG2. !> @param[in] buffer - temporary storage buffer allocated by the user. The size is returned by !> hipsparseCsr2cscEx2_bufferSize(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p nnz, \p csrRowPtr, \p !> csrColInd, or !> \p pBufferSizeInBytes pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseCsr2cscEx2 #ifdef USE_CUDA_NAMES function hipsparseCsr2cscEx2_(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd,cscVal,cscColPtr, & cscRowInd,valType,copyValues,idxBase,alg,buffer) & bind(c, name="cusparseCsr2cscEx2") #else function hipsparseCsr2cscEx2_(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd,cscVal,cscColPtr, & cscRowInd,valType,copyValues,idxBase,alg,buffer) & bind(c, name="hipsparseCsr2cscEx2") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCsr2cscEx2_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: cscVal type(c_ptr),value :: cscColPtr type(c_ptr),value :: cscRowInd integer(kind(HIP_R_32F)),value :: valType integer(kind(HIPSPARSE_ACTION_SYMBOLIC)),value :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase integer(kind(HIPSPARSE_CSR2CSC_ALG_DEFAULT)),value :: alg type(c_ptr),value :: buffer end function end interface !> \ingroup conv_module !> \brief Convert a sparse CSR matrix into a compressed sparse CSR matrix. !> !> \details !> \p hipsparseXcsr2csr_compress converts a CSR matrix into a compressed CSR matrix by !> removing entries in the input CSR matrix that are below a non-negative threshold \p tol: !> !> \f[ !> C(i,j) = A(i, j) \text{ if |A(i, j)| > tol} !> \f] !> !> The user must first call `hipsparseSnnz_compress` "hipsparseXnnz_compress()" to determine the !> number !> of non-zeros per row as well as the total number of non-zeros that will exist in resulting !> compressed CSR !> matrix. The user then uses this information to allocate the column indices array \p !> csrColIndC and the !> values array \p csrValC. The user then calls \p hipsparseXcsr2csr_compress to complete the !> conversion. !> !> \note !> In the case of complex matrices, only the magnitude of the real part of \p tol is used. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] descrA - matrix descriptor for the CSR matrix. !> @param[in] csrValA - array of \p nnzA elements of the sparse CSR matrix. !> @param[in] csrRowPtrA - array of \p m+1 elements that point to the start of every row of the !> uncompressed sparse CSR matrix. !> @param[in] csrColIndA - array of \p nnzA elements containing the column indices of the !> uncompressed !> sparse CSR matrix. !> @param[in] nnzA - number of elements in the column indices and values arrays of the !> uncompressed !> sparse CSR matrix. !> @param[in] nnzPerRow - array of length \p m containing the number of entries that will be !> kept per row in !> the final compressed CSR matrix. !> @param[out] csrValC - array of \p nnzC elements of the compressed sparse CSC matrix. !> @param[out] csrRowPtrC - array of \p m+1 elements that point to the start of every column of !> the compressed !> sparse CSR matrix. !> @param[out] csrColIndC - array of \p nnzC elements containing the row indices of the !> compressed !> sparse CSR matrix. !> @param[in] tol - the non-negative tolerance used for compression. If \p tol is complex, then !> only the magnitude !> of the real part is used. Entries in the input uncompressed CSR array that are !> below the tolerance !> are removed in the output compressed CSR matrix. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p nnzA, \p tol, \p csrValA, \p !> csrRowPtrA, !> \p csrColIndA, \p csrValC, \p csrRowPtrC, \p csrColIndC, or \p nnzPerRow pointer !> is invalid. interface hipsparseScsr2csr_compress #ifdef USE_CUDA_NAMES function hipsparseScsr2csr_compress_(handle,m,n,descrA,csrValA,csrColIndA,csrRowPtrA,nnzA, & nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) & bind(c, name="cusparseScsr2csr_compress") #else function hipsparseScsr2csr_compress_(handle,m,n,descrA,csrValA,csrColIndA,csrRowPtrA,nnzA, & nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) & bind(c, name="hipsparseScsr2csr_compress") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2csr_compress_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrColIndA type(c_ptr),value :: csrRowPtrA integer(c_int),value :: nnzA type(c_ptr),value :: nnzPerRow type(c_ptr),value :: csrValC type(c_ptr),value :: csrColIndC type(c_ptr),value :: csrRowPtrC real(c_float),value :: tol end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsr2csr_compress_assumed_rank #else module procedure & hipsparseScsr2csr_compress_rank_0,& hipsparseScsr2csr_compress_rank_1 #endif #endif end interface interface hipsparseDcsr2csr_compress #ifdef USE_CUDA_NAMES function hipsparseDcsr2csr_compress_(handle,m,n,descrA,csrValA,csrColIndA,csrRowPtrA,nnzA, & nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) & bind(c, name="cusparseDcsr2csr_compress") #else function hipsparseDcsr2csr_compress_(handle,m,n,descrA,csrValA,csrColIndA,csrRowPtrA,nnzA, & nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) & bind(c, name="hipsparseDcsr2csr_compress") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2csr_compress_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrColIndA type(c_ptr),value :: csrRowPtrA integer(c_int),value :: nnzA type(c_ptr),value :: nnzPerRow type(c_ptr),value :: csrValC type(c_ptr),value :: csrColIndC type(c_ptr),value :: csrRowPtrC real(c_double),value :: tol end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsr2csr_compress_assumed_rank #else module procedure & hipsparseDcsr2csr_compress_rank_0,& hipsparseDcsr2csr_compress_rank_1 #endif #endif end interface interface hipsparseCcsr2csr_compress #ifdef USE_CUDA_NAMES function hipsparseCcsr2csr_compress_(handle,m,n,descrA,csrValA,csrColIndA,csrRowPtrA,nnzA, & nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) & bind(c, name="cusparseCcsr2csr_compress") #else function hipsparseCcsr2csr_compress_(handle,m,n,descrA,csrValA,csrColIndA,csrRowPtrA,nnzA, & nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) & bind(c, name="hipsparseCcsr2csr_compress") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2csr_compress_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrColIndA type(c_ptr),value :: csrRowPtrA integer(c_int),value :: nnzA type(c_ptr),value :: nnzPerRow type(c_ptr),value :: csrValC type(c_ptr),value :: csrColIndC type(c_ptr),value :: csrRowPtrC complex(c_float_complex),value :: tol end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsr2csr_compress_assumed_rank #else module procedure & hipsparseCcsr2csr_compress_rank_0,& hipsparseCcsr2csr_compress_rank_1 #endif #endif end interface interface hipsparseZcsr2csr_compress #ifdef USE_CUDA_NAMES function hipsparseZcsr2csr_compress_(handle,m,n,descrA,csrValA,csrColIndA,csrRowPtrA,nnzA, & nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) & bind(c, name="cusparseZcsr2csr_compress") #else function hipsparseZcsr2csr_compress_(handle,m,n,descrA,csrValA,csrColIndA,csrRowPtrA,nnzA, & nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) & bind(c, name="hipsparseZcsr2csr_compress") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2csr_compress_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrColIndA type(c_ptr),value :: csrRowPtrA integer(c_int),value :: nnzA type(c_ptr),value :: nnzPerRow type(c_ptr),value :: csrValC type(c_ptr),value :: csrColIndC type(c_ptr),value :: csrRowPtrC complex(c_double_complex),value :: tol end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsr2csr_compress_assumed_rank #else module procedure & hipsparseZcsr2csr_compress_rank_0,& hipsparseZcsr2csr_compress_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief !> This function converts the sorted CSR format to the unsorted CSR format. The required !> temporary storage has to be allocated by the user. interface hipsparseScsr2csru #ifdef USE_CUDA_NAMES function hipsparseScsr2csru_(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo,pBuffer) & bind(c, name="cusparseScsr2csru") #else function hipsparseScsr2csru_(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo,pBuffer) & bind(c, name="hipsparseScsr2csru") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2csru_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: myInfo type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsr2csru_assumed_rank #else module procedure & hipsparseScsr2csru_rank_0,& hipsparseScsr2csru_rank_1 #endif #endif end interface interface hipsparseDcsr2csru #ifdef USE_CUDA_NAMES function hipsparseDcsr2csru_(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo,pBuffer) & bind(c, name="cusparseDcsr2csru") #else function hipsparseDcsr2csru_(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo,pBuffer) & bind(c, name="hipsparseDcsr2csru") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2csru_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: myInfo type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsr2csru_assumed_rank #else module procedure & hipsparseDcsr2csru_rank_0,& hipsparseDcsr2csru_rank_1 #endif #endif end interface interface hipsparseCcsr2csru #ifdef USE_CUDA_NAMES function hipsparseCcsr2csru_(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo,pBuffer) & bind(c, name="cusparseCcsr2csru") #else function hipsparseCcsr2csru_(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo,pBuffer) & bind(c, name="hipsparseCcsr2csru") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2csru_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: myInfo type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsr2csru_assumed_rank #else module procedure & hipsparseCcsr2csru_rank_0,& hipsparseCcsr2csru_rank_1 #endif #endif end interface interface hipsparseZcsr2csru #ifdef USE_CUDA_NAMES function hipsparseZcsr2csru_(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo,pBuffer) & bind(c, name="cusparseZcsr2csru") #else function hipsparseZcsr2csru_(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo,pBuffer) & bind(c, name="hipsparseZcsr2csru") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2csru_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: myInfo type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsr2csru_assumed_rank #else module procedure & hipsparseZcsr2csru_rank_0,& hipsparseZcsr2csru_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief !> \p hipsparseXcsr2dense functions convert the sparse matrix in CSR format into a dense matrix. !> !> \details !> Given the input CSR matrix of size \p mxn, the routine writes the matrix to the dense array !> \p A such !> that \p A has leading dimension \p ld and is column ordered. This means that \p A has size \p !> ldxn where !> \p ld>=m. All the parameters are assumed to have been preallocated by the user. If the input !> CSR matrix !> has index base of one, it must be set in the `hipsparseMatDescr_t`. See !> `hipsparseSetMatIndexBase` () !> prior to calling \p hipsparseXcsr2dense. !> !> For example, consider the sparse CSR matrix: !> \f[ !> \begin{align} !> \text{csrRowPtr} &= \begin{bmatrix} 0 & 2 & 4 & 7 \end{bmatrix} \\% !> \text{csrColInd} &= \begin{bmatrix} 0 & 3 & 0 & 1 & 0 & 2 & 3 \end{bmatrix} \\% !> \text{csrVal} &= \begin{bmatrix} 1 & 2 & 3 & 4 & 5 & 6 & 7 \end{bmatrix} \\% !> \end{align} !> \f] !> !> \p hipsparseXcsr2dense is used to convert to the dense matrix: !> \f[ !> \begin{bmatrix} !> 1 & 0 & 0 & 2 \\% !> 3 & 4 & 0 & 0 \\% !> 5 & 0 & 6 & 7 !> \end{bmatrix} !> \f] !> !> where the values in the \p A array are column ordered: !> \f[ !> \text{A} &= \begin{bmatrix} 1 & 3 & 5 & 0 & 4 & 0 & 0 & 0 & 6 & 2 & 0 & 7 \end{bmatrix} \\% !> \f] !> !> \note !> This function is executed asynchronously with respect to the host and can return control to !> the application !> on the host before the entire result is ready. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 11.0+) and will be !> removed in CUDA 12.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the dense matrix \p A. Must be non-negative. !> @param[in] n - number of columns of the dense matrix \p A. Must be non-negative. !> @param[in] descr - the descriptor of the dense matrix \p A, the supported matrix type is !> `HIPSPARSE_MATRIX_TYPE_GENERAL` and !> any valid value of the `hipsparseIndexBase_t`. !> @param[in] csrVal - array of nnz ( = \p csrRowPtr[m] - \p csrRowPtr[0] ) non-zero elements of !> matrix \p A. !> @param[in] csrRowPtr - integer array of \p m+1 elements that contains the start of every row !> and the end of the last row plus one. !> @param[in] csrColInd - integer array of nnz ( = \p csrRowPtr[m] - \p csrRowPtr[0] ) column !> indices of the non-zero elements of matrix \p A. !> @param[out] A - array of dimensions (\p ld, \p n). !> @param[in] ld - leading dimension of dense array \p A. Must be at least \p m. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p descr, \p csrVal, \p csrRowPtr, !> \p csrColInd, or \p A is nullptr, \p m or \p n is negative, or \p ld is invalid. #ifndef USE_CUDA_NAMES interface hipsparseScsr2dense function hipsparseScsr2dense_(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) & bind(c, name="hipsparseScsr2dense") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsr2dense_assumed_rank #else module procedure & hipsparseScsr2dense_rank_0,& hipsparseScsr2dense_rank_1,& hipsparseScsr2dense_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsr2dense function hipsparseDcsr2dense_(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) & bind(c, name="hipsparseDcsr2dense") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsr2dense_assumed_rank #else module procedure & hipsparseDcsr2dense_rank_0,& hipsparseDcsr2dense_rank_1,& hipsparseDcsr2dense_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsr2dense function hipsparseCcsr2dense_(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) & bind(c, name="hipsparseCcsr2dense") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsr2dense_assumed_rank #else module procedure & hipsparseCcsr2dense_rank_0,& hipsparseCcsr2dense_rank_1,& hipsparseCcsr2dense_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsr2dense function hipsparseZcsr2dense_(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) & bind(c, name="hipsparseZcsr2dense") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsr2dense_assumed_rank #else module procedure & hipsparseZcsr2dense_rank_0,& hipsparseZcsr2dense_rank_1,& hipsparseZcsr2dense_full_rank #endif #endif end interface #endif !> \ingroup conv_module !> \brief Convert a sparse CSR matrix into a sparse GEBSR matrix. !> !> \details !> \p hipsparseXcsr2gebsr_bufferSize returns the size of the temporary buffer that !> is required by `hipsparseXcsr2gebsrNnz` and `hipsparseScsr2gebsr` "hipsparseXcsr2gebsr()". !> After the temporary buffer size has been determined, it must be allocated by the user prior !> to calling `hipsparseXcsr2gebsrNnz` and `hipsparseScsr2gebsr` "hipsparseXcsr2gebsr()". !> !> See `hipsparseScsr2gebsr()` for a complete code example. !> !> \note !> The routine supports asynchronous execution if the pointer mode is set to device. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dir - direction that specifies whether to count non-zero elements by !> `HIPSPARSE_DIRECTION_ROW` !> or by `HIPSPARSE_DIRECTION_COLUMN`. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] csr_descr - descriptor of the sparse CSR matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrVal - array of \p nnz elements containing the values of the sparse CSR matrix. !> @param[in] csrRowPtr - integer array containing \p m+1 elements that point to the start of !> each row of the CSR matrix. !> @param[in] csrColInd - integer array of the column indices for each non-zero element in the !> CSR matrix. !> @param[in] rowBlockDim - the row block dimension of the general BSR matrix. Between 1 and \p !> m. !> @param[in] colBlockDim - the col block dimension of the general BSR matrix. Between 1 and \p !> n. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseXcsr2gebsrNnz` () !> and `hipsparseScsr2gebsr` "hipsparseXcsr2gebsr()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p rowBlockDim, \p colBlockDim, !> \p csrVal, !> \p csrRowPtr, \p csrColInd, or \p pBufferSizeInBytes pointer is invalid. interface hipsparseScsr2gebsr_bufferSize #ifdef USE_CUDA_NAMES function hipsparseScsr2gebsr_bufferSize_(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & rowBlockDim,colBlockDim,pBufferSizeInBytes) & bind(c, name="cusparseScsr2gebsr_bufferSize") #else function hipsparseScsr2gebsr_bufferSize_(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & rowBlockDim,colBlockDim,pBufferSizeInBytes) & bind(c, name="hipsparseScsr2gebsr_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2gebsr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsr2gebsr_bufferSize_assumed_rank #else module procedure & hipsparseScsr2gebsr_bufferSize_rank_0,& hipsparseScsr2gebsr_bufferSize_rank_1 #endif #endif end interface interface hipsparseDcsr2gebsr_bufferSize #ifdef USE_CUDA_NAMES function hipsparseDcsr2gebsr_bufferSize_(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & rowBlockDim,colBlockDim,pBufferSizeInBytes) & bind(c, name="cusparseDcsr2gebsr_bufferSize") #else function hipsparseDcsr2gebsr_bufferSize_(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & rowBlockDim,colBlockDim,pBufferSizeInBytes) & bind(c, name="hipsparseDcsr2gebsr_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2gebsr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsr2gebsr_bufferSize_assumed_rank #else module procedure & hipsparseDcsr2gebsr_bufferSize_rank_0,& hipsparseDcsr2gebsr_bufferSize_rank_1 #endif #endif end interface interface hipsparseCcsr2gebsr_bufferSize #ifdef USE_CUDA_NAMES function hipsparseCcsr2gebsr_bufferSize_(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & rowBlockDim,colBlockDim,pBufferSizeInBytes) & bind(c, name="cusparseCcsr2gebsr_bufferSize") #else function hipsparseCcsr2gebsr_bufferSize_(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & rowBlockDim,colBlockDim,pBufferSizeInBytes) & bind(c, name="hipsparseCcsr2gebsr_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2gebsr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsr2gebsr_bufferSize_assumed_rank #else module procedure & hipsparseCcsr2gebsr_bufferSize_rank_0,& hipsparseCcsr2gebsr_bufferSize_rank_1 #endif #endif end interface interface hipsparseZcsr2gebsr_bufferSize #ifdef USE_CUDA_NAMES function hipsparseZcsr2gebsr_bufferSize_(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & rowBlockDim,colBlockDim,pBufferSizeInBytes) & bind(c, name="cusparseZcsr2gebsr_bufferSize") #else function hipsparseZcsr2gebsr_bufferSize_(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & rowBlockDim,colBlockDim,pBufferSizeInBytes) & bind(c, name="hipsparseZcsr2gebsr_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2gebsr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsr2gebsr_bufferSize_assumed_rank #else module procedure & hipsparseZcsr2gebsr_bufferSize_rank_0,& hipsparseZcsr2gebsr_bufferSize_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief !> This function computes the number of non-zero block columns per row and the total number of !> non-zero blocks in a sparse !> GEBSR matrix given a sparse CSR matrix as input. !> !> \details !> This is the second step in converting a CSR matrix to a GEBSR matrix. The user must first !> call !> `hipsparseScsr2gebsr_bufferSize` "hipsparseXcsr2gebsr_bufferSize()" to determine the size of !> the required temporary storage buffer. The user then allocates this buffer as well as the !> \p bsrRowPtr array ( size \p mb+1 ) and passes both to \p `hipsparseXcsr2gebsrNnz()`. This !> second !> step then computes the number of non-zero block columns per row and the total number of !> non-zero blocks. !> !> In general, when converting a CSR matrix of size \p m x \p n to a GEBSR matrix, the resulting !> GEBSR matrix will have size !> \p mb x \p nb, where \p mb and \p nb equal: !> \f[ !> \begin{align} !> \text{mb} &= \text{(m - 1) / rowBlockDim + 1} \\% !> \text{nb} &= \text{(n - 1) / colBlockDim + 1} !> \end{align} !> \f] !> !> For example, given a matrix: !> \f[ !> \begin{bmatrix} !> 1 & 0 & 0 & 2 & 4 & 0 \\% !> 3 & 4 & 0 & 0 & 5 & 1 \\% !> 5 & 0 & 6 & 7 & 6 & 2 !> \end{bmatrix} !> \f] !> !> represented in CSR format with the arrays: !> \f[ !> \begin{align} !> \text{csrRowPtr} &= \begin{bmatrix} 0 & 3 & 7 & 12 \end{bmatrix} \\% !> \text{csrColInd} &= \begin{bmatrix} 0 & 3 & 4 & 0 & 1 & 4 & 5 & 0 & 2 & 3 & 4 & 5 !> \end{bmatrix} \\% !> \text{csrVal} &= \begin{bmatrix} 1 & 2 & 4 & 3 & 4 & 5 & 1 & 5 & 6 & 7 & 6 & 2 !> \end{bmatrix} !> \end{align} !> \f] !> !> the \p bsrRowPtr array and total non-zero block count will be filled with: !> \f[ !> \begin{align} !> \text{bsrRowPtr} &= \begin{bmatrix} 0 & 3 \end{bmatrix} \\% !> \text{*bsrNnzDevhost} &= 3 !> \end{align} !> \f] !> !> after calling \p hipsparseXcsr2gebsrNnz with \p rowBlockDim=3 and \p colBlockDim=2. !> !> \note !> As indicated, \p bsrNnzDevhost can point either to host or device memory. This is controlled !> by setting the pointer mode. See `hipsparseSetPointerMode`(). !> !> It might be the case that \p rowBlockDim does not divide evenly into \p m and/or that \p !> colBlockDim does not divide !> evenly into \p n. In these cases, the CSR matrix is expanded in size to fit full GEBSR !> blocks. For example, !> using the original CSR matrix but this time with \p rowBlockDim=2 and \p colBlockDim=3, the !> function !> \p hipsparseXcsr2gebsrNnz computes the GEBSR row pointer array and total number of non-zero !> blocks for the GEBSR matrix: !> !> \f[ !> \left[ !> \begin{array}{c | c} !> \begin{array}{c c c} !> 1 & 0 & 0 \\% !> 3 & 4 & 0 !> \end{array} & !> \begin{array}{c c c} !> 2 & 4 & 0 \\% !> 0 & 5 & 1 !> \end{array} \\% !> \hline !> \begin{array}{c c c} !> 5 & 0 & 6 \\% !> 0 & 0 & 0 !> \end{array} & !> \begin{array}{c c c} !> 7 & 6 & 2 \\% !> 0 & 0 & 0 !> \end{array} !> \end{array} !> \right] !> \f] !> !> See `hipsparseScsr2gebsr()` for a full code example. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dir - direction that specifies whether to count non-zero elements by !> `HIPSPARSE_DIRECTION_ROW` or by !> `HIPSPARSE_DIRECTION_COLUMN`. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] csr_descr - descriptor of the sparse CSR matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrRowPtr - integer array containing \p m+1 elements that point to the start of !> each row of the CSR matrix. !> @param[in] csrColInd - integer array of the column indices for each non-zero element in the !> CSR matrix. !> @param[in] bsr_descr - descriptor of the sparse general BSR matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[out] bsrRowPtr - integer array containing \p mb+1 elements that point to the start of !> each block row of the general BSR matrix. !> !> @param[in] rowBlockDim - the row block dimension of the general BSR matrix, which is between !> \f$1\f$ and \f$\min(m, n)\f$. !> !> @param[in] colBlockDim - the col block dimension of the general BSR matrix, which is between !> \f$1\f$ and \f$\min(m, n)\f$. !> !> @param[out] bsrNnzDevhost - total number of non-zero elements in device or host memory. !> !> @param[in] pbuffer - buffer allocated by the user whose size is determined by calling !> `hipsparseScsr2gebsr_bufferSize` !> "hipsparseXcsr2gebsr_bufferSize()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p rowBlockDim, \p colBlockDim, !> \p csrRowPtr, !> \p csrColInd, \p bsrRowPtr, or \p bsrNnzDevhost pointer is invalid. interface hipsparseXcsr2gebsrNnz #ifdef USE_CUDA_NAMES function hipsparseXcsr2gebsrNnz_(handle,dir,m,n,csr_descr,csrRowPtr,csrColInd,bsr_descr, & bsrRowPtr,rowBlockDim,colBlockDim,bsrNnzDevhost,pbuffer) & bind(c, name="cusparseXcsr2gebsrNnz") #else function hipsparseXcsr2gebsrNnz_(handle,dir,m,n,csr_descr,csrRowPtr,csrColInd,bsr_descr, & bsrRowPtr,rowBlockDim,colBlockDim,bsrNnzDevhost,pbuffer) & bind(c, name="hipsparseXcsr2gebsrNnz") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsr2gebsrNnz_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsrRowPtr integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim type(c_ptr),value :: bsrNnzDevhost type(c_ptr),value :: pbuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseXcsr2gebsrNnz_assumed_rank #else module procedure & hipsparseXcsr2gebsrNnz_rank_0,& hipsparseXcsr2gebsrNnz_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse CSR matrix into a sparse GEBSR matrix. !> !> \details !> \p hipsparseXcsr2gebsr converts a CSR matrix into a GEBSR matrix. It is assumed !> that \p bsrVal, \p bsrColInd, and \p bsrRowPtr are allocated. Allocation size !> for \p bsrRowPtr is computed as \p mb+1, where \p mb is the number of block rows in !> the GEBSR matrix. The number of non-zero blocks in the resulting GEBSR matrix !> is computed using `hipsparseXcsr2gebsrNnz`, which also fills in \p bsrRowPtr. !> !> In more detail, \p hipsparseXcsr2gebsr is the third and final step of the conversion from CSR !> to GEBSR. !> The user first determines the size of the required user-allocated temporary storage buffer !> using !> `hipsparseScsr2gebsr_bufferSize` "hipsparseXcsr2gebsr_bufferSize()". The user then allocates !> this buffer !> as well as the row pointer array \p bsrRowPtr with size \p mb+1, where \p mb is the number of !> block rows !> in the GEBSR matrix and \p nb is the number of block columns in GEBSR matrix: !> !> \f[ !> \begin{align} !> \text{mb} &= \text{(m - 1) / rowBlockDim + 1} \\% !> \text{nb} &= \text{(n - 1) / colBlockDim + 1} !> \end{align} !> \f] !> !> Both the temporary storage buffer and the GEBSR row pointer array are then passed to !> `hipsparseXcsr2gebsrNnz`, !> which fills the GEBSR row pointer array \p bsrRowPtr and also computes the number of non-zero !> blocks, !> \p bsrNnzDevhost, that will exist in the GEBSR matrix. The user then allocates both the GEBSR !> column indices array !> \p bsrColInd with size \p bsrNnzDevhost as well as the GEBSR values array \p bsrVal with size !> \p bsrNnzDevhost*rowBlockDim*colBlockDim. Finally, with all arrays allocated, the conversion !> is completed by calling !> \p hipsparseXcsr2gebsr. !> !> For example, assuming the matrix: !> \f[ !> \begin{bmatrix} !> 1 & 0 & 0 & 2 & 4 & 0 \\% !> 3 & 4 & 0 & 0 & 5 & 1 \\% !> 5 & 0 & 6 & 7 & 6 & 2 !> \end{bmatrix} !> \f] !> !> represented in CSR format with the arrays: !> \f[ !> \begin{align} !> \text{csrRowPtr} &= \begin{bmatrix} 0 & 3 & 7 & 12 \end{bmatrix} \\% !> \text{csrColInd} &= \begin{bmatrix} 0 & 3 & 4 & 0 & 1 & 4 & 5 & 0 & 2 & 3 & 4 & 5 !> \end{bmatrix} \\% !> \text{csrVal} &= \begin{bmatrix} 1 & 2 & 4 & 3 & 4 & 5 & 1 & 5 & 6 & 7 & 6 & 2 !> \end{bmatrix} !> \end{align} !> \f] !> !> then using \p rowBlockDim=3 and \p colBlockDim=2, the final GEBSR matrix is: !> \f[ !> \left[ !> \begin{array}{c | c} !> \begin{array}{c c} !> 1 & 0 \\% !> 3 & 4 \\% !> 3 & 0 !> \end{array} & !> \begin{array}{c c} !> 0 & 2 \\% !> 0 & 0 \\% !> 6 & 7 !> \end{array} & !> \begin{array}{c c} !> 4 & 0 \\% !> 5 & 1 \\% !> 6 & 2 !> \end{array} !> \end{array} !> \right] !> \f] !> !> and is represented with the arrays: !> \f[ !> \begin{align} !> \text{bsrRowPtr} &= \begin{bmatrix} 0 & 3 \end{bmatrix} \\% !> \text{bsrColInd} &= \begin{bmatrix} 0 & 1 & 2 \end{bmatrix} \\% !> \text{bsrVal} &= \begin{bmatrix} 1 & 0 & 3 & 4 & 3 & 0 & 0 & 2 & 0 & 0 & 6 & 7 & 4 & 0 & 5 !> & 1 & 6 & 2 \end{bmatrix} !> \end{align} !> \f] !> !> The above example assumes that the blocks are row ordered. If instead the blocks are column !> ordered, the \p bsrVal arrays !> become: !> \f[ !> \begin{align} !> \text{bsrVal} &= \begin{bmatrix} 1 & 3 & 3 & 0 & 4 & 0 & 0 & 0 & 6 & 2 & 0 & 7 & 4 & 5 & 6 !> & 0 & 1 & 2 \end{bmatrix} !> \end{align} !> \f] !> !> The block order direction is determined by \p dir. !> !> It might be the case that \p rowBlockDim does not divide evenly into \p m and/or that \p !> colBlockDim does not divide !> evenly into \p n. In these cases, the CSR matrix is expanded in size to fit full GEBSR !> blocks. For example, !> using the original CSR matrix but this time with \p rowBlockDim=2 and \p colBlockDim=3, the !> resulting GEBSR matrix !> would look like: !> !> \f[ !> \left[ !> \begin{array}{c | c} !> \begin{array}{c c c} !> 1 & 0 & 0 \\% !> 3 & 4 & 0 !> \end{array} & !> \begin{array}{c c c} !> 2 & 4 & 0 \\% !> 0 & 5 & 1 !> \end{array} \\% !> \hline !> \begin{array}{c c c} !> 5 & 0 & 6 \\% !> 0 & 0 & 0 !> \end{array} & !> \begin{array}{c c c} !> 7 & 6 & 2 \\% !> 0 & 0 & 0 !> \end{array} !> \end{array} !> \right] !> \f] !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dir - the storage format of the blocks, `HIPSPARSE_DIRECTION_ROW` or !> `HIPSPARSE_DIRECTION_COLUMN`. !> @param[in] m - number of rows in the sparse CSR matrix. !> @param[in] n - number of columns in the sparse CSR matrix. !> @param[in] csr_descr - descriptor of the sparse CSR matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrVal - array of \p nnz elements containing the values of the sparse CSR matrix. !> @param[in] csrRowPtr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csrColInd - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[in] bsr_descr - descriptor of the sparse BSR matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[out] bsrVal - array of \p nnzb* \p rowBlockDim* \p colBlockDim containing the values !> of the sparse BSR matrix. !> @param[out] bsrRowPtr - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse BSR matrix. !> @param[out] bsrColInd - array of \p nnzb elements containing the block column indices of the !> sparse BSR matrix. !> @param[in] rowBlockDim - row size of the blocks in the sparse general BSR matrix. !> @param[in] colBlockDim - col size of the blocks in the sparse general BSR matrix. !> @param[in] pbuffer - buffer allocated by the user. The buffer size is determined by calling !> `hipsparseScsr2gebsr_bufferSize` !> "hipsparseXcsr2gebsr_bufferSize()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p rowBlockDim, \p colBlockDim, !> \p bsrVal, !> \p bsrRowPtr, \p bsrColInd, \p csrVal, \p csrRowPtr, or \p csrColInd pointer is !> invalid. interface hipsparseScsr2gebsr #ifdef USE_CUDA_NAMES function hipsparseScsr2gebsr_(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd,bsr_descr, & bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) & bind(c, name="cusparseScsr2gebsr") #else function hipsparseScsr2gebsr_(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd,bsr_descr, & bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) & bind(c, name="hipsparseScsr2gebsr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2gebsr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsrVal type(c_ptr),value :: bsrRowPtr type(c_ptr),value :: bsrColInd integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim type(c_ptr),value :: pbuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsr2gebsr_assumed_rank #else module procedure & hipsparseScsr2gebsr_rank_0,& hipsparseScsr2gebsr_rank_1 #endif #endif end interface interface hipsparseDcsr2gebsr #ifdef USE_CUDA_NAMES function hipsparseDcsr2gebsr_(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd,bsr_descr, & bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) & bind(c, name="cusparseDcsr2gebsr") #else function hipsparseDcsr2gebsr_(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd,bsr_descr, & bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) & bind(c, name="hipsparseDcsr2gebsr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2gebsr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsrVal type(c_ptr),value :: bsrRowPtr type(c_ptr),value :: bsrColInd integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim type(c_ptr),value :: pbuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsr2gebsr_assumed_rank #else module procedure & hipsparseDcsr2gebsr_rank_0,& hipsparseDcsr2gebsr_rank_1 #endif #endif end interface interface hipsparseCcsr2gebsr #ifdef USE_CUDA_NAMES function hipsparseCcsr2gebsr_(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd,bsr_descr, & bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) & bind(c, name="cusparseCcsr2gebsr") #else function hipsparseCcsr2gebsr_(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd,bsr_descr, & bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) & bind(c, name="hipsparseCcsr2gebsr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2gebsr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsrVal type(c_ptr),value :: bsrRowPtr type(c_ptr),value :: bsrColInd integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim type(c_ptr),value :: pbuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsr2gebsr_assumed_rank #else module procedure & hipsparseCcsr2gebsr_rank_0,& hipsparseCcsr2gebsr_rank_1 #endif #endif end interface interface hipsparseZcsr2gebsr #ifdef USE_CUDA_NAMES function hipsparseZcsr2gebsr_(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd,bsr_descr, & bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) & bind(c, name="cusparseZcsr2gebsr") #else function hipsparseZcsr2gebsr_(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd,bsr_descr, & bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) & bind(c, name="hipsparseZcsr2gebsr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2gebsr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsrVal type(c_ptr),value :: bsrRowPtr type(c_ptr),value :: bsrColInd integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim type(c_ptr),value :: pbuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsr2gebsr_assumed_rank #else module procedure & hipsparseZcsr2gebsr_rank_0,& hipsparseZcsr2gebsr_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse CSR matrix into a sparse HYB matrix. !> !> \details !> \p hipsparseXcsr2hyb converts a CSR matrix into a HYB matrix. It is assumed !> that \p hyb has been initialized with `hipsparseCreateHybMat`(). !> !> \note !> This function requires a significant amount of storage for the HYB matrix, !> depending on the matrix structure. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 10.0+) and will be !> removed in CUDA 11.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix, which must be non-negative. !> @param[in] n - number of columns of the sparse CSR matrix, which must be non-negative. !> @param[in] descrA - descriptor of the sparse CSR matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrSortedValA - array containing the values of the sparse CSR matrix. !> @param[in] csrSortedRowPtrA - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix. !> @param[in] csrSortedColIndA - array containing the column indices of the sparse CSR matrix. !> @param[out] hybA - sparse matrix in HYB format. !> @param[in] userEllWidth - width of the ELL part of the HYB matrix (only required if !> \p partitionType == `HIPSPARSE_HYB_PARTITION_USER`). Must be non-negative. !> @param[in] partitionType - `HIPSPARSE_HYB_PARTITION_AUTO` (recommended), !> `HIPSPARSE_HYB_PARTITION_USER`, or !> `HIPSPARSE_HYB_PARTITION_MAX`. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p descrA, \p hybA, \p csrSortedValA, !> \p csrSortedRowPtrA, or \p csrSortedColIndA is nullptr, \p m or \p n is negative, or !> \p userEllWidth or \p partitionType is invalid. !> \retval HIPSPARSE_STATUS_ALLOC_FAILED the buffer for the HYB matrix could not be allocated. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED `hipsparseMatrixType_t` != !> `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseScsr2hyb function hipsparseScsr2hyb_(handle,m,n,descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA, & hybA,userEllWidth,partitionType) & bind(c, name="hipsparseScsr2hyb") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2hyb_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: hybA integer(c_int),value :: userEllWidth integer(kind(HIPSPARSE_HYB_PARTITION_AUTO)),value :: partitionType end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsr2hyb_assumed_rank #else module procedure & hipsparseScsr2hyb_rank_0,& hipsparseScsr2hyb_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDcsr2hyb function hipsparseDcsr2hyb_(handle,m,n,descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA, & hybA,userEllWidth,partitionType) & bind(c, name="hipsparseDcsr2hyb") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2hyb_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: hybA integer(c_int),value :: userEllWidth integer(kind(HIPSPARSE_HYB_PARTITION_AUTO)),value :: partitionType end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsr2hyb_assumed_rank #else module procedure & hipsparseDcsr2hyb_rank_0,& hipsparseDcsr2hyb_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCcsr2hyb function hipsparseCcsr2hyb_(handle,m,n,descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA, & hybA,userEllWidth,partitionType) & bind(c, name="hipsparseCcsr2hyb") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2hyb_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: hybA integer(c_int),value :: userEllWidth integer(kind(HIPSPARSE_HYB_PARTITION_AUTO)),value :: partitionType end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsr2hyb_assumed_rank #else module procedure & hipsparseCcsr2hyb_rank_0,& hipsparseCcsr2hyb_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZcsr2hyb function hipsparseZcsr2hyb_(handle,m,n,descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA, & hybA,userEllWidth,partitionType) & bind(c, name="hipsparseZcsr2hyb") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2hyb_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descrA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA type(c_ptr),value :: hybA integer(c_int),value :: userEllWidth integer(kind(HIPSPARSE_HYB_PARTITION_AUTO)),value :: partitionType end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsr2hyb_assumed_rank #else module procedure & hipsparseZcsr2hyb_rank_0,& hipsparseZcsr2hyb_rank_1 #endif #endif end interface #endif !> \ingroup conv_module !> \brief Sort a sparse CSR matrix. !> !> \details !> \p hipsparseXcsrsort_bufferSizeExt returns the size of the temporary storage buffer !> in bytes required by `hipsparseXcsrsort()`. The temporary storage buffer must be allocated by !> the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] csrRowPtr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csrColInd - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseXcsrsort`(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p nnz, \p csrRowPtr, \p !> csrColInd, or !> \p pBufferSizeInBytes pointer is invalid. interface hipsparseXcsrsort_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseXcsrsort_bufferSizeExt_(handle,m,n,nnz,csrRowPtr,csrColInd, & pBufferSizeInBytes) & bind(c, name="cusparseXcsrsort_bufferSizeExt") #else function hipsparseXcsrsort_bufferSizeExt_(handle,m,n,nnz,csrRowPtr,csrColInd, & pBufferSizeInBytes) & bind(c, name="hipsparseXcsrsort_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrsort_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseXcsrsort_bufferSizeExt_assumed_rank #else module procedure & hipsparseXcsrsort_bufferSizeExt_rank_0,& hipsparseXcsrsort_bufferSizeExt_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Sort a sparse CSR matrix. !> !> \details !> \p hipsparseXcsrsort sorts a matrix in CSR format. The sorted permutation vector !> \p P can be used to obtain the sorted \p csrVal array. In this case, \p P must be !> initialized as the identity permutation. See `hipsparseCreateIdentityPermutation`(). To !> apply the permutation vector to the CSR values, see `hipsparseSgthr` !> "hipsparseXgthr()". !> !> \p hipsparseXcsrsort requires extra temporary storage buffer that must be allocated by !> the user. The storage buffer size can be determined by `hipsparseXcsrsort_bufferSizeExt()`. !> !> \note !> \p P can be \p NULL if a sorted permutation vector is not required. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descrA - descriptor of the sparse CSR matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrRowPtr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[inout] csrColInd - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix. !> @param[inout] P - array of \p nnz integers containing the unsorted map indices. Can be !> \p NULL. !> @param[in] pBuffer - temporary storage buffer allocated by the user. The size is returned by !> `hipsparseXcsrsort_bufferSizeExt`(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p nnz, \p descrA, \p !> csrRowPtr, !> \p csrColInd, or \p pBuffer pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED !> `hipsparseMatrixType_t` != `HIPSPARSE_MATRIX_TYPE_GENERAL`. interface hipsparseXcsrsort #ifdef USE_CUDA_NAMES function hipsparseXcsrsort_(handle,m,n,nnz,descrA,csrRowPtr,csrColInd,P,pBuffer) & bind(c, name="cusparseXcsrsort") #else function hipsparseXcsrsort_(handle,m,n,nnz,descrA,csrRowPtr,csrColInd,P,pBuffer) & bind(c, name="hipsparseXcsrsort") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrsort_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: P type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseXcsrsort_assumed_rank #else module procedure & hipsparseXcsrsort_rank_0,& hipsparseXcsrsort_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief !> This function calculates the amount of temporary storage in bytes required for !> \p hipsparseXcsru2csr() and \p hipsparseXcsr2csru(). interface hipsparseScsru2csr_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseScsru2csr_bufferSizeExt_(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd,myInfo, & pBufferSizeInBytes) & bind(c, name="cusparseScsru2csr_bufferSizeExt") #else function hipsparseScsru2csr_bufferSizeExt_(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd,myInfo, & pBufferSizeInBytes) & bind(c, name="hipsparseScsru2csr_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsru2csr_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsru2csr_bufferSizeExt_assumed_rank #else module procedure & hipsparseScsru2csr_bufferSizeExt_rank_0,& hipsparseScsru2csr_bufferSizeExt_rank_1 #endif #endif end interface interface hipsparseDcsru2csr_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseDcsru2csr_bufferSizeExt_(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd,myInfo, & pBufferSizeInBytes) & bind(c, name="cusparseDcsru2csr_bufferSizeExt") #else function hipsparseDcsru2csr_bufferSizeExt_(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd,myInfo, & pBufferSizeInBytes) & bind(c, name="hipsparseDcsru2csr_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsru2csr_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsru2csr_bufferSizeExt_assumed_rank #else module procedure & hipsparseDcsru2csr_bufferSizeExt_rank_0,& hipsparseDcsru2csr_bufferSizeExt_rank_1 #endif #endif end interface interface hipsparseCcsru2csr_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseCcsru2csr_bufferSizeExt_(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd,myInfo, & pBufferSizeInBytes) & bind(c, name="cusparseCcsru2csr_bufferSizeExt") #else function hipsparseCcsru2csr_bufferSizeExt_(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd,myInfo, & pBufferSizeInBytes) & bind(c, name="hipsparseCcsru2csr_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsru2csr_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsru2csr_bufferSizeExt_assumed_rank #else module procedure & hipsparseCcsru2csr_bufferSizeExt_rank_0,& hipsparseCcsru2csr_bufferSizeExt_rank_1 #endif #endif end interface interface hipsparseZcsru2csr_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseZcsru2csr_bufferSizeExt_(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd,myInfo, & pBufferSizeInBytes) & bind(c, name="cusparseZcsru2csr_bufferSizeExt") #else function hipsparseZcsru2csr_bufferSizeExt_(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd,myInfo, & pBufferSizeInBytes) & bind(c, name="hipsparseZcsru2csr_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsru2csr_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsru2csr_bufferSizeExt_assumed_rank #else module procedure & hipsparseZcsru2csr_bufferSizeExt_rank_0,& hipsparseZcsru2csr_bufferSizeExt_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief !> This function converts the unsorted CSR format to the sorted CSR format. The required !> temporary storage has to be allocated by the user. interface hipsparseScsru2csr #ifdef USE_CUDA_NAMES function hipsparseScsru2csr_(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo,pBuffer) & bind(c, name="cusparseScsru2csr") #else function hipsparseScsru2csr_(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo,pBuffer) & bind(c, name="hipsparseScsru2csr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsru2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: myInfo type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsru2csr_assumed_rank #else module procedure & hipsparseScsru2csr_rank_0,& hipsparseScsru2csr_rank_1 #endif #endif end interface interface hipsparseDcsru2csr #ifdef USE_CUDA_NAMES function hipsparseDcsru2csr_(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo,pBuffer) & bind(c, name="cusparseDcsru2csr") #else function hipsparseDcsru2csr_(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo,pBuffer) & bind(c, name="hipsparseDcsru2csr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsru2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: myInfo type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsru2csr_assumed_rank #else module procedure & hipsparseDcsru2csr_rank_0,& hipsparseDcsru2csr_rank_1 #endif #endif end interface interface hipsparseCcsru2csr #ifdef USE_CUDA_NAMES function hipsparseCcsru2csr_(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo,pBuffer) & bind(c, name="cusparseCcsru2csr") #else function hipsparseCcsru2csr_(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo,pBuffer) & bind(c, name="hipsparseCcsru2csr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsru2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: myInfo type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsru2csr_assumed_rank #else module procedure & hipsparseCcsru2csr_rank_0,& hipsparseCcsru2csr_rank_1 #endif #endif end interface interface hipsparseZcsru2csr #ifdef USE_CUDA_NAMES function hipsparseZcsru2csr_(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo,pBuffer) & bind(c, name="cusparseZcsru2csr") #else function hipsparseZcsru2csr_(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo,pBuffer) & bind(c, name="hipsparseZcsru2csr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsru2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: myInfo type(c_ptr),value :: pBuffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsru2csr_assumed_rank #else module procedure & hipsparseZcsru2csr_rank_0,& hipsparseZcsru2csr_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief !> \p hipsparseXdense2csc functions convert the matrix \p A in dense format into a sparse matrix !> in CSC format. !> !> \details !> Given a dense, column-ordered, matrix \p A with leading dimension \p ld, where \p ld>=m, !> \p hipsparseXdense2csc converts the matrix to a sparse CSC format matrix. !> All the parameters are assumed to have been preallocated by the user and the arrays !> are filled in based on number of non-zeros per row, which can be pre-computed with !> `hipsparseSnnz` "hipsparseXnnz()". Users can set the desired index base in the output CSC !> matrix by setting it in the `hipsparseMatDescr_t`. See `hipsparseSetMatIndexBase`(). !> !> As an example, if using index base zero (that is, the default) and the dense !> matrix: !> !> \f[ !> \begin{bmatrix} !> 1 & 0 & 0 & 2 \\% !> 3 & 4 & 0 & 0 \\% !> 5 & 0 & 6 & 7 !> \end{bmatrix} !> \f] !> !> where the \p A values have column ordering with leading dimension \p ld=m: !> \f[ !> \text{A} &= \begin{bmatrix} 1 & 3 & 5 & 0 & 4 & 0 & 0 & 0 & 6 & 2 & 0 & 7 \end{bmatrix} \\% !> \f] !> !> the conversion results in the CSC arrays: !> !> \f[ !> \begin{align} !> \text{cscRowInd} &= \begin{bmatrix} 0 & 1 & 2 & 1 & 2 & 0 & 2 \end{bmatrix} \\% !> \text{cscColPtr} &= \begin{bmatrix} 0 & 3 & 4 & 5 & 7 \end{bmatrix} \\% !> \text{cscVal} &= \begin{bmatrix} 1 & 3 & 5 & 4 & 6 & 2 & 7 \end{bmatrix} \\% !> \end{align} !> \f] !> !> This function works very similar to `hipsparseSdense2csr` "hipsparseXdense2csr()". !> See `hipsparseSdense2csr()` for a code example. !> !> \note !> This function is executed asynchronously with respect to the host and can return control to !> the !> application on the host before the entire result is ready. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 11.0+) and will be !> removed in CUDA 12.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the dense matrix \p A. Must be non-negative. !> @param[in] n - number of columns of the dense matrix \p A. Must be non-negative. !> @param[in] descr - the descriptor of the dense matrix \p A. The supported matrix type is !> `HIPSPARSE_MATRIX_TYPE_GENERAL` and !> any valid value of the `hipsparseIndexBase_t`. !> @param[in] A - array of dimensions (\p ld, \p n). !> @param[in] ld - leading dimension of dense array \p A. Must be at least \p m. !> @param[in] nnzPerColumn - array of size \p n containing the number of non-zero elements per !> column. !> @param[out] cscVal - array of nnz ( = \p cscColPtr[n] - \p cscColPtr[0] ) nonzero elements of !> matrix \p A. !> @param[out] cscRowInd - integer array of nnz ( = \p cscColPtr[n] - \p cscColPtr[0] ) column !> indices of the non-zero elements of matrix \p A. !> @param[out] cscColPtr - integer array of \p n+1 elements that contains the start of every !> column and the end of the last column plus one. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p descr, \p A, \p nnzPerColumn, \p cscVal, !> \p cscColPtr, or \p cscRowInd is nullptr, \p m or \p n is negative, or \p ld is !> invalid. #ifndef USE_CUDA_NAMES interface hipsparseSdense2csc function hipsparseSdense2csc_(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd,cscColPtr) & bind(c, name="hipsparseSdense2csc") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSdense2csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnzPerColumn type(c_ptr),value :: cscVal type(c_ptr),value :: cscRowInd type(c_ptr),value :: cscColPtr end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSdense2csc_assumed_rank #else module procedure & hipsparseSdense2csc_rank_0,& hipsparseSdense2csc_rank_1,& hipsparseSdense2csc_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDdense2csc function hipsparseDdense2csc_(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd,cscColPtr) & bind(c, name="hipsparseDdense2csc") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDdense2csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnzPerColumn type(c_ptr),value :: cscVal type(c_ptr),value :: cscRowInd type(c_ptr),value :: cscColPtr end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDdense2csc_assumed_rank #else module procedure & hipsparseDdense2csc_rank_0,& hipsparseDdense2csc_rank_1,& hipsparseDdense2csc_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCdense2csc function hipsparseCdense2csc_(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd,cscColPtr) & bind(c, name="hipsparseCdense2csc") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCdense2csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnzPerColumn type(c_ptr),value :: cscVal type(c_ptr),value :: cscRowInd type(c_ptr),value :: cscColPtr end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCdense2csc_assumed_rank #else module procedure & hipsparseCdense2csc_rank_0,& hipsparseCdense2csc_rank_1,& hipsparseCdense2csc_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZdense2csc function hipsparseZdense2csc_(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd,cscColPtr) & bind(c, name="hipsparseZdense2csc") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZdense2csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnzPerColumn type(c_ptr),value :: cscVal type(c_ptr),value :: cscRowInd type(c_ptr),value :: cscColPtr end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZdense2csc_assumed_rank #else module procedure & hipsparseZdense2csc_rank_0,& hipsparseZdense2csc_rank_1,& hipsparseZdense2csc_full_rank #endif #endif end interface #endif !> \ingroup conv_module !> \brief !> \p hipsparseXdense2csr converts the matrix \p A in dense format into a sparse matrix in CSR !> format. !> !> \details !> Given a dense, column-ordered matrix \p A with leading dimension \p ld where \p ld>=m, !> \p hipsparseXdense2csr converts the matrix to a sparse CSR format matrix. All the parameters !> are assumed to have been pre-allocated by the user and the arrays are filled in based on the !> number !> of non-zeros per row, which can be pre-computed with `hipsparseSnnz` "hipsparseXnnz()". The !> desired index base in the output CSR matrix is set in the `hipsparseMatDescr_t`. See !> `hipsparseSetMatIndexBase`(). !> !> As an example, if using index base zero (which is the default) and the dense !> matrix: !> !> \f[ !> \begin{bmatrix} !> 1 & 0 & 0 & 2 \\% !> 3 & 4 & 0 & 0 \\% !> 5 & 0 & 6 & 7 !> \end{bmatrix} !> \f] !> !> The conversion results in the CSR arrays: !> !> \f[ !> \begin{align} !> \text{csrRowPtr} &= \begin{bmatrix} 0 & 2 & 4 & 7 \end{bmatrix} \\% !> \text{csrColInd} &= \begin{bmatrix} 0 & 3 & 0 & 1 & 0 & 2 & 3 \end{bmatrix} \\% !> \text{csrVal} &= \begin{bmatrix} 1 & 2 & 3 & 4 & 5 & 6 & 7 \end{bmatrix} \\% !> \end{align} !> \f] !> !> \note !> This function is executed asynchronously with respect to the host and can return control to !> the !> application on the host before the entire result is ready. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the dense matrix \p A. Must be non-negative. !> @param[in] n - number of columns of the dense matrix \p A. Must be non-negative. !> @param[in] descr - the descriptor of the dense matrix \p A. The supported matrix type is !> `HIPSPARSE_MATRIX_TYPE_GENERAL` and !> any valid value of the `hipsparseIndexBase_t`. !> @param[in] A - array of dimensions (\p ld, \p n). !> @param[in] ld - leading dimension of dense array \p A, which must be at least \p m. !> @param[in] nnzPerRow - array of size \p m containing the number of non-zero elements per row. !> @param[out] csrVal - array of nnz ( = \p csrRowPtr[m] - \p csrRowPtr[0] ) non-zero elements !> of matrix \p A. !> @param[out] csrRowPtr - integer array of \p m+1 elements that contains the start of every row !> and the end of the last row plus one. !> @param[out] csrColInd - integer array of nnz ( = \p csrRowPtr[m] - \p csrRowPtr[0] ) column !> indices of the non-zero elements of matrix \p A. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p descr, \p A, \p nnzPerRow, \p csrVal, !> \p csrRowPtr, or \p csrColInd is nullptr, \p m or \p n is negative, or \p ld is !> invalid. #ifndef USE_CUDA_NAMES interface hipsparseSdense2csr function hipsparseSdense2csr_(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr,csrColInd) & bind(c, name="hipsparseSdense2csr") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSdense2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnzPerRow type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSdense2csr_assumed_rank #else module procedure & hipsparseSdense2csr_rank_0,& hipsparseSdense2csr_rank_1,& hipsparseSdense2csr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDdense2csr function hipsparseDdense2csr_(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr,csrColInd) & bind(c, name="hipsparseDdense2csr") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDdense2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnzPerRow type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDdense2csr_assumed_rank #else module procedure & hipsparseDdense2csr_rank_0,& hipsparseDdense2csr_rank_1,& hipsparseDdense2csr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseCdense2csr function hipsparseCdense2csr_(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr,csrColInd) & bind(c, name="hipsparseCdense2csr") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCdense2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnzPerRow type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCdense2csr_assumed_rank #else module procedure & hipsparseCdense2csr_rank_0,& hipsparseCdense2csr_rank_1,& hipsparseCdense2csr_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZdense2csr function hipsparseZdense2csr_(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr,csrColInd) & bind(c, name="hipsparseZdense2csr") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZdense2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnzPerRow type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZdense2csr_assumed_rank #else module procedure & hipsparseZdense2csr_rank_0,& hipsparseZdense2csr_rank_1,& hipsparseZdense2csr_full_rank #endif #endif end interface #endif !> \ingroup conv_module !> \brief Convert a sparse GEBSR matrix into a sparse CSR matrix. !> !> \details !> \p hipsparseXgebsr2csr converts a GEBSR matrix into a CSR matrix. It is assumed !> that \p csrValC, \p csrColIndC, and \p csrRowPtrC are already allocated prior to !> calling \p hipsparseXgebsr2csr. Allocation size for \p csrRowPtrC equals !> \p m+1 where: !> !> \f[ !> \begin{align} !> \text{m} &= \text{mb * rowBlockDim} \\% !> \text{n} &= \text{nb * colBlockDim} !> \end{align} !> \f] !> !> Allocation size for \p csrValC and \p csrColIndC is computed by the the number of blocks in !> the GEBSR !> matrix, \p nnzb, multiplied by the product of the block dimensions, that is, \p !> nnz=nnzb*rocBlockDim*colBlockDim. !> !> For example, given the GEBSR matrix: !> \f[ !> \left[ !> \begin{array}{c | c | c} !> \begin{array}{c c} !> 6 & 2 \\% !> 1 & 4 \\% !> 5 & 4 !> \end{array} & !> \begin{array}{c c} !> 0 & 3 \\% !> 5 & 0 \\% !> 0 & 7 !> \end{array} & !> \begin{array}{c c} !> 0 & 0 \\% !> 0 & 0 \\% !> 0 & 0 !> \end{array} \\% !> \hline !> \begin{array}{c c} !> 0 & 0 \\% !> 0 & 0 \\% !> 0 & 0 !> \end{array} & !> \begin{array}{c c} !> 3 & 0 \\% !> 0 & 0 \\% !> 0 & 7 !> \end{array} & !> \begin{array}{c c} !> 2 & 2 \\% !> 4 & 3 \\% !> 1 & 4 !> \end{array} \\% !> \end{array} !> \right] !> \f] !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - the storage format of the blocks, `HIPSPARSE_DIRECTION_ROW` or !> `HIPSPARSE_DIRECTION_COLUMN`. !> @param[in] mb - number of block rows in the sparse general BSR matrix. !> @param[in] nb - number of block columns in the sparse general BSR matrix. !> @param[in] descrA - descriptor of the sparse general BSR matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] bsrValA - array of \p nnzb*rowBlockDim*colBlockDim containing the values of the !> sparse BSR matrix. !> @param[in] bsrRowPtrA - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse BSR matrix. !> @param[in] bsrColIndA - array of \p nnzb elements containing the block column indices of the !> sparse BSR matrix. !> @param[in] rowBlockDim - row size of the blocks in the sparse general BSR matrix. !> @param[in] colBlockDim - column size of the blocks in the sparse general BSR matrix. !> @param[in] descrC - descriptor of the sparse CSR matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[out] csrValC - array of \p nnzb*rowBlockDim*colBlockDim elements containing the values !> of the sparse CSR matrix. !> @param[out] csrRowPtrC - array of \p m+1 where \p m=mb*rowBlockDim elements that point to the !> start of every row of the !> sparse CSR matrix. !> @param[out] csrColIndC - array of \p nnzb*block_dim*block_dim elements containing the column !> indices of the sparse CSR matrix. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p mb, \p nb, \p block_dim, \p bsrValA, !> \p bsrRowPtrA, \p bsrColIndA, \p csrValC, \p csrRowPtrC, or \p csrColIndC pointer !> is invalid. interface hipsparseSgebsr2csr #ifdef USE_CUDA_NAMES function hipsparseSgebsr2csr_(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="cusparseSgebsr2csr") #else function hipsparseSgebsr2csr_(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="hipsparseSgebsr2csr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgebsr2csr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSgebsr2csr_assumed_rank #else module procedure & hipsparseSgebsr2csr_rank_0,& hipsparseSgebsr2csr_rank_1 #endif #endif end interface interface hipsparseDgebsr2csr #ifdef USE_CUDA_NAMES function hipsparseDgebsr2csr_(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="cusparseDgebsr2csr") #else function hipsparseDgebsr2csr_(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="hipsparseDgebsr2csr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgebsr2csr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDgebsr2csr_assumed_rank #else module procedure & hipsparseDgebsr2csr_rank_0,& hipsparseDgebsr2csr_rank_1 #endif #endif end interface interface hipsparseCgebsr2csr #ifdef USE_CUDA_NAMES function hipsparseCgebsr2csr_(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="cusparseCgebsr2csr") #else function hipsparseCgebsr2csr_(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="hipsparseCgebsr2csr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgebsr2csr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCgebsr2csr_assumed_rank #else module procedure & hipsparseCgebsr2csr_rank_0,& hipsparseCgebsr2csr_rank_1 #endif #endif end interface interface hipsparseZgebsr2csr #ifdef USE_CUDA_NAMES function hipsparseZgebsr2csr_(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="cusparseZgebsr2csr") #else function hipsparseZgebsr2csr_(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) & bind(c, name="hipsparseZgebsr2csr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgebsr2csr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZgebsr2csr_assumed_rank #else module procedure & hipsparseZgebsr2csr_rank_0,& hipsparseZgebsr2csr_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse GEBSR matrix into a sparse GEBSC matrix. !> !> \details !> \p hipsparseXgebsr2gebsc_bufferSize returns the size of the temporary storage buffer !> required by `hipsparseSgebsr2gebsc` "hipsparseXgebsr2gebsc()". This is the first step !> in converting a sparse matrix in GEBSR format to a sparse matrix in GEBSC format. After !> the size of the temporary storage buffer has been determined, it must be allocated by the !> user. !> !> See `hipsparseSgebsr2gebsc()` for a complete code example. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] mb - number of rows of the sparse General BSR matrix. !> @param[in] nb - number of columns of the sparse General BSR matrix. !> @param[in] nnzb - number of non-zero entries of the sparse General BSR matrix. !> @param[in] bsrVal - array of \p nnzb*rowBlockDim*colBlockDim containing the values of the !> sparse General !> BSR matrix. !> @param[in] bsrRowPtr - array of \p mb+1 elements that point to the start of every row of the !> sparse General BSR matrix. !> @param[in] bsrColInd - array of \p nnzb elements containing the column indices of the sparse !> General BSR matrix. !> @param[in] rowBlockDim - row size of the blocks in the sparse General BSR matrix. !> @param[in] colBlockDim - column size of the blocks in the sparse General BSR matrix. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseSgebsr2gebsc()`, hipsparseDgebsr2gebsc(), !> hipsparseCgebsr2gebsc(), and !> hipsparseZgebsr2gebsc(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p mb, \p nb, \p nnzb, \p bsrRowPtr, \p !> bsrColInd, !> or \p pBufferSizeInBytes pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface hipsparseSgebsr2gebsc_bufferSize #ifdef USE_CUDA_NAMES function hipsparseSgebsr2gebsc_bufferSize_(handle,mb,nb,nnzb,bsrVal,bsrRowPtr,bsrColInd, & rowBlockDim,colBlockDim,pBufferSizeInBytes) & bind(c, name="cusparseSgebsr2gebsc_bufferSize") #else function hipsparseSgebsr2gebsc_bufferSize_(handle,mb,nb,nnzb,bsrVal,bsrRowPtr,bsrColInd, & rowBlockDim,colBlockDim,pBufferSizeInBytes) & bind(c, name="hipsparseSgebsr2gebsc_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgebsr2gebsc_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: bsrVal type(c_ptr),value :: bsrRowPtr type(c_ptr),value :: bsrColInd integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes end function end interface interface hipsparseDgebsr2gebsc_bufferSize #ifdef USE_CUDA_NAMES function hipsparseDgebsr2gebsc_bufferSize_(handle,mb,nb,nnzb,bsrVal,bsrRowPtr,bsrColInd, & rowBlockDim,colBlockDim,pBufferSizeInBytes) & bind(c, name="cusparseDgebsr2gebsc_bufferSize") #else function hipsparseDgebsr2gebsc_bufferSize_(handle,mb,nb,nnzb,bsrVal,bsrRowPtr,bsrColInd, & rowBlockDim,colBlockDim,pBufferSizeInBytes) & bind(c, name="hipsparseDgebsr2gebsc_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgebsr2gebsc_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: bsrVal type(c_ptr),value :: bsrRowPtr type(c_ptr),value :: bsrColInd integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes end function end interface interface hipsparseCgebsr2gebsc_bufferSize #ifdef USE_CUDA_NAMES function hipsparseCgebsr2gebsc_bufferSize_(handle,mb,nb,nnzb,bsrVal,bsrRowPtr,bsrColInd, & rowBlockDim,colBlockDim,pBufferSizeInBytes) & bind(c, name="cusparseCgebsr2gebsc_bufferSize") #else function hipsparseCgebsr2gebsc_bufferSize_(handle,mb,nb,nnzb,bsrVal,bsrRowPtr,bsrColInd, & rowBlockDim,colBlockDim,pBufferSizeInBytes) & bind(c, name="hipsparseCgebsr2gebsc_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgebsr2gebsc_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: bsrVal type(c_ptr),value :: bsrRowPtr type(c_ptr),value :: bsrColInd integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes end function end interface interface hipsparseZgebsr2gebsc_bufferSize #ifdef USE_CUDA_NAMES function hipsparseZgebsr2gebsc_bufferSize_(handle,mb,nb,nnzb,bsrVal,bsrRowPtr,bsrColInd, & rowBlockDim,colBlockDim,pBufferSizeInBytes) & bind(c, name="cusparseZgebsr2gebsc_bufferSize") #else function hipsparseZgebsr2gebsc_bufferSize_(handle,mb,nb,nnzb,bsrVal,bsrRowPtr,bsrColInd, & rowBlockDim,colBlockDim,pBufferSizeInBytes) & bind(c, name="hipsparseZgebsr2gebsc_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgebsr2gebsc_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: bsrVal type(c_ptr),value :: bsrRowPtr type(c_ptr),value :: bsrColInd integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes end function end interface !> \ingroup conv_module !> \brief Convert a sparse GEBSR matrix into a sparse GEBSC matrix !> !> \details !> \p hipsparseXgebsr2gebsc converts a GEBSR matrix into a GEBSC matrix. \p !> hipsparseXgebsr2gebsc !> can also be used to convert a GEBSC matrix into a GEBSR matrix. \p copyValues decides !> whether \p bscVal is being filled during conversion (`HIPSPARSE_ACTION_NUMERIC`) !> or not (`HIPSPARSE_ACTION_SYMBOLIC`). !> !> \p hipsparseXgebsr2gebsc requires extra temporary storage buffer that has to be allocated !> by the user. Storage buffer size can be determined by `hipsparseSgebsr2gebsc_bufferSize` !> "hipsparseXgebsr2gebsc_bufferSize()". !> !> For example, given the GEBSR matrix: !> \f[ !> \left[ !> \begin{array}{c | c} !> \begin{array}{c c} !> 1 & 2 \\% !> 3 & 4 \\% !> 6 & 0 !> \end{array} & !> \begin{array}{c c} !> 0 & 2 \\% !> 0 & 0 \\% !> 3 & 4 !> \end{array} \\% !> \hline !> \begin{array}{c c} !> 5 & 0 \\% !> 1 & 2 \\% !> 3 & 4 !> \end{array} & !> \begin{array}{c c} !> 6 & 7 \\% !> 3 & 4 \\% !> 3 & 4 !> \end{array} \\% !> \end{array} !> \right] !> \f] !> !> represented with the arrays: !> \f[ !> \begin{align} !> \text{bsrRowPtr} &= \begin{bmatrix} 0 & 2 & 4 \end{bmatrix} \\% !> \text{bsrColInd} &= \begin{bmatrix} 0 & 1 & 0 & 1 \end{bmatrix} \\% !> \text{bsrVal} &= \begin{bmatrix} 1 & 2 & 3 & 4 & 6 & 0 & 0 & 2 & 0 & 0 & 3 & 4 & 5 & 0 & 1 !> & 2 & 3 & 4 & 6 & 7 & 3 & 4 & 3 & 4 \end{bmatrix} !> \end{align} !> \f] !> !> this function converts the matrix to GEBSC format: !> \f[ !> \begin{align} !> \text{bscRowInd} &= \begin{bmatrix} 0 & 1 & 0 & 1 \end{bmatrix} \\% !> \text{bscColPtr} &= \begin{bmatrix} 0 & 2 & 4 \end{bmatrix} \\% !> \text{bscVal} &= \begin{bmatrix} 1 & 2 & 3 & 4 & 6 & 0 & 5 & 0 & 1 & 2 & 3 & 4 & 0 & 2 & 0 !> & 0 & 3 & 4 & 6 & 7 & 3 & 4 & 3 & 4 \end{bmatrix} !> \end{align} !> \f] !> !> The GEBSC arrays \p bscRowInd, \p bscColPtr, and \p bscVal must be allocated by the user !> prior !> to calling \p hipsparseXgebsr2gebsc(). The \p bscRowInd array has size \p nnzb, the \p !> bscColPtr !> array has size \p nb+1, and the \p bscVal array has size \p nnzb*rowBlockDim*colBlockDim. !> !> \note !> The resulting matrix can also be seen as the transpose of the input matrix. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] mb - number of rows of the sparse general BSR matrix. !> @param[in] nb - number of columns of the sparse general BSR matrix. !> @param[in] nnzb - number of non-zero entries of the sparse general BSR matrix. !> @param[in] bsrVal - array of \p nnzb * \p rowBlockDim * \p colBlockDim elements of the sparse !> general BSR matrix. !> @param[in] bsrRowPtr - array of \p m+1 elements that point to the start of every row of the !> sparse general BSR matrix. !> @param[in] bsrColInd - array of \p nnz elements containing the column indices of the sparse !> general BSR matrix. !> @param[in] rowBlockDim - row size of the blocks in the sparse general BSR matrix. !> @param[in] colBlockDim - col size of the blocks in the sparse general BSR matrix. !> @param[out] bscVal - array of \p nnz elements of the sparse BSC matrix. !> @param[out] bscRowInd - array of \p nnz elements containing the row indices of the sparse BSC !> matrix. !> @param[out] bscColPtr - array of \p n+1 elements that point to the start of every column of !> the !> sparse BSC matrix. !> @param[in] copyValues - `HIPSPARSE_ACTION_SYMBOLIC` or `HIPSPARSE_ACTION_NUMERIC`. !> @param[in] idxBase - `HIPSPARSE_INDEX_BASE_ZERO` or `HIPSPARSE_INDEX_BASE_ONE`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. The size is returned !> by !> `hipsparseSgebsr2gebsc_bufferSize` "hipsparseXgebsr2gebsc_bufferSize()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p mb, \p nb, \p nnzb, \p bsrVal, !> \p bsrRowPtr, \p bsrColInd, \p bscVal, \p bscRowInd, \p bscColPtr, or !> \p temp_buffer pointer is invalid. !> \retval HIPSPARSE_STATUS_ARCH_MISMATCH the device is not supported. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseSgebsr2gebsc #ifdef USE_CUDA_NAMES function hipsparseSgebsr2gebsc_(handle,mb,nb,nnzb,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim, & colBlockDim,bscVal,bscRowInd,bscColPtr,copyValues,idxBase,temp_buffer) & bind(c, name="cusparseSgebsr2gebsc") #else function hipsparseSgebsr2gebsc_(handle,mb,nb,nnzb,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim, & colBlockDim,bscVal,bscRowInd,bscColPtr,copyValues,idxBase,temp_buffer) & bind(c, name="hipsparseSgebsr2gebsc") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgebsr2gebsc_ type(c_ptr),value :: handle integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: bsrVal type(c_ptr),value :: bsrRowPtr type(c_ptr),value :: bsrColInd integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim type(c_ptr),value :: bscVal type(c_ptr),value :: bscRowInd type(c_ptr),value :: bscColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)),value :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase type(c_ptr),value :: temp_buffer end function end interface interface hipsparseDgebsr2gebsc #ifdef USE_CUDA_NAMES function hipsparseDgebsr2gebsc_(handle,mb,nb,nnzb,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim, & colBlockDim,bscVal,bscRowInd,bscColPtr,copyValues,idxBase,temp_buffer) & bind(c, name="cusparseDgebsr2gebsc") #else function hipsparseDgebsr2gebsc_(handle,mb,nb,nnzb,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim, & colBlockDim,bscVal,bscRowInd,bscColPtr,copyValues,idxBase,temp_buffer) & bind(c, name="hipsparseDgebsr2gebsc") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgebsr2gebsc_ type(c_ptr),value :: handle integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: bsrVal type(c_ptr),value :: bsrRowPtr type(c_ptr),value :: bsrColInd integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim type(c_ptr),value :: bscVal type(c_ptr),value :: bscRowInd type(c_ptr),value :: bscColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)),value :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase type(c_ptr),value :: temp_buffer end function end interface interface hipsparseCgebsr2gebsc #ifdef USE_CUDA_NAMES function hipsparseCgebsr2gebsc_(handle,mb,nb,nnzb,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim, & colBlockDim,bscVal,bscRowInd,bscColPtr,copyValues,idxBase,temp_buffer) & bind(c, name="cusparseCgebsr2gebsc") #else function hipsparseCgebsr2gebsc_(handle,mb,nb,nnzb,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim, & colBlockDim,bscVal,bscRowInd,bscColPtr,copyValues,idxBase,temp_buffer) & bind(c, name="hipsparseCgebsr2gebsc") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgebsr2gebsc_ type(c_ptr),value :: handle integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: bsrVal type(c_ptr),value :: bsrRowPtr type(c_ptr),value :: bsrColInd integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim type(c_ptr),value :: bscVal type(c_ptr),value :: bscRowInd type(c_ptr),value :: bscColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)),value :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase type(c_ptr),value :: temp_buffer end function end interface interface hipsparseZgebsr2gebsc #ifdef USE_CUDA_NAMES function hipsparseZgebsr2gebsc_(handle,mb,nb,nnzb,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim, & colBlockDim,bscVal,bscRowInd,bscColPtr,copyValues,idxBase,temp_buffer) & bind(c, name="cusparseZgebsr2gebsc") #else function hipsparseZgebsr2gebsc_(handle,mb,nb,nnzb,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim, & colBlockDim,bscVal,bscRowInd,bscColPtr,copyValues,idxBase,temp_buffer) & bind(c, name="hipsparseZgebsr2gebsc") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgebsr2gebsc_ type(c_ptr),value :: handle integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: bsrVal type(c_ptr),value :: bsrRowPtr type(c_ptr),value :: bsrColInd integer(c_int),value :: rowBlockDim integer(c_int),value :: colBlockDim type(c_ptr),value :: bscVal type(c_ptr),value :: bscRowInd type(c_ptr),value :: bscColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)),value :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase type(c_ptr),value :: temp_buffer end function end interface !> \ingroup conv_module !> \brief !> This function computes the the size of the user-allocated temporary storage buffer used when !> converting a sparse !> GEBSR matrix to another sparse GEBSR matrix. !> !> \details !> \p hipsparseXgebsr2gebsr_bufferSize returns the size of the temporary storage buffer that is !> required by !> `hipsparseXgebsr2gebsrNnz` () and `hipsparseSgebsr2gebsr` "hipsparseXgebsr2gebsr()". The !> temporary storage !> buffer must be allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - the storage format of the blocks, `HIPSPARSE_DIRECTION_ROW` or !> `HIPSPARSE_DIRECTION_COLUMN`. !> @param[in] mb - number of block rows of the general BSR sparse matrix \f$A\f$. !> @param[in] nb - number of block columns of the general BSR sparse matrix \f$A\f$. !> @param[in] nnzb - number of blocks in the general BSR sparse matrix \f$A\f$. !> @param[in] descrA - the descriptor of the general BSR sparse matrix \f$A\f$. The supported !> matrix type is !> `HIPSPARSE_MATRIX_TYPE_GENERAL` and any valid value of the !> `hipsparseIndexBase_t`. !> @param[in] bsrValA - array of \p nnzb*rowBlockDimA*colBlockDimA containing the values of the !> sparse general BSR matrix \f$A\f$. !> @param[in] bsrRowPtrA - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse general BSR matrix \f$A\f$. !> @param[in] bsrColIndA - array of \p nnzb elements containing the block column indices of the !> sparse general BSR matrix \f$A\f$. !> @param[in] rowBlockDimA - row size of the blocks in the sparse general BSR matrix \f$A\f$. !> @param[in] colBlockDimA - column size of the blocks in the sparse general BSR matrix \f$A\f$. !> @param[in] rowBlockDimC - row size of the blocks in the sparse general BSR matrix \f$C\f$. !> @param[in] colBlockDimC - column size of the blocks in the sparse general BSR matrix \f$C\f$. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseXgebsr2gebsrNnz()`, !> `hipsparseSgebsr2gebsr()`, hipsparseDgebsr2gebsr(), !> hipsparseCgebsr2gebsr(), and !> hipsparseZgebsr2gebsr(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p mb, \p nb, \p nnzb, \p rowBlockDimA, \p !> colBlockDimA, !> \p rowBlockDimC, \p colBlockDimC, \p bsrRowPtrA, \p bsrColIndA, \p descrA, or \p !> pBufferSizeInBytes pointer !> is invalid. interface hipsparseSgebsr2gebsr_bufferSize #ifdef USE_CUDA_NAMES function hipsparseSgebsr2gebsr_bufferSize_(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) & bind(c, name="cusparseSgebsr2gebsr_bufferSize") #else function hipsparseSgebsr2gebsr_bufferSize_(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) & bind(c, name="hipsparseSgebsr2gebsr_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgebsr2gebsr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: rowBlockDimA integer(c_int),value :: colBlockDimA integer(c_int),value :: rowBlockDimC integer(c_int),value :: colBlockDimC integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSgebsr2gebsr_bufferSize_assumed_rank #else module procedure & hipsparseSgebsr2gebsr_bufferSize_rank_0,& hipsparseSgebsr2gebsr_bufferSize_rank_1 #endif #endif end interface interface hipsparseDgebsr2gebsr_bufferSize #ifdef USE_CUDA_NAMES function hipsparseDgebsr2gebsr_bufferSize_(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) & bind(c, name="cusparseDgebsr2gebsr_bufferSize") #else function hipsparseDgebsr2gebsr_bufferSize_(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) & bind(c, name="hipsparseDgebsr2gebsr_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgebsr2gebsr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: rowBlockDimA integer(c_int),value :: colBlockDimA integer(c_int),value :: rowBlockDimC integer(c_int),value :: colBlockDimC integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDgebsr2gebsr_bufferSize_assumed_rank #else module procedure & hipsparseDgebsr2gebsr_bufferSize_rank_0,& hipsparseDgebsr2gebsr_bufferSize_rank_1 #endif #endif end interface interface hipsparseCgebsr2gebsr_bufferSize #ifdef USE_CUDA_NAMES function hipsparseCgebsr2gebsr_bufferSize_(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) & bind(c, name="cusparseCgebsr2gebsr_bufferSize") #else function hipsparseCgebsr2gebsr_bufferSize_(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) & bind(c, name="hipsparseCgebsr2gebsr_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgebsr2gebsr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: rowBlockDimA integer(c_int),value :: colBlockDimA integer(c_int),value :: rowBlockDimC integer(c_int),value :: colBlockDimC integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCgebsr2gebsr_bufferSize_assumed_rank #else module procedure & hipsparseCgebsr2gebsr_bufferSize_rank_0,& hipsparseCgebsr2gebsr_bufferSize_rank_1 #endif #endif end interface interface hipsparseZgebsr2gebsr_bufferSize #ifdef USE_CUDA_NAMES function hipsparseZgebsr2gebsr_bufferSize_(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) & bind(c, name="cusparseZgebsr2gebsr_bufferSize") #else function hipsparseZgebsr2gebsr_bufferSize_(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) & bind(c, name="hipsparseZgebsr2gebsr_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgebsr2gebsr_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: rowBlockDimA integer(c_int),value :: colBlockDimA integer(c_int),value :: rowBlockDimC integer(c_int),value :: colBlockDimC integer(c_int) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZgebsr2gebsr_bufferSize_assumed_rank #else module procedure & hipsparseZgebsr2gebsr_bufferSize_rank_0,& hipsparseZgebsr2gebsr_bufferSize_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief This function is used when converting a GEBSR sparse matrix \f$A\f$ to another GEBSR !> sparse matrix \f$C\f$. !> Specifically, this function determines the number of non-zero blocks that will exist in !> \f$C\f$ (stored using either a host !> or device pointer) and computes the row pointer array for \f$C\f$. !> !> \details !> The routine supports asynchronous execution. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - the storage format of the blocks, `HIPSPARSE_DIRECTION_ROW` or !> `HIPSPARSE_DIRECTION_COLUMN`. !> @param[in] mb - number of block rows of the general BSR sparse matrix \f$A\f$. !> @param[in] nb - number of block columns of the general BSR sparse matrix \f$A\f$. !> @param[in] nnzb - number of blocks in the general BSR sparse matrix \f$A\f$. !> @param[in] descrA - the descriptor of the general BSR sparse matrix \f$A\f$. The supported !> matrix type is !> `HIPSPARSE_MATRIX_TYPE_GENERAL` and any valid value of the !> `hipsparseIndexBase_t`. !> @param[in] bsrRowPtrA - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse general BSR matrix \f$A\f$. !> @param[in] bsrColIndA - array of \p nnzb elements containing the block column indices of the !> sparse general BSR matrix \p A. !> @param[in] rowBlockDimA - row size of the blocks in the sparse general BSR matrix \f$A\f$. !> @param[in] colBlockDimA - column size of the blocks in the sparse general BSR matrix \f$A\f$. !> @param[in] descrC - the descriptor of the general BSR sparse matrix \f$C\f$. The supported !> matrix type is !> `HIPSPARSE_MATRIX_TYPE_GENERAL` and any valid value of the !> `hipsparseIndexBase_t`. !> @param[in] bsrRowPtrC - array of \p mbC+1 elements that point to the start of every block row !> of the !> sparse general BSR matrix \f$C\f$ where \p mbC = ( \p m+rowBlockDimC-1 ) / !> \p rowBlockDimC. !> @param[in] rowBlockDimC - row size of the blocks in the sparse general BSR matrix \f$C\f$. !> @param[in] colBlockDimC - column size of the blocks in the sparse general BSR matrix \f$C\f$. !> @param[out] nnzTotalDevHostPtr - total number of non-zero blocks in general BSR sparse matrix !> \f$C\f$, stored using device or host memory. !> @param[out] buffer - buffer allocated by the user. The size is determined by calling !> `hipsparseSgebsr2gebsr_bufferSize` !> "hipsparseXgebsr2gebsr_bufferSize()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p mb, \p nb, \p nnzb, \p rowBlockDimA, \p !> colBlockDimA, \p rowBlockDimC, !> \p colBlockDimC, \p bsrRowPtrA, \p bsrColIndA, \p bsrRowPtrC, \p descrA, \p !> descrC, \p buffer pointer is invalid. interface hipsparseXgebsr2gebsrNnz #ifdef USE_CUDA_NAMES function hipsparseXgebsr2gebsrNnz_(handle,dirA,mb,nb,nnzb,descrA,bsrRowPtrA,bsrColIndA, & rowBlockDimA,colBlockDimA,descrC,bsrRowPtrC,rowBlockDimC,colBlockDimC,nnzTotalDevHostPtr, & buffer) & bind(c, name="cusparseXgebsr2gebsrNnz") #else function hipsparseXgebsr2gebsrNnz_(handle,dirA,mb,nb,nnzb,descrA,bsrRowPtrA,bsrColIndA, & rowBlockDimA,colBlockDimA,descrC,bsrRowPtrC,rowBlockDimC,colBlockDimC,nnzTotalDevHostPtr, & buffer) & bind(c, name="hipsparseXgebsr2gebsrNnz") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXgebsr2gebsrNnz_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: rowBlockDimA integer(c_int),value :: colBlockDimA type(c_ptr),value :: descrC type(c_ptr),value :: bsrRowPtrC integer(c_int),value :: rowBlockDimC integer(c_int),value :: colBlockDimC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseXgebsr2gebsrNnz_assumed_rank #else module procedure & hipsparseXgebsr2gebsrNnz_rank_0,& hipsparseXgebsr2gebsrNnz_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief !> This function converts the GEBSR sparse matrix \f$A\f$ to another GEBSR sparse matrix !> \f$C\f$. !> !> \details !> The conversion uses three steps. First, the user calls `hipsparseSgebsr2gebsr_bufferSize` !> "hipsparseXgebsr2gebsr_bufferSize()" to determine the size of the required temporary storage !> buffer. !> The user then allocates this buffer. Secondly, the user then allocates \p mbC+1 integers for !> the row !> pointer array for \f$C\f$ where: !> \f[ !> \begin{align} !> \text{mbC} &= \text{(m - 1) / rowBlockDimC + 1} \\% !> \text{nbC} &= \text{(n - 1) / colBlockDimC + 1} !> \end{align} !> \f] !> The user then calls `hipsparseXgebsr2gebsrNnz()` to fill in the row pointer array for \f$C\f$ !> ( \p bsrRowPtrC ) and !> determine the number of non-zero blocks that will exist in \f$C\f$. Finally, the user !> allocates space for the column !> indices array of \f$C\f$ to have \p nnzbC elements and space for the values array of \f$C\f$ !> to have !> \p nnzbC*rowBlockDimC*colBlockDimC and then calls \p hipsparseXgebsr2gebsr to complete the !> conversion. !> !> It could be the case that \p rowBlockDimC does not divide evenly into \p m or \p colBlockDim !> does not divide evenly !> into \p n. In these cases, the GEBSR matrix is expanded in size to fit full GEBSR blocks. For !> example, if !> the original GEBSR matrix A (using \p rowBlockDimA=2, \p colBlockDimA=3) looks like: !> !> \f[ !> \left[ !> \begin{array}{c | c} !> \begin{array}{c c c} !> 1 & 0 & 0 \\% !> 3 & 4 & 0 !> \end{array} & !> \begin{array}{c c c} !> 2 & 0 & 0 \\% !> 4 & 5 & 6 !> \end{array} \\% !> \hline !> \begin{array}{c c c} !> 1 & 2 & 3 \\% !> 1 & 2 & 0 !> \end{array} & !> \begin{array}{c c c} !> 4 & 0 & 0 \\% !> 3 & 0 & 1 !> \end{array} \\% !> \end{array} !> \right] !> \f] !> !> then if the user specifies \p rowBlockDimC=3 and \p colBlockDimC=2, the output GEBSR matrix C !> would be: !> !> \f[ !> \left[ !> \begin{array}{c | c | c} !> \begin{array}{c c} !> 1 & 0 \\% !> 3 & 4 \\% !> 1 & 2 !> \end{array} & !> \begin{array}{c c} !> 0 & 2 \\% !> 0 & 4 \\% !> 3 & 4 !> \end{array} & !> \begin{array}{c c} !> 0 & 0 \\% !> 5 & 6 \\% !> 0 & 0 !> \end{array} \\% !> \hline !> \begin{array}{c c} !> 1 & 2 \\% !> 0 & 0 \\% !> 0 & 0 !> \end{array} & !> \begin{array}{c c} !> 0 & 3 \\% !> 0 & 0 \\% !> 0 & 0 !> \end{array} & !> \begin{array}{c c} !> 0 & 1 \\% !> 0 & 0 \\% !> 0 & 0 !> \end{array} \\% !> \end{array} !> \right] !> \f] !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - the storage format of the blocks, `HIPSPARSE_DIRECTION_ROW` or !> `HIPSPARSE_DIRECTION_COLUMN`. !> @param[in] mb - number of block rows of the general BSR sparse matrix \f$A\f$. !> @param[in] nb - number of block columns of the general BSR sparse matrix \f$A\f$. !> @param[in] nnzb - number of blocks in the general BSR sparse matrix \f$A\f$. !> @param[in] descrA - the descriptor of the general BSR sparse matrix \f$A\f$. The supported !> matrix type is !> `HIPSPARSE_MATRIX_TYPE_GENERAL` and also any valid value of the !> `hipsparseIndexBase_t`. !> @param[in] bsrValA - array of \p nnzb*rowBlockDimA*colBlockDimA containing the values of the !> sparse general BSR matrix \f$A\f$. !> @param[in] bsrRowPtrA - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse general BSR matrix \f$A\f$. !> @param[in] bsrColIndA - array of \p nnzb elements containing the block column indices of the !> sparse general BSR matrix \f$A\f$. !> @param[in] rowBlockDimA - row size of the blocks in the sparse general BSR matrix \f$A\f$. !> @param[in] colBlockDimA - column size of the blocks in the sparse general BSR matrix \f$A\f$. !> @param[in] descrC - the descriptor of the general BSR sparse matrix \f$C\f$. The supported !> matrix type is !> `HIPSPARSE_MATRIX_TYPE_GENERAL` and any valid value of the !> `hipsparseIndexBase_t`. !> @param[in] bsrValC - array of \p nnzbC*rowBlockDimC*colBlockDimC containing the values of the !> sparse general BSR matrix \f$C\f$. !> @param[in] bsrRowPtrC - array of \p mbC+1 elements that point to the start of every block row !> of the !> sparse general BSR matrix \f$C\f$. !> @param[in] bsrColIndC - array of \p nnzbC elements containing the block column indices of the !> sparse general BSR matrix \f$C\f$. !> @param[in] rowBlockDimC - row size of the blocks in the sparse general BSR matrix \f$C\f$. !> @param[in] colBlockDimC - column size of the blocks in the sparse general BSR matrix \f$C\f$. !> @param[out] buffer - buffer allocated by the user. The size is determined by calling !> `hipsparseSgebsr2gebsr_bufferSize` !> "hipsparseXgebsr2gebsr_bufferSize()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p mb, \p nb, \p nnzb, \p rowBlockDimA, \p !> colBlockDimA, !> \p rowBlockDimC, \p colBlockDimC, \p bsrRowPtrA, \p bsrColIndA, \p bsrValA, \p !> bsrRowPtrC, \p bsrColIndC, !> \p bsrValC, \p descrA, \p descrC, or \p buffer pointer is invalid. interface hipsparseSgebsr2gebsr #ifdef USE_CUDA_NAMES function hipsparseSgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC,colBlockDimC, & buffer) & bind(c, name="cusparseSgebsr2gebsr") #else function hipsparseSgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC,colBlockDimC, & buffer) & bind(c, name="hipsparseSgebsr2gebsr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgebsr2gebsr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: rowBlockDimA integer(c_int),value :: colBlockDimA type(c_ptr),value :: descrC type(c_ptr),value :: bsrValC type(c_ptr),value :: bsrRowPtrC type(c_ptr),value :: bsrColIndC integer(c_int),value :: rowBlockDimC integer(c_int),value :: colBlockDimC type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSgebsr2gebsr_assumed_rank #else module procedure & hipsparseSgebsr2gebsr_rank_0,& hipsparseSgebsr2gebsr_rank_1 #endif #endif end interface interface hipsparseDgebsr2gebsr #ifdef USE_CUDA_NAMES function hipsparseDgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC,colBlockDimC, & buffer) & bind(c, name="cusparseDgebsr2gebsr") #else function hipsparseDgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC,colBlockDimC, & buffer) & bind(c, name="hipsparseDgebsr2gebsr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgebsr2gebsr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: rowBlockDimA integer(c_int),value :: colBlockDimA type(c_ptr),value :: descrC type(c_ptr),value :: bsrValC type(c_ptr),value :: bsrRowPtrC type(c_ptr),value :: bsrColIndC integer(c_int),value :: rowBlockDimC integer(c_int),value :: colBlockDimC type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDgebsr2gebsr_assumed_rank #else module procedure & hipsparseDgebsr2gebsr_rank_0,& hipsparseDgebsr2gebsr_rank_1 #endif #endif end interface interface hipsparseCgebsr2gebsr #ifdef USE_CUDA_NAMES function hipsparseCgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC,colBlockDimC, & buffer) & bind(c, name="cusparseCgebsr2gebsr") #else function hipsparseCgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC,colBlockDimC, & buffer) & bind(c, name="hipsparseCgebsr2gebsr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgebsr2gebsr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: rowBlockDimA integer(c_int),value :: colBlockDimA type(c_ptr),value :: descrC type(c_ptr),value :: bsrValC type(c_ptr),value :: bsrRowPtrC type(c_ptr),value :: bsrColIndC integer(c_int),value :: rowBlockDimC integer(c_int),value :: colBlockDimC type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCgebsr2gebsr_assumed_rank #else module procedure & hipsparseCgebsr2gebsr_rank_0,& hipsparseCgebsr2gebsr_rank_1 #endif #endif end interface interface hipsparseZgebsr2gebsr #ifdef USE_CUDA_NAMES function hipsparseZgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC,colBlockDimC, & buffer) & bind(c, name="cusparseZgebsr2gebsr") #else function hipsparseZgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC,colBlockDimC, & buffer) & bind(c, name="hipsparseZgebsr2gebsr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgebsr2gebsr_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descrA type(c_ptr),value :: bsrValA type(c_ptr),value :: bsrRowPtrA type(c_ptr),value :: bsrColIndA integer(c_int),value :: rowBlockDimA integer(c_int),value :: colBlockDimA type(c_ptr),value :: descrC type(c_ptr),value :: bsrValC type(c_ptr),value :: bsrRowPtrC type(c_ptr),value :: bsrColIndC integer(c_int),value :: rowBlockDimC integer(c_int),value :: colBlockDimC type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZgebsr2gebsr_assumed_rank #else module procedure & hipsparseZgebsr2gebsr_rank_0,& hipsparseZgebsr2gebsr_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse HYB matrix into a sparse CSR matrix. !> !> \details !> \p hipsparseXhyb2csr converts a HYB matrix into a CSR matrix. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 10.0+) and will be !> removed in CUDA 11.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] descrA - descriptor of the sparse HYB matrix. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] hybA - sparse matrix in HYB format. !> @param[out] csrSortedValA - array containing the values of the sparse CSR matrix. !> @param[out] csrSortedRowPtrA - array of \p m+1 elements that point to the start of every row !> of the !> sparse CSR matrix. !> @param[out] csrSortedColIndA - array containing the column indices of the sparse CSR matrix. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p descrA, \p hybA, \p csrSortedValA, !> \p csrSortedRowPtrA, or \p csrSortedColIndA is nullptr. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. !> \retval HIPSPARSE_STATUS_NOT_SUPPORTED `hipsparseMatrixType_t` != !> `HIPSPARSE_MATRIX_TYPE_GENERAL`. #ifndef USE_CUDA_NAMES interface hipsparseShyb2csr function hipsparseShyb2csr_(handle,descrA,hybA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA) & bind(c, name="hipsparseShyb2csr") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseShyb2csr_ type(c_ptr),value :: handle type(c_ptr),value :: descrA type(c_ptr),value :: hybA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseShyb2csr_assumed_rank #else module procedure & hipsparseShyb2csr_rank_0,& hipsparseShyb2csr_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDhyb2csr function hipsparseDhyb2csr_(handle,descrA,hybA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA) & bind(c, name="hipsparseDhyb2csr") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDhyb2csr_ type(c_ptr),value :: handle type(c_ptr),value :: descrA type(c_ptr),value :: hybA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDhyb2csr_assumed_rank #else module procedure & hipsparseDhyb2csr_rank_0,& hipsparseDhyb2csr_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseChyb2csr function hipsparseChyb2csr_(handle,descrA,hybA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA) & bind(c, name="hipsparseChyb2csr") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseChyb2csr_ type(c_ptr),value :: handle type(c_ptr),value :: descrA type(c_ptr),value :: hybA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseChyb2csr_assumed_rank #else module procedure & hipsparseChyb2csr_rank_0,& hipsparseChyb2csr_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseZhyb2csr function hipsparseZhyb2csr_(handle,descrA,hybA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA) & bind(c, name="hipsparseZhyb2csr") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZhyb2csr_ type(c_ptr),value :: handle type(c_ptr),value :: descrA type(c_ptr),value :: hybA type(c_ptr),value :: csrSortedValA type(c_ptr),value :: csrSortedRowPtrA type(c_ptr),value :: csrSortedColIndA end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZhyb2csr_assumed_rank #else module procedure & hipsparseZhyb2csr_rank_0,& hipsparseZhyb2csr_rank_1 #endif #endif end interface #endif !> \ingroup conv_module !> \brief !> \p hipsparseXnnz computes the number of non-zero elements per row or column and the total !> number of non-zero elements in a dense matrix. !> !> \details !> For example, given the dense matrix: !> \f[ !> \begin{bmatrix} !> 1 & 0 & 0 & 2 \\% !> 3 & 4 & 0 & 0 \\% !> 5 & 0 & 6 & 7 !> \end{bmatrix} !> \f] !> !> using \p dirA == `HIPSPARSE_DIRECTION_ROW` results in: !> \f[ !> \begin{align} !> \text{nnzPerRowColumn} &= \begin{bmatrix} 2 & 2 & 3 \end{bmatrix} \\% !> \text{nnzTotalDevHostPtr} &= 7 !> \end{align} !> \f] !> !> while using \p dirA == `HIPSPARSE_DIRECTION_COLUMN` results in: !> \f[ !> \begin{align} !> \text{nnzPerRowColumn} &= \begin{bmatrix} 3 & 1 & 1 & 2 \end{bmatrix} \\% !> \text{nnzTotalDevHostPtr} &= 7 !> \end{align} !> \f] !> !> The array \p nnzPerRowColumn must be allocated by the user before calling \p hipsparseXnnz !> and !> has length equal to \p m if \p dirA == `HIPSPARSE_DIRECTION_ROW` or \p n if !> \p dirA == `HIPSPARSE_DIRECTION_COLUMN`. !> !> For a complete code example showing its usage, see the example found with !> `hipsparseSdense2csr()`. !> !> \note !> As indicated, \p nnzTotalDevHostPtr can point either to host or device memory. This is !> controlled !> by setting the pointer mode. See `hipsparseSetPointerMode`(). !> !> \note !> The routine supports asynchronous execution if the pointer mode is set to device. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] dirA - direction that specifies whether to count non-zero elements by !> `HIPSPARSE_DIRECTION_ROW` !> or by `HIPSPARSE_DIRECTION_COLUMN`. !> @param[in] m - number of rows of the dense matrix \p A. Must be non-negative. !> @param[in] n - number of columns of the dense matrix \p A. Must be non-negative. !> @param[in] descrA - the descriptor of the dense matrix \p A. !> @param[in] A - array of dimensions (\p lda, \p n). !> @param[in] lda - leading dimension of dense array \p A. Must be at least \p m. !> @param[out] nnzPerRowColumn - array of size \p m or \p n containing the number of non-zero !> elements per row or column, respectively. !> @param[out] nnzTotalDevHostPtr - total number of non-zero elements in device or host memory. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p descrA, \p A, \p nnzPerRowColumn, !> or \p nnzTotalDevHostPtr is nullptr, \p m or \p n is negative, or \p lda is invalid. interface hipsparseSnnz #ifdef USE_CUDA_NAMES function hipsparseSnnz_(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn,nnzTotalDevHostPtr) & bind(c, name="cusparseSnnz") #else function hipsparseSnnz_(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn,nnzTotalDevHostPtr) & bind(c, name="hipsparseSnnz") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSnnz_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descrA type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSnnz_assumed_rank #else module procedure & hipsparseSnnz_rank_0,& hipsparseSnnz_rank_1,& hipsparseSnnz_full_rank #endif #endif end interface interface hipsparseDnnz #ifdef USE_CUDA_NAMES function hipsparseDnnz_(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn,nnzTotalDevHostPtr) & bind(c, name="cusparseDnnz") #else function hipsparseDnnz_(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn,nnzTotalDevHostPtr) & bind(c, name="hipsparseDnnz") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDnnz_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descrA type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDnnz_assumed_rank #else module procedure & hipsparseDnnz_rank_0,& hipsparseDnnz_rank_1,& hipsparseDnnz_full_rank #endif #endif end interface interface hipsparseCnnz #ifdef USE_CUDA_NAMES function hipsparseCnnz_(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn,nnzTotalDevHostPtr) & bind(c, name="cusparseCnnz") #else function hipsparseCnnz_(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn,nnzTotalDevHostPtr) & bind(c, name="hipsparseCnnz") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCnnz_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descrA type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCnnz_assumed_rank #else module procedure & hipsparseCnnz_rank_0,& hipsparseCnnz_rank_1,& hipsparseCnnz_full_rank #endif #endif end interface interface hipsparseZnnz #ifdef USE_CUDA_NAMES function hipsparseZnnz_(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn,nnzTotalDevHostPtr) & bind(c, name="cusparseZnnz") #else function hipsparseZnnz_(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn,nnzTotalDevHostPtr) & bind(c, name="hipsparseZnnz") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZnnz_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)),value :: dirA integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descrA type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZnnz_assumed_rank #else module procedure & hipsparseZnnz_rank_0,& hipsparseZnnz_rank_1,& hipsparseZnnz_full_rank #endif #endif end interface !> \ingroup conv_module !> This function is used as the first step in converting a CSR matrix to a compressed CSR !> matrix. !> !> \details !> Given a sparse CSR matrix and a non-negative tolerance, this function computes how many !> entries would be left !> in each row of the matrix if elements less than the tolerance were removed. It also computes !> the total number !> of remaining elements in the matrix. !> !> Given an input sparse matrix \f$A\f$ in CSR format, the resulting compressed sparse CSR !> matrix \f$C\f$ is !> computed using: !> \f[ !> C(i,j) = A(i, j) \text{ if |A(i, j)| > tol} !> \f] !> !> The user first allocates \p nnzPerRow with size \p m elements, then calls \p !> hipsparseXnnz_compress. !> The function fills in the \p nnzPerRow array and sets the total number of non-zeros found in !> \p nnzC. !> !> See hipsparseScsr2csr_compress() for a full code example. !> !> \note !> In the case of complex matrices, only the magnitude of the real part of \p tol is used. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] descrA - the descriptor of the sparse CSR matrix. !> @param[in] csrValA - array of \p nnzA elements of the sparse CSR matrix. !> @param[in] csrRowPtrA - array of \p m+1 elements that point to the start of every row of the !> uncompressed sparse CSR matrix. !> @param[out] nnzPerRow - array of length \p m containing the number of entries that will be !> kept per row in !> the final compressed CSR matrix. !> @param[out] nnzC - number of elements in the column indices and values arrays of the !> compressed !> sparse CSR matrix. Can be either host or device pointer. !> @param[in] tol - the non-negative tolerance used for compression. If \p tol is complex, then !> only the magnitude !> of the real part is used. Entries in the input uncompressed CSR array that are !> below the tolerance !> are removed in output compressed CSR matrix. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p tol, \p csrValA, \p !> csrRowPtrA, \p nnzPerRow, or \p nnzC !> pointer is invalid. interface hipsparseSnnz_compress #ifdef USE_CUDA_NAMES function hipsparseSnnz_compress_(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow,nnzC,tol) & bind(c, name="cusparseSnnz_compress") #else function hipsparseSnnz_compress_(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow,nnzC,tol) & bind(c, name="hipsparseSnnz_compress") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSnnz_compress_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: nnzPerRow type(c_ptr),value :: nnzC real(c_float),value :: tol end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSnnz_compress_assumed_rank #else module procedure & hipsparseSnnz_compress_rank_0,& hipsparseSnnz_compress_rank_1 #endif #endif end interface interface hipsparseDnnz_compress #ifdef USE_CUDA_NAMES function hipsparseDnnz_compress_(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow,nnzC,tol) & bind(c, name="cusparseDnnz_compress") #else function hipsparseDnnz_compress_(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow,nnzC,tol) & bind(c, name="hipsparseDnnz_compress") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDnnz_compress_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: nnzPerRow type(c_ptr),value :: nnzC real(c_double),value :: tol end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDnnz_compress_assumed_rank #else module procedure & hipsparseDnnz_compress_rank_0,& hipsparseDnnz_compress_rank_1 #endif #endif end interface interface hipsparseCnnz_compress #ifdef USE_CUDA_NAMES function hipsparseCnnz_compress_(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow,nnzC,tol) & bind(c, name="cusparseCnnz_compress") #else function hipsparseCnnz_compress_(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow,nnzC,tol) & bind(c, name="hipsparseCnnz_compress") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCnnz_compress_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: nnzPerRow type(c_ptr),value :: nnzC complex(c_float_complex),value :: tol end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCnnz_compress_assumed_rank #else module procedure & hipsparseCnnz_compress_rank_0,& hipsparseCnnz_compress_rank_1 #endif #endif end interface interface hipsparseZnnz_compress #ifdef USE_CUDA_NAMES function hipsparseZnnz_compress_(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow,nnzC,tol) & bind(c, name="cusparseZnnz_compress") #else function hipsparseZnnz_compress_(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow,nnzC,tol) & bind(c, name="hipsparseZnnz_compress") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZnnz_compress_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: nnzPerRow type(c_ptr),value :: nnzC complex(c_double_complex),value :: tol end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZnnz_compress_assumed_rank #else module procedure & hipsparseZnnz_compress_rank_0,& hipsparseZnnz_compress_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert and prune a sparse CSR matrix into a sparse CSR matrix. !> !> \details !> \p hipsparseXpruneCsr2csr_bufferSize returns the size of the temporary buffer that !> is required by \p hipsparseXpruneCsr2csrNnz and \p hipsparseXpruneCsr2csr. The !> temporary storage buffer must be allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows in the sparse CSR matrix. !> @param[in] n - number of columns in the sparse CSR matrix. !> @param[in] nnzA - number of non-zeros in the sparse CSR matrix A. !> @param[in] descrA - descriptor of the sparse CSR matrix A. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrValA - array of \p nnzA elements containing the values of the sparse CSR matrix !> A. !> @param[in] csrRowPtrA - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix A. !> @param[in] csrColIndA - array of \p nnzA elements containing the column indices of the sparse !> CSR matrix A. !> @param[in] threshold - pointer to the non-negative pruning threshold, which can exist in !> either host or device memory. !> @param[in] descrC - descriptor of the sparse CSR matrix C. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrValC - array of \p nnzC elements containing the values of the sparse CSR matrix !> C. !> @param[in] csrRowPtrC - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix C. !> @param[in] csrColIndC - array of \p nnzC elements containing the column indices of the sparse !> CSR matrix C. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseSpruneCsr2csrNnz()`, !> hipsparseDpruneCsr2csrNnz(), `hipsparseSpruneCsr2csr()`, and !> hipsparseDpruneCsr2csr(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle or \p pBufferSizeInBytes pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. #ifndef USE_CUDA_NAMES interface hipsparseSpruneCsr2csr_bufferSize function hipsparseSpruneCsr2csr_bufferSize_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,pBufferSizeInBytes) & bind(c, name="hipsparseSpruneCsr2csr_bufferSize") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csr_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: threshold type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSpruneCsr2csr_bufferSize_assumed_rank #else module procedure & hipsparseSpruneCsr2csr_bufferSize_rank_0,& hipsparseSpruneCsr2csr_bufferSize_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDpruneCsr2csr_bufferSize function hipsparseDpruneCsr2csr_bufferSize_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,pBufferSizeInBytes) & bind(c, name="hipsparseDpruneCsr2csr_bufferSize") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csr_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: threshold type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDpruneCsr2csr_bufferSize_assumed_rank #else module procedure & hipsparseDpruneCsr2csr_bufferSize_rank_0,& hipsparseDpruneCsr2csr_bufferSize_rank_1 #endif #endif end interface #endif !> \ingroup conv_module !> \brief Convert and prune sparse a CSR matrix into a sparse CSR matrix. !> !> \details !> \p hipsparseXpruneCsr2csr_bufferSizeExt returns the size of the temporary buffer that !> is required by `hipsparseSpruneCsr2csrNnz` "hipsparseXpruneCsr2csrNnz()" and !> `hipsparseSpruneCsr2csr` "hipsparseXpruneCsr2csr()". The temporary storage buffer !> must be allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows in the sparse CSR matrix. !> @param[in] n - number of columns in the sparse CSR matrix. !> @param[in] nnzA - number of non-zeros in the sparse CSR matrix A. !> @param[in] descrA - descriptor of the sparse CSR matrix A. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrValA - array of \p nnzA elements containing the values of the sparse CSR matrix !> A. !> @param[in] csrRowPtrA - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix A. !> @param[in] csrColIndA - array of \p nnzA elements containing the column indices of the sparse !> CSR matrix A. !> @param[in] threshold - pointer to the non-negative pruning threshold, which can exist in !> either host or device memory. !> @param[in] descrC - descriptor of the sparse CSR matrix C. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrValC - array of \p nnzC elements containing the values of the sparse CSR matrix !> C. !> @param[in] csrRowPtrC - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix C. !> @param[in] csrColIndC - array of \p nnzC elements containing the column indices of the sparse !> CSR matrix C. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseSpruneCsr2csrNnz()`, !> hipsparseDpruneCsr2csrNnz(), `hipsparseSpruneCsr2csr()`, and !> hipsparseDpruneCsr2csr(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle or \p pBufferSizeInBytes pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseSpruneCsr2csr_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseSpruneCsr2csr_bufferSizeExt_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,pBufferSizeInBytes) & bind(c, name="cusparseSpruneCsr2csr_bufferSizeExt") #else function hipsparseSpruneCsr2csr_bufferSizeExt_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,pBufferSizeInBytes) & bind(c, name="hipsparseSpruneCsr2csr_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csr_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: threshold type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSpruneCsr2csr_bufferSizeExt_assumed_rank #else module procedure & hipsparseSpruneCsr2csr_bufferSizeExt_rank_0,& hipsparseSpruneCsr2csr_bufferSizeExt_rank_1 #endif #endif end interface interface hipsparseDpruneCsr2csr_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseDpruneCsr2csr_bufferSizeExt_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,pBufferSizeInBytes) & bind(c, name="cusparseDpruneCsr2csr_bufferSizeExt") #else function hipsparseDpruneCsr2csr_bufferSizeExt_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,pBufferSizeInBytes) & bind(c, name="hipsparseDpruneCsr2csr_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csr_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: threshold type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDpruneCsr2csr_bufferSizeExt_assumed_rank #else module procedure & hipsparseDpruneCsr2csr_bufferSizeExt_rank_0,& hipsparseDpruneCsr2csr_bufferSizeExt_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert and prune sparse a CSR matrix into a sparse CSR matrix. !> !> \details !> \p hipsparseXpruneCsr2csrNnz computes the number of non-zero elements per row and the total !> number of non-zero elements in a sparse CSR matrix after elements less than the threshold are !> pruned from the matrix. !> !> \note The routine supports asynchronous execution if the pointer mode is set to device. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows in the sparse CSR matrix. !> @param[in] n - number of columns in the sparse CSR matrix. !> @param[in] nnzA - number of non-zeros in the sparse CSR matrix A. !> @param[in] descrA - descriptor of the sparse CSR matrix A. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrValA - array of \p nnzA elements containing the values of the sparse CSR matrix !> A. !> @param[in] csrRowPtrA - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix A. !> @param[in] csrColIndA - array of \p nnzA elements containing the column indices of the sparse !> CSR matrix A. !> @param[in] threshold - pointer to the non-negative pruning threshold which can exist in !> either host or device memory. !> @param[in] descrC - descriptor of the sparse CSR matrix C. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[out] csrRowPtrC - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix C. !> @param[out] nnzTotalDevHostPtr - total number of nonzero elements in device or host memory. !> @param[out] buffer - buffer allocated by the user whose size is determined by calling !> `hipsparseSpruneCsr2csr_bufferSize` !> "hipsparseXpruneCsr2csr_bufferSize()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p nnzA, \p threshold, \p !> descrA, !> \p descrC, \p csrValA, \p csrRowPtrA, \p csrColIndA, \p csrRowPtrC, \p !> nnzTotalDevHostPtr, !> or \p buffer pointer is invalid. interface hipsparseSpruneCsr2csrNnz #ifdef USE_CUDA_NAMES function hipsparseSpruneCsr2csrNnz_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA,csrColIndA, & threshold,descrC,csrRowPtrC,nnzTotalDevHostPtr,buffer) & bind(c, name="cusparseSpruneCsr2csrNnz") #else function hipsparseSpruneCsr2csrNnz_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA,csrColIndA, & threshold,descrC,csrRowPtrC,nnzTotalDevHostPtr,buffer) & bind(c, name="hipsparseSpruneCsr2csrNnz") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrNnz_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA real(c_float) :: threshold type(c_ptr),value :: descrC type(c_ptr),value :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSpruneCsr2csrNnz_assumed_rank #else module procedure & hipsparseSpruneCsr2csrNnz_rank_0,& hipsparseSpruneCsr2csrNnz_rank_1 #endif #endif end interface interface hipsparseDpruneCsr2csrNnz #ifdef USE_CUDA_NAMES function hipsparseDpruneCsr2csrNnz_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA,csrColIndA, & threshold,descrC,csrRowPtrC,nnzTotalDevHostPtr,buffer) & bind(c, name="cusparseDpruneCsr2csrNnz") #else function hipsparseDpruneCsr2csrNnz_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA,csrColIndA, & threshold,descrC,csrRowPtrC,nnzTotalDevHostPtr,buffer) & bind(c, name="hipsparseDpruneCsr2csrNnz") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrNnz_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA real(c_double) :: threshold type(c_ptr),value :: descrC type(c_ptr),value :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDpruneCsr2csrNnz_assumed_rank #else module procedure & hipsparseDpruneCsr2csrNnz_rank_0,& hipsparseDpruneCsr2csrNnz_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert and prune a sparse CSR matrix into a sparse CSR matrix. !> !> \details !> This function converts the sparse CSR matrix A into a sparse CSR matrix C by pruning values !> in A !> that are less than the threshold. All the parameters are assumed to have been preallocated by !> the user. !> The user first calls `hipsparseSpruneCsr2csr_bufferSize` !> "hipsparseXpruneCsr2csr_bufferSize()" to !> determine the size of the buffer used by `hipsparseSpruneCsr2csrNnz` !> "hipsparseXpruneCsr2csrNnz()" !> and \p hipsparseXpruneCsr2csr(), which the user then allocates. The user then allocates \p !> csrRowPtrC to !> have \p m+1 elements and then calls hipsparseXpruneCsr2csrNnz(), which fills in the \p !> csrRowPtrC array !> and stores the number of elements that are larger than the pruning \p threshold in \p !> nnzTotalDevHostPtr. !> The user then calls \p hipsparseXpruneCsr2csr() to complete the conversion. This function is !> executed asynchronously !> with respect to the host and can return control to the application on the host before the !> entire result is ready. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows in the sparse CSR matrix. !> @param[in] n - number of columns in the sparse CSR matrix. !> @param[in] nnzA - number of non-zeros in the sparse CSR matrix A. !> @param[in] descrA - descriptor of the sparse CSR matrix A. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrValA - array of \p nnzA elements containing the values of the sparse CSR matrix !> A. !> @param[in] csrRowPtrA - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix A. !> @param[in] csrColIndA - array of \p nnzA elements containing the column indices of the sparse !> CSR matrix A. !> @param[in] threshold - pointer to the non-negative pruning threshold which can exist in !> either host or device memory. !> @param[in] descrC - descriptor of the sparse CSR matrix C. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[out] csrValC - array of \p nnzC elements containing the values of the sparse CSR !> matrix C. !> @param[in] csrRowPtrC - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix C. !> @param[out] csrColIndC - array of \p nnzC elements containing the column indices of the !> sparse CSR matrix C. !> @param[in] buffer - buffer allocated by the user whose size is determined by calling !> `hipsparseSpruneCsr2csr_bufferSize` !> "hipsparseXpruneCsr2csr_bufferSize()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p nnzA, \p threshold, \p !> descrA, \p descrC, \p csrValA, !> \p csrRowPtrA, \p csrcolindA, \p csrvalC, \p csrrowptrC, \p csrcolIndC, or \p !> buffer pointer is invalid. interface hipsparseSpruneCsr2csr #ifdef USE_CUDA_NAMES function hipsparseSpruneCsr2csr_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA,csrColIndA, & threshold,descrC,csrValC,csrRowPtrC,csrColIndC,buffer) & bind(c, name="cusparseSpruneCsr2csr") #else function hipsparseSpruneCsr2csr_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA,csrColIndA, & threshold,descrC,csrValC,csrRowPtrC,csrColIndC,buffer) & bind(c, name="hipsparseSpruneCsr2csr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA real(c_float) :: threshold type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSpruneCsr2csr_assumed_rank #else module procedure & hipsparseSpruneCsr2csr_rank_0,& hipsparseSpruneCsr2csr_rank_1 #endif #endif end interface interface hipsparseDpruneCsr2csr #ifdef USE_CUDA_NAMES function hipsparseDpruneCsr2csr_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA,csrColIndA, & threshold,descrC,csrValC,csrRowPtrC,csrColIndC,buffer) & bind(c, name="cusparseDpruneCsr2csr") #else function hipsparseDpruneCsr2csr_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA,csrColIndA, & threshold,descrC,csrValC,csrRowPtrC,csrColIndC,buffer) & bind(c, name="hipsparseDpruneCsr2csr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA real(c_double) :: threshold type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDpruneCsr2csr_assumed_rank #else module procedure & hipsparseDpruneCsr2csr_rank_0,& hipsparseDpruneCsr2csr_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert and prune by percentage a sparse CSR matrix into a sparse CSR matrix. !> !> \details !> \p hipsparseXpruneCsr2csrByPercentage_bufferSize returns the size of the temporary buffer !> that !> is required by `hipsparseSpruneCsr2csrNnzByPercentage` !> "hipsparseXpruneCsr2csrNnzByPercentage()". !> The temporary storage buffer must be allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows in the sparse CSR matrix. !> @param[in] n - number of columns in the sparse CSR matrix. !> @param[in] nnzA - number of non-zeros in the sparse CSR matrix A. !> @param[in] descrA - descriptor of the sparse CSR matrix A. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrValA - array of \p nnzA elements containing the values of the sparse CSR matrix !> A. !> @param[in] csrRowPtrA - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix A. !> @param[in] csrColIndA - array of \p nnzA elements containing the column indices of the sparse !> CSR matrix A. !> @param[in] percentage - \p percentage>=0 and \p percentage<=100. !> @param[in] descrC - descriptor of the sparse CSR matrix C. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrValC - array of \p nnzC elements containing the values of the sparse CSR matrix !> C. !> @param[in] csrRowPtrC - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix C. !> @param[in] csrColIndC - array of \p nnzC elements containing the column indices of the sparse !> CSR matrix C. !> @param[in] myInfo - prune info structure. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseSpruneCsr2csrNnzByPercentage()`, !> hipsparseDpruneCsr2csrNnzByPercentage(), !> hipsparseSpruneCsr2csrByPercentage(), !> and hipsparseDpruneCsr2csrByPercentage(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle or \p pBufferSizeInBytes pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. #ifndef USE_CUDA_NAMES interface hipsparseSpruneCsr2csrByPercentage_bufferSize function hipsparseSpruneCsr2csrByPercentage_bufferSize_(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo, & pBufferSizeInBytes) & bind(c, name="hipsparseSpruneCsr2csrByPercentage_bufferSize") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrByPercentage_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA real(c_float),value :: percentage type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSpruneCsr2csrByPercentage_bufferSize_assumed_rank #else module procedure & hipsparseSpruneCsr2csrByPercentage_bufferSize_rank_0,& hipsparseSpruneCsr2csrByPercentage_bufferSize_rank_1 #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDpruneCsr2csrByPercentage_bufferSize function hipsparseDpruneCsr2csrByPercentage_bufferSize_(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo, & pBufferSizeInBytes) & bind(c, name="hipsparseDpruneCsr2csrByPercentage_bufferSize") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrByPercentage_bufferSize_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA real(c_double),value :: percentage type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDpruneCsr2csrByPercentage_bufferSize_assumed_rank #else module procedure & hipsparseDpruneCsr2csrByPercentage_bufferSize_rank_0,& hipsparseDpruneCsr2csrByPercentage_bufferSize_rank_1 #endif #endif end interface #endif !> \ingroup conv_module !> \brief Convert and prune by percentage a sparse CSR matrix into a sparse CSR matrix. !> !> \details !> \p hipsparseXpruneCsr2csrByPercentage_bufferSizeExt returns the size of the temporary buffer !> that !> is required by `hipsparseSpruneCsr2csrNnzByPercentage` !> "hipsparseXpruneCsr2csrNnzByPercentage()". !> The temporary storage buffer must be allocated by the user. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows in the sparse CSR matrix. !> @param[in] n - number of columns in the sparse CSR matrix. !> @param[in] nnzA - number of non-zeros in the sparse CSR matrix A. !> @param[in] descrA - descriptor of the sparse CSR matrix A. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrValA - array of \p nnzA elements containing the values of the sparse CSR matrix !> A. !> @param[in] csrRowPtrA - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix A. !> @param[in] csrColIndA - array of \p nnzA elements containing the column indices of the sparse !> CSR matrix A. !> @param[in] percentage - \p percentage>=0 and \p percentage<=100. !> @param[in] descrC - descriptor of the sparse CSR matrix C. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrValC - array of \p nnzC elements containing the values of the sparse CSR matrix !> C. !> @param[in] csrRowPtrC - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix C. !> @param[in] csrColIndC - array of \p nnzC elements containing the column indices of the sparse !> CSR matrix C. !> @param[in] myInfo - prune info structure. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseSpruneCsr2csrNnzByPercentage()`, !> hipsparseDpruneCsr2csrNnzByPercentage(), !> hipsparseSpruneCsr2csrByPercentage(), !> and hipsparseDpruneCsr2csrByPercentage(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle or \p pBufferSizeInBytes pointer is invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseSpruneCsr2csrByPercentage_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseSpruneCsr2csrByPercentage_bufferSizeExt_(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo, & pBufferSizeInBytes) & bind(c, name="cusparseSpruneCsr2csrByPercentage_bufferSizeExt") #else function hipsparseSpruneCsr2csrByPercentage_bufferSizeExt_(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo, & pBufferSizeInBytes) & bind(c, name="hipsparseSpruneCsr2csrByPercentage_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrByPercentage_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA real(c_float),value :: percentage type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSpruneCsr2csrByPercentage_bufferSizeExt_assumed_rank #else module procedure & hipsparseSpruneCsr2csrByPercentage_bufferSizeExt_rank_0,& hipsparseSpruneCsr2csrByPercentage_bufferSizeExt_rank_1 #endif #endif end interface interface hipsparseDpruneCsr2csrByPercentage_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseDpruneCsr2csrByPercentage_bufferSizeExt_(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo, & pBufferSizeInBytes) & bind(c, name="cusparseDpruneCsr2csrByPercentage_bufferSizeExt") #else function hipsparseDpruneCsr2csrByPercentage_bufferSizeExt_(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo, & pBufferSizeInBytes) & bind(c, name="hipsparseDpruneCsr2csrByPercentage_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrByPercentage_bufferSizeExt_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA real(c_double),value :: percentage type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDpruneCsr2csrByPercentage_bufferSizeExt_assumed_rank #else module procedure & hipsparseDpruneCsr2csrByPercentage_bufferSizeExt_rank_0,& hipsparseDpruneCsr2csrByPercentage_bufferSizeExt_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert and prune by percentage a sparse CSR matrix into a sparse CSR matrix. !> !> \details !> \p hipsparseXpruneCsr2csrNnzByPercentage computes the number of non-zero elements per row and !> the total !> number of non-zero elements in a sparse CSR matrix after elements less than the threshold are !> pruned from the matrix. !> !> \note The routine supports asynchronous execution if the pointer mode is set to device. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows in the sparse CSR matrix. !> @param[in] n - number of columns in the sparse CSR matrix. !> @param[in] nnzA - number of non-zeros in the sparse CSR matrix A. !> @param[in] descrA - descriptor of the sparse CSR matrix A. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrValA - array of \p nnzA elements containing the values of the sparse CSR matrix !> A. !> @param[in] csrRowPtrA - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix A. !> @param[in] csrColIndA - array of \p nnzA elements containing the column indices of the sparse !> CSR matrix A. !> @param[in] percentage - \p percentage>=0 and \p percentage<=100. !> @param[in] descrC - descriptor of the sparse CSR matrix C. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[out] csrRowPtrC - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix C. !> @param[out] nnzTotalDevHostPtr - total number of non-zero elements in device or host memory. !> @param[in] myInfo - prune info structure. !> @param[out] buffer - buffer allocated by the user whose size is determined by calling !> `hipsparseSpruneCsr2csrByPercentage_bufferSize` !> "hipsparseXpruneCsr2csrByPercentage_bufferSize()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p nnzA, \p percentage, \p !> descrA, \p descrC, !> \p info, \p csrValA, \p csrRowPtrA, \p csrColIndA, \p csrRowPtrC, \p !> nnzTotalDevHostPtr, or \p buffer !> pointer is invalid. interface hipsparseSpruneCsr2csrNnzByPercentage #ifdef USE_CUDA_NAMES function hipsparseSpruneCsr2csrNnzByPercentage_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,percentage,descrC,csrRowPtrC,nnzTotalDevHostPtr,myInfo,buffer) & bind(c, name="cusparseSpruneCsr2csrNnzByPercentage") #else function hipsparseSpruneCsr2csrNnzByPercentage_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,percentage,descrC,csrRowPtrC,nnzTotalDevHostPtr,myInfo,buffer) & bind(c, name="hipsparseSpruneCsr2csrNnzByPercentage") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrNnzByPercentage_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA real(c_float),value :: percentage type(c_ptr),value :: descrC type(c_ptr),value :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr),value :: myInfo type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSpruneCsr2csrNnzByPercentage_assumed_rank #else module procedure & hipsparseSpruneCsr2csrNnzByPercentage_rank_0,& hipsparseSpruneCsr2csrNnzByPercentage_rank_1 #endif #endif end interface interface hipsparseDpruneCsr2csrNnzByPercentage #ifdef USE_CUDA_NAMES function hipsparseDpruneCsr2csrNnzByPercentage_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,percentage,descrC,csrRowPtrC,nnzTotalDevHostPtr,myInfo,buffer) & bind(c, name="cusparseDpruneCsr2csrNnzByPercentage") #else function hipsparseDpruneCsr2csrNnzByPercentage_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,percentage,descrC,csrRowPtrC,nnzTotalDevHostPtr,myInfo,buffer) & bind(c, name="hipsparseDpruneCsr2csrNnzByPercentage") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrNnzByPercentage_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA real(c_double),value :: percentage type(c_ptr),value :: descrC type(c_ptr),value :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr),value :: myInfo type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDpruneCsr2csrNnzByPercentage_assumed_rank #else module procedure & hipsparseDpruneCsr2csrNnzByPercentage_rank_0,& hipsparseDpruneCsr2csrNnzByPercentage_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert and prune by percentage a sparse CSR matrix into a sparse CSR matrix. !> !> \details !> This function converts the sparse CSR matrix A into a sparse CSR matrix C by pruning values !> in A !> that are less than the threshold. All the parameters are assumed to have been preallocated by !> the user. !> The user first calls `hipsparseSpruneCsr2csr_bufferSize` !> "hipsparseXpruneCsr2csr_bufferSize()" to !> determine the size of the buffer used by `hipsparseSpruneCsr2csrNnz` !> "hipsparseXpruneCsr2csrNnz()" and !> \p hipsparseXpruneCsr2csr(), which the user then allocates. The user then allocates \p !> csrRowPtrC to have !> \p m+1 elements and then calls `hipsparseSpruneCsr2csrNnz` "hipsparseXpruneCsr2csrNnz()" !> which fills !> in the \p csrRowPtrC array and stores the number of elements that are larger than the pruning !> \p threshold !> in \p nnzTotalDevHostPtr. The user then calls \p hipsparseXpruneCsr2csr() to complete the !> conversion. The function !> is executed asynchronously with respect to the host and can return control to the application !> on the host !> before the entire result is ready. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows in the sparse CSR matrix. !> @param[in] n - number of columns in the sparse CSR matrix. !> @param[in] nnzA - number of non-zeros in the sparse CSR matrix A. !> @param[in] descrA - descriptor of the sparse CSR matrix A. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[in] csrValA - array of \p nnzA elements containing the values of the sparse CSR matrix !> A. !> @param[in] csrRowPtrA - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix A. !> @param[in] csrColIndA - array of \p nnzA elements containing the column indices of the sparse !> CSR matrix A. !> @param[in] percentage - \p percentage>=0 and \p percentage<=100. !> @param[in] descrC - descriptor of the sparse CSR matrix C. Currently, only !> `HIPSPARSE_MATRIX_TYPE_GENERAL` is supported. !> @param[out] csrValC - array of \p nnz_C elements containing the values of the sparse CSR !> matrix C. !> @param[in] csrRowPtrC - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix C. !> @param[out] csrColIndC - array of \p nnz_C elements containing the column indices of the !> sparse CSR matrix C. !> @param[in] myInfo - prune info structure. !> @param[in] buffer - buffer allocated by the user whose size is determined by calling !> `hipsparseSpruneCsr2csrByPercentage_bufferSize` !> "hipsparseXpruneCsr2csrByPercentage_bufferSize()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p nnzA, \p percentage, \p !> descrA, \p descrC, \p info, !> \p csrValA, \p csrRowPtrA, \p csrColIndA, \p csrValC, \p csrRowPtrC, \p !> csrColIndC, or \p buffer pointer is !> invalid. interface hipsparseSpruneCsr2csrByPercentage #ifdef USE_CUDA_NAMES function hipsparseSpruneCsr2csrByPercentage_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,buffer) & bind(c, name="cusparseSpruneCsr2csrByPercentage") #else function hipsparseSpruneCsr2csrByPercentage_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,buffer) & bind(c, name="hipsparseSpruneCsr2csrByPercentage") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrByPercentage_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA real(c_float),value :: percentage type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC type(c_ptr),value :: myInfo type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSpruneCsr2csrByPercentage_assumed_rank #else module procedure & hipsparseSpruneCsr2csrByPercentage_rank_0,& hipsparseSpruneCsr2csrByPercentage_rank_1 #endif #endif end interface interface hipsparseDpruneCsr2csrByPercentage #ifdef USE_CUDA_NAMES function hipsparseDpruneCsr2csrByPercentage_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,buffer) & bind(c, name="cusparseDpruneCsr2csrByPercentage") #else function hipsparseDpruneCsr2csrByPercentage_(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,buffer) & bind(c, name="hipsparseDpruneCsr2csrByPercentage") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrByPercentage_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA real(c_double),value :: percentage type(c_ptr),value :: descrC type(c_ptr),value :: csrValC type(c_ptr),value :: csrRowPtrC type(c_ptr),value :: csrColIndC type(c_ptr),value :: myInfo type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDpruneCsr2csrByPercentage_assumed_rank #else module procedure & hipsparseDpruneCsr2csrByPercentage_rank_0,& hipsparseDpruneCsr2csrByPercentage_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief !> \p hipsparseXpruneDense2csr_bufferSize computes the the size of the user-allocated temporary !> storage buffer !> used when converting a dense matrix to a pruned CSR matrix. !> !> \details !> Specifically given an input dense column-ordered matrix A, with leading dimension \p lda, !> where \p lda>=m, !> the resulting pruned sparse CSR matrix C is computed using: !> \f[ !> |C(i,j)| = A(i, j) \text{ if |A(i, j)| > threshold} !> \f] !> !> The first step in this conversion is to determine the required user-allocated buffer size !> using \p hipsparseXpruneDense2csr_bufferSize() that will be passed to the subsequent steps of !> the conversion. !> After the buffer size has been determined, the user must allocate it. This user-allocated !> buffer is then passed !> to `hipsparseSpruneDense2csrNnz` "hipsparseXpruneDense2csrNnz()" and !> `hipsparseSpruneDense2csr` !> "hipsparseXpruneDense2csr()" to complete the conversion. The user is responsible for then !> freeing the buffer after !> the conversion has been completed. !> !> See `hipsparseSpruneDense2csr()` for a full code example. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 12.0+) and will be !> removed in CUDA 13.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the dense matrix \p A. Must be non-negative. !> @param[in] n - number of columns of the dense matrix \p A. Must be non-negative. !> @param[in] A - array of dimensions (\p lda, \p n). !> @param[in] lda - leading dimension of dense array \p A. Must be at least \p m. !> @param[in] threshold - pointer to the pruning non-negative threshold, which can exist in !> either host or device memory. !> @param[in] descr - the descriptor of the dense matrix \p A. The supported matrix type is !> `HIPSPARSE_MATRIX_TYPE_GENERAL` !> and any valid value of the `hipsparseIndexBase_t`. !> @param[in] csrVal - array of nnz ( = \p csrRowPtr[m] - \p csrRowPtr[0] ) non-zero elements of !> matrix \p A. !> @param[in] csrRowPtr - integer array of \p m+1 elements that contains the start of every row !> and the end of the last row plus one. !> @param[in] csrColInd - integer array of nnz ( = \p csrRowPtr[m] - \p csrRowPtr[0] ) column !> indices of the non-zero elements of matrix \p A. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseSpruneDense2csrNnz()`, hipsparseDpruneDense2csrNnz(), !> `hipsparseSpruneDense2csr()`, and hipsparseDpruneDense2csr(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle or \p pBufferSizeInBytes is nullptr, !> or \p m or \p n is negative. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. #ifndef USE_CUDA_NAMES interface hipsparseSpruneDense2csr_bufferSize function hipsparseSpruneDense2csr_bufferSize_(handle,m,n,A,lda,threshold,descr,csrVal, & csrRowPtr,csrColInd,pBufferSizeInBytes) & bind(c, name="hipsparseSpruneDense2csr_bufferSize") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csr_bufferSize_ 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 type(c_ptr),value :: threshold type(c_ptr),value :: descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSpruneDense2csr_bufferSize_assumed_rank #else module procedure & hipsparseSpruneDense2csr_bufferSize_rank_0,& hipsparseSpruneDense2csr_bufferSize_rank_1,& hipsparseSpruneDense2csr_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDpruneDense2csr_bufferSize function hipsparseDpruneDense2csr_bufferSize_(handle,m,n,A,lda,threshold,descr,csrVal, & csrRowPtr,csrColInd,pBufferSizeInBytes) & bind(c, name="hipsparseDpruneDense2csr_bufferSize") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csr_bufferSize_ 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 type(c_ptr),value :: threshold type(c_ptr),value :: descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDpruneDense2csr_bufferSize_assumed_rank #else module procedure & hipsparseDpruneDense2csr_bufferSize_rank_0,& hipsparseDpruneDense2csr_bufferSize_rank_1,& hipsparseDpruneDense2csr_bufferSize_full_rank #endif #endif end interface #endif interface hipsparseSpruneDense2csr_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseSpruneDense2csr_bufferSizeExt_(handle,m,n,A,lda,threshold,descr,csrVal, & csrRowPtr,csrColInd,pBufferSizeInBytes) & bind(c, name="cusparseSpruneDense2csr_bufferSizeExt") #else function hipsparseSpruneDense2csr_bufferSizeExt_(handle,m,n,A,lda,threshold,descr,csrVal, & csrRowPtr,csrColInd,pBufferSizeInBytes) & bind(c, name="hipsparseSpruneDense2csr_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csr_bufferSizeExt_ 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 type(c_ptr),value :: threshold type(c_ptr),value :: descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSpruneDense2csr_bufferSizeExt_assumed_rank #else module procedure & hipsparseSpruneDense2csr_bufferSizeExt_rank_0,& hipsparseSpruneDense2csr_bufferSizeExt_rank_1,& hipsparseSpruneDense2csr_bufferSizeExt_full_rank #endif #endif end interface interface hipsparseDpruneDense2csr_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseDpruneDense2csr_bufferSizeExt_(handle,m,n,A,lda,threshold,descr,csrVal, & csrRowPtr,csrColInd,pBufferSizeInBytes) & bind(c, name="cusparseDpruneDense2csr_bufferSizeExt") #else function hipsparseDpruneDense2csr_bufferSizeExt_(handle,m,n,A,lda,threshold,descr,csrVal, & csrRowPtr,csrColInd,pBufferSizeInBytes) & bind(c, name="hipsparseDpruneDense2csr_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csr_bufferSizeExt_ 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 type(c_ptr),value :: threshold type(c_ptr),value :: descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDpruneDense2csr_bufferSizeExt_assumed_rank #else module procedure & hipsparseDpruneDense2csr_bufferSizeExt_rank_0,& hipsparseDpruneDense2csr_bufferSizeExt_rank_1,& hipsparseDpruneDense2csr_bufferSizeExt_full_rank #endif #endif end interface !> \ingroup conv_module !> \brief !> \p hipsparseXpruneDense2csrNnz computes the number of non-zero elements per row and the total !> number of non-zero elements in a dense matrix after the elements less than the (non-negative) !> threshold are !> pruned from the matrix. !> !> \details !> Given an input dense column ordered matrix \p A, with leading dimension \p lda where \p !> lda>=m, !> the resulting pruned sparse CSR matrix \f$C\f$ is computed using: !> \f[ !> |C(i,j)| = A(i, j) \text{ if |A(i, j)| > threshold} !> \f] !> !> First, the user must determine the size of the required temporary buffer using the routine !> `hipsparseSpruneDense2csr_bufferSize` "hipsparseXpruneDense2csr_bufferSize()" and then !> allocate it. Next, !> the user allocates \p csrRowPtr with size \p m+1. Then the function passes both the temporary !> storage buffer and !> \p csrRowPtr to \p hipsparseXpruneDense2csrNnz to determine the total number of non-zeros !> that !> will exist in the sparse CSR matrix C (after pruning has been performed on \p A ) as well as !> fill the output CSR !> row pointer array \p csrRowPtr. !> !> For example, given the dense matrix: !> !> \f[ !> \begin{bmatrix} !> 6 & 2 & 3 & 7 \\% !> 5 & 6 & 7 & 8 \\% !> 5 & 4 & 8 & 1 !> \end{bmatrix} !> \f] !> !> and the \p threshold value 5, the resulting matrix after pruning is: !> !> \f[ !> \begin{bmatrix} !> 6 & 0 & 0 & 7 \\% !> 0 & 6 & 7 & 8 \\% !> 0 & 0 & 8 & 0 !> \end{bmatrix} !> \f] !> !> and the corresponding row pointer array and non-zero count: !> !> \f[ !> \begin{align} !> \text{csrRowPtr} &= \begin{bmatrix} 0 & 2 & 5 & 6 \end{bmatrix} \\% !> \text{nnzTotalDevHostPtr} &= 6 !> \end{align} !> \f] !> !> The above example assumes a zero index base for the output CSR matrix. Users can set the !> desired index base !> in the output CSR matrix by setting it in the `hipsparseMatDescr_t`. See !> `hipsparseSetMatIndexBase` (). !> !> For a full code example on how to use this routine, see `hipsparseSpruneDense2csr()`. !> !> \note !> The routine supports asynchronous execution if the pointer mode is set to device. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the dense matrix \p A. !> @param[in] n - number of columns of the dense matrix \p A. !> @param[in] A - array of dimensions (\p lda, \p n). !> @param[in] lda - leading dimension of the dense array \p A. !> @param[in] threshold - pointer to the pruning non-negative threshold, which can exist in !> either host or device memory. !> @param[in] descr - the descriptor of the dense matrix \p A. !> @param[out] csrRowPtr - integer array of \p m+1 elements that contains the start of every row !> and the end of the last row plus one. !> @param[out] nnzTotalDevHostPtr - total number of non-zero elements in device or host memory. !> @param[out] buffer - buffer allocated by the user whose size is determined by calling !> `hipsparseSpruneDense2csr_bufferSize` !> "hipsparseXpruneDense2csr_bufferSize()" or !> `hipsparseSpruneDense2csr_bufferSizeExt` !> "hipsparseXpruneDense2csr_bufferSizeExt()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p lda, \p A, \p threshold, \p !> descr, \p csrRowPtr, !> \p nnzTotalDevHostPtr, or \p buffer pointer is invalid. interface hipsparseSpruneDense2csrNnz #ifdef USE_CUDA_NAMES function hipsparseSpruneDense2csrNnz_(handle,m,n,A,lda,threshold,descr,csrRowPtr, & nnzTotalDevHostPtr,buffer) & bind(c, name="cusparseSpruneDense2csrNnz") #else function hipsparseSpruneDense2csrNnz_(handle,m,n,A,lda,threshold,descr,csrRowPtr, & nnzTotalDevHostPtr,buffer) & bind(c, name="hipsparseSpruneDense2csrNnz") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrNnz_ 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 real(c_float) :: threshold type(c_ptr),value :: descr type(c_ptr),value :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSpruneDense2csrNnz_assumed_rank #else module procedure & hipsparseSpruneDense2csrNnz_rank_0,& hipsparseSpruneDense2csrNnz_rank_1,& hipsparseSpruneDense2csrNnz_full_rank #endif #endif end interface interface hipsparseDpruneDense2csrNnz #ifdef USE_CUDA_NAMES function hipsparseDpruneDense2csrNnz_(handle,m,n,A,lda,threshold,descr,csrRowPtr, & nnzTotalDevHostPtr,buffer) & bind(c, name="cusparseDpruneDense2csrNnz") #else function hipsparseDpruneDense2csrNnz_(handle,m,n,A,lda,threshold,descr,csrRowPtr, & nnzTotalDevHostPtr,buffer) & bind(c, name="hipsparseDpruneDense2csrNnz") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrNnz_ 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 real(c_double) :: threshold type(c_ptr),value :: descr type(c_ptr),value :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDpruneDense2csrNnz_assumed_rank #else module procedure & hipsparseDpruneDense2csrNnz_rank_0,& hipsparseDpruneDense2csrNnz_rank_1,& hipsparseDpruneDense2csrNnz_full_rank #endif #endif end interface !> \ingroup conv_module !> \brief !> \p hipsparseXpruneDense2csr converts the matrix \p A in dense format into a sparse matrix in !> CSR format, !> while pruning values that are less than the (non-negative) threshold. All the parameters are !> assumed !> to have been pre-allocated by the user. !> !> \details !> Given an input dense column ordered matrix \p A, with leading dimension \p lda, where \p !> lda>=m, !> the resulting pruned sparse CSR matrix C is computed using: !> \f[ !> |C(i,j)| = A(i, j) \text{ if |A(i, j)| > threshold} !> \f] !> !> The user first calls `hipsparseSpruneDense2csr_bufferSize` !> "hipsparseXpruneDense2csr_bufferSize()" to !> determine the size of the required user-allocated temporary storage buffer. The user then !> allocates this !> buffer. Next, the user allocates \p csrRowPtr to have \p m+1 elements and then calls !> `hipsparseSpruneDense2csrNnz` "hipsparseXpruneDense2csrNnz()", which fills in the \p !> csrRowPtr array !> and stores the number of elements that are larger than the pruning \p threshold in \p !> nnzTotalDevHostPtr. !> The user then allocates \p csrColInd and \p csrVal to have size \p nnzTotalDevHostPtr and !> completes the !> conversion by calling \p hipsparseXpruneDense2csr(). !> !> For example, performing these steps with the dense input matrix \p A : !> \f[ !> \begin{bmatrix} !> 6 & 2 & 3 & 7 \\% !> 5 & 6 & 7 & 8 \\% !> 5 & 4 & 8 & 1 !> \end{bmatrix} !> \f] !> !> and the \p threshold value 5, results in the pruned matrix C: !> !> \f[ !> \begin{bmatrix} !> 6 & 0 & 0 & 7 \\% !> 0 & 6 & 7 & 8 \\% !> 0 & 0 & 8 & 0 !> \end{bmatrix} !> \f] !> !> and corresponding CSR row, column, and values arrays: !> !> \f[ !> \begin{align} !> \text{csrRowPtr} &= \begin{bmatrix} 0 & 2 & 5 & 6 \end{bmatrix} \\% !> \text{csrColInd} &= \begin{bmatrix} 0 & 3 & 1 & 2 & 3 & 2 \end{bmatrix} \\% !> \text{csrVal} &= \begin{bmatrix} 6 & 7 & 6 & 7 & 8 & 8 \end{bmatrix} \\% !> \end{align} !> \f] !> !> \note !> The routine \p hipsparseXpruneDense2csr() is executed asynchronously with respect to the host !> and can !> return control to the application on the host before the entire result is ready. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the dense matrix \p A. !> @param[in] n - number of columns of the dense matrix \p A. !> @param[in] A - array of dimensions (\p lda, \p n). !> @param[in] lda - leading dimension of dense array \p A. !> @param[in] threshold - pointer to the non-negative pruning threshold, which can exist in !> either host or device memory. !> @param[in] descr - the descriptor of the dense matrix \p A. The supported matrix type is !> `HIPSPARSE_MATRIX_TYPE_GENERAL` !> and any valid value of the `hipsparseIndexBase_t`. !> @param[out] csrVal - array of nnz ( = \p csrRowPtr[m] - \p csrRowPtr[0] ) non-zero elements !> of matrix \p A. !> @param[in] csrRowPtr - integer array of \p m+1 elements that contains the start of every row !> and the end of the last row plus one. !> @param[out] csrColInd - integer array of nnz ( = \p csrRowPtr[m] - \p csrRowPtr[0] ) column !> indices of the non-zero elements of matrix \p A. !> !> @param[in] buffer - temporary storage buffer allocated by the user. The size is returned by !> `hipsparseSpruneDense2csr_bufferSize` "hipsparseXpruneDense2csr_bufferSize()" or !> `hipsparseSpruneDense2csr_bufferSizeExt` !> "hipsparseXpruneDense2csr_bufferSizeExt()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p lda, \p A, \p descr, \p !> threshold, \p csrVal, !> \p csrRowPtr, \p csrColInd, or \p buffer pointer is invalid. interface hipsparseSpruneDense2csr #ifdef USE_CUDA_NAMES function hipsparseSpruneDense2csr_(handle,m,n,A,lda,threshold,descr,csrVal,csrRowPtr, & csrColInd,buffer) & bind(c, name="cusparseSpruneDense2csr") #else function hipsparseSpruneDense2csr_(handle,m,n,A,lda,threshold,descr,csrVal,csrRowPtr, & csrColInd,buffer) & bind(c, name="hipsparseSpruneDense2csr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csr_ 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 real(c_float) :: threshold type(c_ptr),value :: descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSpruneDense2csr_assumed_rank #else module procedure & hipsparseSpruneDense2csr_rank_0,& hipsparseSpruneDense2csr_rank_1,& hipsparseSpruneDense2csr_full_rank #endif #endif end interface interface hipsparseDpruneDense2csr #ifdef USE_CUDA_NAMES function hipsparseDpruneDense2csr_(handle,m,n,A,lda,threshold,descr,csrVal,csrRowPtr, & csrColInd,buffer) & bind(c, name="cusparseDpruneDense2csr") #else function hipsparseDpruneDense2csr_(handle,m,n,A,lda,threshold,descr,csrVal,csrRowPtr, & csrColInd,buffer) & bind(c, name="hipsparseDpruneDense2csr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csr_ 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 real(c_double) :: threshold type(c_ptr),value :: descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDpruneDense2csr_assumed_rank #else module procedure & hipsparseDpruneDense2csr_rank_0,& hipsparseDpruneDense2csr_rank_1,& hipsparseDpruneDense2csr_full_rank #endif #endif end interface !> \ingroup conv_module !> \brief !> \p hipsparseXpruneDense2csrByPercentage_bufferSize functions convert the size of the !> user-allocated temporary !> storage buffer used when converting a dense matrix to a pruned CSR matrix where the pruning !> is done !> based on a \p percentage. !> !> \details !> When converting and pruning a dense matrix \p A to a CSR matrix by percentage, the !> following steps are performed. First, the user calls !> \p hipsparseXpruneDense2csrByPercentage_bufferSize, which determines the size of the !> temporary storage buffer. After this is determined, this buffer must be allocated by the !> user. !> Next, the user allocates the \p csrRowPtr array to have \p m+1 elements and calls !> `hipsparseSpruneDense2csrNnzByPercentage` "hipsparseXpruneDense2csrNnzByPercentage()". !> Finally, the user finishes the conversion by allocating the \p csrColInd and \p csrVal arrays !> (whose size is determined by the value at \p nnzTotalDevHostPtr) and calling !> `hipsparseSpruneDense2csrByPercentage` "hipsparseXpruneDense2csrByPercentage()". !> !> The pruning by \p percentage works by first sorting the absolute values of the dense !> matrix \p A. Users can then determine a position in this sorted array by !> \f[ !> pos = ceil(m \cdot n \cdot (percentage/100)) - 1 \\% !> pos = \min(pos, m \cdot n-1) \\% !> pos = \max(pos, 0) \\% !> threshold = sorted_A[pos] !> \f] !> !> After the user has this threshold, they can prune values in the dense matrix \p A, as in !> `hipsparseSpruneDense2csr` "hipsparseXpruneDense2csr()". !> !> \note !> This function is executed asynchronously with respect to the host and can return control to !> the !> application on the host before the entire result is ready. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the dense matrix \p A. !> @param[in] n - number of columns of the dense matrix \p A. !> @param[in] A - array of dimensions (\p lda, \p n). !> @param[in] lda - leading dimension of dense array \p A. !> @param[in] percentage - \p percentage>=0 and \p percentage<=100. !> @param[in] descr - the descriptor of the dense matrix \p A. The supported matrix type is !> `HIPSPARSE_MATRIX_TYPE_GENERAL` and !> any valid value of the `hipsparseIndexBase_t`. !> @param[in] csrVal - array of nnz ( = \p csrRowPtr[m] - \p csrRowPtr[0] ) nonzero elements of !> matrix \p A. !> @param[in] csrRowPtr - integer array of \p m+1 elements that contains the start of every row !> and the end of the last row plus one. !> @param[in] csrColInd - integer array of nnz ( = \p csrRowPtr[m] - \p csrRowPtr[0] ) column !> indices of the non-zero elements of matrix \p A. !> @param[in] myInfo - prune information structure. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseSpruneDense2csrNnzByPercentage()` and !> hipsparseDpruneDense2csrNnzByPercentage(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE the \p handle or \p pBufferSizeInBytes pointer is !> invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. #ifndef USE_CUDA_NAMES interface hipsparseSpruneDense2csrByPercentage_bufferSize function hipsparseSpruneDense2csrByPercentage_bufferSize_(handle,m,n,A,lda,percentage,descr, & csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseSpruneDense2csrByPercentage_bufferSize") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrByPercentage_bufferSize_ 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 real(c_float),value :: percentage type(c_ptr),value :: descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSpruneDense2csrByPercentage_bufferSize_assumed_rank #else module procedure & hipsparseSpruneDense2csrByPercentage_bufferSize_rank_0,& hipsparseSpruneDense2csrByPercentage_bufferSize_rank_1,& hipsparseSpruneDense2csrByPercentage_bufferSize_full_rank #endif #endif end interface #endif #ifndef USE_CUDA_NAMES interface hipsparseDpruneDense2csrByPercentage_bufferSize function hipsparseDpruneDense2csrByPercentage_bufferSize_(handle,m,n,A,lda,percentage,descr, & csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseDpruneDense2csrByPercentage_bufferSize") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrByPercentage_bufferSize_ 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 real(c_double),value :: percentage type(c_ptr),value :: descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDpruneDense2csrByPercentage_bufferSize_assumed_rank #else module procedure & hipsparseDpruneDense2csrByPercentage_bufferSize_rank_0,& hipsparseDpruneDense2csrByPercentage_bufferSize_rank_1,& hipsparseDpruneDense2csrByPercentage_bufferSize_full_rank #endif #endif end interface #endif !> \ingroup conv_module !> \brief !> This function computes the size of the user-allocated temporary storage buffer used !> when converting and pruning by \p percentage a dense matrix to a CSR matrix. !> !> \details !> When converting and pruning a dense matrix \p A to a CSR matrix by \p percentage, the !> following steps are performed. First, the user calls !> \p hipsparseXpruneDense2csrByPercentage_bufferSizeExt, which determines the size of the !> temporary storage buffer. After this is determined, this buffer must be allocated by the !> user. !> Next, the user allocates the \p csrRowPtr array to have \p m+1 elements and calls !> `hipsparseSpruneDense2csrNnzByPercentage` "hipsparseXpruneDense2csrNnzByPercentage()". !> Finally, the user finishes the conversion by allocating the \p csrColInd and \p csrVal arrays !> (whose size is determined by the value at \p nnzTotalDevHostPtr) and calling !> `hipsparseSpruneDense2csrByPercentage` "hipsparseXpruneDense2csrByPercentage()". !> !> The pruning by \p percentage works by first sorting the absolute values of the dense !> matrix \p A. Users can then determine a position in this sorted array by !> \f[ !> pos = ceil(m \cdot n \cdot (percentage/100)) - 1 \\% !> pos = \min(pos, m \cdot n-1) \\% !> pos = \max(pos, 0) \\% !> threshold = sorted_A[pos] !> \f] !> !> After users have this threshold, they can prune values in the dense matrix \p A, as in !> `hipsparseSpruneDense2csr` "hipsparseXpruneDense2csr()". !> !> \note !> This function is executed asynchronously with respect to the host and can return control to !> the !> application on the host before the entire result is ready. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the dense matrix \p A. !> @param[in] n - number of columns of the dense matrix \p A. !> @param[in] A - array of dimensions (\p lda, \p n). !> @param[in] lda - leading dimension of dense array \p A. !> @param[in] percentage - \p percentage>=0 and \p percentage<=100. !> @param[in] descr - the descriptor of the dense matrix \p A. The supported matrix type is !> `HIPSPARSE_MATRIX_TYPE_GENERAL` and !> any valid value of the `hipsparseIndexBase_t`. !> @param[in] csrVal - array of nnz ( = \p csrRowPtr[m] - \p csrRowPtr[0] ) non-zero elements of !> matrix \p A. !> @param[in] csrRowPtr - integer array of \p m+1 elements that contains the start of every row !> and the end of the last row plus one. !> @param[in] csrColInd - integer array of nnz ( = \p csrRowPtr[m] - \p csrRowPtr[0] ) column !> indices of the non-zero elements of matrix \p A. !> @param[in] myInfo - prune information structure. !> @param[out] pBufferSizeInBytes - number of bytes of the temporary storage buffer required by !> `hipsparseSpruneDense2csrNnzByPercentage()` and !> hipsparseDpruneDense2csrNnzByPercentage(). !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE the \p handle or \p pBufferSizeInBytes pointer is !> invalid. !> \retval HIPSPARSE_STATUS_INTERNAL_ERROR an internal error occurred. interface hipsparseSpruneDense2csrByPercentage_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseSpruneDense2csrByPercentage_bufferSizeExt_(handle,m,n,A,lda,percentage, & descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseSpruneDense2csrByPercentage_bufferSizeExt") #else function hipsparseSpruneDense2csrByPercentage_bufferSizeExt_(handle,m,n,A,lda,percentage, & descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseSpruneDense2csrByPercentage_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrByPercentage_bufferSizeExt_ 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 real(c_float),value :: percentage type(c_ptr),value :: descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSpruneDense2csrByPercentage_bufferSizeExt_assumed_rank #else module procedure & hipsparseSpruneDense2csrByPercentage_bufferSizeExt_rank_0,& hipsparseSpruneDense2csrByPercentage_bufferSizeExt_rank_1,& hipsparseSpruneDense2csrByPercentage_bufferSizeExt_full_rank #endif #endif end interface interface hipsparseDpruneDense2csrByPercentage_bufferSizeExt #ifdef USE_CUDA_NAMES function hipsparseDpruneDense2csrByPercentage_bufferSizeExt_(handle,m,n,A,lda,percentage, & descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) & bind(c, name="cusparseDpruneDense2csrByPercentage_bufferSizeExt") #else function hipsparseDpruneDense2csrByPercentage_bufferSizeExt_(handle,m,n,A,lda,percentage, & descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) & bind(c, name="hipsparseDpruneDense2csrByPercentage_bufferSizeExt") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrByPercentage_bufferSizeExt_ 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 real(c_double),value :: percentage type(c_ptr),value :: descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: myInfo integer(c_size_t) :: pBufferSizeInBytes end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDpruneDense2csrByPercentage_bufferSizeExt_assumed_rank #else module procedure & hipsparseDpruneDense2csrByPercentage_bufferSizeExt_rank_0,& hipsparseDpruneDense2csrByPercentage_bufferSizeExt_rank_1,& hipsparseDpruneDense2csrByPercentage_bufferSizeExt_full_rank #endif #endif end interface !> \ingroup conv_module !> \brief !> This function computes the number of non-zero elements per row and the total number of !> non-zero elements in a dense matrix when converting and pruning by \p percentage a dense !> matrix to a CSR matrix. !> !> \details !> When converting and pruning a dense matrix \p A to a CSR matrix by \p percentage, the !> following steps are performed. First, the user calls !> `hipsparseSpruneDense2csrByPercentage_bufferSize` !> "hipsparseXpruneDense2csrByPercentage_bufferSize()", !> which determines the size of the temporary storage buffer. After this is determined, this !> buffer must be allocated !> by the user. Next, the user allocates the \p csrRowPtr array to have \p m+1 elements and !> calls !> \p hipsparseXpruneDense2csrNnzByPercentage. Finally, the user finishes the conversion !> by allocating the \p csrColInd and \p csrVal arrays (which have a size determined by the !> value !> at \p nnzTotalDevHostPtr) and calling `hipsparseSpruneDense2csrByPercentage` !> "hipsparseXpruneDense2csrByPercentage()". !> !> The pruning by \p percentage works by first sorting the absolute values of the dense !> matrix \p A. Users can then determine a position in this sorted array by !> \f[ !> pos = ceil(m \cdot n \cdot (percentage/100)) - 1 \\% !> pos = \min(pos, m \cdot n-1) \\% !> pos = \max(pos, 0) \\% !> threshold = sorted_A[pos] !> \f] !> !> After users have this threshold, they can prune values in the dense matrix \p A, as in !> `hipsparseSpruneDense2csr` "hipsparseXpruneDense2csr()". !> !> \note !> This routine supports asynchronous execution if the pointer mode is set to device. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the dense matrix \p A. !> @param[in] n - number of columns of the dense matrix \p A. !> @param[in] A - array of dimensions (\p lda, \p n). !> @param[in] lda - leading dimension of dense array \p A. !> @param[in] percentage - \p percentage>=0 and \p percentage<=100. !> @param[in] descr - the descriptor of the dense matrix \p A. !> @param[out] csrRowPtr - integer array of \p m+1 elements that contains the start of every row !> and the end of the last row plus one. !> @param[out] nnzTotalDevHostPtr - total number of non-zero elements in device or host memory. !> @param[in] myInfo - prune information structure !> @param[out] buffer - buffer allocated by the user whose size is determined by calling !> `hipsparseSpruneDense2csrByPercentage_bufferSize` !> "hipsparseXpruneDense2csrByPercentage_bufferSize()" !> or `hipsparseSpruneDense2csrByPercentage_bufferSizeExt` !> "hipsparseXpruneDense2csrByPercentage_bufferSizeExt()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p lda, \p percentage, \p A, \p !> descr, \p info, \p csrRowPtr, !> \p nnzTotalDevHostPtr, or \p buffer pointer is invalid. interface hipsparseSpruneDense2csrNnzByPercentage #ifdef USE_CUDA_NAMES function hipsparseSpruneDense2csrNnzByPercentage_(handle,m,n,A,lda,percentage,descr,csrRowPtr, & nnzTotalDevHostPtr,myInfo,buffer) & bind(c, name="cusparseSpruneDense2csrNnzByPercentage") #else function hipsparseSpruneDense2csrNnzByPercentage_(handle,m,n,A,lda,percentage,descr,csrRowPtr, & nnzTotalDevHostPtr,myInfo,buffer) & bind(c, name="hipsparseSpruneDense2csrNnzByPercentage") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrNnzByPercentage_ 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 real(c_float),value :: percentage type(c_ptr),value :: descr type(c_ptr),value :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr),value :: myInfo type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSpruneDense2csrNnzByPercentage_assumed_rank #else module procedure & hipsparseSpruneDense2csrNnzByPercentage_rank_0,& hipsparseSpruneDense2csrNnzByPercentage_rank_1,& hipsparseSpruneDense2csrNnzByPercentage_full_rank #endif #endif end interface interface hipsparseDpruneDense2csrNnzByPercentage #ifdef USE_CUDA_NAMES function hipsparseDpruneDense2csrNnzByPercentage_(handle,m,n,A,lda,percentage,descr,csrRowPtr, & nnzTotalDevHostPtr,myInfo,buffer) & bind(c, name="cusparseDpruneDense2csrNnzByPercentage") #else function hipsparseDpruneDense2csrNnzByPercentage_(handle,m,n,A,lda,percentage,descr,csrRowPtr, & nnzTotalDevHostPtr,myInfo,buffer) & bind(c, name="hipsparseDpruneDense2csrNnzByPercentage") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrNnzByPercentage_ 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 real(c_double),value :: percentage type(c_ptr),value :: descr type(c_ptr),value :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr),value :: myInfo type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDpruneDense2csrNnzByPercentage_assumed_rank #else module procedure & hipsparseDpruneDense2csrNnzByPercentage_rank_0,& hipsparseDpruneDense2csrNnzByPercentage_rank_1,& hipsparseDpruneDense2csrNnzByPercentage_full_rank #endif #endif end interface !> \ingroup conv_module !> \brief !> This function computes the number of non-zero elements per row and the total number of !> non-zero elements in a dense matrix when converting and pruning by \p percentage a dense !> matrix to a CSR matrix. !> !> \details !> When converting and pruning a dense matrix \p A to a CSR matrix by \p percentage, the !> following steps are performed. First, the user calls !> `hipsparseSpruneDense2csrByPercentage_bufferSize` !> "hipsparseXpruneDense2csrByPercentage_bufferSize()", which determines the size of the !> temporary storage buffer. After this is determined, this buffer must be allocated by the !> user. !> Next, the user allocates the \p csrRowPtr array to have \p m+1 elements and calls !> `hipsparseSpruneDense2csrNnzByPercentage` "hipsparseXpruneDense2csrNnzByPercentage()". !> Finally, the !> user finishes the conversion by allocating the \p csrColInd and \p csrVal arrays (which have !> a size !> determined by the value at \p nnzTotalDevHostPtr) and calling \p !> hipsparseXpruneDense2csrByPercentage. !> !> The pruning by \p percentage works by first sorting the absolute values of the dense !> matrix \p A. Users can then determine a position in this sorted array by !> \f[ !> pos = ceil(m \ cdot n \cdot (percentage/100)) - 1 \\% !> pos = \min(pos, m \cdot n-1) \\% !> pos = \max(pos, 0) \\% !> threshold = sorted_A[pos] !> \f] !> !> After users have this threshold, they can prune values in the dense matrix \p A, as in !> `hipsparseSpruneDense2csr` "hipsparseXpruneDense2csr()". !> !> \note !> This routine support asynchronous execution if the pointer mode is set to device. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of the dense matrix \p A. !> @param[in] n - number of columns of the dense matrix \p A. !> @param[in] A - array of dimensions (\p lda, \p n). !> @param[in] lda - leading dimension of dense array \p A. !> @param[in] percentage - \p percentage>=0 and \p percentage<=100. !> @param[in] descr - the descriptor of the dense matrix \p A. The supported matrix type is !> `HIPSPARSE_MATRIX_TYPE_GENERAL` and !> any valid value of the `hipsparseIndexBase_t`. !> @param[out] csrVal - array of nnz ( = \p csrRowPtr[m] - \p csrRowPtr[0] ) non-zero elements !> of matrix \p A. !> @param[in] csrRowPtr - integer array of \p m+1 elements that contains the start of every row !> and the end of the last row plus one. !> @param[out] csrColInd - integer array of nnz ( = \p csrRowPtr[m] - \p csrRowPtr[0] ) column !> indices of the non-zero elements of matrix \p A. !> @param[in] myInfo - prune information structure !> @param[in] buffer - temporary storage buffer allocated by the user. The size is returned by !> `hipsparseSpruneDense2csrByPercentage_bufferSize` !> "hipsparseXpruneDense2csrByPercentage_bufferSize()" or !> `hipsparseSpruneDense2csrByPercentage_bufferSizeExt` !> "hipsparseXpruneDense2csrByPercentage_bufferSizeExt()". !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p m, \p n, \p lda, \p percentage, \p A, \p !> descr, \p info, \p csrVal, !> \p csrRowPtr, \p csrColInd, or \p buffer pointer is invalid. interface hipsparseSpruneDense2csrByPercentage #ifdef USE_CUDA_NAMES function hipsparseSpruneDense2csrByPercentage_(handle,m,n,A,lda,percentage,descr,csrVal, & csrRowPtr,csrColInd,myInfo,buffer) & bind(c, name="cusparseSpruneDense2csrByPercentage") #else function hipsparseSpruneDense2csrByPercentage_(handle,m,n,A,lda,percentage,descr,csrVal, & csrRowPtr,csrColInd,myInfo,buffer) & bind(c, name="hipsparseSpruneDense2csrByPercentage") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrByPercentage_ 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 real(c_float),value :: percentage type(c_ptr),value :: descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: myInfo type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseSpruneDense2csrByPercentage_assumed_rank #else module procedure & hipsparseSpruneDense2csrByPercentage_rank_0,& hipsparseSpruneDense2csrByPercentage_rank_1,& hipsparseSpruneDense2csrByPercentage_full_rank #endif #endif end interface interface hipsparseDpruneDense2csrByPercentage #ifdef USE_CUDA_NAMES function hipsparseDpruneDense2csrByPercentage_(handle,m,n,A,lda,percentage,descr,csrVal, & csrRowPtr,csrColInd,myInfo,buffer) & bind(c, name="cusparseDpruneDense2csrByPercentage") #else function hipsparseDpruneDense2csrByPercentage_(handle,m,n,A,lda,percentage,descr,csrVal, & csrRowPtr,csrColInd,myInfo,buffer) & bind(c, name="hipsparseDpruneDense2csrByPercentage") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrByPercentage_ 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 real(c_double),value :: percentage type(c_ptr),value :: descr type(c_ptr),value :: csrVal type(c_ptr),value :: csrRowPtr type(c_ptr),value :: csrColInd type(c_ptr),value :: myInfo type(c_ptr),value :: buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDpruneDense2csrByPercentage_assumed_rank #else module procedure & hipsparseDpruneDense2csrByPercentage_rank_0,& hipsparseDpruneDense2csrByPercentage_rank_1,& hipsparseDpruneDense2csrByPercentage_full_rank #endif #endif end interface !> \ingroup reordering_module !> \brief Coloring of the adjacency graph of the matrix \f$A\f$ stored in the CSR format. !> !> \details !> \p hipsparseXcsrcolor performs the coloring of the undirected graph represented by the !> (symmetric) sparsity !> pattern of the matrix \f$A\f$ stored in CSR format. Graph coloring is a way of coloring the !> nodes of a graph !> such that no two adjacent nodes are of the same color. The \p fractionToColor is a parameter !> to only color !> a given percentage of the graph nodes. The remaining uncolored nodes receive distinct new !> colors. The optional !> \p reordering array is a permutation array that groups unknowns of the same color. The matrix !> \f$A\f$ !> must be stored as a general matrix with a symmetric sparsity pattern, and if the matrix !> \f$A\f$ is non-symmetric, !> then the user is responsible to provide the symmetric part \f$\frac{A+A^T}{2}\f$. !> !> \deprecated !> This function is deprecated when using the CUDA backend (CUDA 12.0+) and will be !> removed in CUDA 13.0. This deprecation does not apply to the ROCm backend. !> !> @param[in] handle - handle to the hipSPARSE library context queue. !> @param[in] m - number of rows of sparse matrix \f$A\f$. Must be non-negative. !> @param[in] nnz - number of non-zero entries of sparse matrix \f$A\f$. Must be non-negative. !> @param[in] descrA - sparse matrix descriptor. !> @param[in] csrValA - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csrRowPtrA - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csrColIndA - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[in] fractionToColor - fraction of nodes to be colored, which should be in the interval !> \f$[0.0,1.0]\f$. For example, \f$0.8\f$ implies that !> \f$80\f$ percent of nodes will be colored. !> @param[out] ncolors - resulting number of distinct colors. !> @param[out] coloring - resulting mapping of colors. !> @param[out] reordering - optional resulting reordering permutation if \p reordering is a !> non-null pointer. !> @param[inout] myInfo - structure that holds the information collected during the coloring !> algorithm. !> !> \retval HIPSPARSE_STATUS_SUCCESS the operation completed successfully. !> \retval HIPSPARSE_STATUS_NOT_INITIALIZED \p handle is not initialized. !> \retval HIPSPARSE_STATUS_INVALID_VALUE \p handle, \p descrA, \p fractionToColor, !> \p ncolors, \p coloring, or \p info is nullptr, \p m or \p nnz is negative, or !> \p csrValA, \p csrRowPtrA, or \p csrColIndA is nullptr when \p nnz is greater than !> zero. interface hipsparseScsrcolor #ifdef USE_CUDA_NAMES function hipsparseScsrcolor_(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) & bind(c, name="cusparseScsrcolor") #else function hipsparseScsrcolor_(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) & bind(c, name="hipsparseScsrcolor") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrcolor_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: fractionToColor integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseScsrcolor_assumed_rank #else module procedure & hipsparseScsrcolor_rank_0,& hipsparseScsrcolor_rank_1 #endif #endif end interface interface hipsparseDcsrcolor #ifdef USE_CUDA_NAMES function hipsparseDcsrcolor_(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) & bind(c, name="cusparseDcsrcolor") #else function hipsparseDcsrcolor_(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) & bind(c, name="hipsparseDcsrcolor") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrcolor_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: fractionToColor integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseDcsrcolor_assumed_rank #else module procedure & hipsparseDcsrcolor_rank_0,& hipsparseDcsrcolor_rank_1 #endif #endif end interface interface hipsparseCcsrcolor #ifdef USE_CUDA_NAMES function hipsparseCcsrcolor_(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) & bind(c, name="cusparseCcsrcolor") #else function hipsparseCcsrcolor_(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) & bind(c, name="hipsparseCcsrcolor") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrcolor_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: fractionToColor integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseCcsrcolor_assumed_rank #else module procedure & hipsparseCcsrcolor_rank_0,& hipsparseCcsrcolor_rank_1 #endif #endif end interface interface hipsparseZcsrcolor #ifdef USE_CUDA_NAMES function hipsparseZcsrcolor_(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) & bind(c, name="cusparseZcsrcolor") #else function hipsparseZcsrcolor_(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) & bind(c, name="hipsparseZcsrcolor") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrcolor_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descrA type(c_ptr),value :: csrValA type(c_ptr),value :: csrRowPtrA type(c_ptr),value :: csrColIndA type(c_ptr),value :: fractionToColor integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure hipsparseZcsrcolor_assumed_rank #else module procedure & hipsparseZcsrcolor_rank_0,& hipsparseZcsrcolor_rank_1 #endif #endif end interface interface hipsparseCreateSpVec #ifdef USE_CUDA_NAMES function hipsparseCreateSpVec_(spVecDescr,mySize,nnz,indices,values,idxType,idxBase,valueType) & bind(c, name="cusparseCreateSpVec") #else function hipsparseCreateSpVec_(spVecDescr,mySize,nnz,indices,values,idxType,idxBase,valueType) & bind(c, name="hipsparseCreateSpVec") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateSpVec_ type(c_ptr) :: spVecDescr integer(c_int64_t),value :: mySize integer(c_int64_t),value :: nnz type(c_ptr),value :: indices type(c_ptr),value :: values integer(kind(HIPSPARSE_INDEX_16U)),value :: idxType integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase integer(kind(HIP_R_32F)),value :: valueType end function end interface interface hipsparseCreateConstSpVec #ifdef USE_CUDA_NAMES function hipsparseCreateConstSpVec_(spVecDescr,mySize,nnz,indices,values,idxType,idxBase, & valueType) & bind(c, name="cusparseCreateConstSpVec") #else function hipsparseCreateConstSpVec_(spVecDescr,mySize,nnz,indices,values,idxType,idxBase, & valueType) & bind(c, name="hipsparseCreateConstSpVec") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateConstSpVec_ type(c_ptr) :: spVecDescr integer(c_int64_t),value :: mySize integer(c_int64_t),value :: nnz type(c_ptr),value :: indices type(c_ptr),value :: values integer(kind(HIPSPARSE_INDEX_16U)),value :: idxType integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase integer(kind(HIP_R_32F)),value :: valueType end function end interface interface hipsparseDestroySpVec #ifdef USE_CUDA_NAMES function hipsparseDestroySpVec_(spVecDescr) bind(c, name="cusparseDestroySpVec") #else function hipsparseDestroySpVec_(spVecDescr) bind(c, name="hipsparseDestroySpVec") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDestroySpVec_ type(c_ptr),value :: spVecDescr end function end interface interface hipsparseSpVecGet #ifdef USE_CUDA_NAMES function hipsparseSpVecGet_(spVecDescr,mySize,nnz,indices,values,idxType,idxBase,valueType) & bind(c, name="cusparseSpVecGet") #else function hipsparseSpVecGet_(spVecDescr,mySize,nnz,indices,values,idxType,idxBase,valueType) & bind(c, name="hipsparseSpVecGet") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpVecGet_ type(c_ptr),value :: spVecDescr type(c_ptr),value :: mySize integer(c_int64_t) :: nnz type(c_ptr) :: indices type(c_ptr) :: values type(c_ptr),value :: idxType type(c_ptr),value :: idxBase type(c_ptr),value :: valueType end function end interface interface hipsparseConstSpVecGet #ifdef USE_CUDA_NAMES function hipsparseConstSpVecGet_(spVecDescr,mySize,nnz,indices,values,idxType,idxBase, & valueType) & bind(c, name="cusparseConstSpVecGet") #else function hipsparseConstSpVecGet_(spVecDescr,mySize,nnz,indices,values,idxType,idxBase, & valueType) & bind(c, name="hipsparseConstSpVecGet") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseConstSpVecGet_ type(c_ptr),value :: spVecDescr type(c_ptr),value :: mySize integer(c_int64_t) :: nnz type(c_ptr) :: indices type(c_ptr) :: values type(c_ptr),value :: idxType type(c_ptr),value :: idxBase type(c_ptr),value :: valueType end function end interface interface hipsparseSpVecGetIndexBase #ifdef USE_CUDA_NAMES function hipsparseSpVecGetIndexBase_(spVecDescr,idxBase) & bind(c, name="cusparseSpVecGetIndexBase") #else function hipsparseSpVecGetIndexBase_(spVecDescr,idxBase) & bind(c, name="hipsparseSpVecGetIndexBase") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpVecGetIndexBase_ type(c_ptr),value :: spVecDescr type(c_ptr),value :: idxBase end function end interface interface hipsparseSpVecGetValues #ifdef USE_CUDA_NAMES function hipsparseSpVecGetValues_(spVecDescr,values) bind(c, name="cusparseSpVecGetValues") #else function hipsparseSpVecGetValues_(spVecDescr,values) bind(c, name="hipsparseSpVecGetValues") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpVecGetValues_ type(c_ptr),value :: spVecDescr type(c_ptr) :: values end function end interface interface hipsparseConstSpVecGetValues #ifdef USE_CUDA_NAMES function hipsparseConstSpVecGetValues_(spVecDescr,values) & bind(c, name="cusparseConstSpVecGetValues") #else function hipsparseConstSpVecGetValues_(spVecDescr,values) & bind(c, name="hipsparseConstSpVecGetValues") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseConstSpVecGetValues_ type(c_ptr),value :: spVecDescr type(c_ptr) :: values end function end interface interface hipsparseSpVecSetValues #ifdef USE_CUDA_NAMES function hipsparseSpVecSetValues_(spVecDescr,values) bind(c, name="cusparseSpVecSetValues") #else function hipsparseSpVecSetValues_(spVecDescr,values) bind(c, name="hipsparseSpVecSetValues") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpVecSetValues_ type(c_ptr),value :: spVecDescr type(c_ptr),value :: values end function end interface interface hipsparseCreateCoo #ifdef USE_CUDA_NAMES function hipsparseCreateCoo_(spMatDescr,rows,cols,nnz,cooRowInd,cooColInd,cooValues, & cooIdxType,idxBase,valueType) & bind(c, name="cusparseCreateCoo") #else function hipsparseCreateCoo_(spMatDescr,rows,cols,nnz,cooRowInd,cooColInd,cooValues, & cooIdxType,idxBase,valueType) & bind(c, name="hipsparseCreateCoo") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateCoo_ type(c_ptr) :: spMatDescr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: nnz type(c_ptr),value :: cooRowInd type(c_ptr),value :: cooColInd type(c_ptr),value :: cooValues integer(kind(HIPSPARSE_INDEX_16U)),value :: cooIdxType integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase integer(kind(HIP_R_32F)),value :: valueType end function end interface interface hipsparseCreateConstCoo #ifdef USE_CUDA_NAMES function hipsparseCreateConstCoo_(spMatDescr,rows,cols,nnz,cooRowInd,cooColInd,cooValues, & cooIdxType,idxBase,valueType) & bind(c, name="cusparseCreateConstCoo") #else function hipsparseCreateConstCoo_(spMatDescr,rows,cols,nnz,cooRowInd,cooColInd,cooValues, & cooIdxType,idxBase,valueType) & bind(c, name="hipsparseCreateConstCoo") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateConstCoo_ type(c_ptr) :: spMatDescr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: nnz type(c_ptr),value :: cooRowInd type(c_ptr),value :: cooColInd type(c_ptr),value :: cooValues integer(kind(HIPSPARSE_INDEX_16U)),value :: cooIdxType integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase integer(kind(HIP_R_32F)),value :: valueType end function end interface #ifndef USE_CUDA_NAMES interface hipsparseCreateCooAoS function hipsparseCreateCooAoS_(spMatDescr,rows,cols,nnz,cooInd,cooValues,cooIdxType,idxBase, & valueType) & bind(c, name="hipsparseCreateCooAoS") use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateCooAoS_ type(c_ptr) :: spMatDescr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: nnz type(c_ptr),value :: cooInd type(c_ptr),value :: cooValues integer(kind(HIPSPARSE_INDEX_16U)),value :: cooIdxType integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase integer(kind(HIP_R_32F)),value :: valueType end function end interface #endif interface hipsparseCreateCsr #ifdef USE_CUDA_NAMES function hipsparseCreateCsr_(spMatDescr,rows,cols,nnz,csrRowOffsets,csrColInd,csrValues, & csrRowOffsetsType,csrColIndType,idxBase,valueType) & bind(c, name="cusparseCreateCsr") #else function hipsparseCreateCsr_(spMatDescr,rows,cols,nnz,csrRowOffsets,csrColInd,csrValues, & csrRowOffsetsType,csrColIndType,idxBase,valueType) & bind(c, name="hipsparseCreateCsr") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateCsr_ type(c_ptr) :: spMatDescr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: nnz type(c_ptr),value :: csrRowOffsets type(c_ptr),value :: csrColInd type(c_ptr),value :: csrValues integer(kind(HIPSPARSE_INDEX_16U)),value :: csrRowOffsetsType integer(kind(HIPSPARSE_INDEX_16U)),value :: csrColIndType integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase integer(kind(HIP_R_32F)),value :: valueType end function end interface interface hipsparseCreateConstCsr #ifdef USE_CUDA_NAMES function hipsparseCreateConstCsr_(spMatDescr,rows,cols,nnz,csrRowOffsets,csrColInd,csrValues, & csrRowOffsetsType,csrColIndType,idxBase,valueType) & bind(c, name="cusparseCreateConstCsr") #else function hipsparseCreateConstCsr_(spMatDescr,rows,cols,nnz,csrRowOffsets,csrColInd,csrValues, & csrRowOffsetsType,csrColIndType,idxBase,valueType) & bind(c, name="hipsparseCreateConstCsr") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateConstCsr_ type(c_ptr) :: spMatDescr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: nnz type(c_ptr),value :: csrRowOffsets type(c_ptr),value :: csrColInd type(c_ptr),value :: csrValues integer(kind(HIPSPARSE_INDEX_16U)),value :: csrRowOffsetsType integer(kind(HIPSPARSE_INDEX_16U)),value :: csrColIndType integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase integer(kind(HIP_R_32F)),value :: valueType end function end interface interface hipsparseCreateCsc #ifdef USE_CUDA_NAMES function hipsparseCreateCsc_(spMatDescr,rows,cols,nnz,cscColOffsets,cscRowInd,cscValues, & cscColOffsetsType,cscRowIndType,idxBase,valueType) & bind(c, name="cusparseCreateCsc") #else function hipsparseCreateCsc_(spMatDescr,rows,cols,nnz,cscColOffsets,cscRowInd,cscValues, & cscColOffsetsType,cscRowIndType,idxBase,valueType) & bind(c, name="hipsparseCreateCsc") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateCsc_ type(c_ptr) :: spMatDescr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: nnz type(c_ptr),value :: cscColOffsets type(c_ptr),value :: cscRowInd type(c_ptr),value :: cscValues integer(kind(HIPSPARSE_INDEX_16U)),value :: cscColOffsetsType integer(kind(HIPSPARSE_INDEX_16U)),value :: cscRowIndType integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase integer(kind(HIP_R_32F)),value :: valueType end function end interface interface hipsparseCreateConstCsc #ifdef USE_CUDA_NAMES function hipsparseCreateConstCsc_(spMatDescr,rows,cols,nnz,cscColOffsets,cscRowInd,cscValues, & cscColOffsetsType,cscRowIndType,idxBase,valueType) & bind(c, name="cusparseCreateConstCsc") #else function hipsparseCreateConstCsc_(spMatDescr,rows,cols,nnz,cscColOffsets,cscRowInd,cscValues, & cscColOffsetsType,cscRowIndType,idxBase,valueType) & bind(c, name="hipsparseCreateConstCsc") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateConstCsc_ type(c_ptr) :: spMatDescr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: nnz type(c_ptr),value :: cscColOffsets type(c_ptr),value :: cscRowInd type(c_ptr),value :: cscValues integer(kind(HIPSPARSE_INDEX_16U)),value :: cscColOffsetsType integer(kind(HIPSPARSE_INDEX_16U)),value :: cscRowIndType integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase integer(kind(HIP_R_32F)),value :: valueType end function end interface interface hipsparseCreateBlockedEll #ifdef USE_CUDA_NAMES function hipsparseCreateBlockedEll_(spMatDescr,rows,cols,ellBlockSize,ellCols,ellColInd, & ellValue,ellIdxType,idxBase,valueType) & bind(c, name="cusparseCreateBlockedEll") #else function hipsparseCreateBlockedEll_(spMatDescr,rows,cols,ellBlockSize,ellCols,ellColInd, & ellValue,ellIdxType,idxBase,valueType) & bind(c, name="hipsparseCreateBlockedEll") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateBlockedEll_ type(c_ptr) :: spMatDescr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: ellBlockSize integer(c_int64_t),value :: ellCols type(c_ptr),value :: ellColInd type(c_ptr),value :: ellValue integer(kind(HIPSPARSE_INDEX_16U)),value :: ellIdxType integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase integer(kind(HIP_R_32F)),value :: valueType end function end interface interface hipsparseCreateConstBlockedEll #ifdef USE_CUDA_NAMES function hipsparseCreateConstBlockedEll_(spMatDescr,rows,cols,ellBlockSize,ellCols,ellColInd, & ellValue,ellIdxType,idxBase,valueType) & bind(c, name="cusparseCreateConstBlockedEll") #else function hipsparseCreateConstBlockedEll_(spMatDescr,rows,cols,ellBlockSize,ellCols,ellColInd, & ellValue,ellIdxType,idxBase,valueType) & bind(c, name="hipsparseCreateConstBlockedEll") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateConstBlockedEll_ type(c_ptr) :: spMatDescr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: ellBlockSize integer(c_int64_t),value :: ellCols type(c_ptr),value :: ellColInd type(c_ptr),value :: ellValue integer(kind(HIPSPARSE_INDEX_16U)),value :: ellIdxType integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase integer(kind(HIP_R_32F)),value :: valueType end function end interface interface hipsparseCreateSlicedEll #ifdef USE_CUDA_NAMES function hipsparseCreateSlicedEll_(spMatDescr,rows,cols,nnz,sellValuesSize,sliceSize, & sellSliceOffsets,sellColInd,sellValues,sellSliceOffsetsType,sellColIndType,idxBase, & valueType) & bind(c, name="cusparseCreateSlicedEll") #else function hipsparseCreateSlicedEll_(spMatDescr,rows,cols,nnz,sellValuesSize,sliceSize, & sellSliceOffsets,sellColInd,sellValues,sellSliceOffsetsType,sellColIndType,idxBase, & valueType) & bind(c, name="hipsparseCreateSlicedEll") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateSlicedEll_ type(c_ptr) :: spMatDescr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: nnz integer(c_int64_t),value :: sellValuesSize integer(c_int64_t),value :: sliceSize type(c_ptr),value :: sellSliceOffsets type(c_ptr),value :: sellColInd type(c_ptr),value :: sellValues integer(kind(HIPSPARSE_INDEX_16U)),value :: sellSliceOffsetsType integer(kind(HIPSPARSE_INDEX_16U)),value :: sellColIndType integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase integer(kind(HIP_R_32F)),value :: valueType end function end interface interface hipsparseCreateConstSlicedEll #ifdef USE_CUDA_NAMES function hipsparseCreateConstSlicedEll_(spMatDescr,rows,cols,nnz,sellValuesSize,sliceSize, & sellSliceOffsets,sellColInd,sellValues,sellSliceOffsetsType,sellColIndType,idxBase, & valueType) & bind(c, name="cusparseCreateConstSlicedEll") #else function hipsparseCreateConstSlicedEll_(spMatDescr,rows,cols,nnz,sellValuesSize,sliceSize, & sellSliceOffsets,sellColInd,sellValues,sellSliceOffsetsType,sellColIndType,idxBase, & valueType) & bind(c, name="hipsparseCreateConstSlicedEll") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateConstSlicedEll_ type(c_ptr) :: spMatDescr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: nnz integer(c_int64_t),value :: sellValuesSize integer(c_int64_t),value :: sliceSize type(c_ptr),value :: sellSliceOffsets type(c_ptr),value :: sellColInd type(c_ptr),value :: sellValues integer(kind(HIPSPARSE_INDEX_16U)),value :: sellSliceOffsetsType integer(kind(HIPSPARSE_INDEX_16U)),value :: sellColIndType integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase integer(kind(HIP_R_32F)),value :: valueType end function end interface interface hipsparseCreateBsr #ifdef USE_CUDA_NAMES function hipsparseCreateBsr_(spMatDescr,mb,nb,nnzb,rowBlockDim,colBlockDim,bsrRowPtr, & bsrColInd,bsrValues,bsrRowPtrType,bsrColIndType,idxBase,valueType,order) & bind(c, name="cusparseCreateBsr") #else function hipsparseCreateBsr_(spMatDescr,mb,nb,nnzb,rowBlockDim,colBlockDim,bsrRowPtr, & bsrColInd,bsrValues,bsrRowPtrType,bsrColIndType,idxBase,valueType,order) & bind(c, name="hipsparseCreateBsr") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateBsr_ type(c_ptr) :: spMatDescr integer(c_int64_t),value :: mb integer(c_int64_t),value :: nb integer(c_int64_t),value :: nnzb integer(c_int64_t),value :: rowBlockDim integer(c_int64_t),value :: colBlockDim type(c_ptr),value :: bsrRowPtr type(c_ptr),value :: bsrColInd type(c_ptr),value :: bsrValues integer(kind(HIPSPARSE_INDEX_16U)),value :: bsrRowPtrType integer(kind(HIPSPARSE_INDEX_16U)),value :: bsrColIndType integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase integer(kind(HIP_R_32F)),value :: valueType integer(kind(HIPSPARSE_ORDER_COLUMN)),value :: order end function end interface interface hipsparseCreateConstBsr #ifdef USE_CUDA_NAMES function hipsparseCreateConstBsr_(spMatDescr,mb,nb,nnzb,rowBlockDim,colBlockDim,bsrRowPtr, & bsrColInd,bsrValues,bsrRowPtrType,bsrColIndType,idxBase,valueType,order) & bind(c, name="cusparseCreateConstBsr") #else function hipsparseCreateConstBsr_(spMatDescr,mb,nb,nnzb,rowBlockDim,colBlockDim,bsrRowPtr, & bsrColInd,bsrValues,bsrRowPtrType,bsrColIndType,idxBase,valueType,order) & bind(c, name="hipsparseCreateConstBsr") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateConstBsr_ type(c_ptr) :: spMatDescr integer(c_int64_t),value :: mb integer(c_int64_t),value :: nb integer(c_int64_t),value :: nnzb integer(c_int64_t),value :: rowBlockDim integer(c_int64_t),value :: colBlockDim type(c_ptr),value :: bsrRowPtr type(c_ptr),value :: bsrColInd type(c_ptr),value :: bsrValues integer(kind(HIPSPARSE_INDEX_16U)),value :: bsrRowPtrType integer(kind(HIPSPARSE_INDEX_16U)),value :: bsrColIndType integer(kind(HIPSPARSE_INDEX_BASE_ZERO)),value :: idxBase integer(kind(HIP_R_32F)),value :: valueType integer(kind(HIPSPARSE_ORDER_COLUMN)),value :: order end function end interface interface hipsparseDestroySpMat #ifdef USE_CUDA_NAMES function hipsparseDestroySpMat_(spMatDescr) bind(c, name="cusparseDestroySpMat") #else function hipsparseDestroySpMat_(spMatDescr) bind(c, name="hipsparseDestroySpMat") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDestroySpMat_ type(c_ptr),value :: spMatDescr end function end interface interface hipsparseCooGet #ifdef USE_CUDA_NAMES function hipsparseCooGet_(spMatDescr,rows,cols,nnz,cooRowInd,cooColInd,cooValues,idxType, & idxBase,valueType) & bind(c, name="cusparseCooGet") #else function hipsparseCooGet_(spMatDescr,rows,cols,nnz,cooRowInd,cooColInd,cooValues,idxType, & idxBase,valueType) & bind(c, name="hipsparseCooGet") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCooGet_ type(c_ptr),value :: spMatDescr integer(c_int64_t) :: rows integer(c_int64_t) :: cols integer(c_int64_t) :: nnz type(c_ptr) :: cooRowInd type(c_ptr) :: cooColInd type(c_ptr) :: cooValues type(c_ptr),value :: idxType type(c_ptr),value :: idxBase type(c_ptr),value :: valueType end function end interface interface hipsparseConstCooGet #ifdef USE_CUDA_NAMES function hipsparseConstCooGet_(spMatDescr,rows,cols,nnz,cooRowInd,cooColInd,cooValues,idxType, & idxBase,valueType) & bind(c, name="cusparseConstCooGet") #else function hipsparseConstCooGet_(spMatDescr,rows,cols,nnz,cooRowInd,cooColInd,cooValues,idxType, & idxBase,valueType) & bind(c, name="hipsparseConstCooGet") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseConstCooGet_ type(c_ptr),value :: spMatDescr integer(c_int64_t) :: rows integer(c_int64_t) :: cols integer(c_int64_t) :: nnz type(c_ptr) :: cooRowInd type(c_ptr) :: cooColInd type(c_ptr) :: cooValues type(c_ptr),value :: idxType type(c_ptr),value :: idxBase type(c_ptr),value :: valueType end function end interface #ifndef USE_CUDA_NAMES interface hipsparseCooAoSGet function hipsparseCooAoSGet_(spMatDescr,rows,cols,nnz,cooInd,cooValues,idxType,idxBase, & valueType) & bind(c, name="hipsparseCooAoSGet") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCooAoSGet_ type(c_ptr),value :: spMatDescr integer(c_int64_t) :: rows integer(c_int64_t) :: cols integer(c_int64_t) :: nnz type(c_ptr) :: cooInd type(c_ptr) :: cooValues type(c_ptr),value :: idxType type(c_ptr),value :: idxBase type(c_ptr),value :: valueType end function end interface #endif interface hipsparseCsrGet #ifdef USE_CUDA_NAMES function hipsparseCsrGet_(spMatDescr,rows,cols,nnz,csrRowOffsets,csrColInd,csrValues, & csrRowOffsetsType,csrColIndType,idxBase,valueType) & bind(c, name="cusparseCsrGet") #else function hipsparseCsrGet_(spMatDescr,rows,cols,nnz,csrRowOffsets,csrColInd,csrValues, & csrRowOffsetsType,csrColIndType,idxBase,valueType) & bind(c, name="hipsparseCsrGet") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCsrGet_ type(c_ptr),value :: spMatDescr integer(c_int64_t) :: rows integer(c_int64_t) :: cols integer(c_int64_t) :: nnz type(c_ptr) :: csrRowOffsets type(c_ptr) :: csrColInd type(c_ptr) :: csrValues type(c_ptr),value :: csrRowOffsetsType type(c_ptr),value :: csrColIndType type(c_ptr),value :: idxBase type(c_ptr),value :: valueType end function end interface interface hipsparseConstCsrGet #ifdef USE_CUDA_NAMES function hipsparseConstCsrGet_(spMatDescr,rows,cols,nnz,csrRowOffsets,csrColInd,csrValues, & csrRowOffsetsType,csrColIndType,idxBase,valueType) & bind(c, name="cusparseConstCsrGet") #else function hipsparseConstCsrGet_(spMatDescr,rows,cols,nnz,csrRowOffsets,csrColInd,csrValues, & csrRowOffsetsType,csrColIndType,idxBase,valueType) & bind(c, name="hipsparseConstCsrGet") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseConstCsrGet_ type(c_ptr),value :: spMatDescr integer(c_int64_t) :: rows integer(c_int64_t) :: cols integer(c_int64_t) :: nnz type(c_ptr) :: csrRowOffsets type(c_ptr) :: csrColInd type(c_ptr) :: csrValues type(c_ptr),value :: csrRowOffsetsType type(c_ptr),value :: csrColIndType type(c_ptr),value :: idxBase type(c_ptr),value :: valueType end function end interface interface hipsparseCscGet #ifdef USE_CUDA_NAMES function hipsparseCscGet_(spMatDescr,rows,cols,nnz,cscColOffsets,cscRowInd,cscValues, & cscColOffsetsType,cscRowIndType,idxBase,valueType) & bind(c, name="cusparseCscGet") #else function hipsparseCscGet_(spMatDescr,rows,cols,nnz,cscColOffsets,cscRowInd,cscValues, & cscColOffsetsType,cscRowIndType,idxBase,valueType) & bind(c, name="hipsparseCscGet") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCscGet_ type(c_ptr),value :: spMatDescr integer(c_int64_t) :: rows integer(c_int64_t) :: cols integer(c_int64_t) :: nnz type(c_ptr) :: cscColOffsets type(c_ptr) :: cscRowInd type(c_ptr) :: cscValues type(c_ptr),value :: cscColOffsetsType type(c_ptr),value :: cscRowIndType type(c_ptr),value :: idxBase type(c_ptr),value :: valueType end function end interface interface hipsparseConstCscGet #ifdef USE_CUDA_NAMES function hipsparseConstCscGet_(spMatDescr,rows,cols,nnz,cscColOffsets,cscRowInd,cscValues, & cscColOffsetsType,cscRowIndType,idxBase,valueType) & bind(c, name="cusparseConstCscGet") #else function hipsparseConstCscGet_(spMatDescr,rows,cols,nnz,cscColOffsets,cscRowInd,cscValues, & cscColOffsetsType,cscRowIndType,idxBase,valueType) & bind(c, name="hipsparseConstCscGet") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseConstCscGet_ type(c_ptr),value :: spMatDescr integer(c_int64_t) :: rows integer(c_int64_t) :: cols integer(c_int64_t) :: nnz type(c_ptr) :: cscColOffsets type(c_ptr) :: cscRowInd type(c_ptr) :: cscValues type(c_ptr),value :: cscColOffsetsType type(c_ptr),value :: cscRowIndType type(c_ptr),value :: idxBase type(c_ptr),value :: valueType end function end interface interface hipsparseBlockedEllGet #ifdef USE_CUDA_NAMES function hipsparseBlockedEllGet_(spMatDescr,rows,cols,ellBlockSize,ellCols,ellColInd,ellValue, & ellIdxType,idxBase,valueType) & bind(c, name="cusparseBlockedEllGet") #else function hipsparseBlockedEllGet_(spMatDescr,rows,cols,ellBlockSize,ellCols,ellColInd,ellValue, & ellIdxType,idxBase,valueType) & bind(c, name="hipsparseBlockedEllGet") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseBlockedEllGet_ type(c_ptr),value :: spMatDescr integer(c_int64_t) :: rows integer(c_int64_t) :: cols type(c_ptr),value :: ellBlockSize type(c_ptr),value :: ellCols type(c_ptr) :: ellColInd type(c_ptr) :: ellValue type(c_ptr),value :: ellIdxType type(c_ptr),value :: idxBase type(c_ptr),value :: valueType end function end interface interface hipsparseConstBlockedEllGet #ifdef USE_CUDA_NAMES function hipsparseConstBlockedEllGet_(spMatDescr,rows,cols,ellBlockSize,ellCols,ellColInd, & ellValue,ellIdxType,idxBase,valueType) & bind(c, name="cusparseConstBlockedEllGet") #else function hipsparseConstBlockedEllGet_(spMatDescr,rows,cols,ellBlockSize,ellCols,ellColInd, & ellValue,ellIdxType,idxBase,valueType) & bind(c, name="hipsparseConstBlockedEllGet") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseConstBlockedEllGet_ type(c_ptr),value :: spMatDescr integer(c_int64_t) :: rows integer(c_int64_t) :: cols type(c_ptr),value :: ellBlockSize type(c_ptr),value :: ellCols type(c_ptr) :: ellColInd type(c_ptr) :: ellValue type(c_ptr),value :: ellIdxType type(c_ptr),value :: idxBase type(c_ptr),value :: valueType end function end interface interface hipsparseCsrSetPointers #ifdef USE_CUDA_NAMES function hipsparseCsrSetPointers_(spMatDescr,csrRowOffsets,csrColInd,csrValues) & bind(c, name="cusparseCsrSetPointers") #else function hipsparseCsrSetPointers_(spMatDescr,csrRowOffsets,csrColInd,csrValues) & bind(c, name="hipsparseCsrSetPointers") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCsrSetPointers_ type(c_ptr),value :: spMatDescr type(c_ptr),value :: csrRowOffsets type(c_ptr),value :: csrColInd type(c_ptr),value :: csrValues end function end interface interface hipsparseCscSetPointers #ifdef USE_CUDA_NAMES function hipsparseCscSetPointers_(spMatDescr,cscColOffsets,cscRowInd,cscValues) & bind(c, name="cusparseCscSetPointers") #else function hipsparseCscSetPointers_(spMatDescr,cscColOffsets,cscRowInd,cscValues) & bind(c, name="hipsparseCscSetPointers") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCscSetPointers_ type(c_ptr),value :: spMatDescr type(c_ptr),value :: cscColOffsets type(c_ptr),value :: cscRowInd type(c_ptr),value :: cscValues end function end interface interface hipsparseCooSetPointers #ifdef USE_CUDA_NAMES function hipsparseCooSetPointers_(spMatDescr,cooRowInd,cooColInd,cooValues) & bind(c, name="cusparseCooSetPointers") #else function hipsparseCooSetPointers_(spMatDescr,cooRowInd,cooColInd,cooValues) & bind(c, name="hipsparseCooSetPointers") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCooSetPointers_ type(c_ptr),value :: spMatDescr type(c_ptr),value :: cooRowInd type(c_ptr),value :: cooColInd type(c_ptr),value :: cooValues end function end interface #ifndef USE_CUDA_NAMES interface hipsparseBlockedEllSetPointers function hipsparseBlockedEllSetPointers_(spMatDescr,ellColInd,ellValue) & bind(c, name="hipsparseBlockedEllSetPointers") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseBlockedEllSetPointers_ type(c_ptr),value :: spMatDescr type(c_ptr),value :: ellColInd type(c_ptr),value :: ellValue end function end interface #endif interface hipsparseSpMatGetSize #ifdef USE_CUDA_NAMES function hipsparseSpMatGetSize_(spMatDescr,rows,cols,nnz) bind(c, name="cusparseSpMatGetSize") #else function hipsparseSpMatGetSize_(spMatDescr,rows,cols,nnz) bind(c, name="hipsparseSpMatGetSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpMatGetSize_ type(c_ptr),value :: spMatDescr integer(c_int64_t) :: rows integer(c_int64_t) :: cols integer(c_int64_t) :: nnz end function end interface interface hipsparseSpMatGetFormat #ifdef USE_CUDA_NAMES function hipsparseSpMatGetFormat_(spMatDescr,myFormat) bind(c, name="cusparseSpMatGetFormat") #else function hipsparseSpMatGetFormat_(spMatDescr,myFormat) bind(c, name="hipsparseSpMatGetFormat") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpMatGetFormat_ type(c_ptr),value :: spMatDescr type(c_ptr),value :: myFormat end function end interface interface hipsparseSpMatGetIndexBase #ifdef USE_CUDA_NAMES function hipsparseSpMatGetIndexBase_(spMatDescr,idxBase) & bind(c, name="cusparseSpMatGetIndexBase") #else function hipsparseSpMatGetIndexBase_(spMatDescr,idxBase) & bind(c, name="hipsparseSpMatGetIndexBase") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpMatGetIndexBase_ type(c_ptr),value :: spMatDescr type(c_ptr),value :: idxBase end function end interface interface hipsparseSpMatGetValues #ifdef USE_CUDA_NAMES function hipsparseSpMatGetValues_(spMatDescr,values) bind(c, name="cusparseSpMatGetValues") #else function hipsparseSpMatGetValues_(spMatDescr,values) bind(c, name="hipsparseSpMatGetValues") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpMatGetValues_ type(c_ptr),value :: spMatDescr type(c_ptr) :: values end function end interface interface hipsparseConstSpMatGetValues #ifdef USE_CUDA_NAMES function hipsparseConstSpMatGetValues_(spMatDescr,values) & bind(c, name="cusparseConstSpMatGetValues") #else function hipsparseConstSpMatGetValues_(spMatDescr,values) & bind(c, name="hipsparseConstSpMatGetValues") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseConstSpMatGetValues_ type(c_ptr),value :: spMatDescr type(c_ptr) :: values end function end interface interface hipsparseSpMatSetValues #ifdef USE_CUDA_NAMES function hipsparseSpMatSetValues_(spMatDescr,values) bind(c, name="cusparseSpMatSetValues") #else function hipsparseSpMatSetValues_(spMatDescr,values) bind(c, name="hipsparseSpMatSetValues") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpMatSetValues_ type(c_ptr),value :: spMatDescr type(c_ptr),value :: values end function end interface interface hipsparseSpMatGetStridedBatch #ifdef USE_CUDA_NAMES function hipsparseSpMatGetStridedBatch_(spMatDescr,batchCount) & bind(c, name="cusparseSpMatGetStridedBatch") #else function hipsparseSpMatGetStridedBatch_(spMatDescr,batchCount) & bind(c, name="hipsparseSpMatGetStridedBatch") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpMatGetStridedBatch_ type(c_ptr),value :: spMatDescr type(c_ptr),value :: batchCount end function end interface #ifndef USE_CUDA_NAMES interface hipsparseSpMatSetStridedBatch function hipsparseSpMatSetStridedBatch_(spMatDescr,batchCount) & bind(c, name="hipsparseSpMatSetStridedBatch") use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpMatSetStridedBatch_ type(c_ptr),value :: spMatDescr integer(c_int),value :: batchCount end function end interface #endif interface hipsparseCooSetStridedBatch #ifdef USE_CUDA_NAMES function hipsparseCooSetStridedBatch_(spMatDescr,batchCount,batchStride) & bind(c, name="cusparseCooSetStridedBatch") #else function hipsparseCooSetStridedBatch_(spMatDescr,batchCount,batchStride) & bind(c, name="hipsparseCooSetStridedBatch") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCooSetStridedBatch_ type(c_ptr),value :: spMatDescr integer(c_int),value :: batchCount integer(c_int64_t),value :: batchStride end function end interface interface hipsparseCsrSetStridedBatch #ifdef USE_CUDA_NAMES function hipsparseCsrSetStridedBatch_(spMatDescr,batchCount,offsetsBatchStride, & columnsValuesBatchStride) & bind(c, name="cusparseCsrSetStridedBatch") #else function hipsparseCsrSetStridedBatch_(spMatDescr,batchCount,offsetsBatchStride, & columnsValuesBatchStride) & bind(c, name="hipsparseCsrSetStridedBatch") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCsrSetStridedBatch_ type(c_ptr),value :: spMatDescr integer(c_int),value :: batchCount integer(c_int64_t),value :: offsetsBatchStride integer(c_int64_t),value :: columnsValuesBatchStride end function end interface interface hipsparseSpMatGetAttribute #ifdef USE_CUDA_NAMES function hipsparseSpMatGetAttribute_(spMatDescr,attribute,myData,dataSize) & bind(c, name="cusparseSpMatGetAttribute") #else function hipsparseSpMatGetAttribute_(spMatDescr,attribute,myData,dataSize) & bind(c, name="hipsparseSpMatGetAttribute") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpMatGetAttribute_ type(c_ptr),value :: spMatDescr integer(kind(HIPSPARSE_SPMAT_FILL_MODE)),value :: attribute type(c_ptr),value :: myData integer(c_size_t),value :: dataSize end function end interface interface hipsparseSpMatSetAttribute #ifdef USE_CUDA_NAMES function hipsparseSpMatSetAttribute_(spMatDescr,attribute,myData,dataSize) & bind(c, name="cusparseSpMatSetAttribute") #else function hipsparseSpMatSetAttribute_(spMatDescr,attribute,myData,dataSize) & bind(c, name="hipsparseSpMatSetAttribute") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpMatSetAttribute_ type(c_ptr),value :: spMatDescr integer(kind(HIPSPARSE_SPMAT_FILL_MODE)),value :: attribute type(c_ptr),value :: myData integer(c_size_t),value :: dataSize end function end interface interface hipsparseCreateDnVec #ifdef USE_CUDA_NAMES function hipsparseCreateDnVec_(dnVecDescr,mySize,values,valueType) & bind(c, name="cusparseCreateDnVec") #else function hipsparseCreateDnVec_(dnVecDescr,mySize,values,valueType) & bind(c, name="hipsparseCreateDnVec") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateDnVec_ type(c_ptr) :: dnVecDescr integer(c_int64_t),value :: mySize type(c_ptr),value :: values integer(kind(HIP_R_32F)),value :: valueType end function end interface interface hipsparseCreateConstDnVec #ifdef USE_CUDA_NAMES function hipsparseCreateConstDnVec_(dnVecDescr,mySize,values,valueType) & bind(c, name="cusparseCreateConstDnVec") #else function hipsparseCreateConstDnVec_(dnVecDescr,mySize,values,valueType) & bind(c, name="hipsparseCreateConstDnVec") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateConstDnVec_ type(c_ptr) :: dnVecDescr integer(c_int64_t),value :: mySize type(c_ptr),value :: values integer(kind(HIP_R_32F)),value :: valueType end function end interface interface hipsparseDestroyDnVec #ifdef USE_CUDA_NAMES function hipsparseDestroyDnVec_(dnVecDescr) bind(c, name="cusparseDestroyDnVec") #else function hipsparseDestroyDnVec_(dnVecDescr) bind(c, name="hipsparseDestroyDnVec") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDestroyDnVec_ type(c_ptr),value :: dnVecDescr end function end interface interface hipsparseDnVecGet #ifdef USE_CUDA_NAMES function hipsparseDnVecGet_(dnVecDescr,mySize,values,valueType) bind(c, name="cusparseDnVecGet") #else function hipsparseDnVecGet_(dnVecDescr,mySize,values,valueType) & bind(c, name="hipsparseDnVecGet") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDnVecGet_ type(c_ptr),value :: dnVecDescr type(c_ptr),value :: mySize type(c_ptr) :: values type(c_ptr),value :: valueType end function end interface interface hipsparseConstDnVecGet #ifdef USE_CUDA_NAMES function hipsparseConstDnVecGet_(dnVecDescr,mySize,values,valueType) & bind(c, name="cusparseConstDnVecGet") #else function hipsparseConstDnVecGet_(dnVecDescr,mySize,values,valueType) & bind(c, name="hipsparseConstDnVecGet") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseConstDnVecGet_ type(c_ptr),value :: dnVecDescr type(c_ptr),value :: mySize type(c_ptr) :: values type(c_ptr),value :: valueType end function end interface interface hipsparseDnVecGetValues #ifdef USE_CUDA_NAMES function hipsparseDnVecGetValues_(dnVecDescr,values) bind(c, name="cusparseDnVecGetValues") #else function hipsparseDnVecGetValues_(dnVecDescr,values) bind(c, name="hipsparseDnVecGetValues") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDnVecGetValues_ type(c_ptr),value :: dnVecDescr type(c_ptr) :: values end function end interface interface hipsparseConstDnVecGetValues #ifdef USE_CUDA_NAMES function hipsparseConstDnVecGetValues_(dnVecDescr,values) & bind(c, name="cusparseConstDnVecGetValues") #else function hipsparseConstDnVecGetValues_(dnVecDescr,values) & bind(c, name="hipsparseConstDnVecGetValues") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseConstDnVecGetValues_ type(c_ptr),value :: dnVecDescr type(c_ptr) :: values end function end interface interface hipsparseDnVecSetValues #ifdef USE_CUDA_NAMES function hipsparseDnVecSetValues_(dnVecDescr,values) bind(c, name="cusparseDnVecSetValues") #else function hipsparseDnVecSetValues_(dnVecDescr,values) bind(c, name="hipsparseDnVecSetValues") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDnVecSetValues_ type(c_ptr),value :: dnVecDescr type(c_ptr),value :: values end function end interface interface hipsparseCreateDnMat #ifdef USE_CUDA_NAMES function hipsparseCreateDnMat_(dnMatDescr,rows,cols,ld,values,valueType,order) & bind(c, name="cusparseCreateDnMat") #else function hipsparseCreateDnMat_(dnMatDescr,rows,cols,ld,values,valueType,order) & bind(c, name="hipsparseCreateDnMat") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateDnMat_ type(c_ptr) :: dnMatDescr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: ld type(c_ptr),value :: values integer(kind(HIP_R_32F)),value :: valueType integer(kind(HIPSPARSE_ORDER_COLUMN)),value :: order end function end interface interface hipsparseCreateConstDnMat #ifdef USE_CUDA_NAMES function hipsparseCreateConstDnMat_(dnMatDescr,rows,cols,ld,values,valueType,order) & bind(c, name="cusparseCreateConstDnMat") #else function hipsparseCreateConstDnMat_(dnMatDescr,rows,cols,ld,values,valueType,order) & bind(c, name="hipsparseCreateConstDnMat") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateConstDnMat_ type(c_ptr) :: dnMatDescr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: ld type(c_ptr),value :: values integer(kind(HIP_R_32F)),value :: valueType integer(kind(HIPSPARSE_ORDER_COLUMN)),value :: order end function end interface interface hipsparseDestroyDnMat #ifdef USE_CUDA_NAMES function hipsparseDestroyDnMat_(dnMatDescr) bind(c, name="cusparseDestroyDnMat") #else function hipsparseDestroyDnMat_(dnMatDescr) bind(c, name="hipsparseDestroyDnMat") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDestroyDnMat_ type(c_ptr),value :: dnMatDescr end function end interface interface hipsparseDnMatGet #ifdef USE_CUDA_NAMES function hipsparseDnMatGet_(dnMatDescr,rows,cols,ld,values,valueType,order) & bind(c, name="cusparseDnMatGet") #else function hipsparseDnMatGet_(dnMatDescr,rows,cols,ld,values,valueType,order) & bind(c, name="hipsparseDnMatGet") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDnMatGet_ type(c_ptr),value :: dnMatDescr integer(c_int64_t) :: rows integer(c_int64_t) :: cols type(c_ptr),value :: ld type(c_ptr) :: values type(c_ptr),value :: valueType type(c_ptr),value :: order end function end interface interface hipsparseConstDnMatGet #ifdef USE_CUDA_NAMES function hipsparseConstDnMatGet_(dnMatDescr,rows,cols,ld,values,valueType,order) & bind(c, name="cusparseConstDnMatGet") #else function hipsparseConstDnMatGet_(dnMatDescr,rows,cols,ld,values,valueType,order) & bind(c, name="hipsparseConstDnMatGet") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseConstDnMatGet_ type(c_ptr),value :: dnMatDescr integer(c_int64_t) :: rows integer(c_int64_t) :: cols type(c_ptr),value :: ld type(c_ptr) :: values type(c_ptr),value :: valueType type(c_ptr),value :: order end function end interface interface hipsparseDnMatGetValues #ifdef USE_CUDA_NAMES function hipsparseDnMatGetValues_(dnMatDescr,values) bind(c, name="cusparseDnMatGetValues") #else function hipsparseDnMatGetValues_(dnMatDescr,values) bind(c, name="hipsparseDnMatGetValues") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDnMatGetValues_ type(c_ptr),value :: dnMatDescr type(c_ptr) :: values end function end interface interface hipsparseConstDnMatGetValues #ifdef USE_CUDA_NAMES function hipsparseConstDnMatGetValues_(dnMatDescr,values) & bind(c, name="cusparseConstDnMatGetValues") #else function hipsparseConstDnMatGetValues_(dnMatDescr,values) & bind(c, name="hipsparseConstDnMatGetValues") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseConstDnMatGetValues_ type(c_ptr),value :: dnMatDescr type(c_ptr) :: values end function end interface interface hipsparseDnMatSetValues #ifdef USE_CUDA_NAMES function hipsparseDnMatSetValues_(dnMatDescr,values) bind(c, name="cusparseDnMatSetValues") #else function hipsparseDnMatSetValues_(dnMatDescr,values) bind(c, name="hipsparseDnMatSetValues") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDnMatSetValues_ type(c_ptr),value :: dnMatDescr type(c_ptr),value :: values end function end interface interface hipsparseDnMatGetStridedBatch #ifdef USE_CUDA_NAMES function hipsparseDnMatGetStridedBatch_(dnMatDescr,batchCount,batchStride) & bind(c, name="cusparseDnMatGetStridedBatch") #else function hipsparseDnMatGetStridedBatch_(dnMatDescr,batchCount,batchStride) & bind(c, name="hipsparseDnMatGetStridedBatch") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDnMatGetStridedBatch_ type(c_ptr),value :: dnMatDescr type(c_ptr),value :: batchCount type(c_ptr),value :: batchStride end function end interface interface hipsparseDnMatSetStridedBatch #ifdef USE_CUDA_NAMES function hipsparseDnMatSetStridedBatch_(dnMatDescr,batchCount,batchStride) & bind(c, name="cusparseDnMatSetStridedBatch") #else function hipsparseDnMatSetStridedBatch_(dnMatDescr,batchCount,batchStride) & bind(c, name="hipsparseDnMatSetStridedBatch") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDnMatSetStridedBatch_ type(c_ptr),value :: dnMatDescr integer(c_int),value :: batchCount integer(c_int64_t),value :: batchStride end function end interface interface hipsparseAxpby #ifdef USE_CUDA_NAMES function hipsparseAxpby_(handle,alpha,vecX,beta,vecY) bind(c, name="cusparseAxpby") #else function hipsparseAxpby_(handle,alpha,vecX,beta,vecY) bind(c, name="hipsparseAxpby") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseAxpby_ type(c_ptr),value :: handle type(c_ptr),value :: alpha type(c_ptr),value :: vecX type(c_ptr),value :: beta type(c_ptr),value :: vecY end function end interface interface hipsparseDenseToSparse_bufferSize #ifdef USE_CUDA_NAMES function hipsparseDenseToSparse_bufferSize_(handle,matA,matB,alg,pBufferSizeInBytes) & bind(c, name="cusparseDenseToSparse_bufferSize") #else function hipsparseDenseToSparse_bufferSize_(handle,matA,matB,alg,pBufferSizeInBytes) & bind(c, name="hipsparseDenseToSparse_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDenseToSparse_bufferSize_ type(c_ptr),value :: handle type(c_ptr),value :: matA type(c_ptr),value :: matB integer(kind(HIPSPARSE_DENSETOSPARSE_ALG_DEFAULT)),value :: alg integer(c_size_t) :: pBufferSizeInBytes end function end interface interface hipsparseDenseToSparse_analysis #ifdef USE_CUDA_NAMES function hipsparseDenseToSparse_analysis_(handle,matA,matB,alg,externalBuffer) & bind(c, name="cusparseDenseToSparse_analysis") #else function hipsparseDenseToSparse_analysis_(handle,matA,matB,alg,externalBuffer) & bind(c, name="hipsparseDenseToSparse_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDenseToSparse_analysis_ type(c_ptr),value :: handle type(c_ptr),value :: matA type(c_ptr),value :: matB integer(kind(HIPSPARSE_DENSETOSPARSE_ALG_DEFAULT)),value :: alg type(c_ptr),value :: externalBuffer end function end interface interface hipsparseDenseToSparse_convert #ifdef USE_CUDA_NAMES function hipsparseDenseToSparse_convert_(handle,matA,matB,alg,externalBuffer) & bind(c, name="cusparseDenseToSparse_convert") #else function hipsparseDenseToSparse_convert_(handle,matA,matB,alg,externalBuffer) & bind(c, name="hipsparseDenseToSparse_convert") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDenseToSparse_convert_ type(c_ptr),value :: handle type(c_ptr),value :: matA type(c_ptr),value :: matB integer(kind(HIPSPARSE_DENSETOSPARSE_ALG_DEFAULT)),value :: alg type(c_ptr),value :: externalBuffer end function end interface interface hipsparseGather #ifdef USE_CUDA_NAMES function hipsparseGather_(handle,vecY,vecX) bind(c, name="cusparseGather") #else function hipsparseGather_(handle,vecY,vecX) bind(c, name="hipsparseGather") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseGather_ type(c_ptr),value :: handle type(c_ptr),value :: vecY type(c_ptr),value :: vecX end function end interface interface hipsparseRot #ifdef USE_CUDA_NAMES function hipsparseRot_(handle,c_coeff,s_coeff,vecX,vecY) bind(c, name="cusparseRot") #else function hipsparseRot_(handle,c_coeff,s_coeff,vecX,vecY) bind(c, name="hipsparseRot") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseRot_ type(c_ptr),value :: handle type(c_ptr),value :: c_coeff type(c_ptr),value :: s_coeff type(c_ptr),value :: vecX type(c_ptr),value :: vecY end function end interface interface hipsparseScatter #ifdef USE_CUDA_NAMES function hipsparseScatter_(handle,vecX,vecY) bind(c, name="cusparseScatter") #else function hipsparseScatter_(handle,vecX,vecY) bind(c, name="hipsparseScatter") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScatter_ type(c_ptr),value :: handle type(c_ptr),value :: vecX type(c_ptr),value :: vecY end function end interface interface hipsparseSDDMM_bufferSize #ifdef USE_CUDA_NAMES function hipsparseSDDMM_bufferSize_(handle,opA,opB,alpha,A,B,beta,C,computeType,alg, & pBufferSizeInBytes) & bind(c, name="cusparseSDDMM_bufferSize") #else function hipsparseSDDMM_bufferSize_(handle,opA,opB,alpha,A,B,beta,C,computeType,alg, & pBufferSizeInBytes) & bind(c, name="hipsparseSDDMM_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSDDMM_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opB type(c_ptr),value :: alpha type(c_ptr),value :: A type(c_ptr),value :: B type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_SDDMM_ALG_DEFAULT)),value :: alg integer(c_size_t) :: pBufferSizeInBytes end function end interface interface hipsparseSDDMM_preprocess #ifdef USE_CUDA_NAMES function hipsparseSDDMM_preprocess_(handle,opA,opB,alpha,A,B,beta,C,computeType,alg, & tempBuffer) & bind(c, name="cusparseSDDMM_preprocess") #else function hipsparseSDDMM_preprocess_(handle,opA,opB,alpha,A,B,beta,C,computeType,alg, & tempBuffer) & bind(c, name="hipsparseSDDMM_preprocess") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSDDMM_preprocess_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opB type(c_ptr),value :: alpha type(c_ptr),value :: A type(c_ptr),value :: B type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_SDDMM_ALG_DEFAULT)),value :: alg type(c_ptr),value :: tempBuffer end function end interface interface hipsparseSDDMM #ifdef USE_CUDA_NAMES function hipsparseSDDMM_(handle,opA,opB,alpha,A,B,beta,C,computeType,alg,tempBuffer) & bind(c, name="cusparseSDDMM") #else function hipsparseSDDMM_(handle,opA,opB,alpha,A,B,beta,C,computeType,alg,tempBuffer) & bind(c, name="hipsparseSDDMM") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSDDMM_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opB type(c_ptr),value :: alpha type(c_ptr),value :: A type(c_ptr),value :: B type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_SDDMM_ALG_DEFAULT)),value :: alg type(c_ptr),value :: tempBuffer end function end interface interface hipsparseSparseToDense_bufferSize #ifdef USE_CUDA_NAMES function hipsparseSparseToDense_bufferSize_(handle,matA,matB,alg,pBufferSizeInBytes) & bind(c, name="cusparseSparseToDense_bufferSize") #else function hipsparseSparseToDense_bufferSize_(handle,matA,matB,alg,pBufferSizeInBytes) & bind(c, name="hipsparseSparseToDense_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSparseToDense_bufferSize_ type(c_ptr),value :: handle type(c_ptr),value :: matA type(c_ptr),value :: matB integer(kind(HIPSPARSE_SPARSETODENSE_ALG_DEFAULT)),value :: alg integer(c_size_t) :: pBufferSizeInBytes end function end interface interface hipsparseSparseToDense #ifdef USE_CUDA_NAMES function hipsparseSparseToDense_(handle,matA,matB,alg,externalBuffer) & bind(c, name="cusparseSparseToDense") #else function hipsparseSparseToDense_(handle,matA,matB,alg,externalBuffer) & bind(c, name="hipsparseSparseToDense") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSparseToDense_ type(c_ptr),value :: handle type(c_ptr),value :: matA type(c_ptr),value :: matB integer(kind(HIPSPARSE_SPARSETODENSE_ALG_DEFAULT)),value :: alg type(c_ptr),value :: externalBuffer end function end interface interface hipsparseSpGEMM_createDescr #ifdef USE_CUDA_NAMES function hipsparseSpGEMM_createDescr_(descr) bind(c, name="cusparseSpGEMM_createDescr") #else function hipsparseSpGEMM_createDescr_(descr) bind(c, name="hipsparseSpGEMM_createDescr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpGEMM_createDescr_ type(c_ptr) :: descr end function end interface interface hipsparseSpGEMM_destroyDescr #ifdef USE_CUDA_NAMES function hipsparseSpGEMM_destroyDescr_(descr) bind(c, name="cusparseSpGEMM_destroyDescr") #else function hipsparseSpGEMM_destroyDescr_(descr) bind(c, name="hipsparseSpGEMM_destroyDescr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpGEMM_destroyDescr_ type(c_ptr),value :: descr end function end interface interface hipsparseSpGEMM_workEstimation #ifdef USE_CUDA_NAMES function hipsparseSpGEMM_workEstimation_(handle,opA,opB,alpha,matA,matB,beta,matC,computeType, & alg,spgemmDescr,bufferSize1,externalBuffer1) & bind(c, name="cusparseSpGEMM_workEstimation") #else function hipsparseSpGEMM_workEstimation_(handle,opA,opB,alpha,matA,matB,beta,matC,computeType, & alg,spgemmDescr,bufferSize1,externalBuffer1) & bind(c, name="hipsparseSpGEMM_workEstimation") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpGEMM_workEstimation_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opB type(c_ptr),value :: alpha type(c_ptr),value :: matA type(c_ptr),value :: matB type(c_ptr),value :: beta type(c_ptr),value :: matC integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_SPGEMM_DEFAULT)),value :: alg type(c_ptr),value :: spgemmDescr type(c_ptr),value :: bufferSize1 type(c_ptr),value :: externalBuffer1 end function end interface interface hipsparseSpGEMM_compute #ifdef USE_CUDA_NAMES function hipsparseSpGEMM_compute_(handle,opA,opB,alpha,matA,matB,beta,matC,computeType,alg, & spgemmDescr,bufferSize2,externalBuffer2) & bind(c, name="cusparseSpGEMM_compute") #else function hipsparseSpGEMM_compute_(handle,opA,opB,alpha,matA,matB,beta,matC,computeType,alg, & spgemmDescr,bufferSize2,externalBuffer2) & bind(c, name="hipsparseSpGEMM_compute") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpGEMM_compute_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opB type(c_ptr),value :: alpha type(c_ptr),value :: matA type(c_ptr),value :: matB type(c_ptr),value :: beta type(c_ptr),value :: matC integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_SPGEMM_DEFAULT)),value :: alg type(c_ptr),value :: spgemmDescr type(c_ptr),value :: bufferSize2 type(c_ptr),value :: externalBuffer2 end function end interface interface hipsparseSpGEMM_copy #ifdef USE_CUDA_NAMES function hipsparseSpGEMM_copy_(handle,opA,opB,alpha,matA,matB,beta,matC,computeType,alg, & spgemmDescr) & bind(c, name="cusparseSpGEMM_copy") #else function hipsparseSpGEMM_copy_(handle,opA,opB,alpha,matA,matB,beta,matC,computeType,alg, & spgemmDescr) & bind(c, name="hipsparseSpGEMM_copy") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpGEMM_copy_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opB type(c_ptr),value :: alpha type(c_ptr),value :: matA type(c_ptr),value :: matB type(c_ptr),value :: beta type(c_ptr),value :: matC integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_SPGEMM_DEFAULT)),value :: alg type(c_ptr),value :: spgemmDescr end function end interface interface hipsparseSpGEMMreuse_workEstimation #ifdef USE_CUDA_NAMES function hipsparseSpGEMMreuse_workEstimation_(handle,opA,opB,matA,matB,matC,alg,spgemmDescr, & bufferSize1,externalBuffer1) & bind(c, name="cusparseSpGEMMreuse_workEstimation") #else function hipsparseSpGEMMreuse_workEstimation_(handle,opA,opB,matA,matB,matC,alg,spgemmDescr, & bufferSize1,externalBuffer1) & bind(c, name="hipsparseSpGEMMreuse_workEstimation") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpGEMMreuse_workEstimation_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opB type(c_ptr),value :: matA type(c_ptr),value :: matB type(c_ptr),value :: matC integer(kind(HIPSPARSE_SPGEMM_DEFAULT)),value :: alg type(c_ptr),value :: spgemmDescr type(c_ptr),value :: bufferSize1 type(c_ptr),value :: externalBuffer1 end function end interface interface hipsparseSpGEMMreuse_nnz #ifdef USE_CUDA_NAMES function hipsparseSpGEMMreuse_nnz_(handle,opA,opB,matA,matB,matC,alg,spgemmDescr,bufferSize2, & externalBuffer2,bufferSize3,externalBuffer3,bufferSize4,externalBuffer4) & bind(c, name="cusparseSpGEMMreuse_nnz") #else function hipsparseSpGEMMreuse_nnz_(handle,opA,opB,matA,matB,matC,alg,spgemmDescr,bufferSize2, & externalBuffer2,bufferSize3,externalBuffer3,bufferSize4,externalBuffer4) & bind(c, name="hipsparseSpGEMMreuse_nnz") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpGEMMreuse_nnz_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opB type(c_ptr),value :: matA type(c_ptr),value :: matB type(c_ptr),value :: matC integer(kind(HIPSPARSE_SPGEMM_DEFAULT)),value :: alg type(c_ptr),value :: spgemmDescr type(c_ptr),value :: bufferSize2 type(c_ptr),value :: externalBuffer2 type(c_ptr),value :: bufferSize3 type(c_ptr),value :: externalBuffer3 type(c_ptr),value :: bufferSize4 type(c_ptr),value :: externalBuffer4 end function end interface interface hipsparseSpGEMMreuse_copy #ifdef USE_CUDA_NAMES function hipsparseSpGEMMreuse_copy_(handle,opA,opB,matA,matB,matC,alg,spgemmDescr,bufferSize5, & externalBuffer5) & bind(c, name="cusparseSpGEMMreuse_copy") #else function hipsparseSpGEMMreuse_copy_(handle,opA,opB,matA,matB,matC,alg,spgemmDescr,bufferSize5, & externalBuffer5) & bind(c, name="hipsparseSpGEMMreuse_copy") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpGEMMreuse_copy_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opB type(c_ptr),value :: matA type(c_ptr),value :: matB type(c_ptr),value :: matC integer(kind(HIPSPARSE_SPGEMM_DEFAULT)),value :: alg type(c_ptr),value :: spgemmDescr type(c_ptr),value :: bufferSize5 type(c_ptr),value :: externalBuffer5 end function end interface interface hipsparseSpGEMMreuse_compute #ifdef USE_CUDA_NAMES function hipsparseSpGEMMreuse_compute_(handle,opA,opB,alpha,matA,matB,beta,matC,computeType, & alg,spgemmDescr) & bind(c, name="cusparseSpGEMMreuse_compute") #else function hipsparseSpGEMMreuse_compute_(handle,opA,opB,alpha,matA,matB,beta,matC,computeType, & alg,spgemmDescr) & bind(c, name="hipsparseSpGEMMreuse_compute") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpGEMMreuse_compute_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opB type(c_ptr),value :: alpha type(c_ptr),value :: matA type(c_ptr),value :: matB type(c_ptr),value :: beta type(c_ptr),value :: matC integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_SPGEMM_DEFAULT)),value :: alg type(c_ptr),value :: spgemmDescr end function end interface interface hipsparseSpMM_bufferSize #ifdef USE_CUDA_NAMES function hipsparseSpMM_bufferSize_(handle,opA,opB,alpha,matA,matB,beta,matC,computeType,alg, & pBufferSizeInBytes) & bind(c, name="cusparseSpMM_bufferSize") #else function hipsparseSpMM_bufferSize_(handle,opA,opB,alpha,matA,matB,beta,matC,computeType,alg, & pBufferSizeInBytes) & bind(c, name="hipsparseSpMM_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpMM_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opB type(c_ptr),value :: alpha type(c_ptr),value :: matA type(c_ptr),value :: matB type(c_ptr),value :: beta type(c_ptr),value :: matC integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_MM_ALG_DEFAULT)),value :: alg integer(c_size_t) :: pBufferSizeInBytes end function end interface interface hipsparseSpMM_preprocess #ifdef USE_CUDA_NAMES function hipsparseSpMM_preprocess_(handle,opA,opB,alpha,matA,matB,beta,matC,computeType,alg, & externalBuffer) & bind(c, name="cusparseSpMM_preprocess") #else function hipsparseSpMM_preprocess_(handle,opA,opB,alpha,matA,matB,beta,matC,computeType,alg, & externalBuffer) & bind(c, name="hipsparseSpMM_preprocess") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpMM_preprocess_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opB type(c_ptr),value :: alpha type(c_ptr),value :: matA type(c_ptr),value :: matB type(c_ptr),value :: beta type(c_ptr),value :: matC integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_MM_ALG_DEFAULT)),value :: alg type(c_ptr),value :: externalBuffer end function end interface interface hipsparseSpMM #ifdef USE_CUDA_NAMES function hipsparseSpMM_(handle,opA,opB,alpha,matA,matB,beta,matC,computeType,alg, & externalBuffer) & bind(c, name="cusparseSpMM") #else function hipsparseSpMM_(handle,opA,opB,alpha,matA,matB,beta,matC,computeType,alg, & externalBuffer) & bind(c, name="hipsparseSpMM") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpMM_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opB type(c_ptr),value :: alpha type(c_ptr),value :: matA type(c_ptr),value :: matB type(c_ptr),value :: beta type(c_ptr),value :: matC integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_MM_ALG_DEFAULT)),value :: alg type(c_ptr),value :: externalBuffer end function end interface interface hipsparseSpMV_bufferSize #ifdef USE_CUDA_NAMES function hipsparseSpMV_bufferSize_(handle,opA,alpha,matA,vecX,beta,vecY,computeType,alg, & pBufferSizeInBytes) & bind(c, name="cusparseSpMV_bufferSize") #else function hipsparseSpMV_bufferSize_(handle,opA,alpha,matA,vecX,beta,vecY,computeType,alg, & pBufferSizeInBytes) & bind(c, name="hipsparseSpMV_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpMV_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA type(c_ptr),value :: alpha type(c_ptr),value :: matA type(c_ptr),value :: vecX type(c_ptr),value :: beta type(c_ptr),value :: vecY integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_MV_ALG_DEFAULT)),value :: alg integer(c_size_t) :: pBufferSizeInBytes end function end interface interface hipsparseSpMV_preprocess #ifdef USE_CUDA_NAMES function hipsparseSpMV_preprocess_(handle,opA,alpha,matA,vecX,beta,vecY,computeType,alg, & externalBuffer) & bind(c, name="cusparseSpMV_preprocess") #else function hipsparseSpMV_preprocess_(handle,opA,alpha,matA,vecX,beta,vecY,computeType,alg, & externalBuffer) & bind(c, name="hipsparseSpMV_preprocess") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpMV_preprocess_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA type(c_ptr),value :: alpha type(c_ptr),value :: matA type(c_ptr),value :: vecX type(c_ptr),value :: beta type(c_ptr),value :: vecY integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_MV_ALG_DEFAULT)),value :: alg type(c_ptr),value :: externalBuffer end function end interface interface hipsparseSpMV #ifdef USE_CUDA_NAMES function hipsparseSpMV_(handle,opA,alpha,matA,vecX,beta,vecY,computeType,alg,externalBuffer) & bind(c, name="cusparseSpMV") #else function hipsparseSpMV_(handle,opA,alpha,matA,vecX,beta,vecY,computeType,alg,externalBuffer) & bind(c, name="hipsparseSpMV") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpMV_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA type(c_ptr),value :: alpha type(c_ptr),value :: matA type(c_ptr),value :: vecX type(c_ptr),value :: beta type(c_ptr),value :: vecY integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_MV_ALG_DEFAULT)),value :: alg type(c_ptr),value :: externalBuffer end function end interface interface hipsparseSpSM_createDescr #ifdef USE_CUDA_NAMES function hipsparseSpSM_createDescr_(descr) bind(c, name="cusparseSpSM_createDescr") #else function hipsparseSpSM_createDescr_(descr) bind(c, name="hipsparseSpSM_createDescr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpSM_createDescr_ type(c_ptr) :: descr end function end interface interface hipsparseSpSM_destroyDescr #ifdef USE_CUDA_NAMES function hipsparseSpSM_destroyDescr_(descr) bind(c, name="cusparseSpSM_destroyDescr") #else function hipsparseSpSM_destroyDescr_(descr) bind(c, name="hipsparseSpSM_destroyDescr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpSM_destroyDescr_ type(c_ptr),value :: descr end function end interface interface hipsparseSpSM_bufferSize #ifdef USE_CUDA_NAMES function hipsparseSpSM_bufferSize_(handle,opA,opB,alpha,matA,matB,matC,computeType,alg, & spsmDescr,pBufferSizeInBytes) & bind(c, name="cusparseSpSM_bufferSize") #else function hipsparseSpSM_bufferSize_(handle,opA,opB,alpha,matA,matB,matC,computeType,alg, & spsmDescr,pBufferSizeInBytes) & bind(c, name="hipsparseSpSM_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpSM_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opB type(c_ptr),value :: alpha type(c_ptr),value :: matA type(c_ptr),value :: matB type(c_ptr),value :: matC integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_SPSM_ALG_DEFAULT)),value :: alg type(c_ptr),value :: spsmDescr integer(c_size_t) :: pBufferSizeInBytes end function end interface interface hipsparseSpSM_analysis #ifdef USE_CUDA_NAMES function hipsparseSpSM_analysis_(handle,opA,opB,alpha,matA,matB,matC,computeType,alg, & spsmDescr,externalBuffer) & bind(c, name="cusparseSpSM_analysis") #else function hipsparseSpSM_analysis_(handle,opA,opB,alpha,matA,matB,matC,computeType,alg, & spsmDescr,externalBuffer) & bind(c, name="hipsparseSpSM_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpSM_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opB type(c_ptr),value :: alpha type(c_ptr),value :: matA type(c_ptr),value :: matB type(c_ptr),value :: matC integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_SPSM_ALG_DEFAULT)),value :: alg type(c_ptr),value :: spsmDescr type(c_ptr),value :: externalBuffer end function end interface interface hipsparseSpSM_solve #ifdef USE_CUDA_NAMES function hipsparseSpSM_solve_(handle,opA,opB,alpha,matA,matB,matC,computeType,alg,spsmDescr, & externalBuffer) & bind(c, name="cusparseSpSM_solve") #else function hipsparseSpSM_solve_(handle,opA,opB,alpha,matA,matB,matC,computeType,alg,spsmDescr, & externalBuffer) & bind(c, name="hipsparseSpSM_solve") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpSM_solve_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opB type(c_ptr),value :: alpha type(c_ptr),value :: matA type(c_ptr),value :: matB type(c_ptr),value :: matC integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_SPSM_ALG_DEFAULT)),value :: alg type(c_ptr),value :: spsmDescr type(c_ptr),value :: externalBuffer end function end interface #ifndef USE_CUDA_NAMES interface hipsparseSpSM_solve_ex function hipsparseSpSM_solve_ex_(handle,opA,opB,alpha,matA,matB,matC,computeType,alg, & spsmDescr) & bind(c, name="hipsparseSpSM_solve_ex") use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpSM_solve_ex_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opB type(c_ptr),value :: alpha type(c_ptr),value :: matA type(c_ptr),value :: matB type(c_ptr),value :: matC integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_SPSM_ALG_DEFAULT)),value :: alg type(c_ptr),value :: spsmDescr end function end interface #endif interface hipsparseSpSV_createDescr #ifdef USE_CUDA_NAMES function hipsparseSpSV_createDescr_(descr) bind(c, name="cusparseSpSV_createDescr") #else function hipsparseSpSV_createDescr_(descr) bind(c, name="hipsparseSpSV_createDescr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpSV_createDescr_ type(c_ptr) :: descr end function end interface interface hipsparseSpSV_destroyDescr #ifdef USE_CUDA_NAMES function hipsparseSpSV_destroyDescr_(descr) bind(c, name="cusparseSpSV_destroyDescr") #else function hipsparseSpSV_destroyDescr_(descr) bind(c, name="hipsparseSpSV_destroyDescr") #endif use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpSV_destroyDescr_ type(c_ptr),value :: descr end function end interface interface hipsparseSpSV_bufferSize #ifdef USE_CUDA_NAMES function hipsparseSpSV_bufferSize_(handle,opA,alpha,matA,x,y,computeType,alg,spsvDescr, & pBufferSizeInBytes) & bind(c, name="cusparseSpSV_bufferSize") #else function hipsparseSpSV_bufferSize_(handle,opA,alpha,matA,x,y,computeType,alg,spsvDescr, & pBufferSizeInBytes) & bind(c, name="hipsparseSpSV_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpSV_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA type(c_ptr),value :: alpha type(c_ptr),value :: matA type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_SPSV_ALG_DEFAULT)),value :: alg type(c_ptr),value :: spsvDescr integer(c_size_t) :: pBufferSizeInBytes end function end interface interface hipsparseSpSV_analysis #ifdef USE_CUDA_NAMES function hipsparseSpSV_analysis_(handle,opA,alpha,matA,x,y,computeType,alg,spsvDescr, & externalBuffer) & bind(c, name="cusparseSpSV_analysis") #else function hipsparseSpSV_analysis_(handle,opA,alpha,matA,x,y,computeType,alg,spsvDescr, & externalBuffer) & bind(c, name="hipsparseSpSV_analysis") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpSV_analysis_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA type(c_ptr),value :: alpha type(c_ptr),value :: matA type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_SPSV_ALG_DEFAULT)),value :: alg type(c_ptr),value :: spsvDescr type(c_ptr),value :: externalBuffer end function end interface interface hipsparseSpSV_solve #ifdef USE_CUDA_NAMES function hipsparseSpSV_solve_(handle,opA,alpha,matA,x,y,computeType,alg,spsvDescr) & bind(c, name="cusparseSpSV_solve") #else function hipsparseSpSV_solve_(handle,opA,alpha,matA,x,y,computeType,alg,spsvDescr) & bind(c, name="hipsparseSpSV_solve") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpSV_solve_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opA type(c_ptr),value :: alpha type(c_ptr),value :: matA type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(HIP_R_32F)),value :: computeType integer(kind(HIPSPARSE_SPSV_ALG_DEFAULT)),value :: alg type(c_ptr),value :: spsvDescr end function end interface interface hipsparseSpVV_bufferSize #ifdef USE_CUDA_NAMES function hipsparseSpVV_bufferSize_(handle,opX,vecX,vecY,myResult,computeType, & pBufferSizeInBytes) & bind(c, name="cusparseSpVV_bufferSize") #else function hipsparseSpVV_bufferSize_(handle,opX,vecX,vecY,myResult,computeType, & pBufferSizeInBytes) & bind(c, name="hipsparseSpVV_bufferSize") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpVV_bufferSize_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opX type(c_ptr),value :: vecX type(c_ptr),value :: vecY type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: computeType integer(c_size_t) :: pBufferSizeInBytes end function end interface interface hipsparseSpVV #ifdef USE_CUDA_NAMES function hipsparseSpVV_(handle,opX,vecX,vecY,myResult,computeType,externalBuffer) & bind(c, name="cusparseSpVV") #else function hipsparseSpVV_(handle,opX,vecX,vecY,myResult,computeType,externalBuffer) & bind(c, name="hipsparseSpVV") #endif use iso_c_binding use hipfort_hipsparse_enums use hipfort_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpVV_ type(c_ptr),value :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)),value :: opX type(c_ptr),value :: vecX type(c_ptr),value :: vecY type(c_ptr),value :: myResult integer(kind(HIP_R_32F)),value :: computeType type(c_ptr),value :: externalBuffer end function end interface #ifdef USE_FPOINTER_INTERFACES contains #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSaxpyi_assumed_rank(handle,nnz,alpha,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSaxpyi_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd real(c_float),target,contiguous,dimension(..) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseSaxpyi_assumed_rank = hipsparseSaxpyi_(handle,nnz,alpha,c_loc(xVal),c_loc(xInd), & c_loc(y),idxBase) end function #else function hipsparseSaxpyi_rank_0(handle,nnz,alpha,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSaxpyi_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float) :: alpha real(c_float),target :: xVal integer(c_int),target :: xInd real(c_float),target :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseSaxpyi_rank_0 = hipsparseSaxpyi_(handle,nnz,alpha,c_loc(xVal),c_loc(xInd),c_loc(y), & idxBase) end function function hipsparseSaxpyi_rank_1(handle,nnz,alpha,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSaxpyi_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float) :: alpha real(c_float),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd real(c_float),target,dimension(:) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseSaxpyi_rank_1 = hipsparseSaxpyi_(handle,nnz,alpha,c_loc(xVal),c_loc(xInd),c_loc(y), & idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDaxpyi_assumed_rank(handle,nnz,alpha,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDaxpyi_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd real(c_double),target,contiguous,dimension(..) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDaxpyi_assumed_rank = hipsparseDaxpyi_(handle,nnz,alpha,c_loc(xVal),c_loc(xInd), & c_loc(y),idxBase) end function #else function hipsparseDaxpyi_rank_0(handle,nnz,alpha,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDaxpyi_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double) :: alpha real(c_double),target :: xVal integer(c_int),target :: xInd real(c_double),target :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDaxpyi_rank_0 = hipsparseDaxpyi_(handle,nnz,alpha,c_loc(xVal),c_loc(xInd),c_loc(y), & idxBase) end function function hipsparseDaxpyi_rank_1(handle,nnz,alpha,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDaxpyi_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double) :: alpha real(c_double),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd real(c_double),target,dimension(:) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDaxpyi_rank_1 = hipsparseDaxpyi_(handle,nnz,alpha,c_loc(xVal),c_loc(xInd),c_loc(y), & idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCaxpyi_assumed_rank(handle,nnz,alpha,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCaxpyi_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd complex(c_float_complex),target,contiguous,dimension(..) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCaxpyi_assumed_rank = hipsparseCaxpyi_(handle,nnz,alpha,c_loc(xVal),c_loc(xInd), & c_loc(y),idxBase) end function #else function hipsparseCaxpyi_rank_0(handle,nnz,alpha,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCaxpyi_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex) :: alpha complex(c_float_complex),target :: xVal integer(c_int),target :: xInd complex(c_float_complex),target :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCaxpyi_rank_0 = hipsparseCaxpyi_(handle,nnz,alpha,c_loc(xVal),c_loc(xInd),c_loc(y), & idxBase) end function function hipsparseCaxpyi_rank_1(handle,nnz,alpha,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCaxpyi_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd complex(c_float_complex),target,dimension(:) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCaxpyi_rank_1 = hipsparseCaxpyi_(handle,nnz,alpha,c_loc(xVal),c_loc(xInd),c_loc(y), & idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZaxpyi_assumed_rank(handle,nnz,alpha,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZaxpyi_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd complex(c_double_complex),target,contiguous,dimension(..) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZaxpyi_assumed_rank = hipsparseZaxpyi_(handle,nnz,alpha,c_loc(xVal),c_loc(xInd), & c_loc(y),idxBase) end function #else function hipsparseZaxpyi_rank_0(handle,nnz,alpha,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZaxpyi_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex) :: alpha complex(c_double_complex),target :: xVal integer(c_int),target :: xInd complex(c_double_complex),target :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZaxpyi_rank_0 = hipsparseZaxpyi_(handle,nnz,alpha,c_loc(xVal),c_loc(xInd),c_loc(y), & idxBase) end function function hipsparseZaxpyi_rank_1(handle,nnz,alpha,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZaxpyi_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd complex(c_double_complex),target,dimension(:) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZaxpyi_rank_1 = hipsparseZaxpyi_(handle,nnz,alpha,c_loc(xVal),c_loc(xInd),c_loc(y), & idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCdotci_assumed_rank(handle,nnz,xVal,xInd,y,myResult,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCdotci_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd complex(c_float_complex),target,contiguous,dimension(..) :: y complex(c_float_complex),target,contiguous,dimension(..) :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCdotci_assumed_rank = hipsparseCdotci_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & c_loc(myResult),idxBase) end function #else function hipsparseCdotci_rank_0(handle,nnz,xVal,xInd,y,myResult,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCdotci_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target :: xVal integer(c_int),target :: xInd complex(c_float_complex),target :: y complex(c_float_complex),target :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCdotci_rank_0 = hipsparseCdotci_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & c_loc(myResult),idxBase) end function function hipsparseCdotci_rank_1(handle,nnz,xVal,xInd,y,myResult,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCdotci_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd complex(c_float_complex),target,dimension(:) :: y complex(c_float_complex),target,dimension(:) :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCdotci_rank_1 = hipsparseCdotci_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & c_loc(myResult),idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZdotci_assumed_rank(handle,nnz,xVal,xInd,y,myResult,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZdotci_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd complex(c_double_complex),target,contiguous,dimension(..) :: y complex(c_double_complex),target,contiguous,dimension(..) :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZdotci_assumed_rank = hipsparseZdotci_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & c_loc(myResult),idxBase) end function #else function hipsparseZdotci_rank_0(handle,nnz,xVal,xInd,y,myResult,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZdotci_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target :: xVal integer(c_int),target :: xInd complex(c_double_complex),target :: y complex(c_double_complex),target :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZdotci_rank_0 = hipsparseZdotci_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & c_loc(myResult),idxBase) end function function hipsparseZdotci_rank_1(handle,nnz,xVal,xInd,y,myResult,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZdotci_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd complex(c_double_complex),target,dimension(:) :: y complex(c_double_complex),target,dimension(:) :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZdotci_rank_1 = hipsparseZdotci_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & c_loc(myResult),idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSdoti_assumed_rank(handle,nnz,xVal,xInd,y,myResult,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSdoti_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd real(c_float),target,contiguous,dimension(..) :: y real(c_float),target,contiguous,dimension(..) :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseSdoti_assumed_rank = hipsparseSdoti_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & c_loc(myResult),idxBase) end function #else function hipsparseSdoti_rank_0(handle,nnz,xVal,xInd,y,myResult,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSdoti_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target :: xVal integer(c_int),target :: xInd real(c_float),target :: y real(c_float),target :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseSdoti_rank_0 = hipsparseSdoti_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & c_loc(myResult),idxBase) end function function hipsparseSdoti_rank_1(handle,nnz,xVal,xInd,y,myResult,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSdoti_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd real(c_float),target,dimension(:) :: y real(c_float),target,dimension(:) :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseSdoti_rank_1 = hipsparseSdoti_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & c_loc(myResult),idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDdoti_assumed_rank(handle,nnz,xVal,xInd,y,myResult,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDdoti_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd real(c_double),target,contiguous,dimension(..) :: y real(c_double),target,contiguous,dimension(..) :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDdoti_assumed_rank = hipsparseDdoti_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & c_loc(myResult),idxBase) end function #else function hipsparseDdoti_rank_0(handle,nnz,xVal,xInd,y,myResult,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDdoti_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target :: xVal integer(c_int),target :: xInd real(c_double),target :: y real(c_double),target :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDdoti_rank_0 = hipsparseDdoti_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & c_loc(myResult),idxBase) end function function hipsparseDdoti_rank_1(handle,nnz,xVal,xInd,y,myResult,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDdoti_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd real(c_double),target,dimension(:) :: y real(c_double),target,dimension(:) :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDdoti_rank_1 = hipsparseDdoti_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & c_loc(myResult),idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCdoti_assumed_rank(handle,nnz,xVal,xInd,y,myResult,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCdoti_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd complex(c_float_complex),target,contiguous,dimension(..) :: y complex(c_float_complex),target,contiguous,dimension(..) :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCdoti_assumed_rank = hipsparseCdoti_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & c_loc(myResult),idxBase) end function #else function hipsparseCdoti_rank_0(handle,nnz,xVal,xInd,y,myResult,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCdoti_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target :: xVal integer(c_int),target :: xInd complex(c_float_complex),target :: y complex(c_float_complex),target :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCdoti_rank_0 = hipsparseCdoti_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & c_loc(myResult),idxBase) end function function hipsparseCdoti_rank_1(handle,nnz,xVal,xInd,y,myResult,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCdoti_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd complex(c_float_complex),target,dimension(:) :: y complex(c_float_complex),target,dimension(:) :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCdoti_rank_1 = hipsparseCdoti_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & c_loc(myResult),idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZdoti_assumed_rank(handle,nnz,xVal,xInd,y,myResult,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZdoti_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd complex(c_double_complex),target,contiguous,dimension(..) :: y complex(c_double_complex),target,contiguous,dimension(..) :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZdoti_assumed_rank = hipsparseZdoti_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & c_loc(myResult),idxBase) end function #else function hipsparseZdoti_rank_0(handle,nnz,xVal,xInd,y,myResult,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZdoti_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target :: xVal integer(c_int),target :: xInd complex(c_double_complex),target :: y complex(c_double_complex),target :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZdoti_rank_0 = hipsparseZdoti_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & c_loc(myResult),idxBase) end function function hipsparseZdoti_rank_1(handle,nnz,xVal,xInd,y,myResult,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZdoti_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd complex(c_double_complex),target,dimension(:) :: y complex(c_double_complex),target,dimension(:) :: myResult integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZdoti_rank_1 = hipsparseZdoti_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & c_loc(myResult),idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSgthr_assumed_rank(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgthr_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,contiguous,dimension(..) :: y real(c_float),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseSgthr_assumed_rank = hipsparseSgthr_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd), & idxBase) end function #else function hipsparseSgthr_rank_0(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgthr_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target :: y real(c_float),target :: xVal integer(c_int),target :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseSgthr_rank_0 = hipsparseSgthr_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd),idxBase) end function function hipsparseSgthr_rank_1(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgthr_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,dimension(:) :: y real(c_float),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseSgthr_rank_1 = hipsparseSgthr_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd),idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDgthr_assumed_rank(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgthr_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,contiguous,dimension(..) :: y real(c_double),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDgthr_assumed_rank = hipsparseDgthr_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd), & idxBase) end function #else function hipsparseDgthr_rank_0(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgthr_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target :: y real(c_double),target :: xVal integer(c_int),target :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDgthr_rank_0 = hipsparseDgthr_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd),idxBase) end function function hipsparseDgthr_rank_1(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgthr_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,dimension(:) :: y real(c_double),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDgthr_rank_1 = hipsparseDgthr_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd),idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCgthr_assumed_rank(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgthr_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,contiguous,dimension(..) :: y complex(c_float_complex),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCgthr_assumed_rank = hipsparseCgthr_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd), & idxBase) end function #else function hipsparseCgthr_rank_0(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgthr_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target :: y complex(c_float_complex),target :: xVal integer(c_int),target :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCgthr_rank_0 = hipsparseCgthr_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd),idxBase) end function function hipsparseCgthr_rank_1(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgthr_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,dimension(:) :: y complex(c_float_complex),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCgthr_rank_1 = hipsparseCgthr_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd),idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZgthr_assumed_rank(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgthr_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,contiguous,dimension(..) :: y complex(c_double_complex),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZgthr_assumed_rank = hipsparseZgthr_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd), & idxBase) end function #else function hipsparseZgthr_rank_0(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgthr_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target :: y complex(c_double_complex),target :: xVal integer(c_int),target :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZgthr_rank_0 = hipsparseZgthr_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd),idxBase) end function function hipsparseZgthr_rank_1(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgthr_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,dimension(:) :: y complex(c_double_complex),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZgthr_rank_1 = hipsparseZgthr_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd),idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSgthrz_assumed_rank(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgthrz_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,contiguous,dimension(..) :: y real(c_float),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseSgthrz_assumed_rank = hipsparseSgthrz_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd), & idxBase) end function #else function hipsparseSgthrz_rank_0(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgthrz_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target :: y real(c_float),target :: xVal integer(c_int),target :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseSgthrz_rank_0 = hipsparseSgthrz_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd),idxBase) end function function hipsparseSgthrz_rank_1(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgthrz_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,dimension(:) :: y real(c_float),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseSgthrz_rank_1 = hipsparseSgthrz_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd),idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDgthrz_assumed_rank(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgthrz_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,contiguous,dimension(..) :: y real(c_double),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDgthrz_assumed_rank = hipsparseDgthrz_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd), & idxBase) end function #else function hipsparseDgthrz_rank_0(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgthrz_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target :: y real(c_double),target :: xVal integer(c_int),target :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDgthrz_rank_0 = hipsparseDgthrz_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd),idxBase) end function function hipsparseDgthrz_rank_1(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgthrz_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,dimension(:) :: y real(c_double),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDgthrz_rank_1 = hipsparseDgthrz_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd),idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCgthrz_assumed_rank(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgthrz_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,contiguous,dimension(..) :: y complex(c_float_complex),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCgthrz_assumed_rank = hipsparseCgthrz_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd), & idxBase) end function #else function hipsparseCgthrz_rank_0(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgthrz_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target :: y complex(c_float_complex),target :: xVal integer(c_int),target :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCgthrz_rank_0 = hipsparseCgthrz_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd),idxBase) end function function hipsparseCgthrz_rank_1(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgthrz_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,dimension(:) :: y complex(c_float_complex),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCgthrz_rank_1 = hipsparseCgthrz_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd),idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZgthrz_assumed_rank(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgthrz_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,contiguous,dimension(..) :: y complex(c_double_complex),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZgthrz_assumed_rank = hipsparseZgthrz_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd), & idxBase) end function #else function hipsparseZgthrz_rank_0(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgthrz_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target :: y complex(c_double_complex),target :: xVal integer(c_int),target :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZgthrz_rank_0 = hipsparseZgthrz_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd),idxBase) end function function hipsparseZgthrz_rank_1(handle,nnz,y,xVal,xInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgthrz_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,dimension(:) :: y complex(c_double_complex),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZgthrz_rank_1 = hipsparseZgthrz_(handle,nnz,c_loc(y),c_loc(xVal),c_loc(xInd),idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSroti_assumed_rank(handle,nnz,xVal,xInd,y,c,s,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSroti_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd real(c_float),target,contiguous,dimension(..) :: y real(c_float) :: c real(c_float) :: s integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseSroti_assumed_rank = hipsparseSroti_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y),c, & s,idxBase) end function #else function hipsparseSroti_rank_0(handle,nnz,xVal,xInd,y,c,s,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSroti_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target :: xVal integer(c_int),target :: xInd real(c_float),target :: y real(c_float) :: c real(c_float) :: s integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseSroti_rank_0 = hipsparseSroti_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y),c,s, & idxBase) end function function hipsparseSroti_rank_1(handle,nnz,xVal,xInd,y,c,s,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSroti_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd real(c_float),target,dimension(:) :: y real(c_float) :: c real(c_float) :: s integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseSroti_rank_1 = hipsparseSroti_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y),c,s, & idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDroti_assumed_rank(handle,nnz,xVal,xInd,y,c,s,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDroti_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd real(c_double),target,contiguous,dimension(..) :: y real(c_double) :: c real(c_double) :: s integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDroti_assumed_rank = hipsparseDroti_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y),c, & s,idxBase) end function #else function hipsparseDroti_rank_0(handle,nnz,xVal,xInd,y,c,s,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDroti_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target :: xVal integer(c_int),target :: xInd real(c_double),target :: y real(c_double) :: c real(c_double) :: s integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDroti_rank_0 = hipsparseDroti_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y),c,s, & idxBase) end function function hipsparseDroti_rank_1(handle,nnz,xVal,xInd,y,c,s,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDroti_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd real(c_double),target,dimension(:) :: y real(c_double) :: c real(c_double) :: s integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDroti_rank_1 = hipsparseDroti_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y),c,s, & idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSsctr_assumed_rank(handle,nnz,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSsctr_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd real(c_float),target,contiguous,dimension(..) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseSsctr_assumed_rank = hipsparseSsctr_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & idxBase) end function #else function hipsparseSsctr_rank_0(handle,nnz,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSsctr_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target :: xVal integer(c_int),target :: xInd real(c_float),target :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseSsctr_rank_0 = hipsparseSsctr_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y),idxBase) end function function hipsparseSsctr_rank_1(handle,nnz,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSsctr_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd real(c_float),target,dimension(:) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseSsctr_rank_1 = hipsparseSsctr_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y),idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDsctr_assumed_rank(handle,nnz,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDsctr_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd real(c_double),target,contiguous,dimension(..) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDsctr_assumed_rank = hipsparseDsctr_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & idxBase) end function #else function hipsparseDsctr_rank_0(handle,nnz,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDsctr_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target :: xVal integer(c_int),target :: xInd real(c_double),target :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDsctr_rank_0 = hipsparseDsctr_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y),idxBase) end function function hipsparseDsctr_rank_1(handle,nnz,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDsctr_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd real(c_double),target,dimension(:) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDsctr_rank_1 = hipsparseDsctr_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y),idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCsctr_assumed_rank(handle,nnz,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCsctr_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd complex(c_float_complex),target,contiguous,dimension(..) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCsctr_assumed_rank = hipsparseCsctr_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & idxBase) end function #else function hipsparseCsctr_rank_0(handle,nnz,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCsctr_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target :: xVal integer(c_int),target :: xInd complex(c_float_complex),target :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCsctr_rank_0 = hipsparseCsctr_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y),idxBase) end function function hipsparseCsctr_rank_1(handle,nnz,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCsctr_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd complex(c_float_complex),target,dimension(:) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCsctr_rank_1 = hipsparseCsctr_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y),idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZsctr_assumed_rank(handle,nnz,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZsctr_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,contiguous,dimension(..) :: xVal integer(c_int),target,contiguous,dimension(..) :: xInd complex(c_double_complex),target,contiguous,dimension(..) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZsctr_assumed_rank = hipsparseZsctr_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y), & idxBase) end function #else function hipsparseZsctr_rank_0(handle,nnz,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZsctr_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target :: xVal integer(c_int),target :: xInd complex(c_double_complex),target :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZsctr_rank_0 = hipsparseZsctr_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y),idxBase) end function function hipsparseZsctr_rank_1(handle,nnz,xVal,xInd,y,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZsctr_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,dimension(:) :: xVal integer(c_int),target,dimension(:) :: xInd complex(c_double_complex),target,dimension(:) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZsctr_rank_1 = hipsparseZsctr_(handle,nnz,c_loc(xVal),c_loc(xInd),c_loc(y),idxBase) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSbsrmv_assumed_rank(handle,dirA,transA,mb,nb,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim real(c_float),target,contiguous,dimension(..) :: x real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y ! hipsparseSbsrmv_assumed_rank = hipsparseSbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA, & c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,c_loc(x), & beta,c_loc(y)) end function #else function hipsparseSbsrmv_rank_0(handle,dirA,transA,mb,nb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrmv_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim real(c_float),target :: x real(c_float) :: beta real(c_float),target :: y ! hipsparseSbsrmv_rank_0 = hipsparseSbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA, & c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,c_loc(x), & beta,c_loc(y)) end function function hipsparseSbsrmv_rank_1(handle,dirA,transA,mb,nb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrmv_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim real(c_float),target,dimension(:) :: x real(c_float) :: beta real(c_float),target,dimension(:) :: y ! hipsparseSbsrmv_rank_1 = hipsparseSbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA, & c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,c_loc(x), & beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDbsrmv_assumed_rank(handle,dirA,transA,mb,nb,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim real(c_double),target,contiguous,dimension(..) :: x real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y ! hipsparseDbsrmv_assumed_rank = hipsparseDbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA, & c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,c_loc(x), & beta,c_loc(y)) end function #else function hipsparseDbsrmv_rank_0(handle,dirA,transA,mb,nb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrmv_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim real(c_double),target :: x real(c_double) :: beta real(c_double),target :: y ! hipsparseDbsrmv_rank_0 = hipsparseDbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA, & c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,c_loc(x), & beta,c_loc(y)) end function function hipsparseDbsrmv_rank_1(handle,dirA,transA,mb,nb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrmv_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim real(c_double),target,dimension(:) :: x real(c_double) :: beta real(c_double),target,dimension(:) :: y ! hipsparseDbsrmv_rank_1 = hipsparseDbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA, & c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,c_loc(x), & beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCbsrmv_assumed_rank(handle,dirA,transA,mb,nb,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim complex(c_float_complex),target,contiguous,dimension(..) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y ! hipsparseCbsrmv_assumed_rank = hipsparseCbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA, & c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,c_loc(x), & beta,c_loc(y)) end function #else function hipsparseCbsrmv_rank_0(handle,dirA,transA,mb,nb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrmv_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim complex(c_float_complex),target :: x complex(c_float_complex) :: beta complex(c_float_complex),target :: y ! hipsparseCbsrmv_rank_0 = hipsparseCbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA, & c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,c_loc(x), & beta,c_loc(y)) end function function hipsparseCbsrmv_rank_1(handle,dirA,transA,mb,nb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrmv_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim complex(c_float_complex),target,dimension(:) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y ! hipsparseCbsrmv_rank_1 = hipsparseCbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA, & c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,c_loc(x), & beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZbsrmv_assumed_rank(handle,dirA,transA,mb,nb,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim complex(c_double_complex),target,contiguous,dimension(..) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y ! hipsparseZbsrmv_assumed_rank = hipsparseZbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA, & c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,c_loc(x), & beta,c_loc(y)) end function #else function hipsparseZbsrmv_rank_0(handle,dirA,transA,mb,nb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrmv_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim complex(c_double_complex),target :: x complex(c_double_complex) :: beta complex(c_double_complex),target :: y ! hipsparseZbsrmv_rank_0 = hipsparseZbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA, & c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,c_loc(x), & beta,c_loc(y)) end function function hipsparseZbsrmv_rank_1(handle,dirA,transA,mb,nb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrmv_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim complex(c_double_complex),target,dimension(:) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y ! hipsparseZbsrmv_rank_1 = hipsparseZbsrmv_(handle,dirA,transA,mb,nb,nnzb,alpha,descrA, & c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,c_loc(x), & beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSbsrsv2_bufferSize_assumed_rank(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsv2_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseSbsrsv2_bufferSize_assumed_rank = hipsparseSbsrsv2_bufferSize_(handle,dirA,transA, & mb,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function #else function hipsparseSbsrsv2_bufferSize_rank_0(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsv2_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseSbsrsv2_bufferSize_rank_0 = hipsparseSbsrsv2_bufferSize_(handle,dirA,transA,mb, & nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function function hipsparseSbsrsv2_bufferSize_rank_1(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsv2_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseSbsrsv2_bufferSize_rank_1 = hipsparseSbsrsv2_bufferSize_(handle,dirA,transA,mb, & nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDbsrsv2_bufferSize_assumed_rank(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsv2_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDbsrsv2_bufferSize_assumed_rank = hipsparseDbsrsv2_bufferSize_(handle,dirA,transA, & mb,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function #else function hipsparseDbsrsv2_bufferSize_rank_0(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsv2_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDbsrsv2_bufferSize_rank_0 = hipsparseDbsrsv2_bufferSize_(handle,dirA,transA,mb, & nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function function hipsparseDbsrsv2_bufferSize_rank_1(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsv2_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDbsrsv2_bufferSize_rank_1 = hipsparseDbsrsv2_bufferSize_(handle,dirA,transA,mb, & nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCbsrsv2_bufferSize_assumed_rank(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsv2_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCbsrsv2_bufferSize_assumed_rank = hipsparseCbsrsv2_bufferSize_(handle,dirA,transA, & mb,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function #else function hipsparseCbsrsv2_bufferSize_rank_0(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsv2_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCbsrsv2_bufferSize_rank_0 = hipsparseCbsrsv2_bufferSize_(handle,dirA,transA,mb, & nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function function hipsparseCbsrsv2_bufferSize_rank_1(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsv2_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCbsrsv2_bufferSize_rank_1 = hipsparseCbsrsv2_bufferSize_(handle,dirA,transA,mb, & nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZbsrsv2_bufferSize_assumed_rank(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsv2_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZbsrsv2_bufferSize_assumed_rank = hipsparseZbsrsv2_bufferSize_(handle,dirA,transA, & mb,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function #else function hipsparseZbsrsv2_bufferSize_rank_0(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsv2_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZbsrsv2_bufferSize_rank_0 = hipsparseZbsrsv2_bufferSize_(handle,dirA,transA,mb, & nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function function hipsparseZbsrsv2_bufferSize_rank_1(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsv2_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZbsrsv2_bufferSize_rank_1 = hipsparseZbsrsv2_bufferSize_(handle,dirA,transA,mb, & nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSbsrsv2_bufferSizeExt_assumed_rank(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsv2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSbsrsv2_bufferSizeExt_assumed_rank = hipsparseSbsrsv2_bufferSizeExt_(handle,dirA, & transA,mb,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,pBufferSizeInBytes) end function #else function hipsparseSbsrsv2_bufferSizeExt_rank_0(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsv2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSbsrsv2_bufferSizeExt_rank_0 = hipsparseSbsrsv2_bufferSizeExt_(handle,dirA,transA, & mb,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function function hipsparseSbsrsv2_bufferSizeExt_rank_1(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsv2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSbsrsv2_bufferSizeExt_rank_1 = hipsparseSbsrsv2_bufferSizeExt_(handle,dirA,transA, & mb,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDbsrsv2_bufferSizeExt_assumed_rank(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsv2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDbsrsv2_bufferSizeExt_assumed_rank = hipsparseDbsrsv2_bufferSizeExt_(handle,dirA, & transA,mb,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,pBufferSizeInBytes) end function #else function hipsparseDbsrsv2_bufferSizeExt_rank_0(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsv2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDbsrsv2_bufferSizeExt_rank_0 = hipsparseDbsrsv2_bufferSizeExt_(handle,dirA,transA, & mb,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function function hipsparseDbsrsv2_bufferSizeExt_rank_1(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsv2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDbsrsv2_bufferSizeExt_rank_1 = hipsparseDbsrsv2_bufferSizeExt_(handle,dirA,transA, & mb,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCbsrsv2_bufferSizeExt_assumed_rank(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsv2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCbsrsv2_bufferSizeExt_assumed_rank = hipsparseCbsrsv2_bufferSizeExt_(handle,dirA, & transA,mb,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,pBufferSizeInBytes) end function #else function hipsparseCbsrsv2_bufferSizeExt_rank_0(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsv2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCbsrsv2_bufferSizeExt_rank_0 = hipsparseCbsrsv2_bufferSizeExt_(handle,dirA,transA, & mb,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function function hipsparseCbsrsv2_bufferSizeExt_rank_1(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsv2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCbsrsv2_bufferSizeExt_rank_1 = hipsparseCbsrsv2_bufferSizeExt_(handle,dirA,transA, & mb,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZbsrsv2_bufferSizeExt_assumed_rank(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsv2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZbsrsv2_bufferSizeExt_assumed_rank = hipsparseZbsrsv2_bufferSizeExt_(handle,dirA, & transA,mb,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,pBufferSizeInBytes) end function #else function hipsparseZbsrsv2_bufferSizeExt_rank_0(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsv2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZbsrsv2_bufferSizeExt_rank_0 = hipsparseZbsrsv2_bufferSizeExt_(handle,dirA,transA, & mb,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function function hipsparseZbsrsv2_bufferSizeExt_rank_1(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsv2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZbsrsv2_bufferSizeExt_rank_1 = hipsparseZbsrsv2_bufferSizeExt_(handle,dirA,transA, & mb,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSbsrsv2_analysis_assumed_rank(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsv2_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsrsv2_analysis_assumed_rank = hipsparseSbsrsv2_analysis_(handle,dirA,transA,mb, & nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function #else function hipsparseSbsrsv2_analysis_rank_0(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsv2_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsrsv2_analysis_rank_0 = hipsparseSbsrsv2_analysis_(handle,dirA,transA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function function hipsparseSbsrsv2_analysis_rank_1(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsv2_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsrsv2_analysis_rank_1 = hipsparseSbsrsv2_analysis_(handle,dirA,transA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDbsrsv2_analysis_assumed_rank(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsv2_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsrsv2_analysis_assumed_rank = hipsparseDbsrsv2_analysis_(handle,dirA,transA,mb, & nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function #else function hipsparseDbsrsv2_analysis_rank_0(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsv2_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsrsv2_analysis_rank_0 = hipsparseDbsrsv2_analysis_(handle,dirA,transA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function function hipsparseDbsrsv2_analysis_rank_1(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsv2_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsrsv2_analysis_rank_1 = hipsparseDbsrsv2_analysis_(handle,dirA,transA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCbsrsv2_analysis_assumed_rank(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsv2_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsrsv2_analysis_assumed_rank = hipsparseCbsrsv2_analysis_(handle,dirA,transA,mb, & nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function #else function hipsparseCbsrsv2_analysis_rank_0(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsv2_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsrsv2_analysis_rank_0 = hipsparseCbsrsv2_analysis_(handle,dirA,transA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function function hipsparseCbsrsv2_analysis_rank_1(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsv2_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsrsv2_analysis_rank_1 = hipsparseCbsrsv2_analysis_(handle,dirA,transA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZbsrsv2_analysis_assumed_rank(handle,dirA,transA,mb,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsv2_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsrsv2_analysis_assumed_rank = hipsparseZbsrsv2_analysis_(handle,dirA,transA,mb, & nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function #else function hipsparseZbsrsv2_analysis_rank_0(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsv2_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsrsv2_analysis_rank_0 = hipsparseZbsrsv2_analysis_(handle,dirA,transA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function function hipsparseZbsrsv2_analysis_rank_1(handle,dirA,transA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsv2_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsrsv2_analysis_rank_1 = hipsparseZbsrsv2_analysis_(handle,dirA,transA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSbsrsv2_solve_assumed_rank(handle,dirA,transA,mb,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsv2_solve_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo real(c_float),target,contiguous,dimension(..) :: f real(c_float),target,contiguous,dimension(..) :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsrsv2_solve_assumed_rank = hipsparseSbsrsv2_solve_(handle,dirA,transA,mb,nnzb, & alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,c_loc(f),c_loc(x),policy,pBuffer) end function #else function hipsparseSbsrsv2_solve_rank_0(handle,dirA,transA,mb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsv2_solve_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo real(c_float),target :: f real(c_float),target :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsrsv2_solve_rank_0 = hipsparseSbsrsv2_solve_(handle,dirA,transA,mb,nnzb,alpha, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,c_loc(f),c_loc(x),policy,pBuffer) end function function hipsparseSbsrsv2_solve_rank_1(handle,dirA,transA,mb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsv2_solve_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo real(c_float),target,dimension(:) :: f real(c_float),target,dimension(:) :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsrsv2_solve_rank_1 = hipsparseSbsrsv2_solve_(handle,dirA,transA,mb,nnzb,alpha, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,c_loc(f),c_loc(x),policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDbsrsv2_solve_assumed_rank(handle,dirA,transA,mb,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsv2_solve_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo real(c_double),target,contiguous,dimension(..) :: f real(c_double),target,contiguous,dimension(..) :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsrsv2_solve_assumed_rank = hipsparseDbsrsv2_solve_(handle,dirA,transA,mb,nnzb, & alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,c_loc(f),c_loc(x),policy,pBuffer) end function #else function hipsparseDbsrsv2_solve_rank_0(handle,dirA,transA,mb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsv2_solve_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo real(c_double),target :: f real(c_double),target :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsrsv2_solve_rank_0 = hipsparseDbsrsv2_solve_(handle,dirA,transA,mb,nnzb,alpha, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,c_loc(f),c_loc(x),policy,pBuffer) end function function hipsparseDbsrsv2_solve_rank_1(handle,dirA,transA,mb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsv2_solve_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo real(c_double),target,dimension(:) :: f real(c_double),target,dimension(:) :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsrsv2_solve_rank_1 = hipsparseDbsrsv2_solve_(handle,dirA,transA,mb,nnzb,alpha, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,c_loc(f),c_loc(x),policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCbsrsv2_solve_assumed_rank(handle,dirA,transA,mb,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsv2_solve_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo complex(c_float_complex),target,contiguous,dimension(..) :: f complex(c_float_complex),target,contiguous,dimension(..) :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsrsv2_solve_assumed_rank = hipsparseCbsrsv2_solve_(handle,dirA,transA,mb,nnzb, & alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,c_loc(f),c_loc(x),policy,pBuffer) end function #else function hipsparseCbsrsv2_solve_rank_0(handle,dirA,transA,mb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsv2_solve_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo complex(c_float_complex),target :: f complex(c_float_complex),target :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsrsv2_solve_rank_0 = hipsparseCbsrsv2_solve_(handle,dirA,transA,mb,nnzb,alpha, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,c_loc(f),c_loc(x),policy,pBuffer) end function function hipsparseCbsrsv2_solve_rank_1(handle,dirA,transA,mb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsv2_solve_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo complex(c_float_complex),target,dimension(:) :: f complex(c_float_complex),target,dimension(:) :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsrsv2_solve_rank_1 = hipsparseCbsrsv2_solve_(handle,dirA,transA,mb,nnzb,alpha, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,c_loc(f),c_loc(x),policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZbsrsv2_solve_assumed_rank(handle,dirA,transA,mb,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsv2_solve_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo complex(c_double_complex),target,contiguous,dimension(..) :: f complex(c_double_complex),target,contiguous,dimension(..) :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsrsv2_solve_assumed_rank = hipsparseZbsrsv2_solve_(handle,dirA,transA,mb,nnzb, & alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,c_loc(f),c_loc(x),policy,pBuffer) end function #else function hipsparseZbsrsv2_solve_rank_0(handle,dirA,transA,mb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsv2_solve_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo complex(c_double_complex),target :: f complex(c_double_complex),target :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsrsv2_solve_rank_0 = hipsparseZbsrsv2_solve_(handle,dirA,transA,mb,nnzb,alpha, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,c_loc(f),c_loc(x),policy,pBuffer) end function function hipsparseZbsrsv2_solve_rank_1(handle,dirA,transA,mb,nnzb,alpha,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsv2_solve_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: mb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo complex(c_double_complex),target,dimension(:) :: f complex(c_double_complex),target,dimension(:) :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsrsv2_solve_rank_1 = hipsparseZbsrsv2_solve_(handle,dirA,transA,mb,nnzb,alpha, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,c_loc(f),c_loc(x),policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSbsrxmv_assumed_rank(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr, & bsrVal,bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrxmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: trans integer(c_int) :: sizeOfMask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: bsrVal integer(c_int),target,contiguous,dimension(..) :: bsrMaskPtr integer(c_int),target,contiguous,dimension(..) :: bsrRowPtr integer(c_int),target,contiguous,dimension(..) :: bsrEndPtr integer(c_int),target,contiguous,dimension(..) :: bsrColInd integer(c_int) :: blockDim real(c_float),target,contiguous,dimension(..) :: x real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y ! hipsparseSbsrxmv_assumed_rank = hipsparseSbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb, & alpha,descr,c_loc(bsrVal),c_loc(bsrMaskPtr),c_loc(bsrRowPtr),c_loc(bsrEndPtr), & c_loc(bsrColInd),blockDim,c_loc(x),beta,c_loc(y)) end function #else function hipsparseSbsrxmv_rank_0(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr,bsrVal, & bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrxmv_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: trans integer(c_int) :: sizeOfMask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target :: bsrVal integer(c_int),target :: bsrMaskPtr integer(c_int),target :: bsrRowPtr integer(c_int),target :: bsrEndPtr integer(c_int),target :: bsrColInd integer(c_int) :: blockDim real(c_float),target :: x real(c_float) :: beta real(c_float),target :: y ! hipsparseSbsrxmv_rank_0 = hipsparseSbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha, & descr,c_loc(bsrVal),c_loc(bsrMaskPtr),c_loc(bsrRowPtr),c_loc(bsrEndPtr),c_loc(bsrColInd), & blockDim,c_loc(x),beta,c_loc(y)) end function function hipsparseSbsrxmv_rank_1(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr,bsrVal, & bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrxmv_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: trans integer(c_int) :: sizeOfMask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsrVal integer(c_int),target,dimension(:) :: bsrMaskPtr integer(c_int),target,dimension(:) :: bsrRowPtr integer(c_int),target,dimension(:) :: bsrEndPtr integer(c_int),target,dimension(:) :: bsrColInd integer(c_int) :: blockDim real(c_float),target,dimension(:) :: x real(c_float) :: beta real(c_float),target,dimension(:) :: y ! hipsparseSbsrxmv_rank_1 = hipsparseSbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha, & descr,c_loc(bsrVal),c_loc(bsrMaskPtr),c_loc(bsrRowPtr),c_loc(bsrEndPtr),c_loc(bsrColInd), & blockDim,c_loc(x),beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDbsrxmv_assumed_rank(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr, & bsrVal,bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrxmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: trans integer(c_int) :: sizeOfMask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: bsrVal integer(c_int),target,contiguous,dimension(..) :: bsrMaskPtr integer(c_int),target,contiguous,dimension(..) :: bsrRowPtr integer(c_int),target,contiguous,dimension(..) :: bsrEndPtr integer(c_int),target,contiguous,dimension(..) :: bsrColInd integer(c_int) :: blockDim real(c_double),target,contiguous,dimension(..) :: x real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y ! hipsparseDbsrxmv_assumed_rank = hipsparseDbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb, & alpha,descr,c_loc(bsrVal),c_loc(bsrMaskPtr),c_loc(bsrRowPtr),c_loc(bsrEndPtr), & c_loc(bsrColInd),blockDim,c_loc(x),beta,c_loc(y)) end function #else function hipsparseDbsrxmv_rank_0(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr,bsrVal, & bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrxmv_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: trans integer(c_int) :: sizeOfMask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target :: bsrVal integer(c_int),target :: bsrMaskPtr integer(c_int),target :: bsrRowPtr integer(c_int),target :: bsrEndPtr integer(c_int),target :: bsrColInd integer(c_int) :: blockDim real(c_double),target :: x real(c_double) :: beta real(c_double),target :: y ! hipsparseDbsrxmv_rank_0 = hipsparseDbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha, & descr,c_loc(bsrVal),c_loc(bsrMaskPtr),c_loc(bsrRowPtr),c_loc(bsrEndPtr),c_loc(bsrColInd), & blockDim,c_loc(x),beta,c_loc(y)) end function function hipsparseDbsrxmv_rank_1(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr,bsrVal, & bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrxmv_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: trans integer(c_int) :: sizeOfMask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsrVal integer(c_int),target,dimension(:) :: bsrMaskPtr integer(c_int),target,dimension(:) :: bsrRowPtr integer(c_int),target,dimension(:) :: bsrEndPtr integer(c_int),target,dimension(:) :: bsrColInd integer(c_int) :: blockDim real(c_double),target,dimension(:) :: x real(c_double) :: beta real(c_double),target,dimension(:) :: y ! hipsparseDbsrxmv_rank_1 = hipsparseDbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha, & descr,c_loc(bsrVal),c_loc(bsrMaskPtr),c_loc(bsrRowPtr),c_loc(bsrEndPtr),c_loc(bsrColInd), & blockDim,c_loc(x),beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCbsrxmv_assumed_rank(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr, & bsrVal,bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrxmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: trans integer(c_int) :: sizeOfMask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: bsrVal integer(c_int),target,contiguous,dimension(..) :: bsrMaskPtr integer(c_int),target,contiguous,dimension(..) :: bsrRowPtr integer(c_int),target,contiguous,dimension(..) :: bsrEndPtr integer(c_int),target,contiguous,dimension(..) :: bsrColInd integer(c_int) :: blockDim complex(c_float_complex),target,contiguous,dimension(..) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y ! hipsparseCbsrxmv_assumed_rank = hipsparseCbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb, & alpha,descr,c_loc(bsrVal),c_loc(bsrMaskPtr),c_loc(bsrRowPtr),c_loc(bsrEndPtr), & c_loc(bsrColInd),blockDim,c_loc(x),beta,c_loc(y)) end function #else function hipsparseCbsrxmv_rank_0(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr,bsrVal, & bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrxmv_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: trans integer(c_int) :: sizeOfMask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target :: bsrVal integer(c_int),target :: bsrMaskPtr integer(c_int),target :: bsrRowPtr integer(c_int),target :: bsrEndPtr integer(c_int),target :: bsrColInd integer(c_int) :: blockDim complex(c_float_complex),target :: x complex(c_float_complex) :: beta complex(c_float_complex),target :: y ! hipsparseCbsrxmv_rank_0 = hipsparseCbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha, & descr,c_loc(bsrVal),c_loc(bsrMaskPtr),c_loc(bsrRowPtr),c_loc(bsrEndPtr),c_loc(bsrColInd), & blockDim,c_loc(x),beta,c_loc(y)) end function function hipsparseCbsrxmv_rank_1(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr,bsrVal, & bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrxmv_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: trans integer(c_int) :: sizeOfMask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsrVal integer(c_int),target,dimension(:) :: bsrMaskPtr integer(c_int),target,dimension(:) :: bsrRowPtr integer(c_int),target,dimension(:) :: bsrEndPtr integer(c_int),target,dimension(:) :: bsrColInd integer(c_int) :: blockDim complex(c_float_complex),target,dimension(:) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y ! hipsparseCbsrxmv_rank_1 = hipsparseCbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha, & descr,c_loc(bsrVal),c_loc(bsrMaskPtr),c_loc(bsrRowPtr),c_loc(bsrEndPtr),c_loc(bsrColInd), & blockDim,c_loc(x),beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZbsrxmv_assumed_rank(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr, & bsrVal,bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrxmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: trans integer(c_int) :: sizeOfMask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: bsrVal integer(c_int),target,contiguous,dimension(..) :: bsrMaskPtr integer(c_int),target,contiguous,dimension(..) :: bsrRowPtr integer(c_int),target,contiguous,dimension(..) :: bsrEndPtr integer(c_int),target,contiguous,dimension(..) :: bsrColInd integer(c_int) :: blockDim complex(c_double_complex),target,contiguous,dimension(..) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y ! hipsparseZbsrxmv_assumed_rank = hipsparseZbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb, & alpha,descr,c_loc(bsrVal),c_loc(bsrMaskPtr),c_loc(bsrRowPtr),c_loc(bsrEndPtr), & c_loc(bsrColInd),blockDim,c_loc(x),beta,c_loc(y)) end function #else function hipsparseZbsrxmv_rank_0(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr,bsrVal, & bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrxmv_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: trans integer(c_int) :: sizeOfMask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target :: bsrVal integer(c_int),target :: bsrMaskPtr integer(c_int),target :: bsrRowPtr integer(c_int),target :: bsrEndPtr integer(c_int),target :: bsrColInd integer(c_int) :: blockDim complex(c_double_complex),target :: x complex(c_double_complex) :: beta complex(c_double_complex),target :: y ! hipsparseZbsrxmv_rank_0 = hipsparseZbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha, & descr,c_loc(bsrVal),c_loc(bsrMaskPtr),c_loc(bsrRowPtr),c_loc(bsrEndPtr),c_loc(bsrColInd), & blockDim,c_loc(x),beta,c_loc(y)) end function function hipsparseZbsrxmv_rank_1(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha,descr,bsrVal, & bsrMaskPtr,bsrRowPtr,bsrEndPtr,bsrColInd,blockDim,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrxmv_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: trans integer(c_int) :: sizeOfMask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsrVal integer(c_int),target,dimension(:) :: bsrMaskPtr integer(c_int),target,dimension(:) :: bsrRowPtr integer(c_int),target,dimension(:) :: bsrEndPtr integer(c_int),target,dimension(:) :: bsrColInd integer(c_int) :: blockDim complex(c_double_complex),target,dimension(:) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y ! hipsparseZbsrxmv_rank_1 = hipsparseZbsrxmv_(handle,dir,trans,sizeOfMask,mb,nb,nnzb,alpha, & descr,c_loc(bsrVal),c_loc(bsrMaskPtr),c_loc(bsrRowPtr),c_loc(bsrEndPtr),c_loc(bsrColInd), & blockDim,c_loc(x),beta,c_loc(y)) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrmv_assumed_rank(handle,transA,m,n,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA real(c_float),target,contiguous,dimension(..) :: x real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y ! hipsparseScsrmv_assumed_rank = hipsparseScsrmv_(handle,transA,m,n,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(x),beta,c_loc(y)) end function #else function hipsparseScsrmv_rank_0(handle,transA,m,n,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrmv_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA real(c_float),target :: x real(c_float) :: beta real(c_float),target :: y ! hipsparseScsrmv_rank_0 = hipsparseScsrmv_(handle,transA,m,n,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(x),beta,c_loc(y)) end function function hipsparseScsrmv_rank_1(handle,transA,m,n,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrmv_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_float),target,dimension(:) :: x real(c_float) :: beta real(c_float),target,dimension(:) :: y ! hipsparseScsrmv_rank_1 = hipsparseScsrmv_(handle,transA,m,n,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(x),beta,c_loc(y)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrmv_assumed_rank(handle,transA,m,n,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA real(c_double),target,contiguous,dimension(..) :: x real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y ! hipsparseDcsrmv_assumed_rank = hipsparseDcsrmv_(handle,transA,m,n,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(x),beta,c_loc(y)) end function #else function hipsparseDcsrmv_rank_0(handle,transA,m,n,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrmv_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA real(c_double),target :: x real(c_double) :: beta real(c_double),target :: y ! hipsparseDcsrmv_rank_0 = hipsparseDcsrmv_(handle,transA,m,n,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(x),beta,c_loc(y)) end function function hipsparseDcsrmv_rank_1(handle,transA,m,n,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrmv_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_double),target,dimension(:) :: x real(c_double) :: beta real(c_double),target,dimension(:) :: y ! hipsparseDcsrmv_rank_1 = hipsparseDcsrmv_(handle,transA,m,n,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(x),beta,c_loc(y)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrmv_assumed_rank(handle,transA,m,n,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA complex(c_float_complex),target,contiguous,dimension(..) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y ! hipsparseCcsrmv_assumed_rank = hipsparseCcsrmv_(handle,transA,m,n,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(x),beta,c_loc(y)) end function #else function hipsparseCcsrmv_rank_0(handle,transA,m,n,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrmv_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA complex(c_float_complex),target :: x complex(c_float_complex) :: beta complex(c_float_complex),target :: y ! hipsparseCcsrmv_rank_0 = hipsparseCcsrmv_(handle,transA,m,n,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(x),beta,c_loc(y)) end function function hipsparseCcsrmv_rank_1(handle,transA,m,n,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrmv_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_float_complex),target,dimension(:) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y ! hipsparseCcsrmv_rank_1 = hipsparseCcsrmv_(handle,transA,m,n,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(x),beta,c_loc(y)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrmv_assumed_rank(handle,transA,m,n,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA complex(c_double_complex),target,contiguous,dimension(..) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y ! hipsparseZcsrmv_assumed_rank = hipsparseZcsrmv_(handle,transA,m,n,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(x),beta,c_loc(y)) end function #else function hipsparseZcsrmv_rank_0(handle,transA,m,n,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrmv_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA complex(c_double_complex),target :: x complex(c_double_complex) :: beta complex(c_double_complex),target :: y ! hipsparseZcsrmv_rank_0 = hipsparseZcsrmv_(handle,transA,m,n,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(x),beta,c_loc(y)) end function function hipsparseZcsrmv_rank_1(handle,transA,m,n,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrmv_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_double_complex),target,dimension(:) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y ! hipsparseZcsrmv_rank_1 = hipsparseZcsrmv_(handle,transA,m,n,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(x),beta,c_loc(y)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrsv2_bufferSize_assumed_rank(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsv2_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseScsrsv2_bufferSize_assumed_rank = hipsparseScsrsv2_bufferSize_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseScsrsv2_bufferSize_rank_0(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsv2_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseScsrsv2_bufferSize_rank_0 = hipsparseScsrsv2_bufferSize_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseScsrsv2_bufferSize_rank_1(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsv2_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseScsrsv2_bufferSize_rank_1 = hipsparseScsrsv2_bufferSize_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrsv2_bufferSize_assumed_rank(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsv2_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDcsrsv2_bufferSize_assumed_rank = hipsparseDcsrsv2_bufferSize_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseDcsrsv2_bufferSize_rank_0(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsv2_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDcsrsv2_bufferSize_rank_0 = hipsparseDcsrsv2_bufferSize_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseDcsrsv2_bufferSize_rank_1(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsv2_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDcsrsv2_bufferSize_rank_1 = hipsparseDcsrsv2_bufferSize_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrsv2_bufferSize_assumed_rank(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsv2_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCcsrsv2_bufferSize_assumed_rank = hipsparseCcsrsv2_bufferSize_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseCcsrsv2_bufferSize_rank_0(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsv2_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCcsrsv2_bufferSize_rank_0 = hipsparseCcsrsv2_bufferSize_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseCcsrsv2_bufferSize_rank_1(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsv2_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCcsrsv2_bufferSize_rank_1 = hipsparseCcsrsv2_bufferSize_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrsv2_bufferSize_assumed_rank(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsv2_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZcsrsv2_bufferSize_assumed_rank = hipsparseZcsrsv2_bufferSize_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseZcsrsv2_bufferSize_rank_0(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsv2_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZcsrsv2_bufferSize_rank_0 = hipsparseZcsrsv2_bufferSize_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseZcsrsv2_bufferSize_rank_1(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsv2_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZcsrsv2_bufferSize_rank_1 = hipsparseZcsrsv2_bufferSize_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrsv2_bufferSizeExt_assumed_rank(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsv2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsrsv2_bufferSizeExt_assumed_rank = hipsparseScsrsv2_bufferSizeExt_(handle,transA, & m,nnz,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseScsrsv2_bufferSizeExt_rank_0(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsv2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsrsv2_bufferSizeExt_rank_0 = hipsparseScsrsv2_bufferSizeExt_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseScsrsv2_bufferSizeExt_rank_1(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsv2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsrsv2_bufferSizeExt_rank_1 = hipsparseScsrsv2_bufferSizeExt_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrsv2_bufferSizeExt_assumed_rank(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsv2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsrsv2_bufferSizeExt_assumed_rank = hipsparseDcsrsv2_bufferSizeExt_(handle,transA, & m,nnz,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseDcsrsv2_bufferSizeExt_rank_0(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsv2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsrsv2_bufferSizeExt_rank_0 = hipsparseDcsrsv2_bufferSizeExt_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseDcsrsv2_bufferSizeExt_rank_1(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsv2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsrsv2_bufferSizeExt_rank_1 = hipsparseDcsrsv2_bufferSizeExt_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrsv2_bufferSizeExt_assumed_rank(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsv2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsrsv2_bufferSizeExt_assumed_rank = hipsparseCcsrsv2_bufferSizeExt_(handle,transA, & m,nnz,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseCcsrsv2_bufferSizeExt_rank_0(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsv2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsrsv2_bufferSizeExt_rank_0 = hipsparseCcsrsv2_bufferSizeExt_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseCcsrsv2_bufferSizeExt_rank_1(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsv2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsrsv2_bufferSizeExt_rank_1 = hipsparseCcsrsv2_bufferSizeExt_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrsv2_bufferSizeExt_assumed_rank(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsv2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsrsv2_bufferSizeExt_assumed_rank = hipsparseZcsrsv2_bufferSizeExt_(handle,transA, & m,nnz,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseZcsrsv2_bufferSizeExt_rank_0(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsv2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsrsv2_bufferSizeExt_rank_0 = hipsparseZcsrsv2_bufferSizeExt_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseZcsrsv2_bufferSizeExt_rank_1(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsv2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsrsv2_bufferSizeExt_rank_1 = hipsparseZcsrsv2_bufferSizeExt_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrsv2_analysis_assumed_rank(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsv2_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrsv2_analysis_assumed_rank = hipsparseScsrsv2_analysis_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function #else function hipsparseScsrsv2_analysis_rank_0(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsv2_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrsv2_analysis_rank_0 = hipsparseScsrsv2_analysis_(handle,transA,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function function hipsparseScsrsv2_analysis_rank_1(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsv2_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrsv2_analysis_rank_1 = hipsparseScsrsv2_analysis_(handle,transA,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrsv2_analysis_assumed_rank(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsv2_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrsv2_analysis_assumed_rank = hipsparseDcsrsv2_analysis_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function #else function hipsparseDcsrsv2_analysis_rank_0(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsv2_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrsv2_analysis_rank_0 = hipsparseDcsrsv2_analysis_(handle,transA,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function function hipsparseDcsrsv2_analysis_rank_1(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsv2_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrsv2_analysis_rank_1 = hipsparseDcsrsv2_analysis_(handle,transA,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrsv2_analysis_assumed_rank(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsv2_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrsv2_analysis_assumed_rank = hipsparseCcsrsv2_analysis_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function #else function hipsparseCcsrsv2_analysis_rank_0(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsv2_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrsv2_analysis_rank_0 = hipsparseCcsrsv2_analysis_(handle,transA,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function function hipsparseCcsrsv2_analysis_rank_1(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsv2_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrsv2_analysis_rank_1 = hipsparseCcsrsv2_analysis_(handle,transA,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrsv2_analysis_assumed_rank(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsv2_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrsv2_analysis_assumed_rank = hipsparseZcsrsv2_analysis_(handle,transA,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function #else function hipsparseZcsrsv2_analysis_rank_0(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsv2_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrsv2_analysis_rank_0 = hipsparseZcsrsv2_analysis_(handle,transA,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function function hipsparseZcsrsv2_analysis_rank_1(handle,transA,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsv2_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrsv2_analysis_rank_1 = hipsparseZcsrsv2_analysis_(handle,transA,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrsv2_solve_assumed_rank(handle,transA,m,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsv2_solve_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo real(c_float),target,contiguous,dimension(..) :: f real(c_float),target,contiguous,dimension(..) :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrsv2_solve_assumed_rank = hipsparseScsrsv2_solve_(handle,transA,m,nnz,alpha, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & c_loc(f),c_loc(x),policy,pBuffer) end function #else function hipsparseScsrsv2_solve_rank_0(handle,transA,m,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsv2_solve_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo real(c_float),target :: f real(c_float),target :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrsv2_solve_rank_0 = hipsparseScsrsv2_solve_(handle,transA,m,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,c_loc(f), & c_loc(x),policy,pBuffer) end function function hipsparseScsrsv2_solve_rank_1(handle,transA,m,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsv2_solve_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo real(c_float),target,dimension(:) :: f real(c_float),target,dimension(:) :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrsv2_solve_rank_1 = hipsparseScsrsv2_solve_(handle,transA,m,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,c_loc(f), & c_loc(x),policy,pBuffer) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrsv2_solve_assumed_rank(handle,transA,m,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsv2_solve_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo real(c_double),target,contiguous,dimension(..) :: f real(c_double),target,contiguous,dimension(..) :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrsv2_solve_assumed_rank = hipsparseDcsrsv2_solve_(handle,transA,m,nnz,alpha, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & c_loc(f),c_loc(x),policy,pBuffer) end function #else function hipsparseDcsrsv2_solve_rank_0(handle,transA,m,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsv2_solve_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo real(c_double),target :: f real(c_double),target :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrsv2_solve_rank_0 = hipsparseDcsrsv2_solve_(handle,transA,m,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,c_loc(f), & c_loc(x),policy,pBuffer) end function function hipsparseDcsrsv2_solve_rank_1(handle,transA,m,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsv2_solve_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo real(c_double),target,dimension(:) :: f real(c_double),target,dimension(:) :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrsv2_solve_rank_1 = hipsparseDcsrsv2_solve_(handle,transA,m,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,c_loc(f), & c_loc(x),policy,pBuffer) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrsv2_solve_assumed_rank(handle,transA,m,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsv2_solve_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo complex(c_float_complex),target,contiguous,dimension(..) :: f complex(c_float_complex),target,contiguous,dimension(..) :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrsv2_solve_assumed_rank = hipsparseCcsrsv2_solve_(handle,transA,m,nnz,alpha, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & c_loc(f),c_loc(x),policy,pBuffer) end function #else function hipsparseCcsrsv2_solve_rank_0(handle,transA,m,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsv2_solve_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo complex(c_float_complex),target :: f complex(c_float_complex),target :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrsv2_solve_rank_0 = hipsparseCcsrsv2_solve_(handle,transA,m,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,c_loc(f), & c_loc(x),policy,pBuffer) end function function hipsparseCcsrsv2_solve_rank_1(handle,transA,m,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsv2_solve_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo complex(c_float_complex),target,dimension(:) :: f complex(c_float_complex),target,dimension(:) :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrsv2_solve_rank_1 = hipsparseCcsrsv2_solve_(handle,transA,m,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,c_loc(f), & c_loc(x),policy,pBuffer) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrsv2_solve_assumed_rank(handle,transA,m,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsv2_solve_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo complex(c_double_complex),target,contiguous,dimension(..) :: f complex(c_double_complex),target,contiguous,dimension(..) :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrsv2_solve_assumed_rank = hipsparseZcsrsv2_solve_(handle,transA,m,nnz,alpha, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & c_loc(f),c_loc(x),policy,pBuffer) end function #else function hipsparseZcsrsv2_solve_rank_0(handle,transA,m,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsv2_solve_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo complex(c_double_complex),target :: f complex(c_double_complex),target :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrsv2_solve_rank_0 = hipsparseZcsrsv2_solve_(handle,transA,m,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,c_loc(f), & c_loc(x),policy,pBuffer) end function function hipsparseZcsrsv2_solve_rank_1(handle,transA,m,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,f,x,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsv2_solve_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo complex(c_double_complex),target,dimension(:) :: f complex(c_double_complex),target,dimension(:) :: x integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrsv2_solve_rank_1 = hipsparseZcsrsv2_solve_(handle,transA,m,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,c_loc(f), & c_loc(x),policy,pBuffer) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSgemvi_assumed_rank(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgemvi_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: nnz real(c_float),target,contiguous,dimension(..) :: x integer(c_int),target,contiguous,dimension(..) :: xInd real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase type(c_ptr) :: pBuffer ! hipsparseSgemvi_assumed_rank = hipsparseSgemvi_(handle,transA,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x),c_loc(xInd),beta,c_loc(y),idxBase,pBuffer) end function #else function hipsparseSgemvi_rank_0(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgemvi_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda integer(c_int) :: nnz real(c_float),target :: x integer(c_int),target :: xInd real(c_float) :: beta real(c_float),target :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase type(c_ptr) :: pBuffer ! hipsparseSgemvi_rank_0 = hipsparseSgemvi_(handle,transA,m,n,alpha,c_loc(A),lda,nnz,c_loc(x), & c_loc(xInd),beta,c_loc(y),idxBase,pBuffer) end function function hipsparseSgemvi_rank_1(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgemvi_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: nnz real(c_float),target,dimension(:) :: x integer(c_int),target,dimension(:) :: xInd real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase type(c_ptr) :: pBuffer ! hipsparseSgemvi_rank_1 = hipsparseSgemvi_(handle,transA,m,n,alpha,c_loc(A),lda,nnz,c_loc(x), & c_loc(xInd),beta,c_loc(y),idxBase,pBuffer) end function function hipsparseSgemvi_full_rank(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgemvi_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: nnz real(c_float),target,dimension(:) :: x integer(c_int),target,dimension(:) :: xInd real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase type(c_ptr) :: pBuffer ! hipsparseSgemvi_full_rank = hipsparseSgemvi_(handle,transA,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x),c_loc(xInd),beta,c_loc(y),idxBase,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDgemvi_assumed_rank(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgemvi_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: nnz real(c_double),target,contiguous,dimension(..) :: x integer(c_int),target,contiguous,dimension(..) :: xInd real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase type(c_ptr) :: pBuffer ! hipsparseDgemvi_assumed_rank = hipsparseDgemvi_(handle,transA,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x),c_loc(xInd),beta,c_loc(y),idxBase,pBuffer) end function #else function hipsparseDgemvi_rank_0(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgemvi_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda integer(c_int) :: nnz real(c_double),target :: x integer(c_int),target :: xInd real(c_double) :: beta real(c_double),target :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase type(c_ptr) :: pBuffer ! hipsparseDgemvi_rank_0 = hipsparseDgemvi_(handle,transA,m,n,alpha,c_loc(A),lda,nnz,c_loc(x), & c_loc(xInd),beta,c_loc(y),idxBase,pBuffer) end function function hipsparseDgemvi_rank_1(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgemvi_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: nnz real(c_double),target,dimension(:) :: x integer(c_int),target,dimension(:) :: xInd real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase type(c_ptr) :: pBuffer ! hipsparseDgemvi_rank_1 = hipsparseDgemvi_(handle,transA,m,n,alpha,c_loc(A),lda,nnz,c_loc(x), & c_loc(xInd),beta,c_loc(y),idxBase,pBuffer) end function function hipsparseDgemvi_full_rank(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgemvi_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: nnz real(c_double),target,dimension(:) :: x integer(c_int),target,dimension(:) :: xInd real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase type(c_ptr) :: pBuffer ! hipsparseDgemvi_full_rank = hipsparseDgemvi_(handle,transA,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x),c_loc(xInd),beta,c_loc(y),idxBase,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCgemvi_assumed_rank(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgemvi_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: nnz complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int),target,contiguous,dimension(..) :: xInd complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase type(c_ptr) :: pBuffer ! hipsparseCgemvi_assumed_rank = hipsparseCgemvi_(handle,transA,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x),c_loc(xInd),beta,c_loc(y),idxBase,pBuffer) end function #else function hipsparseCgemvi_rank_0(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgemvi_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int) :: nnz complex(c_float_complex),target :: x integer(c_int),target :: xInd complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase type(c_ptr) :: pBuffer ! hipsparseCgemvi_rank_0 = hipsparseCgemvi_(handle,transA,m,n,alpha,c_loc(A),lda,nnz,c_loc(x), & c_loc(xInd),beta,c_loc(y),idxBase,pBuffer) end function function hipsparseCgemvi_rank_1(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgemvi_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: nnz complex(c_float_complex),target,dimension(:) :: x integer(c_int),target,dimension(:) :: xInd complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase type(c_ptr) :: pBuffer ! hipsparseCgemvi_rank_1 = hipsparseCgemvi_(handle,transA,m,n,alpha,c_loc(A),lda,nnz,c_loc(x), & c_loc(xInd),beta,c_loc(y),idxBase,pBuffer) end function function hipsparseCgemvi_full_rank(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgemvi_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: nnz complex(c_float_complex),target,dimension(:) :: x integer(c_int),target,dimension(:) :: xInd complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase type(c_ptr) :: pBuffer ! hipsparseCgemvi_full_rank = hipsparseCgemvi_(handle,transA,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x),c_loc(xInd),beta,c_loc(y),idxBase,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZgemvi_assumed_rank(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgemvi_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: nnz complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int),target,contiguous,dimension(..) :: xInd complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase type(c_ptr) :: pBuffer ! hipsparseZgemvi_assumed_rank = hipsparseZgemvi_(handle,transA,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x),c_loc(xInd),beta,c_loc(y),idxBase,pBuffer) end function #else function hipsparseZgemvi_rank_0(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgemvi_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int) :: nnz complex(c_double_complex),target :: x integer(c_int),target :: xInd complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase type(c_ptr) :: pBuffer ! hipsparseZgemvi_rank_0 = hipsparseZgemvi_(handle,transA,m,n,alpha,c_loc(A),lda,nnz,c_loc(x), & c_loc(xInd),beta,c_loc(y),idxBase,pBuffer) end function function hipsparseZgemvi_rank_1(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgemvi_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: nnz complex(c_double_complex),target,dimension(:) :: x integer(c_int),target,dimension(:) :: xInd complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase type(c_ptr) :: pBuffer ! hipsparseZgemvi_rank_1 = hipsparseZgemvi_(handle,transA,m,n,alpha,c_loc(A),lda,nnz,c_loc(x), & c_loc(xInd),beta,c_loc(y),idxBase,pBuffer) end function function hipsparseZgemvi_full_rank(handle,transA,m,n,alpha,A,lda,nnz,x,xInd,beta,y,idxBase, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgemvi_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: nnz complex(c_double_complex),target,dimension(:) :: x integer(c_int),target,dimension(:) :: xInd complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase type(c_ptr) :: pBuffer ! hipsparseZgemvi_full_rank = hipsparseZgemvi_(handle,transA,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x),c_loc(xInd),beta,c_loc(y),idxBase,pBuffer) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseShybmv_assumed_rank(handle,transA,alpha,descrA,hybA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseShybmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA real(c_float) :: alpha type(c_ptr) :: descrA type(c_ptr) :: hybA real(c_float),target,contiguous,dimension(..) :: x real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y ! hipsparseShybmv_assumed_rank = hipsparseShybmv_(handle,transA,alpha,descrA,hybA,c_loc(x), & beta,c_loc(y)) end function #else function hipsparseShybmv_rank_0(handle,transA,alpha,descrA,hybA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseShybmv_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA real(c_float) :: alpha type(c_ptr) :: descrA type(c_ptr) :: hybA real(c_float),target :: x real(c_float) :: beta real(c_float),target :: y ! hipsparseShybmv_rank_0 = hipsparseShybmv_(handle,transA,alpha,descrA,hybA,c_loc(x),beta, & c_loc(y)) end function function hipsparseShybmv_rank_1(handle,transA,alpha,descrA,hybA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseShybmv_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA real(c_float) :: alpha type(c_ptr) :: descrA type(c_ptr) :: hybA real(c_float),target,dimension(:) :: x real(c_float) :: beta real(c_float),target,dimension(:) :: y ! hipsparseShybmv_rank_1 = hipsparseShybmv_(handle,transA,alpha,descrA,hybA,c_loc(x),beta, & c_loc(y)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDhybmv_assumed_rank(handle,transA,alpha,descrA,hybA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDhybmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA real(c_double) :: alpha type(c_ptr) :: descrA type(c_ptr) :: hybA real(c_double),target,contiguous,dimension(..) :: x real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y ! hipsparseDhybmv_assumed_rank = hipsparseDhybmv_(handle,transA,alpha,descrA,hybA,c_loc(x), & beta,c_loc(y)) end function #else function hipsparseDhybmv_rank_0(handle,transA,alpha,descrA,hybA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDhybmv_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA real(c_double) :: alpha type(c_ptr) :: descrA type(c_ptr) :: hybA real(c_double),target :: x real(c_double) :: beta real(c_double),target :: y ! hipsparseDhybmv_rank_0 = hipsparseDhybmv_(handle,transA,alpha,descrA,hybA,c_loc(x),beta, & c_loc(y)) end function function hipsparseDhybmv_rank_1(handle,transA,alpha,descrA,hybA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDhybmv_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA real(c_double) :: alpha type(c_ptr) :: descrA type(c_ptr) :: hybA real(c_double),target,dimension(:) :: x real(c_double) :: beta real(c_double),target,dimension(:) :: y ! hipsparseDhybmv_rank_1 = hipsparseDhybmv_(handle,transA,alpha,descrA,hybA,c_loc(x),beta, & c_loc(y)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseChybmv_assumed_rank(handle,transA,alpha,descrA,hybA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseChybmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA complex(c_float_complex) :: alpha type(c_ptr) :: descrA type(c_ptr) :: hybA complex(c_float_complex),target,contiguous,dimension(..) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y ! hipsparseChybmv_assumed_rank = hipsparseChybmv_(handle,transA,alpha,descrA,hybA,c_loc(x), & beta,c_loc(y)) end function #else function hipsparseChybmv_rank_0(handle,transA,alpha,descrA,hybA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseChybmv_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA complex(c_float_complex) :: alpha type(c_ptr) :: descrA type(c_ptr) :: hybA complex(c_float_complex),target :: x complex(c_float_complex) :: beta complex(c_float_complex),target :: y ! hipsparseChybmv_rank_0 = hipsparseChybmv_(handle,transA,alpha,descrA,hybA,c_loc(x),beta, & c_loc(y)) end function function hipsparseChybmv_rank_1(handle,transA,alpha,descrA,hybA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseChybmv_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA complex(c_float_complex) :: alpha type(c_ptr) :: descrA type(c_ptr) :: hybA complex(c_float_complex),target,dimension(:) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y ! hipsparseChybmv_rank_1 = hipsparseChybmv_(handle,transA,alpha,descrA,hybA,c_loc(x),beta, & c_loc(y)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZhybmv_assumed_rank(handle,transA,alpha,descrA,hybA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZhybmv_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA complex(c_double_complex) :: alpha type(c_ptr) :: descrA type(c_ptr) :: hybA complex(c_double_complex),target,contiguous,dimension(..) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y ! hipsparseZhybmv_assumed_rank = hipsparseZhybmv_(handle,transA,alpha,descrA,hybA,c_loc(x), & beta,c_loc(y)) end function #else function hipsparseZhybmv_rank_0(handle,transA,alpha,descrA,hybA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZhybmv_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA complex(c_double_complex) :: alpha type(c_ptr) :: descrA type(c_ptr) :: hybA complex(c_double_complex),target :: x complex(c_double_complex) :: beta complex(c_double_complex),target :: y ! hipsparseZhybmv_rank_0 = hipsparseZhybmv_(handle,transA,alpha,descrA,hybA,c_loc(x),beta, & c_loc(y)) end function function hipsparseZhybmv_rank_1(handle,transA,alpha,descrA,hybA,x,beta,y) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZhybmv_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA complex(c_double_complex) :: alpha type(c_ptr) :: descrA type(c_ptr) :: hybA complex(c_double_complex),target,dimension(:) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y ! hipsparseZhybmv_rank_1 = hipsparseZhybmv_(handle,transA,alpha,descrA,hybA,c_loc(x),beta, & c_loc(y)) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSbsrmm_assumed_rank(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA, & bsrValA,bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrmm_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipsparseSbsrmm_assumed_rank = hipsparseSbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb, & alpha,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,c_loc(B),ldb, & beta,c_loc(C),ldc) end function #else function hipsparseSbsrmm_rank_0(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrmm_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim real(c_float),target :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target :: C integer(c_int) :: ldc ! hipsparseSbsrmm_rank_0 = hipsparseSbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseSbsrmm_rank_1(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrmm_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! hipsparseSbsrmm_rank_1 = hipsparseSbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseSbsrmm_full_rank(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA, & bsrValA,bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrmm_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipsparseSbsrmm_full_rank = hipsparseSbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDbsrmm_assumed_rank(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA, & bsrValA,bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrmm_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipsparseDbsrmm_assumed_rank = hipsparseDbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb, & alpha,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,c_loc(B),ldb, & beta,c_loc(C),ldc) end function #else function hipsparseDbsrmm_rank_0(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrmm_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim real(c_double),target :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target :: C integer(c_int) :: ldc ! hipsparseDbsrmm_rank_0 = hipsparseDbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseDbsrmm_rank_1(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrmm_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! hipsparseDbsrmm_rank_1 = hipsparseDbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseDbsrmm_full_rank(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA, & bsrValA,bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrmm_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipsparseDbsrmm_full_rank = hipsparseDbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCbsrmm_assumed_rank(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA, & bsrValA,bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrmm_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipsparseCbsrmm_assumed_rank = hipsparseCbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb, & alpha,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,c_loc(B),ldb, & beta,c_loc(C),ldc) end function #else function hipsparseCbsrmm_rank_0(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrmm_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim complex(c_float_complex),target :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc ! hipsparseCbsrmm_rank_0 = hipsparseCbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseCbsrmm_rank_1(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrmm_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! hipsparseCbsrmm_rank_1 = hipsparseCbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseCbsrmm_full_rank(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA, & bsrValA,bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrmm_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipsparseCbsrmm_full_rank = hipsparseCbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZbsrmm_assumed_rank(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA, & bsrValA,bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrmm_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipsparseZbsrmm_assumed_rank = hipsparseZbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb, & alpha,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,c_loc(B),ldb, & beta,c_loc(C),ldc) end function #else function hipsparseZbsrmm_rank_0(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrmm_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim complex(c_double_complex),target :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc ! hipsparseZbsrmm_rank_0 = hipsparseZbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseZbsrmm_rank_1(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrmm_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! hipsparseZbsrmm_rank_1 = hipsparseZbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseZbsrmm_full_rank(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha,descrA, & bsrValA,bsrRowPtrA,bsrColIndA,blockDim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrmm_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipsparseZbsrmm_full_rank = hipsparseZbsrmm_(handle,dirA,transA,transB,mb,n,kb,nnzb,alpha, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSbsrsm2_bufferSize_assumed_rank(handle,dirA,transA,transX,mb,nrhs,nnzb, & descrA,bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsm2_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseSbsrsm2_bufferSize_assumed_rank = hipsparseSbsrsm2_bufferSize_(handle,dirA,transA, & transX,mb,nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,pBufferSizeInBytes) end function #else function hipsparseSbsrsm2_bufferSize_rank_0(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsm2_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseSbsrsm2_bufferSize_rank_0 = hipsparseSbsrsm2_bufferSize_(handle,dirA,transA,transX, & mb,nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function function hipsparseSbsrsm2_bufferSize_rank_1(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsm2_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseSbsrsm2_bufferSize_rank_1 = hipsparseSbsrsm2_bufferSize_(handle,dirA,transA,transX, & mb,nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDbsrsm2_bufferSize_assumed_rank(handle,dirA,transA,transX,mb,nrhs,nnzb, & descrA,bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsm2_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDbsrsm2_bufferSize_assumed_rank = hipsparseDbsrsm2_bufferSize_(handle,dirA,transA, & transX,mb,nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,pBufferSizeInBytes) end function #else function hipsparseDbsrsm2_bufferSize_rank_0(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsm2_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDbsrsm2_bufferSize_rank_0 = hipsparseDbsrsm2_bufferSize_(handle,dirA,transA,transX, & mb,nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function function hipsparseDbsrsm2_bufferSize_rank_1(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsm2_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDbsrsm2_bufferSize_rank_1 = hipsparseDbsrsm2_bufferSize_(handle,dirA,transA,transX, & mb,nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCbsrsm2_bufferSize_assumed_rank(handle,dirA,transA,transX,mb,nrhs,nnzb, & descrA,bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsm2_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCbsrsm2_bufferSize_assumed_rank = hipsparseCbsrsm2_bufferSize_(handle,dirA,transA, & transX,mb,nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,pBufferSizeInBytes) end function #else function hipsparseCbsrsm2_bufferSize_rank_0(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsm2_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCbsrsm2_bufferSize_rank_0 = hipsparseCbsrsm2_bufferSize_(handle,dirA,transA,transX, & mb,nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function function hipsparseCbsrsm2_bufferSize_rank_1(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsm2_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCbsrsm2_bufferSize_rank_1 = hipsparseCbsrsm2_bufferSize_(handle,dirA,transA,transX, & mb,nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZbsrsm2_bufferSize_assumed_rank(handle,dirA,transA,transX,mb,nrhs,nnzb, & descrA,bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsm2_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZbsrsm2_bufferSize_assumed_rank = hipsparseZbsrsm2_bufferSize_(handle,dirA,transA, & transX,mb,nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,pBufferSizeInBytes) end function #else function hipsparseZbsrsm2_bufferSize_rank_0(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsm2_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZbsrsm2_bufferSize_rank_0 = hipsparseZbsrsm2_bufferSize_(handle,dirA,transA,transX, & mb,nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function function hipsparseZbsrsm2_bufferSize_rank_1(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsm2_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZbsrsm2_bufferSize_rank_1 = hipsparseZbsrsm2_bufferSize_(handle,dirA,transA,transX, & mb,nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSbsrsm2_analysis_assumed_rank(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsm2_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsrsm2_analysis_assumed_rank = hipsparseSbsrsm2_analysis_(handle,dirA,transA, & transX,mb,nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,policy,pBuffer) end function #else function hipsparseSbsrsm2_analysis_rank_0(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsm2_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsrsm2_analysis_rank_0 = hipsparseSbsrsm2_analysis_(handle,dirA,transA,transX,mb, & nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,policy,pBuffer) end function function hipsparseSbsrsm2_analysis_rank_1(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsm2_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsrsm2_analysis_rank_1 = hipsparseSbsrsm2_analysis_(handle,dirA,transA,transX,mb, & nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDbsrsm2_analysis_assumed_rank(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsm2_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsrsm2_analysis_assumed_rank = hipsparseDbsrsm2_analysis_(handle,dirA,transA, & transX,mb,nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,policy,pBuffer) end function #else function hipsparseDbsrsm2_analysis_rank_0(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsm2_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsrsm2_analysis_rank_0 = hipsparseDbsrsm2_analysis_(handle,dirA,transA,transX,mb, & nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,policy,pBuffer) end function function hipsparseDbsrsm2_analysis_rank_1(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsm2_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsrsm2_analysis_rank_1 = hipsparseDbsrsm2_analysis_(handle,dirA,transA,transX,mb, & nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCbsrsm2_analysis_assumed_rank(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsm2_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsrsm2_analysis_assumed_rank = hipsparseCbsrsm2_analysis_(handle,dirA,transA, & transX,mb,nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,policy,pBuffer) end function #else function hipsparseCbsrsm2_analysis_rank_0(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsm2_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsrsm2_analysis_rank_0 = hipsparseCbsrsm2_analysis_(handle,dirA,transA,transX,mb, & nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,policy,pBuffer) end function function hipsparseCbsrsm2_analysis_rank_1(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsm2_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsrsm2_analysis_rank_1 = hipsparseCbsrsm2_analysis_(handle,dirA,transA,transX,mb, & nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZbsrsm2_analysis_assumed_rank(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsm2_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsrsm2_analysis_assumed_rank = hipsparseZbsrsm2_analysis_(handle,dirA,transA, & transX,mb,nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,policy,pBuffer) end function #else function hipsparseZbsrsm2_analysis_rank_0(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsm2_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsrsm2_analysis_rank_0 = hipsparseZbsrsm2_analysis_(handle,dirA,transA,transX,mb, & nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,policy,pBuffer) end function function hipsparseZbsrsm2_analysis_rank_1(handle,dirA,transA,transX,mb,nrhs,nnzb,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsm2_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsrsm2_analysis_rank_1 = hipsparseZbsrsm2_analysis_(handle,dirA,transA,transX,mb, & nrhs,nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSbsrsm2_solve_assumed_rank(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha, & descrA,bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsm2_solve_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: X integer(c_int) :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsrsm2_solve_assumed_rank = hipsparseSbsrsm2_solve_(handle,dirA,transA,transX,mb, & nrhs,nnzb,alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,pBuffer) end function #else function hipsparseSbsrsm2_solve_rank_0(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsm2_solve_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo real(c_float),target :: B integer(c_int) :: ldb real(c_float),target :: X integer(c_int) :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsrsm2_solve_rank_0 = hipsparseSbsrsm2_solve_(handle,dirA,transA,transX,mb,nrhs, & nnzb,alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,pBuffer) end function function hipsparseSbsrsm2_solve_rank_1(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsm2_solve_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: X integer(c_int) :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsrsm2_solve_rank_1 = hipsparseSbsrsm2_solve_(handle,dirA,transA,transX,mb,nrhs, & nnzb,alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,pBuffer) end function function hipsparseSbsrsm2_solve_full_rank(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrsm2_solve_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:,:) :: X integer(c_int) :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsrsm2_solve_full_rank = hipsparseSbsrsm2_solve_(handle,dirA,transA,transX,mb, & nrhs,nnzb,alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDbsrsm2_solve_assumed_rank(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha, & descrA,bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsm2_solve_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: X integer(c_int) :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsrsm2_solve_assumed_rank = hipsparseDbsrsm2_solve_(handle,dirA,transA,transX,mb, & nrhs,nnzb,alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,pBuffer) end function #else function hipsparseDbsrsm2_solve_rank_0(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsm2_solve_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo real(c_double),target :: B integer(c_int) :: ldb real(c_double),target :: X integer(c_int) :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsrsm2_solve_rank_0 = hipsparseDbsrsm2_solve_(handle,dirA,transA,transX,mb,nrhs, & nnzb,alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,pBuffer) end function function hipsparseDbsrsm2_solve_rank_1(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsm2_solve_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: X integer(c_int) :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsrsm2_solve_rank_1 = hipsparseDbsrsm2_solve_(handle,dirA,transA,transX,mb,nrhs, & nnzb,alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,pBuffer) end function function hipsparseDbsrsm2_solve_full_rank(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrsm2_solve_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:,:) :: X integer(c_int) :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsrsm2_solve_full_rank = hipsparseDbsrsm2_solve_(handle,dirA,transA,transX,mb, & nrhs,nnzb,alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCbsrsm2_solve_assumed_rank(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha, & descrA,bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsm2_solve_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_float_complex),target,contiguous,dimension(..) :: X integer(c_int) :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsrsm2_solve_assumed_rank = hipsparseCbsrsm2_solve_(handle,dirA,transA,transX,mb, & nrhs,nnzb,alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,pBuffer) end function #else function hipsparseCbsrsm2_solve_rank_0(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsm2_solve_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo complex(c_float_complex),target :: B integer(c_int) :: ldb complex(c_float_complex),target :: X integer(c_int) :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsrsm2_solve_rank_0 = hipsparseCbsrsm2_solve_(handle,dirA,transA,transX,mb,nrhs, & nnzb,alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,pBuffer) end function function hipsparseCbsrsm2_solve_rank_1(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsm2_solve_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_float_complex),target,dimension(:) :: X integer(c_int) :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsrsm2_solve_rank_1 = hipsparseCbsrsm2_solve_(handle,dirA,transA,transX,mb,nrhs, & nnzb,alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,pBuffer) end function function hipsparseCbsrsm2_solve_full_rank(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrsm2_solve_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_float_complex),target,dimension(:,:) :: X integer(c_int) :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsrsm2_solve_full_rank = hipsparseCbsrsm2_solve_(handle,dirA,transA,transX,mb, & nrhs,nnzb,alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZbsrsm2_solve_assumed_rank(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha, & descrA,bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsm2_solve_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_double_complex),target,contiguous,dimension(..) :: X integer(c_int) :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsrsm2_solve_assumed_rank = hipsparseZbsrsm2_solve_(handle,dirA,transA,transX,mb, & nrhs,nnzb,alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,pBuffer) end function #else function hipsparseZbsrsm2_solve_rank_0(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsm2_solve_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo complex(c_double_complex),target :: B integer(c_int) :: ldb complex(c_double_complex),target :: X integer(c_int) :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsrsm2_solve_rank_0 = hipsparseZbsrsm2_solve_(handle,dirA,transA,transX,mb,nrhs, & nnzb,alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,pBuffer) end function function hipsparseZbsrsm2_solve_rank_1(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsm2_solve_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_double_complex),target,dimension(:) :: X integer(c_int) :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsrsm2_solve_rank_1 = hipsparseZbsrsm2_solve_(handle,dirA,transA,transX,mb,nrhs, & nnzb,alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA), & blockDim,myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,pBuffer) end function function hipsparseZbsrsm2_solve_full_rank(handle,dirA,transA,transX,mb,nrhs,nnzb,alpha,descrA, & bsrSortedValA,bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,B,ldb,X,ldx,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrsm2_solve_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transX integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_double_complex),target,dimension(:,:) :: X integer(c_int) :: ldx integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsrsm2_solve_full_rank = hipsparseZbsrsm2_solve_(handle,dirA,transA,transX,mb, & nrhs,nnzb,alpha,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA), & c_loc(bsrSortedColIndA),blockDim,myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,pBuffer) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrmm_assumed_rank(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrmm_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipsparseScsrmm_assumed_rank = hipsparseScsrmm_(handle,transA,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function #else function hipsparseScsrmm_rank_0(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrmm_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA real(c_float),target :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target :: C integer(c_int) :: ldc ! hipsparseScsrmm_rank_0 = hipsparseScsrmm_(handle,transA,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseScsrmm_rank_1(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrmm_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! hipsparseScsrmm_rank_1 = hipsparseScsrmm_(handle,transA,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseScsrmm_full_rank(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrmm_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipsparseScsrmm_full_rank = hipsparseScsrmm_(handle,transA,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrmm_assumed_rank(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrmm_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipsparseDcsrmm_assumed_rank = hipsparseDcsrmm_(handle,transA,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function #else function hipsparseDcsrmm_rank_0(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrmm_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA real(c_double),target :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target :: C integer(c_int) :: ldc ! hipsparseDcsrmm_rank_0 = hipsparseDcsrmm_(handle,transA,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseDcsrmm_rank_1(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrmm_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! hipsparseDcsrmm_rank_1 = hipsparseDcsrmm_(handle,transA,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseDcsrmm_full_rank(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrmm_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipsparseDcsrmm_full_rank = hipsparseDcsrmm_(handle,transA,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrmm_assumed_rank(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrmm_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipsparseCcsrmm_assumed_rank = hipsparseCcsrmm_(handle,transA,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function #else function hipsparseCcsrmm_rank_0(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrmm_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA complex(c_float_complex),target :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc ! hipsparseCcsrmm_rank_0 = hipsparseCcsrmm_(handle,transA,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseCcsrmm_rank_1(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrmm_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! hipsparseCcsrmm_rank_1 = hipsparseCcsrmm_(handle,transA,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseCcsrmm_full_rank(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrmm_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipsparseCcsrmm_full_rank = hipsparseCcsrmm_(handle,transA,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrmm_assumed_rank(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrmm_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipsparseZcsrmm_assumed_rank = hipsparseZcsrmm_(handle,transA,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function #else function hipsparseZcsrmm_rank_0(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrmm_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA complex(c_double_complex),target :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc ! hipsparseZcsrmm_rank_0 = hipsparseZcsrmm_(handle,transA,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseZcsrmm_rank_1(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrmm_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! hipsparseZcsrmm_rank_1 = hipsparseZcsrmm_(handle,transA,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseZcsrmm_full_rank(handle,transA,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrmm_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipsparseZcsrmm_full_rank = hipsparseZcsrmm_(handle,transA,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrmm2_assumed_rank(handle,transA,transB,m,n,k,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrmm2_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipsparseScsrmm2_assumed_rank = hipsparseScsrmm2_(handle,transA,transB,m,n,k,nnz,alpha, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb, & beta,c_loc(C),ldc) end function #else function hipsparseScsrmm2_rank_0(handle,transA,transB,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrmm2_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA real(c_float),target :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target :: C integer(c_int) :: ldc ! hipsparseScsrmm2_rank_0 = hipsparseScsrmm2_(handle,transA,transB,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseScsrmm2_rank_1(handle,transA,transB,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrmm2_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! hipsparseScsrmm2_rank_1 = hipsparseScsrmm2_(handle,transA,transB,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseScsrmm2_full_rank(handle,transA,transB,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrmm2_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipsparseScsrmm2_full_rank = hipsparseScsrmm2_(handle,transA,transB,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrmm2_assumed_rank(handle,transA,transB,m,n,k,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrmm2_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipsparseDcsrmm2_assumed_rank = hipsparseDcsrmm2_(handle,transA,transB,m,n,k,nnz,alpha, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb, & beta,c_loc(C),ldc) end function #else function hipsparseDcsrmm2_rank_0(handle,transA,transB,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrmm2_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA real(c_double),target :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target :: C integer(c_int) :: ldc ! hipsparseDcsrmm2_rank_0 = hipsparseDcsrmm2_(handle,transA,transB,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseDcsrmm2_rank_1(handle,transA,transB,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrmm2_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! hipsparseDcsrmm2_rank_1 = hipsparseDcsrmm2_(handle,transA,transB,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseDcsrmm2_full_rank(handle,transA,transB,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrmm2_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipsparseDcsrmm2_full_rank = hipsparseDcsrmm2_(handle,transA,transB,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrmm2_assumed_rank(handle,transA,transB,m,n,k,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrmm2_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipsparseCcsrmm2_assumed_rank = hipsparseCcsrmm2_(handle,transA,transB,m,n,k,nnz,alpha, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb, & beta,c_loc(C),ldc) end function #else function hipsparseCcsrmm2_rank_0(handle,transA,transB,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrmm2_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA complex(c_float_complex),target :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc ! hipsparseCcsrmm2_rank_0 = hipsparseCcsrmm2_(handle,transA,transB,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseCcsrmm2_rank_1(handle,transA,transB,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrmm2_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! hipsparseCcsrmm2_rank_1 = hipsparseCcsrmm2_(handle,transA,transB,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseCcsrmm2_full_rank(handle,transA,transB,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrmm2_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipsparseCcsrmm2_full_rank = hipsparseCcsrmm2_(handle,transA,transB,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrmm2_assumed_rank(handle,transA,transB,m,n,k,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrmm2_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipsparseZcsrmm2_assumed_rank = hipsparseZcsrmm2_(handle,transA,transB,m,n,k,nnz,alpha, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb, & beta,c_loc(C),ldc) end function #else function hipsparseZcsrmm2_rank_0(handle,transA,transB,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrmm2_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA complex(c_double_complex),target :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc ! hipsparseZcsrmm2_rank_0 = hipsparseZcsrmm2_(handle,transA,transB,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseZcsrmm2_rank_1(handle,transA,transB,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrmm2_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! hipsparseZcsrmm2_rank_1 = hipsparseZcsrmm2_(handle,transA,transB,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function function hipsparseZcsrmm2_full_rank(handle,transA,transB,m,n,k,nnz,alpha,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrmm2_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipsparseZcsrmm2_full_rank = hipsparseZcsrmm2_(handle,transA,transB,m,n,k,nnz,alpha,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),c_loc(B),ldb,beta, & c_loc(C),ldc) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrsm2_bufferSizeExt_assumed_rank(handle,algo,transA,transB,m,nrhs,nnz, & alpha,descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsm2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float),target,contiguous,dimension(..) :: alpha type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsrsm2_bufferSizeExt_assumed_rank = hipsparseScsrsm2_bufferSizeExt_(handle,algo, & transA,transB,m,nrhs,nnz,c_loc(alpha),descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBufferSizeInBytes) end function #else function hipsparseScsrsm2_bufferSizeExt_rank_0(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsm2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float),target :: alpha type(c_ptr) :: descrA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA real(c_float),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsrsm2_bufferSizeExt_rank_0 = hipsparseScsrsm2_bufferSizeExt_(handle,algo,transA, & transB,m,nrhs,nnz,c_loc(alpha),descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBufferSizeInBytes) end function function hipsparseScsrsm2_bufferSizeExt_rank_1(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsm2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float),target,dimension(:) :: alpha type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_float),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsrsm2_bufferSizeExt_rank_1 = hipsparseScsrsm2_bufferSizeExt_(handle,algo,transA, & transB,m,nrhs,nnz,c_loc(alpha),descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBufferSizeInBytes) end function function hipsparseScsrsm2_bufferSizeExt_full_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsm2_bufferSizeExt_full_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float),target,dimension(:) :: alpha type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsrsm2_bufferSizeExt_full_rank = hipsparseScsrsm2_bufferSizeExt_(handle,algo, & transA,transB,m,nrhs,nnz,c_loc(alpha),descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrsm2_bufferSizeExt_assumed_rank(handle,algo,transA,transB,m,nrhs,nnz, & alpha,descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsm2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double),target,contiguous,dimension(..) :: alpha type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsrsm2_bufferSizeExt_assumed_rank = hipsparseDcsrsm2_bufferSizeExt_(handle,algo, & transA,transB,m,nrhs,nnz,c_loc(alpha),descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBufferSizeInBytes) end function #else function hipsparseDcsrsm2_bufferSizeExt_rank_0(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsm2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double),target :: alpha type(c_ptr) :: descrA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA real(c_double),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsrsm2_bufferSizeExt_rank_0 = hipsparseDcsrsm2_bufferSizeExt_(handle,algo,transA, & transB,m,nrhs,nnz,c_loc(alpha),descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBufferSizeInBytes) end function function hipsparseDcsrsm2_bufferSizeExt_rank_1(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsm2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double),target,dimension(:) :: alpha type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_double),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsrsm2_bufferSizeExt_rank_1 = hipsparseDcsrsm2_bufferSizeExt_(handle,algo,transA, & transB,m,nrhs,nnz,c_loc(alpha),descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBufferSizeInBytes) end function function hipsparseDcsrsm2_bufferSizeExt_full_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsm2_bufferSizeExt_full_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double),target,dimension(:) :: alpha type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsrsm2_bufferSizeExt_full_rank = hipsparseDcsrsm2_bufferSizeExt_(handle,algo, & transA,transB,m,nrhs,nnz,c_loc(alpha),descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrsm2_bufferSizeExt_assumed_rank(handle,algo,transA,transB,m,nrhs,nnz, & alpha,descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsm2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex),target,contiguous,dimension(..) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsrsm2_bufferSizeExt_assumed_rank = hipsparseCcsrsm2_bufferSizeExt_(handle,algo, & transA,transB,m,nrhs,nnz,c_loc(alpha),descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBufferSizeInBytes) end function #else function hipsparseCcsrsm2_bufferSizeExt_rank_0(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsm2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex),target :: alpha type(c_ptr) :: descrA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA complex(c_float_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsrsm2_bufferSizeExt_rank_0 = hipsparseCcsrsm2_bufferSizeExt_(handle,algo,transA, & transB,m,nrhs,nnz,c_loc(alpha),descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBufferSizeInBytes) end function function hipsparseCcsrsm2_bufferSizeExt_rank_1(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsm2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex),target,dimension(:) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsrsm2_bufferSizeExt_rank_1 = hipsparseCcsrsm2_bufferSizeExt_(handle,algo,transA, & transB,m,nrhs,nnz,c_loc(alpha),descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBufferSizeInBytes) end function function hipsparseCcsrsm2_bufferSizeExt_full_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsm2_bufferSizeExt_full_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex),target,dimension(:) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsrsm2_bufferSizeExt_full_rank = hipsparseCcsrsm2_bufferSizeExt_(handle,algo, & transA,transB,m,nrhs,nnz,c_loc(alpha),descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrsm2_bufferSizeExt_assumed_rank(handle,algo,transA,transB,m,nrhs,nnz, & alpha,descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsm2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex),target,contiguous,dimension(..) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsrsm2_bufferSizeExt_assumed_rank = hipsparseZcsrsm2_bufferSizeExt_(handle,algo, & transA,transB,m,nrhs,nnz,c_loc(alpha),descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBufferSizeInBytes) end function #else function hipsparseZcsrsm2_bufferSizeExt_rank_0(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsm2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex),target :: alpha type(c_ptr) :: descrA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA complex(c_double_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsrsm2_bufferSizeExt_rank_0 = hipsparseZcsrsm2_bufferSizeExt_(handle,algo,transA, & transB,m,nrhs,nnz,c_loc(alpha),descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBufferSizeInBytes) end function function hipsparseZcsrsm2_bufferSizeExt_rank_1(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsm2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex),target,dimension(:) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsrsm2_bufferSizeExt_rank_1 = hipsparseZcsrsm2_bufferSizeExt_(handle,algo,transA, & transB,m,nrhs,nnz,c_loc(alpha),descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBufferSizeInBytes) end function function hipsparseZcsrsm2_bufferSizeExt_full_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsm2_bufferSizeExt_full_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex),target,dimension(:) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsrsm2_bufferSizeExt_full_rank = hipsparseZcsrsm2_bufferSizeExt_(handle,algo, & transA,transB,m,nrhs,nnz,c_loc(alpha),descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrsm2_analysis_assumed_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsm2_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrsm2_analysis_assumed_rank = hipsparseScsrsm2_analysis_(handle,algo,transA, & transB,m,nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function #else function hipsparseScsrsm2_analysis_rank_0(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsm2_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA real(c_float),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrsm2_analysis_rank_0 = hipsparseScsrsm2_analysis_(handle,algo,transA,transB,m, & nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function function hipsparseScsrsm2_analysis_rank_1(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsm2_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_float),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrsm2_analysis_rank_1 = hipsparseScsrsm2_analysis_(handle,algo,transA,transB,m, & nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function function hipsparseScsrsm2_analysis_full_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsm2_analysis_full_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrsm2_analysis_full_rank = hipsparseScsrsm2_analysis_(handle,algo,transA,transB, & m,nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrsm2_analysis_assumed_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsm2_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrsm2_analysis_assumed_rank = hipsparseDcsrsm2_analysis_(handle,algo,transA, & transB,m,nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function #else function hipsparseDcsrsm2_analysis_rank_0(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsm2_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA real(c_double),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrsm2_analysis_rank_0 = hipsparseDcsrsm2_analysis_(handle,algo,transA,transB,m, & nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function function hipsparseDcsrsm2_analysis_rank_1(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsm2_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_double),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrsm2_analysis_rank_1 = hipsparseDcsrsm2_analysis_(handle,algo,transA,transB,m, & nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function function hipsparseDcsrsm2_analysis_full_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsm2_analysis_full_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrsm2_analysis_full_rank = hipsparseDcsrsm2_analysis_(handle,algo,transA,transB, & m,nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrsm2_analysis_assumed_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsm2_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrsm2_analysis_assumed_rank = hipsparseCcsrsm2_analysis_(handle,algo,transA, & transB,m,nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function #else function hipsparseCcsrsm2_analysis_rank_0(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsm2_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA complex(c_float_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrsm2_analysis_rank_0 = hipsparseCcsrsm2_analysis_(handle,algo,transA,transB,m, & nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function function hipsparseCcsrsm2_analysis_rank_1(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsm2_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrsm2_analysis_rank_1 = hipsparseCcsrsm2_analysis_(handle,algo,transA,transB,m, & nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function function hipsparseCcsrsm2_analysis_full_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsm2_analysis_full_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrsm2_analysis_full_rank = hipsparseCcsrsm2_analysis_(handle,algo,transA,transB, & m,nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrsm2_analysis_assumed_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsm2_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrsm2_analysis_assumed_rank = hipsparseZcsrsm2_analysis_(handle,algo,transA, & transB,m,nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function #else function hipsparseZcsrsm2_analysis_rank_0(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsm2_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA complex(c_double_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrsm2_analysis_rank_0 = hipsparseZcsrsm2_analysis_(handle,algo,transA,transB,m, & nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function function hipsparseZcsrsm2_analysis_rank_1(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsm2_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrsm2_analysis_rank_1 = hipsparseZcsrsm2_analysis_(handle,algo,transA,transB,m, & nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function function hipsparseZcsrsm2_analysis_full_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsm2_analysis_full_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrsm2_analysis_full_rank = hipsparseZcsrsm2_analysis_(handle,algo,transA,transB, & m,nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrsm2_solve_assumed_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsm2_solve_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrsm2_solve_assumed_rank = hipsparseScsrsm2_solve_(handle,algo,transA,transB,m, & nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function #else function hipsparseScsrsm2_solve_rank_0(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsm2_solve_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA real(c_float),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrsm2_solve_rank_0 = hipsparseScsrsm2_solve_(handle,algo,transA,transB,m,nrhs, & nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & c_loc(B),ldb,myInfo,policy,pBuffer) end function function hipsparseScsrsm2_solve_rank_1(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsm2_solve_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_float),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrsm2_solve_rank_1 = hipsparseScsrsm2_solve_(handle,algo,transA,transB,m,nrhs, & nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & c_loc(B),ldb,myInfo,policy,pBuffer) end function function hipsparseScsrsm2_solve_full_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrsm2_solve_full_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrsm2_solve_full_rank = hipsparseScsrsm2_solve_(handle,algo,transA,transB,m,nrhs, & nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & c_loc(B),ldb,myInfo,policy,pBuffer) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrsm2_solve_assumed_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsm2_solve_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrsm2_solve_assumed_rank = hipsparseDcsrsm2_solve_(handle,algo,transA,transB,m, & nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function #else function hipsparseDcsrsm2_solve_rank_0(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsm2_solve_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA real(c_double),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrsm2_solve_rank_0 = hipsparseDcsrsm2_solve_(handle,algo,transA,transB,m,nrhs, & nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & c_loc(B),ldb,myInfo,policy,pBuffer) end function function hipsparseDcsrsm2_solve_rank_1(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsm2_solve_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_double),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrsm2_solve_rank_1 = hipsparseDcsrsm2_solve_(handle,algo,transA,transB,m,nrhs, & nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & c_loc(B),ldb,myInfo,policy,pBuffer) end function function hipsparseDcsrsm2_solve_full_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrsm2_solve_full_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrsm2_solve_full_rank = hipsparseDcsrsm2_solve_(handle,algo,transA,transB,m,nrhs, & nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & c_loc(B),ldb,myInfo,policy,pBuffer) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrsm2_solve_assumed_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsm2_solve_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrsm2_solve_assumed_rank = hipsparseCcsrsm2_solve_(handle,algo,transA,transB,m, & nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function #else function hipsparseCcsrsm2_solve_rank_0(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsm2_solve_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA complex(c_float_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrsm2_solve_rank_0 = hipsparseCcsrsm2_solve_(handle,algo,transA,transB,m,nrhs, & nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & c_loc(B),ldb,myInfo,policy,pBuffer) end function function hipsparseCcsrsm2_solve_rank_1(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsm2_solve_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrsm2_solve_rank_1 = hipsparseCcsrsm2_solve_(handle,algo,transA,transB,m,nrhs, & nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & c_loc(B),ldb,myInfo,policy,pBuffer) end function function hipsparseCcsrsm2_solve_full_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrsm2_solve_full_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrsm2_solve_full_rank = hipsparseCcsrsm2_solve_(handle,algo,transA,transB,m,nrhs, & nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & c_loc(B),ldb,myInfo,policy,pBuffer) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrsm2_solve_assumed_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha, & descrA,csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsm2_solve_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrsm2_solve_assumed_rank = hipsparseZcsrsm2_solve_(handle,algo,transA,transB,m, & nrhs,nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA), & c_loc(csrSortedColIndA),c_loc(B),ldb,myInfo,policy,pBuffer) end function #else function hipsparseZcsrsm2_solve_rank_0(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsm2_solve_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA complex(c_double_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrsm2_solve_rank_0 = hipsparseZcsrsm2_solve_(handle,algo,transA,transB,m,nrhs, & nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & c_loc(B),ldb,myInfo,policy,pBuffer) end function function hipsparseZcsrsm2_solve_rank_1(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsm2_solve_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrsm2_solve_rank_1 = hipsparseZcsrsm2_solve_(handle,algo,transA,transB,m,nrhs, & nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & c_loc(B),ldb,myInfo,policy,pBuffer) end function function hipsparseZcsrsm2_solve_full_rank(handle,algo,transA,transB,m,nrhs,nnz,alpha,descrA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,B,ldb,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrsm2_solve_full_rank type(c_ptr) :: handle integer(c_int) :: algo integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrsm2_solve_full_rank = hipsparseZcsrsm2_solve_(handle,algo,transA,transB,m,nrhs, & nnz,alpha,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & c_loc(B),ldb,myInfo,policy,pBuffer) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSgemmi_assumed_rank(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB, & cscRowIndB,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgemmi_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: cscValB integer(c_int),target,contiguous,dimension(..) :: cscColPtrB integer(c_int),target,contiguous,dimension(..) :: cscRowIndB real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipsparseSgemmi_assumed_rank = hipsparseSgemmi_(handle,m,n,k,nnz,alpha,c_loc(A),lda, & c_loc(cscValB),c_loc(cscColPtrB),c_loc(cscRowIndB),beta,c_loc(C),ldc) end function #else function hipsparseSgemmi_rank_0(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB,cscRowIndB, & beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgemmi_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: cscValB integer(c_int),target :: cscColPtrB integer(c_int),target :: cscRowIndB real(c_float) :: beta real(c_float),target :: C integer(c_int) :: ldc ! hipsparseSgemmi_rank_0 = hipsparseSgemmi_(handle,m,n,k,nnz,alpha,c_loc(A),lda, & c_loc(cscValB),c_loc(cscColPtrB),c_loc(cscRowIndB),beta,c_loc(C),ldc) end function function hipsparseSgemmi_rank_1(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB,cscRowIndB, & beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgemmi_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: cscValB integer(c_int),target,dimension(:) :: cscColPtrB integer(c_int),target,dimension(:) :: cscRowIndB real(c_float) :: beta real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! hipsparseSgemmi_rank_1 = hipsparseSgemmi_(handle,m,n,k,nnz,alpha,c_loc(A),lda, & c_loc(cscValB),c_loc(cscColPtrB),c_loc(cscRowIndB),beta,c_loc(C),ldc) end function function hipsparseSgemmi_full_rank(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB,cscRowIndB, & beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgemmi_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: cscValB integer(c_int),target,dimension(:) :: cscColPtrB integer(c_int),target,dimension(:) :: cscRowIndB real(c_float) :: beta real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipsparseSgemmi_full_rank = hipsparseSgemmi_(handle,m,n,k,nnz,alpha,c_loc(A),lda, & c_loc(cscValB),c_loc(cscColPtrB),c_loc(cscRowIndB),beta,c_loc(C),ldc) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDgemmi_assumed_rank(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB, & cscRowIndB,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgemmi_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: cscValB integer(c_int),target,contiguous,dimension(..) :: cscColPtrB integer(c_int),target,contiguous,dimension(..) :: cscRowIndB real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipsparseDgemmi_assumed_rank = hipsparseDgemmi_(handle,m,n,k,nnz,alpha,c_loc(A),lda, & c_loc(cscValB),c_loc(cscColPtrB),c_loc(cscRowIndB),beta,c_loc(C),ldc) end function #else function hipsparseDgemmi_rank_0(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB,cscRowIndB, & beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgemmi_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: cscValB integer(c_int),target :: cscColPtrB integer(c_int),target :: cscRowIndB real(c_double) :: beta real(c_double),target :: C integer(c_int) :: ldc ! hipsparseDgemmi_rank_0 = hipsparseDgemmi_(handle,m,n,k,nnz,alpha,c_loc(A),lda, & c_loc(cscValB),c_loc(cscColPtrB),c_loc(cscRowIndB),beta,c_loc(C),ldc) end function function hipsparseDgemmi_rank_1(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB,cscRowIndB, & beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgemmi_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: cscValB integer(c_int),target,dimension(:) :: cscColPtrB integer(c_int),target,dimension(:) :: cscRowIndB real(c_double) :: beta real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! hipsparseDgemmi_rank_1 = hipsparseDgemmi_(handle,m,n,k,nnz,alpha,c_loc(A),lda, & c_loc(cscValB),c_loc(cscColPtrB),c_loc(cscRowIndB),beta,c_loc(C),ldc) end function function hipsparseDgemmi_full_rank(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB,cscRowIndB, & beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgemmi_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: cscValB integer(c_int),target,dimension(:) :: cscColPtrB integer(c_int),target,dimension(:) :: cscRowIndB real(c_double) :: beta real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipsparseDgemmi_full_rank = hipsparseDgemmi_(handle,m,n,k,nnz,alpha,c_loc(A),lda, & c_loc(cscValB),c_loc(cscColPtrB),c_loc(cscRowIndB),beta,c_loc(C),ldc) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCgemmi_assumed_rank(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB, & cscRowIndB,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgemmi_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: cscValB integer(c_int),target,contiguous,dimension(..) :: cscColPtrB integer(c_int),target,contiguous,dimension(..) :: cscRowIndB complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipsparseCgemmi_assumed_rank = hipsparseCgemmi_(handle,m,n,k,nnz,alpha,c_loc(A),lda, & c_loc(cscValB),c_loc(cscColPtrB),c_loc(cscRowIndB),beta,c_loc(C),ldc) end function #else function hipsparseCgemmi_rank_0(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB,cscRowIndB, & beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgemmi_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: cscValB integer(c_int),target :: cscColPtrB integer(c_int),target :: cscRowIndB complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc ! hipsparseCgemmi_rank_0 = hipsparseCgemmi_(handle,m,n,k,nnz,alpha,c_loc(A),lda, & c_loc(cscValB),c_loc(cscColPtrB),c_loc(cscRowIndB),beta,c_loc(C),ldc) end function function hipsparseCgemmi_rank_1(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB,cscRowIndB, & beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgemmi_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: cscValB integer(c_int),target,dimension(:) :: cscColPtrB integer(c_int),target,dimension(:) :: cscRowIndB complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! hipsparseCgemmi_rank_1 = hipsparseCgemmi_(handle,m,n,k,nnz,alpha,c_loc(A),lda, & c_loc(cscValB),c_loc(cscColPtrB),c_loc(cscRowIndB),beta,c_loc(C),ldc) end function function hipsparseCgemmi_full_rank(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB,cscRowIndB, & beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgemmi_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: cscValB integer(c_int),target,dimension(:) :: cscColPtrB integer(c_int),target,dimension(:) :: cscRowIndB complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipsparseCgemmi_full_rank = hipsparseCgemmi_(handle,m,n,k,nnz,alpha,c_loc(A),lda, & c_loc(cscValB),c_loc(cscColPtrB),c_loc(cscRowIndB),beta,c_loc(C),ldc) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZgemmi_assumed_rank(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB, & cscRowIndB,beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgemmi_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: cscValB integer(c_int),target,contiguous,dimension(..) :: cscColPtrB integer(c_int),target,contiguous,dimension(..) :: cscRowIndB complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! hipsparseZgemmi_assumed_rank = hipsparseZgemmi_(handle,m,n,k,nnz,alpha,c_loc(A),lda, & c_loc(cscValB),c_loc(cscColPtrB),c_loc(cscRowIndB),beta,c_loc(C),ldc) end function #else function hipsparseZgemmi_rank_0(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB,cscRowIndB, & beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgemmi_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: cscValB integer(c_int),target :: cscColPtrB integer(c_int),target :: cscRowIndB complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc ! hipsparseZgemmi_rank_0 = hipsparseZgemmi_(handle,m,n,k,nnz,alpha,c_loc(A),lda, & c_loc(cscValB),c_loc(cscColPtrB),c_loc(cscRowIndB),beta,c_loc(C),ldc) end function function hipsparseZgemmi_rank_1(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB,cscRowIndB, & beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgemmi_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: cscValB integer(c_int),target,dimension(:) :: cscColPtrB integer(c_int),target,dimension(:) :: cscRowIndB complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! hipsparseZgemmi_rank_1 = hipsparseZgemmi_(handle,m,n,k,nnz,alpha,c_loc(A),lda, & c_loc(cscValB),c_loc(cscColPtrB),c_loc(cscRowIndB),beta,c_loc(C),ldc) end function function hipsparseZgemmi_full_rank(handle,m,n,k,nnz,alpha,A,lda,cscValB,cscColPtrB,cscRowIndB, & beta,C,ldc) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgemmi_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: cscValB integer(c_int),target,dimension(:) :: cscColPtrB integer(c_int),target,dimension(:) :: cscRowIndB complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! hipsparseZgemmi_full_rank = hipsparseZgemmi_(handle,m,n,k,nnz,alpha,c_loc(A),lda, & c_loc(cscValB),c_loc(cscColPtrB),c_loc(cscRowIndB),beta,c_loc(C),ldc) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseXcsrgeamNnz_assumed_rank(handle,m,n,descrA,nnzA,csrRowPtrA,csrColIndA, & descrB,nnzB,csrRowPtrB,csrColIndB,descrC,csrRowPtrC,nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrgeamNnz_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target,contiguous,dimension(..) :: csrRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrColIndB type(c_ptr) :: descrC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr ! hipsparseXcsrgeamNnz_assumed_rank = hipsparseXcsrgeamNnz_(handle,m,n,descrA,nnzA, & c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB),c_loc(csrColIndB), & descrC,c_loc(csrRowPtrC),nnzTotalDevHostPtr) end function #else function hipsparseXcsrgeamNnz_rank_0(handle,m,n,descrA,nnzA,csrRowPtrA,csrColIndA,descrB,nnzB, & csrRowPtrB,csrColIndB,descrC,csrRowPtrC,nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrgeamNnz_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target :: csrRowPtrB integer(c_int),target :: csrColIndB type(c_ptr) :: descrC integer(c_int),target :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr ! hipsparseXcsrgeamNnz_rank_0 = hipsparseXcsrgeamNnz_(handle,m,n,descrA,nnzA, & c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB),c_loc(csrColIndB), & descrC,c_loc(csrRowPtrC),nnzTotalDevHostPtr) end function function hipsparseXcsrgeamNnz_rank_1(handle,m,n,descrA,nnzA,csrRowPtrA,csrColIndA,descrB,nnzB, & csrRowPtrB,csrColIndB,descrC,csrRowPtrC,nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrgeamNnz_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target,dimension(:) :: csrRowPtrB integer(c_int),target,dimension(:) :: csrColIndB type(c_ptr) :: descrC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr ! hipsparseXcsrgeamNnz_rank_1 = hipsparseXcsrgeamNnz_(handle,m,n,descrA,nnzA, & c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB),c_loc(csrColIndB), & descrC,c_loc(csrRowPtrC),nnzTotalDevHostPtr) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrgeam_assumed_rank(handle,m,n,alpha,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,beta,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC, & csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgeam_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_float),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA real(c_float) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_float),target,contiguous,dimension(..) :: csrValB integer(c_int),target,contiguous,dimension(..) :: csrRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrColIndB type(c_ptr) :: descrC real(c_float),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC ! hipsparseScsrgeam_assumed_rank = hipsparseScsrgeam_(handle,m,n,alpha,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),beta,descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #else function hipsparseScsrgeam_rank_0(handle,m,n,alpha,descrA,nnzA,csrValA,csrRowPtrA,csrColIndA, & beta,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgeam_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_float),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA real(c_float) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_float),target :: csrValB integer(c_int),target :: csrRowPtrB integer(c_int),target :: csrColIndB type(c_ptr) :: descrC real(c_float),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC ! hipsparseScsrgeam_rank_0 = hipsparseScsrgeam_(handle,m,n,alpha,descrA,nnzA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),beta,descrB,nnzB,c_loc(csrValB),c_loc(csrRowPtrB), & c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC)) end function function hipsparseScsrgeam_rank_1(handle,m,n,alpha,descrA,nnzA,csrValA,csrRowPtrA,csrColIndA, & beta,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgeam_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_float),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA real(c_float) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_float),target,dimension(:) :: csrValB integer(c_int),target,dimension(:) :: csrRowPtrB integer(c_int),target,dimension(:) :: csrColIndB type(c_ptr) :: descrC real(c_float),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC ! hipsparseScsrgeam_rank_1 = hipsparseScsrgeam_(handle,m,n,alpha,descrA,nnzA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),beta,descrB,nnzB,c_loc(csrValB),c_loc(csrRowPtrB), & c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrgeam_assumed_rank(handle,m,n,alpha,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,beta,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC, & csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgeam_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_double),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA real(c_double) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_double),target,contiguous,dimension(..) :: csrValB integer(c_int),target,contiguous,dimension(..) :: csrRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrColIndB type(c_ptr) :: descrC real(c_double),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC ! hipsparseDcsrgeam_assumed_rank = hipsparseDcsrgeam_(handle,m,n,alpha,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),beta,descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #else function hipsparseDcsrgeam_rank_0(handle,m,n,alpha,descrA,nnzA,csrValA,csrRowPtrA,csrColIndA, & beta,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgeam_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_double),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA real(c_double) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_double),target :: csrValB integer(c_int),target :: csrRowPtrB integer(c_int),target :: csrColIndB type(c_ptr) :: descrC real(c_double),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC ! hipsparseDcsrgeam_rank_0 = hipsparseDcsrgeam_(handle,m,n,alpha,descrA,nnzA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),beta,descrB,nnzB,c_loc(csrValB),c_loc(csrRowPtrB), & c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC)) end function function hipsparseDcsrgeam_rank_1(handle,m,n,alpha,descrA,nnzA,csrValA,csrRowPtrA,csrColIndA, & beta,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgeam_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_double),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA real(c_double) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_double),target,dimension(:) :: csrValB integer(c_int),target,dimension(:) :: csrRowPtrB integer(c_int),target,dimension(:) :: csrColIndB type(c_ptr) :: descrC real(c_double),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC ! hipsparseDcsrgeam_rank_1 = hipsparseDcsrgeam_(handle,m,n,alpha,descrA,nnzA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),beta,descrB,nnzB,c_loc(csrValB),c_loc(csrRowPtrB), & c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrgeam_assumed_rank(handle,m,n,alpha,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,beta,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC, & csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgeam_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_float_complex),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA complex(c_float_complex) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_float_complex),target,contiguous,dimension(..) :: csrValB integer(c_int),target,contiguous,dimension(..) :: csrRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrColIndB type(c_ptr) :: descrC complex(c_float_complex),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC ! hipsparseCcsrgeam_assumed_rank = hipsparseCcsrgeam_(handle,m,n,alpha,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),beta,descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #else function hipsparseCcsrgeam_rank_0(handle,m,n,alpha,descrA,nnzA,csrValA,csrRowPtrA,csrColIndA, & beta,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgeam_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_float_complex),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA complex(c_float_complex) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_float_complex),target :: csrValB integer(c_int),target :: csrRowPtrB integer(c_int),target :: csrColIndB type(c_ptr) :: descrC complex(c_float_complex),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC ! hipsparseCcsrgeam_rank_0 = hipsparseCcsrgeam_(handle,m,n,alpha,descrA,nnzA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),beta,descrB,nnzB,c_loc(csrValB),c_loc(csrRowPtrB), & c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC)) end function function hipsparseCcsrgeam_rank_1(handle,m,n,alpha,descrA,nnzA,csrValA,csrRowPtrA,csrColIndA, & beta,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgeam_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_float_complex),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA complex(c_float_complex) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_float_complex),target,dimension(:) :: csrValB integer(c_int),target,dimension(:) :: csrRowPtrB integer(c_int),target,dimension(:) :: csrColIndB type(c_ptr) :: descrC complex(c_float_complex),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC ! hipsparseCcsrgeam_rank_1 = hipsparseCcsrgeam_(handle,m,n,alpha,descrA,nnzA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),beta,descrB,nnzB,c_loc(csrValB),c_loc(csrRowPtrB), & c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrgeam_assumed_rank(handle,m,n,alpha,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,beta,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC, & csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgeam_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_double_complex),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA complex(c_double_complex) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_double_complex),target,contiguous,dimension(..) :: csrValB integer(c_int),target,contiguous,dimension(..) :: csrRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrColIndB type(c_ptr) :: descrC complex(c_double_complex),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC ! hipsparseZcsrgeam_assumed_rank = hipsparseZcsrgeam_(handle,m,n,alpha,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),beta,descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #else function hipsparseZcsrgeam_rank_0(handle,m,n,alpha,descrA,nnzA,csrValA,csrRowPtrA,csrColIndA, & beta,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgeam_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_double_complex),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA complex(c_double_complex) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_double_complex),target :: csrValB integer(c_int),target :: csrRowPtrB integer(c_int),target :: csrColIndB type(c_ptr) :: descrC complex(c_double_complex),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC ! hipsparseZcsrgeam_rank_0 = hipsparseZcsrgeam_(handle,m,n,alpha,descrA,nnzA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),beta,descrB,nnzB,c_loc(csrValB),c_loc(csrRowPtrB), & c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC)) end function function hipsparseZcsrgeam_rank_1(handle,m,n,alpha,descrA,nnzA,csrValA,csrRowPtrA,csrColIndA, & beta,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgeam_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_double_complex),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA complex(c_double_complex) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_double_complex),target,dimension(:) :: csrValB integer(c_int),target,dimension(:) :: csrRowPtrB integer(c_int),target,dimension(:) :: csrColIndB type(c_ptr) :: descrC complex(c_double_complex),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC ! hipsparseZcsrgeam_rank_1 = hipsparseZcsrgeam_(handle,m,n,alpha,descrA,nnzA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),beta,descrB,nnzB,c_loc(csrValB),c_loc(csrRowPtrB), & c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC)) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrgeam2_bufferSizeExt_assumed_rank(handle,m,n,alpha,descrA,nnzA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB, & csrSortedRowPtrB,csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgeam2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA real(c_float) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_float),target,contiguous,dimension(..) :: csrSortedValB integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndB type(c_ptr) :: descrC real(c_float),target,contiguous,dimension(..) :: csrSortedValC integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsrgeam2_bufferSizeExt_assumed_rank = hipsparseScsrgeam2_bufferSizeExt_(handle,m, & n,alpha,descrA,nnzA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & beta,descrB,nnzB,c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB), & descrC,c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC), & pBufferSizeInBytes) end function #else function hipsparseScsrgeam2_bufferSizeExt_rank_0(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgeam2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA real(c_float) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_float),target :: csrSortedValB integer(c_int),target :: csrSortedRowPtrB integer(c_int),target :: csrSortedColIndB type(c_ptr) :: descrC real(c_float),target :: csrSortedValC integer(c_int),target :: csrSortedRowPtrC integer(c_int),target :: csrSortedColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsrgeam2_bufferSizeExt_rank_0 = hipsparseScsrgeam2_bufferSizeExt_(handle,m,n, & alpha,descrA,nnzA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & beta,descrB,nnzB,c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB), & descrC,c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC), & pBufferSizeInBytes) end function function hipsparseScsrgeam2_bufferSizeExt_rank_1(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgeam2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_float) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_float),target,dimension(:) :: csrSortedValB integer(c_int),target,dimension(:) :: csrSortedRowPtrB integer(c_int),target,dimension(:) :: csrSortedColIndB type(c_ptr) :: descrC real(c_float),target,dimension(:) :: csrSortedValC integer(c_int),target,dimension(:) :: csrSortedRowPtrC integer(c_int),target,dimension(:) :: csrSortedColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsrgeam2_bufferSizeExt_rank_1 = hipsparseScsrgeam2_bufferSizeExt_(handle,m,n, & alpha,descrA,nnzA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & beta,descrB,nnzB,c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB), & descrC,c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC), & pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrgeam2_bufferSizeExt_assumed_rank(handle,m,n,alpha,descrA,nnzA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB, & csrSortedRowPtrB,csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgeam2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA real(c_double) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_double),target,contiguous,dimension(..) :: csrSortedValB integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndB type(c_ptr) :: descrC real(c_double),target,contiguous,dimension(..) :: csrSortedValC integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsrgeam2_bufferSizeExt_assumed_rank = hipsparseDcsrgeam2_bufferSizeExt_(handle,m, & n,alpha,descrA,nnzA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & beta,descrB,nnzB,c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB), & descrC,c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC), & pBufferSizeInBytes) end function #else function hipsparseDcsrgeam2_bufferSizeExt_rank_0(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgeam2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA real(c_double) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_double),target :: csrSortedValB integer(c_int),target :: csrSortedRowPtrB integer(c_int),target :: csrSortedColIndB type(c_ptr) :: descrC real(c_double),target :: csrSortedValC integer(c_int),target :: csrSortedRowPtrC integer(c_int),target :: csrSortedColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsrgeam2_bufferSizeExt_rank_0 = hipsparseDcsrgeam2_bufferSizeExt_(handle,m,n, & alpha,descrA,nnzA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & beta,descrB,nnzB,c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB), & descrC,c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC), & pBufferSizeInBytes) end function function hipsparseDcsrgeam2_bufferSizeExt_rank_1(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgeam2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_double) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_double),target,dimension(:) :: csrSortedValB integer(c_int),target,dimension(:) :: csrSortedRowPtrB integer(c_int),target,dimension(:) :: csrSortedColIndB type(c_ptr) :: descrC real(c_double),target,dimension(:) :: csrSortedValC integer(c_int),target,dimension(:) :: csrSortedRowPtrC integer(c_int),target,dimension(:) :: csrSortedColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsrgeam2_bufferSizeExt_rank_1 = hipsparseDcsrgeam2_bufferSizeExt_(handle,m,n, & alpha,descrA,nnzA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & beta,descrB,nnzB,c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB), & descrC,c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC), & pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrgeam2_bufferSizeExt_assumed_rank(handle,m,n,alpha,descrA,nnzA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB, & csrSortedRowPtrB,csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgeam2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA complex(c_float_complex) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValB integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndB type(c_ptr) :: descrC complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValC integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsrgeam2_bufferSizeExt_assumed_rank = hipsparseCcsrgeam2_bufferSizeExt_(handle,m, & n,alpha,descrA,nnzA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & beta,descrB,nnzB,c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB), & descrC,c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC), & pBufferSizeInBytes) end function #else function hipsparseCcsrgeam2_bufferSizeExt_rank_0(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgeam2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA complex(c_float_complex) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_float_complex),target :: csrSortedValB integer(c_int),target :: csrSortedRowPtrB integer(c_int),target :: csrSortedColIndB type(c_ptr) :: descrC complex(c_float_complex),target :: csrSortedValC integer(c_int),target :: csrSortedRowPtrC integer(c_int),target :: csrSortedColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsrgeam2_bufferSizeExt_rank_0 = hipsparseCcsrgeam2_bufferSizeExt_(handle,m,n, & alpha,descrA,nnzA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & beta,descrB,nnzB,c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB), & descrC,c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC), & pBufferSizeInBytes) end function function hipsparseCcsrgeam2_bufferSizeExt_rank_1(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgeam2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_float_complex) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_float_complex),target,dimension(:) :: csrSortedValB integer(c_int),target,dimension(:) :: csrSortedRowPtrB integer(c_int),target,dimension(:) :: csrSortedColIndB type(c_ptr) :: descrC complex(c_float_complex),target,dimension(:) :: csrSortedValC integer(c_int),target,dimension(:) :: csrSortedRowPtrC integer(c_int),target,dimension(:) :: csrSortedColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsrgeam2_bufferSizeExt_rank_1 = hipsparseCcsrgeam2_bufferSizeExt_(handle,m,n, & alpha,descrA,nnzA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & beta,descrB,nnzB,c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB), & descrC,c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC), & pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrgeam2_bufferSizeExt_assumed_rank(handle,m,n,alpha,descrA,nnzA, & csrSortedValA,csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB, & csrSortedRowPtrB,csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgeam2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA complex(c_double_complex) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValB integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndB type(c_ptr) :: descrC complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValC integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsrgeam2_bufferSizeExt_assumed_rank = hipsparseZcsrgeam2_bufferSizeExt_(handle,m, & n,alpha,descrA,nnzA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & beta,descrB,nnzB,c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB), & descrC,c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC), & pBufferSizeInBytes) end function #else function hipsparseZcsrgeam2_bufferSizeExt_rank_0(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgeam2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA complex(c_double_complex) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_double_complex),target :: csrSortedValB integer(c_int),target :: csrSortedRowPtrB integer(c_int),target :: csrSortedColIndB type(c_ptr) :: descrC complex(c_double_complex),target :: csrSortedValC integer(c_int),target :: csrSortedRowPtrC integer(c_int),target :: csrSortedColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsrgeam2_bufferSizeExt_rank_0 = hipsparseZcsrgeam2_bufferSizeExt_(handle,m,n, & alpha,descrA,nnzA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & beta,descrB,nnzB,c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB), & descrC,c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC), & pBufferSizeInBytes) end function function hipsparseZcsrgeam2_bufferSizeExt_rank_1(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgeam2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_double_complex) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_double_complex),target,dimension(:) :: csrSortedValB integer(c_int),target,dimension(:) :: csrSortedRowPtrB integer(c_int),target,dimension(:) :: csrSortedColIndB type(c_ptr) :: descrC complex(c_double_complex),target,dimension(:) :: csrSortedValC integer(c_int),target,dimension(:) :: csrSortedRowPtrC integer(c_int),target,dimension(:) :: csrSortedColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsrgeam2_bufferSizeExt_rank_1 = hipsparseZcsrgeam2_bufferSizeExt_(handle,m,n, & alpha,descrA,nnzA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA), & beta,descrB,nnzB,c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB), & descrC,c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC), & pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseXcsrgeam2Nnz_assumed_rank(handle,m,n,descrA,nnzA,csrSortedRowPtrA, & csrSortedColIndA,descrB,nnzB,csrSortedRowPtrB,csrSortedColIndB,descrC,csrSortedRowPtrC, & nnzTotalDevHostPtr,workspace) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrgeam2Nnz_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndB type(c_ptr) :: descrC integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: workspace ! hipsparseXcsrgeam2Nnz_assumed_rank = hipsparseXcsrgeam2Nnz_(handle,m,n,descrA,nnzA, & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),descrB,nnzB,c_loc(csrSortedRowPtrB), & c_loc(csrSortedColIndB),descrC,c_loc(csrSortedRowPtrC),nnzTotalDevHostPtr,workspace) end function #else function hipsparseXcsrgeam2Nnz_rank_0(handle,m,n,descrA,nnzA,csrSortedRowPtrA, & csrSortedColIndA,descrB,nnzB,csrSortedRowPtrB,csrSortedColIndB,descrC,csrSortedRowPtrC, & nnzTotalDevHostPtr,workspace) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrgeam2Nnz_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target :: csrSortedRowPtrB integer(c_int),target :: csrSortedColIndB type(c_ptr) :: descrC integer(c_int),target :: csrSortedRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: workspace ! hipsparseXcsrgeam2Nnz_rank_0 = hipsparseXcsrgeam2Nnz_(handle,m,n,descrA,nnzA, & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),descrB,nnzB,c_loc(csrSortedRowPtrB), & c_loc(csrSortedColIndB),descrC,c_loc(csrSortedRowPtrC),nnzTotalDevHostPtr,workspace) end function function hipsparseXcsrgeam2Nnz_rank_1(handle,m,n,descrA,nnzA,csrSortedRowPtrA, & csrSortedColIndA,descrB,nnzB,csrSortedRowPtrB,csrSortedColIndB,descrC,csrSortedRowPtrC, & nnzTotalDevHostPtr,workspace) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrgeam2Nnz_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target,dimension(:) :: csrSortedRowPtrB integer(c_int),target,dimension(:) :: csrSortedColIndB type(c_ptr) :: descrC integer(c_int),target,dimension(:) :: csrSortedRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: workspace ! hipsparseXcsrgeam2Nnz_rank_1 = hipsparseXcsrgeam2Nnz_(handle,m,n,descrA,nnzA, & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),descrB,nnzB,c_loc(csrSortedRowPtrB), & c_loc(csrSortedColIndB),descrC,c_loc(csrSortedRowPtrC),nnzTotalDevHostPtr,workspace) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrgeam2_assumed_rank(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgeam2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA real(c_float) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_float),target,contiguous,dimension(..) :: csrSortedValB integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndB type(c_ptr) :: descrC real(c_float),target,contiguous,dimension(..) :: csrSortedValC integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndC type(c_ptr) :: pBuffer ! hipsparseScsrgeam2_assumed_rank = hipsparseScsrgeam2_(handle,m,n,alpha,descrA,nnzA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),beta,descrB,nnzB, & c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB),descrC, & c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC),pBuffer) end function #else function hipsparseScsrgeam2_rank_0(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgeam2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA real(c_float) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_float),target :: csrSortedValB integer(c_int),target :: csrSortedRowPtrB integer(c_int),target :: csrSortedColIndB type(c_ptr) :: descrC real(c_float),target :: csrSortedValC integer(c_int),target :: csrSortedRowPtrC integer(c_int),target :: csrSortedColIndC type(c_ptr) :: pBuffer ! hipsparseScsrgeam2_rank_0 = hipsparseScsrgeam2_(handle,m,n,alpha,descrA,nnzA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),beta,descrB,nnzB, & c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB),descrC, & c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC),pBuffer) end function function hipsparseScsrgeam2_rank_1(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgeam2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_float) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_float),target,dimension(:) :: csrSortedValB integer(c_int),target,dimension(:) :: csrSortedRowPtrB integer(c_int),target,dimension(:) :: csrSortedColIndB type(c_ptr) :: descrC real(c_float),target,dimension(:) :: csrSortedValC integer(c_int),target,dimension(:) :: csrSortedRowPtrC integer(c_int),target,dimension(:) :: csrSortedColIndC type(c_ptr) :: pBuffer ! hipsparseScsrgeam2_rank_1 = hipsparseScsrgeam2_(handle,m,n,alpha,descrA,nnzA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),beta,descrB,nnzB, & c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB),descrC, & c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC),pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrgeam2_assumed_rank(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgeam2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA real(c_double) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_double),target,contiguous,dimension(..) :: csrSortedValB integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndB type(c_ptr) :: descrC real(c_double),target,contiguous,dimension(..) :: csrSortedValC integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndC type(c_ptr) :: pBuffer ! hipsparseDcsrgeam2_assumed_rank = hipsparseDcsrgeam2_(handle,m,n,alpha,descrA,nnzA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),beta,descrB,nnzB, & c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB),descrC, & c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC),pBuffer) end function #else function hipsparseDcsrgeam2_rank_0(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgeam2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA real(c_double) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_double),target :: csrSortedValB integer(c_int),target :: csrSortedRowPtrB integer(c_int),target :: csrSortedColIndB type(c_ptr) :: descrC real(c_double),target :: csrSortedValC integer(c_int),target :: csrSortedRowPtrC integer(c_int),target :: csrSortedColIndC type(c_ptr) :: pBuffer ! hipsparseDcsrgeam2_rank_0 = hipsparseDcsrgeam2_(handle,m,n,alpha,descrA,nnzA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),beta,descrB,nnzB, & c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB),descrC, & c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC),pBuffer) end function function hipsparseDcsrgeam2_rank_1(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgeam2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA real(c_double) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_double),target,dimension(:) :: csrSortedValB integer(c_int),target,dimension(:) :: csrSortedRowPtrB integer(c_int),target,dimension(:) :: csrSortedColIndB type(c_ptr) :: descrC real(c_double),target,dimension(:) :: csrSortedValC integer(c_int),target,dimension(:) :: csrSortedRowPtrC integer(c_int),target,dimension(:) :: csrSortedColIndC type(c_ptr) :: pBuffer ! hipsparseDcsrgeam2_rank_1 = hipsparseDcsrgeam2_(handle,m,n,alpha,descrA,nnzA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),beta,descrB,nnzB, & c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB),descrC, & c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC),pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrgeam2_assumed_rank(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgeam2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA complex(c_float_complex) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValB integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndB type(c_ptr) :: descrC complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValC integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndC type(c_ptr) :: pBuffer ! hipsparseCcsrgeam2_assumed_rank = hipsparseCcsrgeam2_(handle,m,n,alpha,descrA,nnzA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),beta,descrB,nnzB, & c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB),descrC, & c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC),pBuffer) end function #else function hipsparseCcsrgeam2_rank_0(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgeam2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA complex(c_float_complex) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_float_complex),target :: csrSortedValB integer(c_int),target :: csrSortedRowPtrB integer(c_int),target :: csrSortedColIndB type(c_ptr) :: descrC complex(c_float_complex),target :: csrSortedValC integer(c_int),target :: csrSortedRowPtrC integer(c_int),target :: csrSortedColIndC type(c_ptr) :: pBuffer ! hipsparseCcsrgeam2_rank_0 = hipsparseCcsrgeam2_(handle,m,n,alpha,descrA,nnzA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),beta,descrB,nnzB, & c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB),descrC, & c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC),pBuffer) end function function hipsparseCcsrgeam2_rank_1(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgeam2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_float_complex) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_float_complex),target,dimension(:) :: csrSortedValB integer(c_int),target,dimension(:) :: csrSortedRowPtrB integer(c_int),target,dimension(:) :: csrSortedColIndB type(c_ptr) :: descrC complex(c_float_complex),target,dimension(:) :: csrSortedValC integer(c_int),target,dimension(:) :: csrSortedRowPtrC integer(c_int),target,dimension(:) :: csrSortedColIndC type(c_ptr) :: pBuffer ! hipsparseCcsrgeam2_rank_1 = hipsparseCcsrgeam2_(handle,m,n,alpha,descrA,nnzA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),beta,descrB,nnzB, & c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB),descrC, & c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC),pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrgeam2_assumed_rank(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgeam2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA complex(c_double_complex) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValB integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndB type(c_ptr) :: descrC complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValC integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndC type(c_ptr) :: pBuffer ! hipsparseZcsrgeam2_assumed_rank = hipsparseZcsrgeam2_(handle,m,n,alpha,descrA,nnzA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),beta,descrB,nnzB, & c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB),descrC, & c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC),pBuffer) end function #else function hipsparseZcsrgeam2_rank_0(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgeam2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA complex(c_double_complex) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_double_complex),target :: csrSortedValB integer(c_int),target :: csrSortedRowPtrB integer(c_int),target :: csrSortedColIndB type(c_ptr) :: descrC complex(c_double_complex),target :: csrSortedValC integer(c_int),target :: csrSortedRowPtrC integer(c_int),target :: csrSortedColIndC type(c_ptr) :: pBuffer ! hipsparseZcsrgeam2_rank_0 = hipsparseZcsrgeam2_(handle,m,n,alpha,descrA,nnzA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),beta,descrB,nnzB, & c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB),descrC, & c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC),pBuffer) end function function hipsparseZcsrgeam2_rank_1(handle,m,n,alpha,descrA,nnzA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,beta,descrB,nnzB,csrSortedValB,csrSortedRowPtrB, & csrSortedColIndB,descrC,csrSortedValC,csrSortedRowPtrC,csrSortedColIndC,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgeam2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA complex(c_double_complex) :: beta type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_double_complex),target,dimension(:) :: csrSortedValB integer(c_int),target,dimension(:) :: csrSortedRowPtrB integer(c_int),target,dimension(:) :: csrSortedColIndB type(c_ptr) :: descrC complex(c_double_complex),target,dimension(:) :: csrSortedValC integer(c_int),target,dimension(:) :: csrSortedRowPtrC integer(c_int),target,dimension(:) :: csrSortedColIndC type(c_ptr) :: pBuffer ! hipsparseZcsrgeam2_rank_1 = hipsparseZcsrgeam2_(handle,m,n,alpha,descrA,nnzA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),beta,descrB,nnzB, & c_loc(csrSortedValB),c_loc(csrSortedRowPtrB),c_loc(csrSortedColIndB),descrC, & c_loc(csrSortedValC),c_loc(csrSortedRowPtrC),c_loc(csrSortedColIndC),pBuffer) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseXcsrgemmNnz_assumed_rank(handle,transA,transB,m,n,k,descrA,nnzA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrRowPtrB,csrColIndB,descrC,csrRowPtrC,nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrgemmNnz_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target,contiguous,dimension(..) :: csrRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrColIndB type(c_ptr) :: descrC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr ! hipsparseXcsrgemmNnz_assumed_rank = hipsparseXcsrgemmNnz_(handle,transA,transB,m,n,k,descrA, & nnzA,c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB),c_loc(csrColIndB), & descrC,c_loc(csrRowPtrC),nnzTotalDevHostPtr) end function #else function hipsparseXcsrgemmNnz_rank_0(handle,transA,transB,m,n,k,descrA,nnzA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrRowPtrB,csrColIndB,descrC,csrRowPtrC,nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrgemmNnz_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target :: csrRowPtrB integer(c_int),target :: csrColIndB type(c_ptr) :: descrC integer(c_int),target :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr ! hipsparseXcsrgemmNnz_rank_0 = hipsparseXcsrgemmNnz_(handle,transA,transB,m,n,k,descrA,nnzA, & c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB),c_loc(csrColIndB), & descrC,c_loc(csrRowPtrC),nnzTotalDevHostPtr) end function function hipsparseXcsrgemmNnz_rank_1(handle,transA,transB,m,n,k,descrA,nnzA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrRowPtrB,csrColIndB,descrC,csrRowPtrC,nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrgemmNnz_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target,dimension(:) :: csrRowPtrB integer(c_int),target,dimension(:) :: csrColIndB type(c_ptr) :: descrC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr ! hipsparseXcsrgemmNnz_rank_1 = hipsparseXcsrgemmNnz_(handle,transA,transB,m,n,k,descrA,nnzA, & c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB),c_loc(csrColIndB), & descrC,c_loc(csrRowPtrC),nnzTotalDevHostPtr) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrgemm_assumed_rank(handle,transA,transB,m,n,k,descrA,nnzA,csrValA, & csrRowPtrA,csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC, & csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgemm_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_float),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_float),target,contiguous,dimension(..) :: csrValB integer(c_int),target,contiguous,dimension(..) :: csrRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrColIndB type(c_ptr) :: descrC real(c_float),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC ! hipsparseScsrgemm_assumed_rank = hipsparseScsrgemm_(handle,transA,transB,m,n,k,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #else function hipsparseScsrgemm_rank_0(handle,transA,transB,m,n,k,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgemm_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_float),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_float),target :: csrValB integer(c_int),target :: csrRowPtrB integer(c_int),target :: csrColIndB type(c_ptr) :: descrC real(c_float),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC ! hipsparseScsrgemm_rank_0 = hipsparseScsrgemm_(handle,transA,transB,m,n,k,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function function hipsparseScsrgemm_rank_1(handle,transA,transB,m,n,k,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgemm_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_float),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_float),target,dimension(:) :: csrValB integer(c_int),target,dimension(:) :: csrRowPtrB integer(c_int),target,dimension(:) :: csrColIndB type(c_ptr) :: descrC real(c_float),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC ! hipsparseScsrgemm_rank_1 = hipsparseScsrgemm_(handle,transA,transB,m,n,k,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrgemm_assumed_rank(handle,transA,transB,m,n,k,descrA,nnzA,csrValA, & csrRowPtrA,csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC, & csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgemm_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_double),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_double),target,contiguous,dimension(..) :: csrValB integer(c_int),target,contiguous,dimension(..) :: csrRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrColIndB type(c_ptr) :: descrC real(c_double),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC ! hipsparseDcsrgemm_assumed_rank = hipsparseDcsrgemm_(handle,transA,transB,m,n,k,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #else function hipsparseDcsrgemm_rank_0(handle,transA,transB,m,n,k,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgemm_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_double),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_double),target :: csrValB integer(c_int),target :: csrRowPtrB integer(c_int),target :: csrColIndB type(c_ptr) :: descrC real(c_double),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC ! hipsparseDcsrgemm_rank_0 = hipsparseDcsrgemm_(handle,transA,transB,m,n,k,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function function hipsparseDcsrgemm_rank_1(handle,transA,transB,m,n,k,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgemm_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_double),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_double),target,dimension(:) :: csrValB integer(c_int),target,dimension(:) :: csrRowPtrB integer(c_int),target,dimension(:) :: csrColIndB type(c_ptr) :: descrC real(c_double),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC ! hipsparseDcsrgemm_rank_1 = hipsparseDcsrgemm_(handle,transA,transB,m,n,k,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrgemm_assumed_rank(handle,transA,transB,m,n,k,descrA,nnzA,csrValA, & csrRowPtrA,csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC, & csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgemm_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_float_complex),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_float_complex),target,contiguous,dimension(..) :: csrValB integer(c_int),target,contiguous,dimension(..) :: csrRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrColIndB type(c_ptr) :: descrC complex(c_float_complex),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC ! hipsparseCcsrgemm_assumed_rank = hipsparseCcsrgemm_(handle,transA,transB,m,n,k,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #else function hipsparseCcsrgemm_rank_0(handle,transA,transB,m,n,k,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgemm_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_float_complex),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_float_complex),target :: csrValB integer(c_int),target :: csrRowPtrB integer(c_int),target :: csrColIndB type(c_ptr) :: descrC complex(c_float_complex),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC ! hipsparseCcsrgemm_rank_0 = hipsparseCcsrgemm_(handle,transA,transB,m,n,k,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function function hipsparseCcsrgemm_rank_1(handle,transA,transB,m,n,k,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgemm_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_float_complex),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_float_complex),target,dimension(:) :: csrValB integer(c_int),target,dimension(:) :: csrRowPtrB integer(c_int),target,dimension(:) :: csrColIndB type(c_ptr) :: descrC complex(c_float_complex),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC ! hipsparseCcsrgemm_rank_1 = hipsparseCcsrgemm_(handle,transA,transB,m,n,k,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrgemm_assumed_rank(handle,transA,transB,m,n,k,descrA,nnzA,csrValA, & csrRowPtrA,csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC, & csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgemm_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_double_complex),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_double_complex),target,contiguous,dimension(..) :: csrValB integer(c_int),target,contiguous,dimension(..) :: csrRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrColIndB type(c_ptr) :: descrC complex(c_double_complex),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC ! hipsparseZcsrgemm_assumed_rank = hipsparseZcsrgemm_(handle,transA,transB,m,n,k,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #else function hipsparseZcsrgemm_rank_0(handle,transA,transB,m,n,k,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgemm_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_double_complex),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_double_complex),target :: csrValB integer(c_int),target :: csrRowPtrB integer(c_int),target :: csrColIndB type(c_ptr) :: descrC complex(c_double_complex),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC ! hipsparseZcsrgemm_rank_0 = hipsparseZcsrgemm_(handle,transA,transB,m,n,k,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function function hipsparseZcsrgemm_rank_1(handle,transA,transB,m,n,k,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgemm_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transA integer(kind(HIPSPARSE_OPERATION_NON_TRANSPOSE)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_double_complex),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_double_complex),target,dimension(:) :: csrValB integer(c_int),target,dimension(:) :: csrRowPtrB integer(c_int),target,dimension(:) :: csrColIndB type(c_ptr) :: descrC complex(c_double_complex),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC ! hipsparseZcsrgemm_rank_1 = hipsparseZcsrgemm_(handle,transA,transB,m,n,k,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrgemm2_bufferSizeExt_assumed_rank(handle,m,n,k,alpha,descrA,nnzA, & csrRowPtrA,csrColIndA,descrB,nnzB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrRowPtrD, & csrColIndD,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgemm2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target,contiguous,dimension(..) :: csrRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrColIndB real(c_float) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD integer(c_int),target,contiguous,dimension(..) :: csrRowPtrD integer(c_int),target,contiguous,dimension(..) :: csrColIndD type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsrgemm2_bufferSizeExt_assumed_rank = hipsparseScsrgemm2_bufferSizeExt_(handle,m, & n,k,alpha,descrA,nnzA,c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB), & c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrRowPtrD),c_loc(csrColIndD),myInfo, & pBufferSizeInBytes) end function #else function hipsparseScsrgemm2_bufferSizeExt_rank_0(handle,m,n,k,alpha,descrA,nnzA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrRowPtrD,csrColIndD, & myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgemm2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target :: csrRowPtrB integer(c_int),target :: csrColIndB real(c_float) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD integer(c_int),target :: csrRowPtrD integer(c_int),target :: csrColIndD type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsrgemm2_bufferSizeExt_rank_0 = hipsparseScsrgemm2_bufferSizeExt_(handle,m,n,k, & alpha,descrA,nnzA,c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB), & c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrRowPtrD),c_loc(csrColIndD),myInfo, & pBufferSizeInBytes) end function function hipsparseScsrgemm2_bufferSizeExt_rank_1(handle,m,n,k,alpha,descrA,nnzA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrRowPtrD,csrColIndD, & myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgemm2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target,dimension(:) :: csrRowPtrB integer(c_int),target,dimension(:) :: csrColIndB real(c_float) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD integer(c_int),target,dimension(:) :: csrRowPtrD integer(c_int),target,dimension(:) :: csrColIndD type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsrgemm2_bufferSizeExt_rank_1 = hipsparseScsrgemm2_bufferSizeExt_(handle,m,n,k, & alpha,descrA,nnzA,c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB), & c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrRowPtrD),c_loc(csrColIndD),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrgemm2_bufferSizeExt_assumed_rank(handle,m,n,k,alpha,descrA,nnzA, & csrRowPtrA,csrColIndA,descrB,nnzB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrRowPtrD, & csrColIndD,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgemm2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target,contiguous,dimension(..) :: csrRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrColIndB real(c_double) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD integer(c_int),target,contiguous,dimension(..) :: csrRowPtrD integer(c_int),target,contiguous,dimension(..) :: csrColIndD type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsrgemm2_bufferSizeExt_assumed_rank = hipsparseDcsrgemm2_bufferSizeExt_(handle,m, & n,k,alpha,descrA,nnzA,c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB), & c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrRowPtrD),c_loc(csrColIndD),myInfo, & pBufferSizeInBytes) end function #else function hipsparseDcsrgemm2_bufferSizeExt_rank_0(handle,m,n,k,alpha,descrA,nnzA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrRowPtrD,csrColIndD, & myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgemm2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target :: csrRowPtrB integer(c_int),target :: csrColIndB real(c_double) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD integer(c_int),target :: csrRowPtrD integer(c_int),target :: csrColIndD type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsrgemm2_bufferSizeExt_rank_0 = hipsparseDcsrgemm2_bufferSizeExt_(handle,m,n,k, & alpha,descrA,nnzA,c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB), & c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrRowPtrD),c_loc(csrColIndD),myInfo, & pBufferSizeInBytes) end function function hipsparseDcsrgemm2_bufferSizeExt_rank_1(handle,m,n,k,alpha,descrA,nnzA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrRowPtrD,csrColIndD, & myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgemm2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target,dimension(:) :: csrRowPtrB integer(c_int),target,dimension(:) :: csrColIndB real(c_double) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD integer(c_int),target,dimension(:) :: csrRowPtrD integer(c_int),target,dimension(:) :: csrColIndD type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsrgemm2_bufferSizeExt_rank_1 = hipsparseDcsrgemm2_bufferSizeExt_(handle,m,n,k, & alpha,descrA,nnzA,c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB), & c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrRowPtrD),c_loc(csrColIndD),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrgemm2_bufferSizeExt_assumed_rank(handle,m,n,k,alpha,descrA,nnzA, & csrRowPtrA,csrColIndA,descrB,nnzB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrRowPtrD, & csrColIndD,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgemm2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target,contiguous,dimension(..) :: csrRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrColIndB complex(c_float_complex) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD integer(c_int),target,contiguous,dimension(..) :: csrRowPtrD integer(c_int),target,contiguous,dimension(..) :: csrColIndD type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsrgemm2_bufferSizeExt_assumed_rank = hipsparseCcsrgemm2_bufferSizeExt_(handle,m, & n,k,alpha,descrA,nnzA,c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB), & c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrRowPtrD),c_loc(csrColIndD),myInfo, & pBufferSizeInBytes) end function #else function hipsparseCcsrgemm2_bufferSizeExt_rank_0(handle,m,n,k,alpha,descrA,nnzA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrRowPtrD,csrColIndD, & myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgemm2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target :: csrRowPtrB integer(c_int),target :: csrColIndB complex(c_float_complex) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD integer(c_int),target :: csrRowPtrD integer(c_int),target :: csrColIndD type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsrgemm2_bufferSizeExt_rank_0 = hipsparseCcsrgemm2_bufferSizeExt_(handle,m,n,k, & alpha,descrA,nnzA,c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB), & c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrRowPtrD),c_loc(csrColIndD),myInfo, & pBufferSizeInBytes) end function function hipsparseCcsrgemm2_bufferSizeExt_rank_1(handle,m,n,k,alpha,descrA,nnzA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrRowPtrD,csrColIndD, & myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgemm2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target,dimension(:) :: csrRowPtrB integer(c_int),target,dimension(:) :: csrColIndB complex(c_float_complex) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD integer(c_int),target,dimension(:) :: csrRowPtrD integer(c_int),target,dimension(:) :: csrColIndD type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsrgemm2_bufferSizeExt_rank_1 = hipsparseCcsrgemm2_bufferSizeExt_(handle,m,n,k, & alpha,descrA,nnzA,c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB), & c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrRowPtrD),c_loc(csrColIndD),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrgemm2_bufferSizeExt_assumed_rank(handle,m,n,k,alpha,descrA,nnzA, & csrRowPtrA,csrColIndA,descrB,nnzB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrRowPtrD, & csrColIndD,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgemm2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target,contiguous,dimension(..) :: csrRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrColIndB complex(c_double_complex) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD integer(c_int),target,contiguous,dimension(..) :: csrRowPtrD integer(c_int),target,contiguous,dimension(..) :: csrColIndD type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsrgemm2_bufferSizeExt_assumed_rank = hipsparseZcsrgemm2_bufferSizeExt_(handle,m, & n,k,alpha,descrA,nnzA,c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB), & c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrRowPtrD),c_loc(csrColIndD),myInfo, & pBufferSizeInBytes) end function #else function hipsparseZcsrgemm2_bufferSizeExt_rank_0(handle,m,n,k,alpha,descrA,nnzA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrRowPtrD,csrColIndD, & myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgemm2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target :: csrRowPtrB integer(c_int),target :: csrColIndB complex(c_double_complex) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD integer(c_int),target :: csrRowPtrD integer(c_int),target :: csrColIndD type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsrgemm2_bufferSizeExt_rank_0 = hipsparseZcsrgemm2_bufferSizeExt_(handle,m,n,k, & alpha,descrA,nnzA,c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB), & c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrRowPtrD),c_loc(csrColIndD),myInfo, & pBufferSizeInBytes) end function function hipsparseZcsrgemm2_bufferSizeExt_rank_1(handle,m,n,k,alpha,descrA,nnzA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrRowPtrD,csrColIndD, & myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgemm2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target,dimension(:) :: csrRowPtrB integer(c_int),target,dimension(:) :: csrColIndB complex(c_double_complex) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD integer(c_int),target,dimension(:) :: csrRowPtrD integer(c_int),target,dimension(:) :: csrColIndD type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsrgemm2_bufferSizeExt_rank_1 = hipsparseZcsrgemm2_bufferSizeExt_(handle,m,n,k, & alpha,descrA,nnzA,c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB), & c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrRowPtrD),c_loc(csrColIndD),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseXcsrgemm2Nnz_assumed_rank(handle,m,n,k,descrA,nnzA,csrRowPtrA,csrColIndA, & descrB,nnzB,csrRowPtrB,csrColIndB,descrD,nnzD,csrRowPtrD,csrColIndD,descrC,csrRowPtrC, & nnzTotalDevHostPtr,myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrgemm2Nnz_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target,contiguous,dimension(..) :: csrRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrColIndB type(c_ptr) :: descrD integer(c_int) :: nnzD integer(c_int),target,contiguous,dimension(..) :: csrRowPtrD integer(c_int),target,contiguous,dimension(..) :: csrColIndD type(c_ptr) :: descrC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseXcsrgemm2Nnz_assumed_rank = hipsparseXcsrgemm2Nnz_(handle,m,n,k,descrA,nnzA, & c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB),c_loc(csrColIndB), & descrD,nnzD,c_loc(csrRowPtrD),c_loc(csrColIndD),descrC,c_loc(csrRowPtrC), & nnzTotalDevHostPtr,myInfo,pBuffer) end function #else function hipsparseXcsrgemm2Nnz_rank_0(handle,m,n,k,descrA,nnzA,csrRowPtrA,csrColIndA,descrB, & nnzB,csrRowPtrB,csrColIndB,descrD,nnzD,csrRowPtrD,csrColIndD,descrC,csrRowPtrC, & nnzTotalDevHostPtr,myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrgemm2Nnz_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target :: csrRowPtrB integer(c_int),target :: csrColIndB type(c_ptr) :: descrD integer(c_int) :: nnzD integer(c_int),target :: csrRowPtrD integer(c_int),target :: csrColIndD type(c_ptr) :: descrC integer(c_int),target :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseXcsrgemm2Nnz_rank_0 = hipsparseXcsrgemm2Nnz_(handle,m,n,k,descrA,nnzA, & c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB),c_loc(csrColIndB), & descrD,nnzD,c_loc(csrRowPtrD),c_loc(csrColIndD),descrC,c_loc(csrRowPtrC), & nnzTotalDevHostPtr,myInfo,pBuffer) end function function hipsparseXcsrgemm2Nnz_rank_1(handle,m,n,k,descrA,nnzA,csrRowPtrA,csrColIndA,descrB, & nnzB,csrRowPtrB,csrColIndB,descrD,nnzD,csrRowPtrD,csrColIndD,descrC,csrRowPtrC, & nnzTotalDevHostPtr,myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrgemm2Nnz_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descrA integer(c_int) :: nnzA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB integer(c_int),target,dimension(:) :: csrRowPtrB integer(c_int),target,dimension(:) :: csrColIndB type(c_ptr) :: descrD integer(c_int) :: nnzD integer(c_int),target,dimension(:) :: csrRowPtrD integer(c_int),target,dimension(:) :: csrColIndD type(c_ptr) :: descrC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseXcsrgemm2Nnz_rank_1 = hipsparseXcsrgemm2Nnz_(handle,m,n,k,descrA,nnzA, & c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrRowPtrB),c_loc(csrColIndB), & descrD,nnzD,c_loc(csrRowPtrD),c_loc(csrColIndD),descrC,c_loc(csrRowPtrC), & nnzTotalDevHostPtr,myInfo,pBuffer) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrgemm2_assumed_rank(handle,m,n,k,alpha,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrValD,csrRowPtrD, & csrColIndD,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgemm2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_float),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_float),target,contiguous,dimension(..) :: csrValB integer(c_int),target,contiguous,dimension(..) :: csrRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrColIndB real(c_float) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD real(c_float),target,contiguous,dimension(..) :: csrValD integer(c_int),target,contiguous,dimension(..) :: csrRowPtrD integer(c_int),target,contiguous,dimension(..) :: csrColIndD type(c_ptr) :: descrC real(c_float),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseScsrgemm2_assumed_rank = hipsparseScsrgemm2_(handle,m,n,k,alpha,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrValD),c_loc(csrRowPtrD), & c_loc(csrColIndD),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),myInfo,pBuffer) end function #else function hipsparseScsrgemm2_rank_0(handle,m,n,k,alpha,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrValD,csrRowPtrD, & csrColIndD,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgemm2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_float),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_float),target :: csrValB integer(c_int),target :: csrRowPtrB integer(c_int),target :: csrColIndB real(c_float) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD real(c_float),target :: csrValD integer(c_int),target :: csrRowPtrD integer(c_int),target :: csrColIndD type(c_ptr) :: descrC real(c_float),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseScsrgemm2_rank_0 = hipsparseScsrgemm2_(handle,m,n,k,alpha,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrValD),c_loc(csrRowPtrD), & c_loc(csrColIndD),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),myInfo,pBuffer) end function function hipsparseScsrgemm2_rank_1(handle,m,n,k,alpha,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrValD,csrRowPtrD, & csrColIndD,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrgemm2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_float),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_float),target,dimension(:) :: csrValB integer(c_int),target,dimension(:) :: csrRowPtrB integer(c_int),target,dimension(:) :: csrColIndB real(c_float) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD real(c_float),target,dimension(:) :: csrValD integer(c_int),target,dimension(:) :: csrRowPtrD integer(c_int),target,dimension(:) :: csrColIndD type(c_ptr) :: descrC real(c_float),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseScsrgemm2_rank_1 = hipsparseScsrgemm2_(handle,m,n,k,alpha,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrValD),c_loc(csrRowPtrD), & c_loc(csrColIndD),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),myInfo,pBuffer) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrgemm2_assumed_rank(handle,m,n,k,alpha,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrValD,csrRowPtrD, & csrColIndD,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgemm2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_double),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_double),target,contiguous,dimension(..) :: csrValB integer(c_int),target,contiguous,dimension(..) :: csrRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrColIndB real(c_double) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD real(c_double),target,contiguous,dimension(..) :: csrValD integer(c_int),target,contiguous,dimension(..) :: csrRowPtrD integer(c_int),target,contiguous,dimension(..) :: csrColIndD type(c_ptr) :: descrC real(c_double),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseDcsrgemm2_assumed_rank = hipsparseDcsrgemm2_(handle,m,n,k,alpha,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrValD),c_loc(csrRowPtrD), & c_loc(csrColIndD),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),myInfo,pBuffer) end function #else function hipsparseDcsrgemm2_rank_0(handle,m,n,k,alpha,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrValD,csrRowPtrD, & csrColIndD,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgemm2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_double),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_double),target :: csrValB integer(c_int),target :: csrRowPtrB integer(c_int),target :: csrColIndB real(c_double) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD real(c_double),target :: csrValD integer(c_int),target :: csrRowPtrD integer(c_int),target :: csrColIndD type(c_ptr) :: descrC real(c_double),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseDcsrgemm2_rank_0 = hipsparseDcsrgemm2_(handle,m,n,k,alpha,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrValD),c_loc(csrRowPtrD), & c_loc(csrColIndD),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),myInfo,pBuffer) end function function hipsparseDcsrgemm2_rank_1(handle,m,n,k,alpha,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrValD,csrRowPtrD, & csrColIndD,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrgemm2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA real(c_double),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB real(c_double),target,dimension(:) :: csrValB integer(c_int),target,dimension(:) :: csrRowPtrB integer(c_int),target,dimension(:) :: csrColIndB real(c_double) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD real(c_double),target,dimension(:) :: csrValD integer(c_int),target,dimension(:) :: csrRowPtrD integer(c_int),target,dimension(:) :: csrColIndD type(c_ptr) :: descrC real(c_double),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseDcsrgemm2_rank_1 = hipsparseDcsrgemm2_(handle,m,n,k,alpha,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrValD),c_loc(csrRowPtrD), & c_loc(csrColIndD),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),myInfo,pBuffer) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrgemm2_assumed_rank(handle,m,n,k,alpha,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrValD,csrRowPtrD, & csrColIndD,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgemm2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_float_complex),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_float_complex),target,contiguous,dimension(..) :: csrValB integer(c_int),target,contiguous,dimension(..) :: csrRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrColIndB complex(c_float_complex) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD complex(c_float_complex),target,contiguous,dimension(..) :: csrValD integer(c_int),target,contiguous,dimension(..) :: csrRowPtrD integer(c_int),target,contiguous,dimension(..) :: csrColIndD type(c_ptr) :: descrC complex(c_float_complex),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseCcsrgemm2_assumed_rank = hipsparseCcsrgemm2_(handle,m,n,k,alpha,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrValD),c_loc(csrRowPtrD), & c_loc(csrColIndD),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),myInfo,pBuffer) end function #else function hipsparseCcsrgemm2_rank_0(handle,m,n,k,alpha,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrValD,csrRowPtrD, & csrColIndD,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgemm2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_float_complex),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_float_complex),target :: csrValB integer(c_int),target :: csrRowPtrB integer(c_int),target :: csrColIndB complex(c_float_complex) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD complex(c_float_complex),target :: csrValD integer(c_int),target :: csrRowPtrD integer(c_int),target :: csrColIndD type(c_ptr) :: descrC complex(c_float_complex),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseCcsrgemm2_rank_0 = hipsparseCcsrgemm2_(handle,m,n,k,alpha,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrValD),c_loc(csrRowPtrD), & c_loc(csrColIndD),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),myInfo,pBuffer) end function function hipsparseCcsrgemm2_rank_1(handle,m,n,k,alpha,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrValD,csrRowPtrD, & csrColIndD,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrgemm2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_float_complex),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_float_complex),target,dimension(:) :: csrValB integer(c_int),target,dimension(:) :: csrRowPtrB integer(c_int),target,dimension(:) :: csrColIndB complex(c_float_complex) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD complex(c_float_complex),target,dimension(:) :: csrValD integer(c_int),target,dimension(:) :: csrRowPtrD integer(c_int),target,dimension(:) :: csrColIndD type(c_ptr) :: descrC complex(c_float_complex),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseCcsrgemm2_rank_1 = hipsparseCcsrgemm2_(handle,m,n,k,alpha,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrValD),c_loc(csrRowPtrD), & c_loc(csrColIndD),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),myInfo,pBuffer) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrgemm2_assumed_rank(handle,m,n,k,alpha,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrValD,csrRowPtrD, & csrColIndD,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgemm2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_double_complex),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_double_complex),target,contiguous,dimension(..) :: csrValB integer(c_int),target,contiguous,dimension(..) :: csrRowPtrB integer(c_int),target,contiguous,dimension(..) :: csrColIndB complex(c_double_complex) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD complex(c_double_complex),target,contiguous,dimension(..) :: csrValD integer(c_int),target,contiguous,dimension(..) :: csrRowPtrD integer(c_int),target,contiguous,dimension(..) :: csrColIndD type(c_ptr) :: descrC complex(c_double_complex),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseZcsrgemm2_assumed_rank = hipsparseZcsrgemm2_(handle,m,n,k,alpha,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrValD),c_loc(csrRowPtrD), & c_loc(csrColIndD),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),myInfo,pBuffer) end function #else function hipsparseZcsrgemm2_rank_0(handle,m,n,k,alpha,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrValD,csrRowPtrD, & csrColIndD,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgemm2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_double_complex),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_double_complex),target :: csrValB integer(c_int),target :: csrRowPtrB integer(c_int),target :: csrColIndB complex(c_double_complex) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD complex(c_double_complex),target :: csrValD integer(c_int),target :: csrRowPtrD integer(c_int),target :: csrColIndD type(c_ptr) :: descrC complex(c_double_complex),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseZcsrgemm2_rank_0 = hipsparseZcsrgemm2_(handle,m,n,k,alpha,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrValD),c_loc(csrRowPtrD), & c_loc(csrColIndD),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),myInfo,pBuffer) end function function hipsparseZcsrgemm2_rank_1(handle,m,n,k,alpha,descrA,nnzA,csrValA,csrRowPtrA, & csrColIndA,descrB,nnzB,csrValB,csrRowPtrB,csrColIndB,beta,descrD,nnzD,csrValD,csrRowPtrD, & csrColIndD,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrgemm2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha type(c_ptr) :: descrA integer(c_int) :: nnzA complex(c_double_complex),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA type(c_ptr) :: descrB integer(c_int) :: nnzB complex(c_double_complex),target,dimension(:) :: csrValB integer(c_int),target,dimension(:) :: csrRowPtrB integer(c_int),target,dimension(:) :: csrColIndB complex(c_double_complex) :: beta type(c_ptr) :: descrD integer(c_int) :: nnzD complex(c_double_complex),target,dimension(:) :: csrValD integer(c_int),target,dimension(:) :: csrRowPtrD integer(c_int),target,dimension(:) :: csrColIndD type(c_ptr) :: descrC complex(c_double_complex),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseZcsrgemm2_rank_1 = hipsparseZcsrgemm2_(handle,m,n,k,alpha,descrA,nnzA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),descrB,nnzB,c_loc(csrValB), & c_loc(csrRowPtrB),c_loc(csrColIndB),beta,descrD,nnzD,c_loc(csrValD),c_loc(csrRowPtrD), & c_loc(csrColIndD),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),myInfo,pBuffer) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSbsric02_bufferSize_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsric02_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseSbsric02_bufferSize_assumed_rank = hipsparseSbsric02_bufferSize_(handle,dirA,mb, & nnzb,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo, & pBufferSizeInBytes) end function #else function hipsparseSbsric02_bufferSize_rank_0(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsric02_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseSbsric02_bufferSize_rank_0 = hipsparseSbsric02_bufferSize_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo, & pBufferSizeInBytes) end function function hipsparseSbsric02_bufferSize_rank_1(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsric02_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseSbsric02_bufferSize_rank_1 = hipsparseSbsric02_bufferSize_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo, & pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDbsric02_bufferSize_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsric02_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDbsric02_bufferSize_assumed_rank = hipsparseDbsric02_bufferSize_(handle,dirA,mb, & nnzb,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo, & pBufferSizeInBytes) end function #else function hipsparseDbsric02_bufferSize_rank_0(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsric02_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDbsric02_bufferSize_rank_0 = hipsparseDbsric02_bufferSize_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo, & pBufferSizeInBytes) end function function hipsparseDbsric02_bufferSize_rank_1(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsric02_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDbsric02_bufferSize_rank_1 = hipsparseDbsric02_bufferSize_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo, & pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCbsric02_bufferSize_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsric02_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCbsric02_bufferSize_assumed_rank = hipsparseCbsric02_bufferSize_(handle,dirA,mb, & nnzb,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo, & pBufferSizeInBytes) end function #else function hipsparseCbsric02_bufferSize_rank_0(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsric02_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCbsric02_bufferSize_rank_0 = hipsparseCbsric02_bufferSize_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo, & pBufferSizeInBytes) end function function hipsparseCbsric02_bufferSize_rank_1(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsric02_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCbsric02_bufferSize_rank_1 = hipsparseCbsric02_bufferSize_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo, & pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZbsric02_bufferSize_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsric02_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZbsric02_bufferSize_assumed_rank = hipsparseZbsric02_bufferSize_(handle,dirA,mb, & nnzb,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo, & pBufferSizeInBytes) end function #else function hipsparseZbsric02_bufferSize_rank_0(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsric02_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZbsric02_bufferSize_rank_0 = hipsparseZbsric02_bufferSize_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo, & pBufferSizeInBytes) end function function hipsparseZbsric02_bufferSize_rank_1(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsric02_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZbsric02_bufferSize_rank_1 = hipsparseZbsric02_bufferSize_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo, & pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSbsric02_analysis_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsric02_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsric02_analysis_assumed_rank = hipsparseSbsric02_analysis_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function #else function hipsparseSbsric02_analysis_rank_0(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsric02_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsric02_analysis_rank_0 = hipsparseSbsric02_analysis_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function function hipsparseSbsric02_analysis_rank_1(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsric02_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsric02_analysis_rank_1 = hipsparseSbsric02_analysis_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDbsric02_analysis_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsric02_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsric02_analysis_assumed_rank = hipsparseDbsric02_analysis_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function #else function hipsparseDbsric02_analysis_rank_0(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsric02_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsric02_analysis_rank_0 = hipsparseDbsric02_analysis_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function function hipsparseDbsric02_analysis_rank_1(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsric02_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsric02_analysis_rank_1 = hipsparseDbsric02_analysis_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCbsric02_analysis_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsric02_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsric02_analysis_assumed_rank = hipsparseCbsric02_analysis_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function #else function hipsparseCbsric02_analysis_rank_0(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsric02_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsric02_analysis_rank_0 = hipsparseCbsric02_analysis_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function function hipsparseCbsric02_analysis_rank_1(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsric02_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsric02_analysis_rank_1 = hipsparseCbsric02_analysis_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZbsric02_analysis_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsric02_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsric02_analysis_assumed_rank = hipsparseZbsric02_analysis_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function #else function hipsparseZbsric02_analysis_rank_0(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsric02_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsric02_analysis_rank_0 = hipsparseZbsric02_analysis_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function function hipsparseZbsric02_analysis_rank_1(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsric02_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsric02_analysis_rank_1 = hipsparseZbsric02_analysis_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSbsric02_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsric02_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsric02_assumed_rank = hipsparseSbsric02_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function #else function hipsparseSbsric02_rank_0(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsric02_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsric02_rank_0 = hipsparseSbsric02_(handle,dirA,mb,nnzb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function function hipsparseSbsric02_rank_1(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsric02_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsric02_rank_1 = hipsparseSbsric02_(handle,dirA,mb,nnzb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDbsric02_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsric02_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsric02_assumed_rank = hipsparseDbsric02_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function #else function hipsparseDbsric02_rank_0(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsric02_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsric02_rank_0 = hipsparseDbsric02_(handle,dirA,mb,nnzb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function function hipsparseDbsric02_rank_1(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsric02_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsric02_rank_1 = hipsparseDbsric02_(handle,dirA,mb,nnzb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCbsric02_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsric02_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsric02_assumed_rank = hipsparseCbsric02_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function #else function hipsparseCbsric02_rank_0(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsric02_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsric02_rank_0 = hipsparseCbsric02_(handle,dirA,mb,nnzb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function function hipsparseCbsric02_rank_1(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsric02_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsric02_rank_1 = hipsparseCbsric02_(handle,dirA,mb,nnzb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZbsric02_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsric02_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsric02_assumed_rank = hipsparseZbsric02_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function #else function hipsparseZbsric02_rank_0(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsric02_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsric02_rank_0 = hipsparseZbsric02_(handle,dirA,mb,nnzb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function function hipsparseZbsric02_rank_1(handle,dirA,mb,nnzb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsric02_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsric02_rank_1 = hipsparseZbsric02_(handle,dirA,mb,nnzb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSbsrilu02_bufferSize_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrilu02_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseSbsrilu02_bufferSize_assumed_rank = hipsparseSbsrilu02_bufferSize_(handle,dirA,mb, & nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function #else function hipsparseSbsrilu02_bufferSize_rank_0(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrilu02_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseSbsrilu02_bufferSize_rank_0 = hipsparseSbsrilu02_bufferSize_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function function hipsparseSbsrilu02_bufferSize_rank_1(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrilu02_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseSbsrilu02_bufferSize_rank_1 = hipsparseSbsrilu02_bufferSize_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDbsrilu02_bufferSize_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrilu02_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDbsrilu02_bufferSize_assumed_rank = hipsparseDbsrilu02_bufferSize_(handle,dirA,mb, & nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function #else function hipsparseDbsrilu02_bufferSize_rank_0(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrilu02_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDbsrilu02_bufferSize_rank_0 = hipsparseDbsrilu02_bufferSize_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function function hipsparseDbsrilu02_bufferSize_rank_1(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrilu02_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDbsrilu02_bufferSize_rank_1 = hipsparseDbsrilu02_bufferSize_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCbsrilu02_bufferSize_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrilu02_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCbsrilu02_bufferSize_assumed_rank = hipsparseCbsrilu02_bufferSize_(handle,dirA,mb, & nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function #else function hipsparseCbsrilu02_bufferSize_rank_0(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrilu02_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCbsrilu02_bufferSize_rank_0 = hipsparseCbsrilu02_bufferSize_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function function hipsparseCbsrilu02_bufferSize_rank_1(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrilu02_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCbsrilu02_bufferSize_rank_1 = hipsparseCbsrilu02_bufferSize_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZbsrilu02_bufferSize_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrilu02_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZbsrilu02_bufferSize_assumed_rank = hipsparseZbsrilu02_bufferSize_(handle,dirA,mb, & nnzb,descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function #else function hipsparseZbsrilu02_bufferSize_rank_0(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrilu02_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZbsrilu02_bufferSize_rank_0 = hipsparseZbsrilu02_bufferSize_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function function hipsparseZbsrilu02_bufferSize_rank_1(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrilu02_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZbsrilu02_bufferSize_rank_1 = hipsparseZbsrilu02_bufferSize_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSbsrilu02_analysis_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrilu02_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsrilu02_analysis_assumed_rank = hipsparseSbsrilu02_analysis_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function #else function hipsparseSbsrilu02_analysis_rank_0(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrilu02_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsrilu02_analysis_rank_0 = hipsparseSbsrilu02_analysis_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function function hipsparseSbsrilu02_analysis_rank_1(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrilu02_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsrilu02_analysis_rank_1 = hipsparseSbsrilu02_analysis_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDbsrilu02_analysis_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrilu02_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsrilu02_analysis_assumed_rank = hipsparseDbsrilu02_analysis_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function #else function hipsparseDbsrilu02_analysis_rank_0(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrilu02_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsrilu02_analysis_rank_0 = hipsparseDbsrilu02_analysis_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function function hipsparseDbsrilu02_analysis_rank_1(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrilu02_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsrilu02_analysis_rank_1 = hipsparseDbsrilu02_analysis_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCbsrilu02_analysis_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrilu02_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsrilu02_analysis_assumed_rank = hipsparseCbsrilu02_analysis_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function #else function hipsparseCbsrilu02_analysis_rank_0(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrilu02_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsrilu02_analysis_rank_0 = hipsparseCbsrilu02_analysis_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function function hipsparseCbsrilu02_analysis_rank_1(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrilu02_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsrilu02_analysis_rank_1 = hipsparseCbsrilu02_analysis_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZbsrilu02_analysis_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrilu02_analysis_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: bsrSortedValA integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsrilu02_analysis_assumed_rank = hipsparseZbsrilu02_analysis_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function #else function hipsparseZbsrilu02_analysis_rank_0(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrilu02_analysis_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target :: bsrSortedValA integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsrilu02_analysis_rank_0 = hipsparseZbsrilu02_analysis_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function function hipsparseZbsrilu02_analysis_rank_1(handle,dirA,mb,nnzb,descrA,bsrSortedValA, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrilu02_analysis_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrSortedValA integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsrilu02_analysis_rank_1 = hipsparseZbsrilu02_analysis_(handle,dirA,mb,nnzb, & descrA,c_loc(bsrSortedValA),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim, & myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSbsrilu02_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrilu02_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: bsrSortedValA_valM integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsrilu02_assumed_rank = hipsparseSbsrilu02_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrSortedValA_valM),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,myInfo, & policy,pBuffer) end function #else function hipsparseSbsrilu02_rank_0(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrilu02_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target :: bsrSortedValA_valM integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsrilu02_rank_0 = hipsparseSbsrilu02_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrSortedValA_valM),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,myInfo, & policy,pBuffer) end function function hipsparseSbsrilu02_rank_1(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsrilu02_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrSortedValA_valM integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseSbsrilu02_rank_1 = hipsparseSbsrilu02_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrSortedValA_valM),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,myInfo, & policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDbsrilu02_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrilu02_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: bsrSortedValA_valM integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsrilu02_assumed_rank = hipsparseDbsrilu02_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrSortedValA_valM),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,myInfo, & policy,pBuffer) end function #else function hipsparseDbsrilu02_rank_0(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrilu02_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target :: bsrSortedValA_valM integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsrilu02_rank_0 = hipsparseDbsrilu02_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrSortedValA_valM),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,myInfo, & policy,pBuffer) end function function hipsparseDbsrilu02_rank_1(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsrilu02_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrSortedValA_valM integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDbsrilu02_rank_1 = hipsparseDbsrilu02_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrSortedValA_valM),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,myInfo, & policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCbsrilu02_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrilu02_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: bsrSortedValA_valM integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsrilu02_assumed_rank = hipsparseCbsrilu02_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrSortedValA_valM),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,myInfo, & policy,pBuffer) end function #else function hipsparseCbsrilu02_rank_0(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrilu02_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target :: bsrSortedValA_valM integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsrilu02_rank_0 = hipsparseCbsrilu02_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrSortedValA_valM),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,myInfo, & policy,pBuffer) end function function hipsparseCbsrilu02_rank_1(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsrilu02_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrSortedValA_valM integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCbsrilu02_rank_1 = hipsparseCbsrilu02_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrSortedValA_valM),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,myInfo, & policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZbsrilu02_assumed_rank(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrilu02_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: bsrSortedValA_valM integer(c_int),target,contiguous,dimension(..) :: bsrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsrilu02_assumed_rank = hipsparseZbsrilu02_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrSortedValA_valM),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,myInfo, & policy,pBuffer) end function #else function hipsparseZbsrilu02_rank_0(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrilu02_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target :: bsrSortedValA_valM integer(c_int),target :: bsrSortedRowPtrA integer(c_int),target :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsrilu02_rank_0 = hipsparseZbsrilu02_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrSortedValA_valM),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,myInfo, & policy,pBuffer) end function function hipsparseZbsrilu02_rank_1(handle,dirA,mb,nnzb,descrA,bsrSortedValA_valM, & bsrSortedRowPtrA,bsrSortedColIndA,blockDim,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsrilu02_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrSortedValA_valM integer(c_int),target,dimension(:) :: bsrSortedRowPtrA integer(c_int),target,dimension(:) :: bsrSortedColIndA integer(c_int) :: blockDim type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZbsrilu02_rank_1 = hipsparseZbsrilu02_(handle,dirA,mb,nnzb,descrA, & c_loc(bsrSortedValA_valM),c_loc(bsrSortedRowPtrA),c_loc(bsrSortedColIndA),blockDim,myInfo, & policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsric02_bufferSize_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsric02_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseScsric02_bufferSize_assumed_rank = hipsparseScsric02_bufferSize_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseScsric02_bufferSize_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsric02_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseScsric02_bufferSize_rank_0 = hipsparseScsric02_bufferSize_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseScsric02_bufferSize_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsric02_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseScsric02_bufferSize_rank_1 = hipsparseScsric02_bufferSize_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsric02_bufferSize_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsric02_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDcsric02_bufferSize_assumed_rank = hipsparseDcsric02_bufferSize_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseDcsric02_bufferSize_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsric02_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDcsric02_bufferSize_rank_0 = hipsparseDcsric02_bufferSize_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseDcsric02_bufferSize_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsric02_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDcsric02_bufferSize_rank_1 = hipsparseDcsric02_bufferSize_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsric02_bufferSize_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsric02_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCcsric02_bufferSize_assumed_rank = hipsparseCcsric02_bufferSize_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseCcsric02_bufferSize_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsric02_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCcsric02_bufferSize_rank_0 = hipsparseCcsric02_bufferSize_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseCcsric02_bufferSize_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsric02_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCcsric02_bufferSize_rank_1 = hipsparseCcsric02_bufferSize_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsric02_bufferSize_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsric02_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZcsric02_bufferSize_assumed_rank = hipsparseZcsric02_bufferSize_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseZcsric02_bufferSize_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsric02_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZcsric02_bufferSize_rank_0 = hipsparseZcsric02_bufferSize_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseZcsric02_bufferSize_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsric02_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZcsric02_bufferSize_rank_1 = hipsparseZcsric02_bufferSize_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsric02_bufferSizeExt_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsric02_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsric02_bufferSizeExt_assumed_rank = hipsparseScsric02_bufferSizeExt_(handle,m, & nnz,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseScsric02_bufferSizeExt_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsric02_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsric02_bufferSizeExt_rank_0 = hipsparseScsric02_bufferSizeExt_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseScsric02_bufferSizeExt_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsric02_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsric02_bufferSizeExt_rank_1 = hipsparseScsric02_bufferSizeExt_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsric02_bufferSizeExt_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsric02_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsric02_bufferSizeExt_assumed_rank = hipsparseDcsric02_bufferSizeExt_(handle,m, & nnz,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseDcsric02_bufferSizeExt_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsric02_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsric02_bufferSizeExt_rank_0 = hipsparseDcsric02_bufferSizeExt_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseDcsric02_bufferSizeExt_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsric02_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsric02_bufferSizeExt_rank_1 = hipsparseDcsric02_bufferSizeExt_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsric02_bufferSizeExt_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsric02_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsric02_bufferSizeExt_assumed_rank = hipsparseCcsric02_bufferSizeExt_(handle,m, & nnz,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseCcsric02_bufferSizeExt_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsric02_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsric02_bufferSizeExt_rank_0 = hipsparseCcsric02_bufferSizeExt_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseCcsric02_bufferSizeExt_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsric02_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsric02_bufferSizeExt_rank_1 = hipsparseCcsric02_bufferSizeExt_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsric02_bufferSizeExt_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsric02_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsric02_bufferSizeExt_assumed_rank = hipsparseZcsric02_bufferSizeExt_(handle,m, & nnz,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseZcsric02_bufferSizeExt_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsric02_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsric02_bufferSizeExt_rank_0 = hipsparseZcsric02_bufferSizeExt_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseZcsric02_bufferSizeExt_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsric02_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsric02_bufferSizeExt_rank_1 = hipsparseZcsric02_bufferSizeExt_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsric02_analysis_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsric02_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsric02_analysis_assumed_rank = hipsparseScsric02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #else function hipsparseScsric02_analysis_rank_0(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsric02_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsric02_analysis_rank_0 = hipsparseScsric02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function function hipsparseScsric02_analysis_rank_1(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsric02_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsric02_analysis_rank_1 = hipsparseScsric02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsric02_analysis_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsric02_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsric02_analysis_assumed_rank = hipsparseDcsric02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #else function hipsparseDcsric02_analysis_rank_0(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsric02_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsric02_analysis_rank_0 = hipsparseDcsric02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function function hipsparseDcsric02_analysis_rank_1(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsric02_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsric02_analysis_rank_1 = hipsparseDcsric02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsric02_analysis_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsric02_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsric02_analysis_assumed_rank = hipsparseCcsric02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #else function hipsparseCcsric02_analysis_rank_0(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsric02_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsric02_analysis_rank_0 = hipsparseCcsric02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function function hipsparseCcsric02_analysis_rank_1(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsric02_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsric02_analysis_rank_1 = hipsparseCcsric02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsric02_analysis_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsric02_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsric02_analysis_assumed_rank = hipsparseZcsric02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #else function hipsparseZcsric02_analysis_rank_0(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsric02_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsric02_analysis_rank_0 = hipsparseZcsric02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function function hipsparseZcsric02_analysis_rank_1(handle,m,nnz,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsric02_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsric02_analysis_rank_1 = hipsparseZcsric02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsric02_assumed_rank(handle,m,nnz,descrA,csrSortedValA_valM, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsric02_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrSortedValA_valM integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsric02_assumed_rank = hipsparseScsric02_(handle,m,nnz,descrA, & c_loc(csrSortedValA_valM),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function #else function hipsparseScsric02_rank_0(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsric02_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target :: csrSortedValA_valM integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsric02_rank_0 = hipsparseScsric02_(handle,m,nnz,descrA,c_loc(csrSortedValA_valM), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function function hipsparseScsric02_rank_1(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsric02_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA_valM integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsric02_rank_1 = hipsparseScsric02_(handle,m,nnz,descrA,c_loc(csrSortedValA_valM), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsric02_assumed_rank(handle,m,nnz,descrA,csrSortedValA_valM, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsric02_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrSortedValA_valM integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsric02_assumed_rank = hipsparseDcsric02_(handle,m,nnz,descrA, & c_loc(csrSortedValA_valM),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function #else function hipsparseDcsric02_rank_0(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsric02_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target :: csrSortedValA_valM integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsric02_rank_0 = hipsparseDcsric02_(handle,m,nnz,descrA,c_loc(csrSortedValA_valM), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function function hipsparseDcsric02_rank_1(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsric02_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA_valM integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsric02_rank_1 = hipsparseDcsric02_(handle,m,nnz,descrA,c_loc(csrSortedValA_valM), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsric02_assumed_rank(handle,m,nnz,descrA,csrSortedValA_valM, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsric02_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA_valM integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsric02_assumed_rank = hipsparseCcsric02_(handle,m,nnz,descrA, & c_loc(csrSortedValA_valM),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function #else function hipsparseCcsric02_rank_0(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsric02_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target :: csrSortedValA_valM integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsric02_rank_0 = hipsparseCcsric02_(handle,m,nnz,descrA,c_loc(csrSortedValA_valM), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function function hipsparseCcsric02_rank_1(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsric02_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA_valM integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsric02_rank_1 = hipsparseCcsric02_(handle,m,nnz,descrA,c_loc(csrSortedValA_valM), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsric02_assumed_rank(handle,m,nnz,descrA,csrSortedValA_valM, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsric02_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA_valM integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsric02_assumed_rank = hipsparseZcsric02_(handle,m,nnz,descrA, & c_loc(csrSortedValA_valM),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function #else function hipsparseZcsric02_rank_0(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsric02_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target :: csrSortedValA_valM integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsric02_rank_0 = hipsparseZcsric02_(handle,m,nnz,descrA,c_loc(csrSortedValA_valM), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function function hipsparseZcsric02_rank_1(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsric02_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA_valM integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsric02_rank_1 = hipsparseZcsric02_(handle,m,nnz,descrA,c_loc(csrSortedValA_valM), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrilu02_bufferSize_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrilu02_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseScsrilu02_bufferSize_assumed_rank = hipsparseScsrilu02_bufferSize_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseScsrilu02_bufferSize_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrilu02_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseScsrilu02_bufferSize_rank_0 = hipsparseScsrilu02_bufferSize_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseScsrilu02_bufferSize_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrilu02_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseScsrilu02_bufferSize_rank_1 = hipsparseScsrilu02_bufferSize_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrilu02_bufferSize_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrilu02_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDcsrilu02_bufferSize_assumed_rank = hipsparseDcsrilu02_bufferSize_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseDcsrilu02_bufferSize_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrilu02_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDcsrilu02_bufferSize_rank_0 = hipsparseDcsrilu02_bufferSize_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseDcsrilu02_bufferSize_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrilu02_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseDcsrilu02_bufferSize_rank_1 = hipsparseDcsrilu02_bufferSize_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrilu02_bufferSize_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrilu02_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCcsrilu02_bufferSize_assumed_rank = hipsparseCcsrilu02_bufferSize_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseCcsrilu02_bufferSize_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrilu02_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCcsrilu02_bufferSize_rank_0 = hipsparseCcsrilu02_bufferSize_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseCcsrilu02_bufferSize_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrilu02_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseCcsrilu02_bufferSize_rank_1 = hipsparseCcsrilu02_bufferSize_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrilu02_bufferSize_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrilu02_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZcsrilu02_bufferSize_assumed_rank = hipsparseZcsrilu02_bufferSize_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseZcsrilu02_bufferSize_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrilu02_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZcsrilu02_bufferSize_rank_0 = hipsparseZcsrilu02_bufferSize_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseZcsrilu02_bufferSize_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrilu02_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_int) :: pBufferSizeInBytes ! hipsparseZcsrilu02_bufferSize_rank_1 = hipsparseZcsrilu02_bufferSize_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrilu02_bufferSizeExt_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrilu02_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsrilu02_bufferSizeExt_assumed_rank = hipsparseScsrilu02_bufferSizeExt_(handle,m, & nnz,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseScsrilu02_bufferSizeExt_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrilu02_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsrilu02_bufferSizeExt_rank_0 = hipsparseScsrilu02_bufferSizeExt_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseScsrilu02_bufferSizeExt_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrilu02_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsrilu02_bufferSizeExt_rank_1 = hipsparseScsrilu02_bufferSizeExt_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrilu02_bufferSizeExt_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrilu02_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsrilu02_bufferSizeExt_assumed_rank = hipsparseDcsrilu02_bufferSizeExt_(handle,m, & nnz,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseDcsrilu02_bufferSizeExt_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrilu02_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsrilu02_bufferSizeExt_rank_0 = hipsparseDcsrilu02_bufferSizeExt_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseDcsrilu02_bufferSizeExt_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrilu02_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsrilu02_bufferSizeExt_rank_1 = hipsparseDcsrilu02_bufferSizeExt_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrilu02_bufferSizeExt_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrilu02_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsrilu02_bufferSizeExt_assumed_rank = hipsparseCcsrilu02_bufferSizeExt_(handle,m, & nnz,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseCcsrilu02_bufferSizeExt_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrilu02_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsrilu02_bufferSizeExt_rank_0 = hipsparseCcsrilu02_bufferSizeExt_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseCcsrilu02_bufferSizeExt_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrilu02_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsrilu02_bufferSizeExt_rank_1 = hipsparseCcsrilu02_bufferSizeExt_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrilu02_bufferSizeExt_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrilu02_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsrilu02_bufferSizeExt_assumed_rank = hipsparseZcsrilu02_bufferSizeExt_(handle,m, & nnz,descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #else function hipsparseZcsrilu02_bufferSizeExt_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrilu02_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsrilu02_bufferSizeExt_rank_0 = hipsparseZcsrilu02_bufferSizeExt_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function function hipsparseZcsrilu02_bufferSizeExt_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrilu02_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsrilu02_bufferSizeExt_rank_1 = hipsparseZcsrilu02_bufferSizeExt_(handle,m,nnz, & descrA,c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo, & pBufferSizeInBytes) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrilu02_analysis_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrilu02_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrilu02_analysis_assumed_rank = hipsparseScsrilu02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #else function hipsparseScsrilu02_analysis_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrilu02_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrilu02_analysis_rank_0 = hipsparseScsrilu02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function function hipsparseScsrilu02_analysis_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrilu02_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrilu02_analysis_rank_1 = hipsparseScsrilu02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrilu02_analysis_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrilu02_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrilu02_analysis_assumed_rank = hipsparseDcsrilu02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #else function hipsparseDcsrilu02_analysis_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrilu02_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrilu02_analysis_rank_0 = hipsparseDcsrilu02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function function hipsparseDcsrilu02_analysis_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrilu02_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrilu02_analysis_rank_1 = hipsparseDcsrilu02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrilu02_analysis_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrilu02_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrilu02_analysis_assumed_rank = hipsparseCcsrilu02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #else function hipsparseCcsrilu02_analysis_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrilu02_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrilu02_analysis_rank_0 = hipsparseCcsrilu02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function function hipsparseCcsrilu02_analysis_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrilu02_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrilu02_analysis_rank_1 = hipsparseCcsrilu02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrilu02_analysis_assumed_rank(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrilu02_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrilu02_analysis_assumed_rank = hipsparseZcsrilu02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #else function hipsparseZcsrilu02_analysis_rank_0(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrilu02_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrilu02_analysis_rank_0 = hipsparseZcsrilu02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function function hipsparseZcsrilu02_analysis_rank_1(handle,m,nnz,descrA,csrSortedValA, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrilu02_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrilu02_analysis_rank_1 = hipsparseZcsrilu02_analysis_(handle,m,nnz,descrA, & c_loc(csrSortedValA),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrilu02_assumed_rank(handle,m,nnz,descrA,csrSortedValA_valM, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrilu02_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrSortedValA_valM integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrilu02_assumed_rank = hipsparseScsrilu02_(handle,m,nnz,descrA, & c_loc(csrSortedValA_valM),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function #else function hipsparseScsrilu02_rank_0(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrilu02_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target :: csrSortedValA_valM integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrilu02_rank_0 = hipsparseScsrilu02_(handle,m,nnz,descrA, & c_loc(csrSortedValA_valM),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function function hipsparseScsrilu02_rank_1(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrilu02_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA_valM integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseScsrilu02_rank_1 = hipsparseScsrilu02_(handle,m,nnz,descrA, & c_loc(csrSortedValA_valM),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrilu02_assumed_rank(handle,m,nnz,descrA,csrSortedValA_valM, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrilu02_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrSortedValA_valM integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrilu02_assumed_rank = hipsparseDcsrilu02_(handle,m,nnz,descrA, & c_loc(csrSortedValA_valM),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function #else function hipsparseDcsrilu02_rank_0(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrilu02_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target :: csrSortedValA_valM integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrilu02_rank_0 = hipsparseDcsrilu02_(handle,m,nnz,descrA, & c_loc(csrSortedValA_valM),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function function hipsparseDcsrilu02_rank_1(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrilu02_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA_valM integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseDcsrilu02_rank_1 = hipsparseDcsrilu02_(handle,m,nnz,descrA, & c_loc(csrSortedValA_valM),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrilu02_assumed_rank(handle,m,nnz,descrA,csrSortedValA_valM, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrilu02_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA_valM integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrilu02_assumed_rank = hipsparseCcsrilu02_(handle,m,nnz,descrA, & c_loc(csrSortedValA_valM),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function #else function hipsparseCcsrilu02_rank_0(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrilu02_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target :: csrSortedValA_valM integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrilu02_rank_0 = hipsparseCcsrilu02_(handle,m,nnz,descrA, & c_loc(csrSortedValA_valM),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function function hipsparseCcsrilu02_rank_1(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrilu02_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA_valM integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseCcsrilu02_rank_1 = hipsparseCcsrilu02_(handle,m,nnz,descrA, & c_loc(csrSortedValA_valM),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrilu02_assumed_rank(handle,m,nnz,descrA,csrSortedValA_valM, & csrSortedRowPtrA,csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrilu02_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA_valM integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrilu02_assumed_rank = hipsparseZcsrilu02_(handle,m,nnz,descrA, & c_loc(csrSortedValA_valM),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function #else function hipsparseZcsrilu02_rank_0(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrilu02_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target :: csrSortedValA_valM integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrilu02_rank_0 = hipsparseZcsrilu02_(handle,m,nnz,descrA, & c_loc(csrSortedValA_valM),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function function hipsparseZcsrilu02_rank_1(handle,m,nnz,descrA,csrSortedValA_valM,csrSortedRowPtrA, & csrSortedColIndA,myInfo,policy,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrilu02_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA_valM integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: myInfo integer(kind(HIPSPARSE_SOLVE_POLICY_NO_LEVEL)) :: policy type(c_ptr) :: pBuffer ! hipsparseZcsrilu02_rank_1 = hipsparseZcsrilu02_(handle,m,nnz,descrA, & c_loc(csrSortedValA_valM),c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),myInfo,policy, & pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSgpsvInterleavedBatch_bufferSizeExt_assumed_rank(handle,algo,m,ds,dl,d,du, & dw,x,batchCount,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgpsvInterleavedBatch_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m real(c_float),target,contiguous,dimension(..) :: ds real(c_float),target,contiguous,dimension(..) :: dl real(c_float),target,contiguous,dimension(..) :: d real(c_float),target,contiguous,dimension(..) :: du real(c_float),target,contiguous,dimension(..) :: dw real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: batchCount integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSgpsvInterleavedBatch_bufferSizeExt_assumed_rank = & hipsparseSgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batchCount,pBufferSizeInBytes) end function #else function hipsparseSgpsvInterleavedBatch_bufferSizeExt_rank_0(handle,algo,m,ds,dl,d,du,dw,x, & batchCount,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgpsvInterleavedBatch_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m real(c_float),target :: ds real(c_float),target :: dl real(c_float),target :: d real(c_float),target :: du real(c_float),target :: dw real(c_float),target :: x integer(c_int) :: batchCount integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSgpsvInterleavedBatch_bufferSizeExt_rank_0 = & hipsparseSgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batchCount,pBufferSizeInBytes) end function function hipsparseSgpsvInterleavedBatch_bufferSizeExt_rank_1(handle,algo,m,ds,dl,d,du,dw,x, & batchCount,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgpsvInterleavedBatch_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m real(c_float),target,dimension(:) :: ds real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:) :: dw real(c_float),target,dimension(:) :: x integer(c_int) :: batchCount integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSgpsvInterleavedBatch_bufferSizeExt_rank_1 = & hipsparseSgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batchCount,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDgpsvInterleavedBatch_bufferSizeExt_assumed_rank(handle,algo,m,ds,dl,d,du, & dw,x,batchCount,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgpsvInterleavedBatch_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m real(c_double),target,contiguous,dimension(..) :: ds real(c_double),target,contiguous,dimension(..) :: dl real(c_double),target,contiguous,dimension(..) :: d real(c_double),target,contiguous,dimension(..) :: du real(c_double),target,contiguous,dimension(..) :: dw real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: batchCount integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDgpsvInterleavedBatch_bufferSizeExt_assumed_rank = & hipsparseDgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batchCount,pBufferSizeInBytes) end function #else function hipsparseDgpsvInterleavedBatch_bufferSizeExt_rank_0(handle,algo,m,ds,dl,d,du,dw,x, & batchCount,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgpsvInterleavedBatch_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m real(c_double),target :: ds real(c_double),target :: dl real(c_double),target :: d real(c_double),target :: du real(c_double),target :: dw real(c_double),target :: x integer(c_int) :: batchCount integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDgpsvInterleavedBatch_bufferSizeExt_rank_0 = & hipsparseDgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batchCount,pBufferSizeInBytes) end function function hipsparseDgpsvInterleavedBatch_bufferSizeExt_rank_1(handle,algo,m,ds,dl,d,du,dw,x, & batchCount,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgpsvInterleavedBatch_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m real(c_double),target,dimension(:) :: ds real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:) :: dw real(c_double),target,dimension(:) :: x integer(c_int) :: batchCount integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDgpsvInterleavedBatch_bufferSizeExt_rank_1 = & hipsparseDgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batchCount,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCgpsvInterleavedBatch_bufferSizeExt_assumed_rank(handle,algo,m,ds,dl,d,du, & dw,x,batchCount,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgpsvInterleavedBatch_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m complex(c_float_complex),target,contiguous,dimension(..) :: ds complex(c_float_complex),target,contiguous,dimension(..) :: dl complex(c_float_complex),target,contiguous,dimension(..) :: d complex(c_float_complex),target,contiguous,dimension(..) :: du complex(c_float_complex),target,contiguous,dimension(..) :: dw complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: batchCount integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCgpsvInterleavedBatch_bufferSizeExt_assumed_rank = & hipsparseCgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batchCount,pBufferSizeInBytes) end function #else function hipsparseCgpsvInterleavedBatch_bufferSizeExt_rank_0(handle,algo,m,ds,dl,d,du,dw,x, & batchCount,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgpsvInterleavedBatch_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m complex(c_float_complex),target :: ds complex(c_float_complex),target :: dl complex(c_float_complex),target :: d complex(c_float_complex),target :: du complex(c_float_complex),target :: dw complex(c_float_complex),target :: x integer(c_int) :: batchCount integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCgpsvInterleavedBatch_bufferSizeExt_rank_0 = & hipsparseCgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batchCount,pBufferSizeInBytes) end function function hipsparseCgpsvInterleavedBatch_bufferSizeExt_rank_1(handle,algo,m,ds,dl,d,du,dw,x, & batchCount,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgpsvInterleavedBatch_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m complex(c_float_complex),target,dimension(:) :: ds complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:) :: dw complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: batchCount integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCgpsvInterleavedBatch_bufferSizeExt_rank_1 = & hipsparseCgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batchCount,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZgpsvInterleavedBatch_bufferSizeExt_assumed_rank(handle,algo,m,ds,dl,d,du, & dw,x,batchCount,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgpsvInterleavedBatch_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m complex(c_double_complex),target,contiguous,dimension(..) :: ds complex(c_double_complex),target,contiguous,dimension(..) :: dl complex(c_double_complex),target,contiguous,dimension(..) :: d complex(c_double_complex),target,contiguous,dimension(..) :: du complex(c_double_complex),target,contiguous,dimension(..) :: dw complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: batchCount integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZgpsvInterleavedBatch_bufferSizeExt_assumed_rank = & hipsparseZgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batchCount,pBufferSizeInBytes) end function #else function hipsparseZgpsvInterleavedBatch_bufferSizeExt_rank_0(handle,algo,m,ds,dl,d,du,dw,x, & batchCount,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgpsvInterleavedBatch_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m complex(c_double_complex),target :: ds complex(c_double_complex),target :: dl complex(c_double_complex),target :: d complex(c_double_complex),target :: du complex(c_double_complex),target :: dw complex(c_double_complex),target :: x integer(c_int) :: batchCount integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZgpsvInterleavedBatch_bufferSizeExt_rank_0 = & hipsparseZgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batchCount,pBufferSizeInBytes) end function function hipsparseZgpsvInterleavedBatch_bufferSizeExt_rank_1(handle,algo,m,ds,dl,d,du,dw,x, & batchCount,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgpsvInterleavedBatch_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m complex(c_double_complex),target,dimension(:) :: ds complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:) :: dw complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: batchCount integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZgpsvInterleavedBatch_bufferSizeExt_rank_1 = & hipsparseZgpsvInterleavedBatch_bufferSizeExt_(handle,algo,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batchCount,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSgpsvInterleavedBatch_assumed_rank(handle,algo,m,ds,dl,d,du,dw,x,batchCount, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgpsvInterleavedBatch_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m real(c_float),target,contiguous,dimension(..) :: ds real(c_float),target,contiguous,dimension(..) :: dl real(c_float),target,contiguous,dimension(..) :: d real(c_float),target,contiguous,dimension(..) :: du real(c_float),target,contiguous,dimension(..) :: dw real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: batchCount type(c_ptr) :: pBuffer ! hipsparseSgpsvInterleavedBatch_assumed_rank = hipsparseSgpsvInterleavedBatch_(handle,algo,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batchCount,pBuffer) end function #else function hipsparseSgpsvInterleavedBatch_rank_0(handle,algo,m,ds,dl,d,du,dw,x,batchCount,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgpsvInterleavedBatch_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m real(c_float),target :: ds real(c_float),target :: dl real(c_float),target :: d real(c_float),target :: du real(c_float),target :: dw real(c_float),target :: x integer(c_int) :: batchCount type(c_ptr) :: pBuffer ! hipsparseSgpsvInterleavedBatch_rank_0 = hipsparseSgpsvInterleavedBatch_(handle,algo,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batchCount,pBuffer) end function function hipsparseSgpsvInterleavedBatch_rank_1(handle,algo,m,ds,dl,d,du,dw,x,batchCount,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgpsvInterleavedBatch_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m real(c_float),target,dimension(:) :: ds real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:) :: dw real(c_float),target,dimension(:) :: x integer(c_int) :: batchCount type(c_ptr) :: pBuffer ! hipsparseSgpsvInterleavedBatch_rank_1 = hipsparseSgpsvInterleavedBatch_(handle,algo,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batchCount,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDgpsvInterleavedBatch_assumed_rank(handle,algo,m,ds,dl,d,du,dw,x,batchCount, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgpsvInterleavedBatch_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m real(c_double),target,contiguous,dimension(..) :: ds real(c_double),target,contiguous,dimension(..) :: dl real(c_double),target,contiguous,dimension(..) :: d real(c_double),target,contiguous,dimension(..) :: du real(c_double),target,contiguous,dimension(..) :: dw real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: batchCount type(c_ptr) :: pBuffer ! hipsparseDgpsvInterleavedBatch_assumed_rank = hipsparseDgpsvInterleavedBatch_(handle,algo,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batchCount,pBuffer) end function #else function hipsparseDgpsvInterleavedBatch_rank_0(handle,algo,m,ds,dl,d,du,dw,x,batchCount,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgpsvInterleavedBatch_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m real(c_double),target :: ds real(c_double),target :: dl real(c_double),target :: d real(c_double),target :: du real(c_double),target :: dw real(c_double),target :: x integer(c_int) :: batchCount type(c_ptr) :: pBuffer ! hipsparseDgpsvInterleavedBatch_rank_0 = hipsparseDgpsvInterleavedBatch_(handle,algo,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batchCount,pBuffer) end function function hipsparseDgpsvInterleavedBatch_rank_1(handle,algo,m,ds,dl,d,du,dw,x,batchCount,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgpsvInterleavedBatch_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m real(c_double),target,dimension(:) :: ds real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:) :: dw real(c_double),target,dimension(:) :: x integer(c_int) :: batchCount type(c_ptr) :: pBuffer ! hipsparseDgpsvInterleavedBatch_rank_1 = hipsparseDgpsvInterleavedBatch_(handle,algo,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batchCount,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCgpsvInterleavedBatch_assumed_rank(handle,algo,m,ds,dl,d,du,dw,x,batchCount, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgpsvInterleavedBatch_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m complex(c_float_complex),target,contiguous,dimension(..) :: ds complex(c_float_complex),target,contiguous,dimension(..) :: dl complex(c_float_complex),target,contiguous,dimension(..) :: d complex(c_float_complex),target,contiguous,dimension(..) :: du complex(c_float_complex),target,contiguous,dimension(..) :: dw complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: batchCount type(c_ptr) :: pBuffer ! hipsparseCgpsvInterleavedBatch_assumed_rank = hipsparseCgpsvInterleavedBatch_(handle,algo,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batchCount,pBuffer) end function #else function hipsparseCgpsvInterleavedBatch_rank_0(handle,algo,m,ds,dl,d,du,dw,x,batchCount,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgpsvInterleavedBatch_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m complex(c_float_complex),target :: ds complex(c_float_complex),target :: dl complex(c_float_complex),target :: d complex(c_float_complex),target :: du complex(c_float_complex),target :: dw complex(c_float_complex),target :: x integer(c_int) :: batchCount type(c_ptr) :: pBuffer ! hipsparseCgpsvInterleavedBatch_rank_0 = hipsparseCgpsvInterleavedBatch_(handle,algo,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batchCount,pBuffer) end function function hipsparseCgpsvInterleavedBatch_rank_1(handle,algo,m,ds,dl,d,du,dw,x,batchCount,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgpsvInterleavedBatch_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m complex(c_float_complex),target,dimension(:) :: ds complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:) :: dw complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: batchCount type(c_ptr) :: pBuffer ! hipsparseCgpsvInterleavedBatch_rank_1 = hipsparseCgpsvInterleavedBatch_(handle,algo,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batchCount,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZgpsvInterleavedBatch_assumed_rank(handle,algo,m,ds,dl,d,du,dw,x,batchCount, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgpsvInterleavedBatch_assumed_rank type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m complex(c_double_complex),target,contiguous,dimension(..) :: ds complex(c_double_complex),target,contiguous,dimension(..) :: dl complex(c_double_complex),target,contiguous,dimension(..) :: d complex(c_double_complex),target,contiguous,dimension(..) :: du complex(c_double_complex),target,contiguous,dimension(..) :: dw complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: batchCount type(c_ptr) :: pBuffer ! hipsparseZgpsvInterleavedBatch_assumed_rank = hipsparseZgpsvInterleavedBatch_(handle,algo,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batchCount,pBuffer) end function #else function hipsparseZgpsvInterleavedBatch_rank_0(handle,algo,m,ds,dl,d,du,dw,x,batchCount,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgpsvInterleavedBatch_rank_0 type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m complex(c_double_complex),target :: ds complex(c_double_complex),target :: dl complex(c_double_complex),target :: d complex(c_double_complex),target :: du complex(c_double_complex),target :: dw complex(c_double_complex),target :: x integer(c_int) :: batchCount type(c_ptr) :: pBuffer ! hipsparseZgpsvInterleavedBatch_rank_0 = hipsparseZgpsvInterleavedBatch_(handle,algo,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batchCount,pBuffer) end function function hipsparseZgpsvInterleavedBatch_rank_1(handle,algo,m,ds,dl,d,du,dw,x,batchCount,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgpsvInterleavedBatch_rank_1 type(c_ptr) :: handle integer(c_int) :: algo integer(c_int) :: m complex(c_double_complex),target,dimension(:) :: ds complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:) :: dw complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: batchCount type(c_ptr) :: pBuffer ! hipsparseZgpsvInterleavedBatch_rank_1 = hipsparseZgpsvInterleavedBatch_(handle,algo,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batchCount,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSgtsv2_bufferSizeExt_assumed_rank(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: dl real(c_float),target,contiguous,dimension(..) :: d real(c_float),target,contiguous,dimension(..) :: du real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSgtsv2_bufferSizeExt_assumed_rank = hipsparseSgtsv2_bufferSizeExt_(handle,m,n, & c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function #else function hipsparseSgtsv2_bufferSizeExt_rank_0(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: dl real(c_float),target :: d real(c_float),target :: du real(c_float),target :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSgtsv2_bufferSizeExt_rank_0 = hipsparseSgtsv2_bufferSizeExt_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function function hipsparseSgtsv2_bufferSizeExt_rank_1(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSgtsv2_bufferSizeExt_rank_1 = hipsparseSgtsv2_bufferSizeExt_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function function hipsparseSgtsv2_bufferSizeExt_full_rank(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_bufferSizeExt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSgtsv2_bufferSizeExt_full_rank = hipsparseSgtsv2_bufferSizeExt_(handle,m,n, & c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDgtsv2_bufferSizeExt_assumed_rank(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: dl real(c_double),target,contiguous,dimension(..) :: d real(c_double),target,contiguous,dimension(..) :: du real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDgtsv2_bufferSizeExt_assumed_rank = hipsparseDgtsv2_bufferSizeExt_(handle,m,n, & c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function #else function hipsparseDgtsv2_bufferSizeExt_rank_0(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: dl real(c_double),target :: d real(c_double),target :: du real(c_double),target :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDgtsv2_bufferSizeExt_rank_0 = hipsparseDgtsv2_bufferSizeExt_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function function hipsparseDgtsv2_bufferSizeExt_rank_1(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDgtsv2_bufferSizeExt_rank_1 = hipsparseDgtsv2_bufferSizeExt_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function function hipsparseDgtsv2_bufferSizeExt_full_rank(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_bufferSizeExt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDgtsv2_bufferSizeExt_full_rank = hipsparseDgtsv2_bufferSizeExt_(handle,m,n, & c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCgtsv2_bufferSizeExt_assumed_rank(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: dl complex(c_float_complex),target,contiguous,dimension(..) :: d complex(c_float_complex),target,contiguous,dimension(..) :: du complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCgtsv2_bufferSizeExt_assumed_rank = hipsparseCgtsv2_bufferSizeExt_(handle,m,n, & c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function #else function hipsparseCgtsv2_bufferSizeExt_rank_0(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: dl complex(c_float_complex),target :: d complex(c_float_complex),target :: du complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCgtsv2_bufferSizeExt_rank_0 = hipsparseCgtsv2_bufferSizeExt_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function function hipsparseCgtsv2_bufferSizeExt_rank_1(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCgtsv2_bufferSizeExt_rank_1 = hipsparseCgtsv2_bufferSizeExt_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function function hipsparseCgtsv2_bufferSizeExt_full_rank(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_bufferSizeExt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCgtsv2_bufferSizeExt_full_rank = hipsparseCgtsv2_bufferSizeExt_(handle,m,n, & c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZgtsv2_bufferSizeExt_assumed_rank(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: dl complex(c_double_complex),target,contiguous,dimension(..) :: d complex(c_double_complex),target,contiguous,dimension(..) :: du complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZgtsv2_bufferSizeExt_assumed_rank = hipsparseZgtsv2_bufferSizeExt_(handle,m,n, & c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function #else function hipsparseZgtsv2_bufferSizeExt_rank_0(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: dl complex(c_double_complex),target :: d complex(c_double_complex),target :: du complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZgtsv2_bufferSizeExt_rank_0 = hipsparseZgtsv2_bufferSizeExt_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function function hipsparseZgtsv2_bufferSizeExt_rank_1(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZgtsv2_bufferSizeExt_rank_1 = hipsparseZgtsv2_bufferSizeExt_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function function hipsparseZgtsv2_bufferSizeExt_full_rank(handle,m,n,dl,d,du,B,ldb,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_bufferSizeExt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZgtsv2_bufferSizeExt_full_rank = hipsparseZgtsv2_bufferSizeExt_(handle,m,n, & c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSgtsv2_assumed_rank(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: dl real(c_float),target,contiguous,dimension(..) :: d real(c_float),target,contiguous,dimension(..) :: du real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseSgtsv2_assumed_rank = hipsparseSgtsv2_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du), & c_loc(B),ldb,pBuffer) end function #else function hipsparseSgtsv2_rank_0(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: dl real(c_float),target :: d real(c_float),target :: du real(c_float),target :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseSgtsv2_rank_0 = hipsparseSgtsv2_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B), & ldb,pBuffer) end function function hipsparseSgtsv2_rank_1(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseSgtsv2_rank_1 = hipsparseSgtsv2_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B), & ldb,pBuffer) end function function hipsparseSgtsv2_full_rank(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseSgtsv2_full_rank = hipsparseSgtsv2_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du), & c_loc(B),ldb,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDgtsv2_assumed_rank(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: dl real(c_double),target,contiguous,dimension(..) :: d real(c_double),target,contiguous,dimension(..) :: du real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseDgtsv2_assumed_rank = hipsparseDgtsv2_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du), & c_loc(B),ldb,pBuffer) end function #else function hipsparseDgtsv2_rank_0(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: dl real(c_double),target :: d real(c_double),target :: du real(c_double),target :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseDgtsv2_rank_0 = hipsparseDgtsv2_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B), & ldb,pBuffer) end function function hipsparseDgtsv2_rank_1(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseDgtsv2_rank_1 = hipsparseDgtsv2_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B), & ldb,pBuffer) end function function hipsparseDgtsv2_full_rank(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseDgtsv2_full_rank = hipsparseDgtsv2_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du), & c_loc(B),ldb,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCgtsv2_assumed_rank(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: dl complex(c_float_complex),target,contiguous,dimension(..) :: d complex(c_float_complex),target,contiguous,dimension(..) :: du complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseCgtsv2_assumed_rank = hipsparseCgtsv2_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du), & c_loc(B),ldb,pBuffer) end function #else function hipsparseCgtsv2_rank_0(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: dl complex(c_float_complex),target :: d complex(c_float_complex),target :: du complex(c_float_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseCgtsv2_rank_0 = hipsparseCgtsv2_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B), & ldb,pBuffer) end function function hipsparseCgtsv2_rank_1(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseCgtsv2_rank_1 = hipsparseCgtsv2_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B), & ldb,pBuffer) end function function hipsparseCgtsv2_full_rank(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseCgtsv2_full_rank = hipsparseCgtsv2_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du), & c_loc(B),ldb,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZgtsv2_assumed_rank(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: dl complex(c_double_complex),target,contiguous,dimension(..) :: d complex(c_double_complex),target,contiguous,dimension(..) :: du complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseZgtsv2_assumed_rank = hipsparseZgtsv2_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du), & c_loc(B),ldb,pBuffer) end function #else function hipsparseZgtsv2_rank_0(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: dl complex(c_double_complex),target :: d complex(c_double_complex),target :: du complex(c_double_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseZgtsv2_rank_0 = hipsparseZgtsv2_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B), & ldb,pBuffer) end function function hipsparseZgtsv2_rank_1(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseZgtsv2_rank_1 = hipsparseZgtsv2_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B), & ldb,pBuffer) end function function hipsparseZgtsv2_full_rank(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseZgtsv2_full_rank = hipsparseZgtsv2_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du), & c_loc(B),ldb,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSgtsv2_nopivot_bufferSizeExt_assumed_rank(handle,m,n,dl,d,du,B,ldb, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_nopivot_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: dl real(c_float),target,contiguous,dimension(..) :: d real(c_float),target,contiguous,dimension(..) :: du real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSgtsv2_nopivot_bufferSizeExt_assumed_rank = hipsparseSgtsv2_nopivot_bufferSizeExt_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function #else function hipsparseSgtsv2_nopivot_bufferSizeExt_rank_0(handle,m,n,dl,d,du,B,ldb, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_nopivot_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: dl real(c_float),target :: d real(c_float),target :: du real(c_float),target :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSgtsv2_nopivot_bufferSizeExt_rank_0 = hipsparseSgtsv2_nopivot_bufferSizeExt_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function function hipsparseSgtsv2_nopivot_bufferSizeExt_rank_1(handle,m,n,dl,d,du,B,ldb, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_nopivot_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSgtsv2_nopivot_bufferSizeExt_rank_1 = hipsparseSgtsv2_nopivot_bufferSizeExt_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function function hipsparseSgtsv2_nopivot_bufferSizeExt_full_rank(handle,m,n,dl,d,du,B,ldb, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_nopivot_bufferSizeExt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSgtsv2_nopivot_bufferSizeExt_full_rank = hipsparseSgtsv2_nopivot_bufferSizeExt_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDgtsv2_nopivot_bufferSizeExt_assumed_rank(handle,m,n,dl,d,du,B,ldb, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_nopivot_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: dl real(c_double),target,contiguous,dimension(..) :: d real(c_double),target,contiguous,dimension(..) :: du real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDgtsv2_nopivot_bufferSizeExt_assumed_rank = hipsparseDgtsv2_nopivot_bufferSizeExt_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function #else function hipsparseDgtsv2_nopivot_bufferSizeExt_rank_0(handle,m,n,dl,d,du,B,ldb, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_nopivot_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: dl real(c_double),target :: d real(c_double),target :: du real(c_double),target :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDgtsv2_nopivot_bufferSizeExt_rank_0 = hipsparseDgtsv2_nopivot_bufferSizeExt_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function function hipsparseDgtsv2_nopivot_bufferSizeExt_rank_1(handle,m,n,dl,d,du,B,ldb, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_nopivot_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDgtsv2_nopivot_bufferSizeExt_rank_1 = hipsparseDgtsv2_nopivot_bufferSizeExt_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function function hipsparseDgtsv2_nopivot_bufferSizeExt_full_rank(handle,m,n,dl,d,du,B,ldb, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_nopivot_bufferSizeExt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDgtsv2_nopivot_bufferSizeExt_full_rank = hipsparseDgtsv2_nopivot_bufferSizeExt_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCgtsv2_nopivot_bufferSizeExt_assumed_rank(handle,m,n,dl,d,du,B,ldb, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_nopivot_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: dl complex(c_float_complex),target,contiguous,dimension(..) :: d complex(c_float_complex),target,contiguous,dimension(..) :: du complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCgtsv2_nopivot_bufferSizeExt_assumed_rank = hipsparseCgtsv2_nopivot_bufferSizeExt_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function #else function hipsparseCgtsv2_nopivot_bufferSizeExt_rank_0(handle,m,n,dl,d,du,B,ldb, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_nopivot_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: dl complex(c_float_complex),target :: d complex(c_float_complex),target :: du complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCgtsv2_nopivot_bufferSizeExt_rank_0 = hipsparseCgtsv2_nopivot_bufferSizeExt_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function function hipsparseCgtsv2_nopivot_bufferSizeExt_rank_1(handle,m,n,dl,d,du,B,ldb, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_nopivot_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCgtsv2_nopivot_bufferSizeExt_rank_1 = hipsparseCgtsv2_nopivot_bufferSizeExt_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function function hipsparseCgtsv2_nopivot_bufferSizeExt_full_rank(handle,m,n,dl,d,du,B,ldb, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_nopivot_bufferSizeExt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCgtsv2_nopivot_bufferSizeExt_full_rank = hipsparseCgtsv2_nopivot_bufferSizeExt_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZgtsv2_nopivot_bufferSizeExt_assumed_rank(handle,m,n,dl,d,du,B,ldb, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_nopivot_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: dl complex(c_double_complex),target,contiguous,dimension(..) :: d complex(c_double_complex),target,contiguous,dimension(..) :: du complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZgtsv2_nopivot_bufferSizeExt_assumed_rank = hipsparseZgtsv2_nopivot_bufferSizeExt_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function #else function hipsparseZgtsv2_nopivot_bufferSizeExt_rank_0(handle,m,n,dl,d,du,B,ldb, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_nopivot_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: dl complex(c_double_complex),target :: d complex(c_double_complex),target :: du complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZgtsv2_nopivot_bufferSizeExt_rank_0 = hipsparseZgtsv2_nopivot_bufferSizeExt_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function function hipsparseZgtsv2_nopivot_bufferSizeExt_rank_1(handle,m,n,dl,d,du,B,ldb, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_nopivot_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZgtsv2_nopivot_bufferSizeExt_rank_1 = hipsparseZgtsv2_nopivot_bufferSizeExt_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function function hipsparseZgtsv2_nopivot_bufferSizeExt_full_rank(handle,m,n,dl,d,du,B,ldb, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_nopivot_bufferSizeExt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZgtsv2_nopivot_bufferSizeExt_full_rank = hipsparseZgtsv2_nopivot_bufferSizeExt_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSgtsv2_nopivot_assumed_rank(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_nopivot_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: dl real(c_float),target,contiguous,dimension(..) :: d real(c_float),target,contiguous,dimension(..) :: du real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseSgtsv2_nopivot_assumed_rank = hipsparseSgtsv2_nopivot_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,pBuffer) end function #else function hipsparseSgtsv2_nopivot_rank_0(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_nopivot_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: dl real(c_float),target :: d real(c_float),target :: du real(c_float),target :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseSgtsv2_nopivot_rank_0 = hipsparseSgtsv2_nopivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,pBuffer) end function function hipsparseSgtsv2_nopivot_rank_1(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_nopivot_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseSgtsv2_nopivot_rank_1 = hipsparseSgtsv2_nopivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,pBuffer) end function function hipsparseSgtsv2_nopivot_full_rank(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2_nopivot_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseSgtsv2_nopivot_full_rank = hipsparseSgtsv2_nopivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDgtsv2_nopivot_assumed_rank(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_nopivot_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: dl real(c_double),target,contiguous,dimension(..) :: d real(c_double),target,contiguous,dimension(..) :: du real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseDgtsv2_nopivot_assumed_rank = hipsparseDgtsv2_nopivot_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,pBuffer) end function #else function hipsparseDgtsv2_nopivot_rank_0(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_nopivot_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: dl real(c_double),target :: d real(c_double),target :: du real(c_double),target :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseDgtsv2_nopivot_rank_0 = hipsparseDgtsv2_nopivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,pBuffer) end function function hipsparseDgtsv2_nopivot_rank_1(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_nopivot_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseDgtsv2_nopivot_rank_1 = hipsparseDgtsv2_nopivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,pBuffer) end function function hipsparseDgtsv2_nopivot_full_rank(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2_nopivot_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseDgtsv2_nopivot_full_rank = hipsparseDgtsv2_nopivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCgtsv2_nopivot_assumed_rank(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_nopivot_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: dl complex(c_float_complex),target,contiguous,dimension(..) :: d complex(c_float_complex),target,contiguous,dimension(..) :: du complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseCgtsv2_nopivot_assumed_rank = hipsparseCgtsv2_nopivot_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,pBuffer) end function #else function hipsparseCgtsv2_nopivot_rank_0(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_nopivot_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: dl complex(c_float_complex),target :: d complex(c_float_complex),target :: du complex(c_float_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseCgtsv2_nopivot_rank_0 = hipsparseCgtsv2_nopivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,pBuffer) end function function hipsparseCgtsv2_nopivot_rank_1(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_nopivot_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseCgtsv2_nopivot_rank_1 = hipsparseCgtsv2_nopivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,pBuffer) end function function hipsparseCgtsv2_nopivot_full_rank(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2_nopivot_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseCgtsv2_nopivot_full_rank = hipsparseCgtsv2_nopivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZgtsv2_nopivot_assumed_rank(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_nopivot_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: dl complex(c_double_complex),target,contiguous,dimension(..) :: d complex(c_double_complex),target,contiguous,dimension(..) :: du complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseZgtsv2_nopivot_assumed_rank = hipsparseZgtsv2_nopivot_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,pBuffer) end function #else function hipsparseZgtsv2_nopivot_rank_0(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_nopivot_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: dl complex(c_double_complex),target :: d complex(c_double_complex),target :: du complex(c_double_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseZgtsv2_nopivot_rank_0 = hipsparseZgtsv2_nopivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,pBuffer) end function function hipsparseZgtsv2_nopivot_rank_1(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_nopivot_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseZgtsv2_nopivot_rank_1 = hipsparseZgtsv2_nopivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,pBuffer) end function function hipsparseZgtsv2_nopivot_full_rank(handle,m,n,dl,d,du,B,ldb,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2_nopivot_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: pBuffer ! hipsparseZgtsv2_nopivot_full_rank = hipsparseZgtsv2_nopivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSgtsv2StridedBatch_bufferSizeExt_assumed_rank(handle,m,dl,d,du,x,batchCount, & batchStride,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2StridedBatch_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m real(c_float),target,contiguous,dimension(..) :: dl real(c_float),target,contiguous,dimension(..) :: d real(c_float),target,contiguous,dimension(..) :: du real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: batchCount integer(c_int) :: batchStride integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSgtsv2StridedBatch_bufferSizeExt_assumed_rank = & hipsparseSgtsv2StridedBatch_bufferSizeExt_(handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x), & batchCount,batchStride,pBufferSizeInBytes) end function #else function hipsparseSgtsv2StridedBatch_bufferSizeExt_rank_0(handle,m,dl,d,du,x,batchCount, & batchStride,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2StridedBatch_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m real(c_float),target :: dl real(c_float),target :: d real(c_float),target :: du real(c_float),target :: x integer(c_int) :: batchCount integer(c_int) :: batchStride integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSgtsv2StridedBatch_bufferSizeExt_rank_0 = & hipsparseSgtsv2StridedBatch_bufferSizeExt_(handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x), & batchCount,batchStride,pBufferSizeInBytes) end function function hipsparseSgtsv2StridedBatch_bufferSizeExt_rank_1(handle,m,dl,d,du,x,batchCount, & batchStride,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2StridedBatch_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:) :: x integer(c_int) :: batchCount integer(c_int) :: batchStride integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSgtsv2StridedBatch_bufferSizeExt_rank_1 = & hipsparseSgtsv2StridedBatch_bufferSizeExt_(handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x), & batchCount,batchStride,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDgtsv2StridedBatch_bufferSizeExt_assumed_rank(handle,m,dl,d,du,x,batchCount, & batchStride,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2StridedBatch_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m real(c_double),target,contiguous,dimension(..) :: dl real(c_double),target,contiguous,dimension(..) :: d real(c_double),target,contiguous,dimension(..) :: du real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: batchCount integer(c_int) :: batchStride integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDgtsv2StridedBatch_bufferSizeExt_assumed_rank = & hipsparseDgtsv2StridedBatch_bufferSizeExt_(handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x), & batchCount,batchStride,pBufferSizeInBytes) end function #else function hipsparseDgtsv2StridedBatch_bufferSizeExt_rank_0(handle,m,dl,d,du,x,batchCount, & batchStride,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2StridedBatch_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m real(c_double),target :: dl real(c_double),target :: d real(c_double),target :: du real(c_double),target :: x integer(c_int) :: batchCount integer(c_int) :: batchStride integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDgtsv2StridedBatch_bufferSizeExt_rank_0 = & hipsparseDgtsv2StridedBatch_bufferSizeExt_(handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x), & batchCount,batchStride,pBufferSizeInBytes) end function function hipsparseDgtsv2StridedBatch_bufferSizeExt_rank_1(handle,m,dl,d,du,x,batchCount, & batchStride,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2StridedBatch_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:) :: x integer(c_int) :: batchCount integer(c_int) :: batchStride integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDgtsv2StridedBatch_bufferSizeExt_rank_1 = & hipsparseDgtsv2StridedBatch_bufferSizeExt_(handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x), & batchCount,batchStride,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCgtsv2StridedBatch_bufferSizeExt_assumed_rank(handle,m,dl,d,du,x,batchCount, & batchStride,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2StridedBatch_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m complex(c_float_complex),target,contiguous,dimension(..) :: dl complex(c_float_complex),target,contiguous,dimension(..) :: d complex(c_float_complex),target,contiguous,dimension(..) :: du complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: batchCount integer(c_int) :: batchStride integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCgtsv2StridedBatch_bufferSizeExt_assumed_rank = & hipsparseCgtsv2StridedBatch_bufferSizeExt_(handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x), & batchCount,batchStride,pBufferSizeInBytes) end function #else function hipsparseCgtsv2StridedBatch_bufferSizeExt_rank_0(handle,m,dl,d,du,x,batchCount, & batchStride,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2StridedBatch_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m complex(c_float_complex),target :: dl complex(c_float_complex),target :: d complex(c_float_complex),target :: du complex(c_float_complex),target :: x integer(c_int) :: batchCount integer(c_int) :: batchStride integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCgtsv2StridedBatch_bufferSizeExt_rank_0 = & hipsparseCgtsv2StridedBatch_bufferSizeExt_(handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x), & batchCount,batchStride,pBufferSizeInBytes) end function function hipsparseCgtsv2StridedBatch_bufferSizeExt_rank_1(handle,m,dl,d,du,x,batchCount, & batchStride,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2StridedBatch_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: batchCount integer(c_int) :: batchStride integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCgtsv2StridedBatch_bufferSizeExt_rank_1 = & hipsparseCgtsv2StridedBatch_bufferSizeExt_(handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x), & batchCount,batchStride,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZgtsv2StridedBatch_bufferSizeExt_assumed_rank(handle,m,dl,d,du,x,batchCount, & batchStride,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2StridedBatch_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m complex(c_double_complex),target,contiguous,dimension(..) :: dl complex(c_double_complex),target,contiguous,dimension(..) :: d complex(c_double_complex),target,contiguous,dimension(..) :: du complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: batchCount integer(c_int) :: batchStride integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZgtsv2StridedBatch_bufferSizeExt_assumed_rank = & hipsparseZgtsv2StridedBatch_bufferSizeExt_(handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x), & batchCount,batchStride,pBufferSizeInBytes) end function #else function hipsparseZgtsv2StridedBatch_bufferSizeExt_rank_0(handle,m,dl,d,du,x,batchCount, & batchStride,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2StridedBatch_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m complex(c_double_complex),target :: dl complex(c_double_complex),target :: d complex(c_double_complex),target :: du complex(c_double_complex),target :: x integer(c_int) :: batchCount integer(c_int) :: batchStride integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZgtsv2StridedBatch_bufferSizeExt_rank_0 = & hipsparseZgtsv2StridedBatch_bufferSizeExt_(handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x), & batchCount,batchStride,pBufferSizeInBytes) end function function hipsparseZgtsv2StridedBatch_bufferSizeExt_rank_1(handle,m,dl,d,du,x,batchCount, & batchStride,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2StridedBatch_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: batchCount integer(c_int) :: batchStride integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZgtsv2StridedBatch_bufferSizeExt_rank_1 = & hipsparseZgtsv2StridedBatch_bufferSizeExt_(handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x), & batchCount,batchStride,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSgtsv2StridedBatch_assumed_rank(handle,m,dl,d,du,x,batchCount,batchStride, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2StridedBatch_assumed_rank type(c_ptr) :: handle integer(c_int) :: m real(c_float),target,contiguous,dimension(..) :: dl real(c_float),target,contiguous,dimension(..) :: d real(c_float),target,contiguous,dimension(..) :: du real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: batchCount integer(c_int) :: batchStride type(c_ptr) :: pBuffer ! hipsparseSgtsv2StridedBatch_assumed_rank = hipsparseSgtsv2StridedBatch_(handle,m,c_loc(dl), & c_loc(d),c_loc(du),c_loc(x),batchCount,batchStride,pBuffer) end function #else function hipsparseSgtsv2StridedBatch_rank_0(handle,m,dl,d,du,x,batchCount,batchStride,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2StridedBatch_rank_0 type(c_ptr) :: handle integer(c_int) :: m real(c_float),target :: dl real(c_float),target :: d real(c_float),target :: du real(c_float),target :: x integer(c_int) :: batchCount integer(c_int) :: batchStride type(c_ptr) :: pBuffer ! hipsparseSgtsv2StridedBatch_rank_0 = hipsparseSgtsv2StridedBatch_(handle,m,c_loc(dl), & c_loc(d),c_loc(du),c_loc(x),batchCount,batchStride,pBuffer) end function function hipsparseSgtsv2StridedBatch_rank_1(handle,m,dl,d,du,x,batchCount,batchStride,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgtsv2StridedBatch_rank_1 type(c_ptr) :: handle integer(c_int) :: m real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:) :: x integer(c_int) :: batchCount integer(c_int) :: batchStride type(c_ptr) :: pBuffer ! hipsparseSgtsv2StridedBatch_rank_1 = hipsparseSgtsv2StridedBatch_(handle,m,c_loc(dl), & c_loc(d),c_loc(du),c_loc(x),batchCount,batchStride,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDgtsv2StridedBatch_assumed_rank(handle,m,dl,d,du,x,batchCount,batchStride, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2StridedBatch_assumed_rank type(c_ptr) :: handle integer(c_int) :: m real(c_double),target,contiguous,dimension(..) :: dl real(c_double),target,contiguous,dimension(..) :: d real(c_double),target,contiguous,dimension(..) :: du real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: batchCount integer(c_int) :: batchStride type(c_ptr) :: pBuffer ! hipsparseDgtsv2StridedBatch_assumed_rank = hipsparseDgtsv2StridedBatch_(handle,m,c_loc(dl), & c_loc(d),c_loc(du),c_loc(x),batchCount,batchStride,pBuffer) end function #else function hipsparseDgtsv2StridedBatch_rank_0(handle,m,dl,d,du,x,batchCount,batchStride,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2StridedBatch_rank_0 type(c_ptr) :: handle integer(c_int) :: m real(c_double),target :: dl real(c_double),target :: d real(c_double),target :: du real(c_double),target :: x integer(c_int) :: batchCount integer(c_int) :: batchStride type(c_ptr) :: pBuffer ! hipsparseDgtsv2StridedBatch_rank_0 = hipsparseDgtsv2StridedBatch_(handle,m,c_loc(dl), & c_loc(d),c_loc(du),c_loc(x),batchCount,batchStride,pBuffer) end function function hipsparseDgtsv2StridedBatch_rank_1(handle,m,dl,d,du,x,batchCount,batchStride,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgtsv2StridedBatch_rank_1 type(c_ptr) :: handle integer(c_int) :: m real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:) :: x integer(c_int) :: batchCount integer(c_int) :: batchStride type(c_ptr) :: pBuffer ! hipsparseDgtsv2StridedBatch_rank_1 = hipsparseDgtsv2StridedBatch_(handle,m,c_loc(dl), & c_loc(d),c_loc(du),c_loc(x),batchCount,batchStride,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCgtsv2StridedBatch_assumed_rank(handle,m,dl,d,du,x,batchCount,batchStride, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2StridedBatch_assumed_rank type(c_ptr) :: handle integer(c_int) :: m complex(c_float_complex),target,contiguous,dimension(..) :: dl complex(c_float_complex),target,contiguous,dimension(..) :: d complex(c_float_complex),target,contiguous,dimension(..) :: du complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: batchCount integer(c_int) :: batchStride type(c_ptr) :: pBuffer ! hipsparseCgtsv2StridedBatch_assumed_rank = hipsparseCgtsv2StridedBatch_(handle,m,c_loc(dl), & c_loc(d),c_loc(du),c_loc(x),batchCount,batchStride,pBuffer) end function #else function hipsparseCgtsv2StridedBatch_rank_0(handle,m,dl,d,du,x,batchCount,batchStride,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2StridedBatch_rank_0 type(c_ptr) :: handle integer(c_int) :: m complex(c_float_complex),target :: dl complex(c_float_complex),target :: d complex(c_float_complex),target :: du complex(c_float_complex),target :: x integer(c_int) :: batchCount integer(c_int) :: batchStride type(c_ptr) :: pBuffer ! hipsparseCgtsv2StridedBatch_rank_0 = hipsparseCgtsv2StridedBatch_(handle,m,c_loc(dl), & c_loc(d),c_loc(du),c_loc(x),batchCount,batchStride,pBuffer) end function function hipsparseCgtsv2StridedBatch_rank_1(handle,m,dl,d,du,x,batchCount,batchStride,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgtsv2StridedBatch_rank_1 type(c_ptr) :: handle integer(c_int) :: m complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: batchCount integer(c_int) :: batchStride type(c_ptr) :: pBuffer ! hipsparseCgtsv2StridedBatch_rank_1 = hipsparseCgtsv2StridedBatch_(handle,m,c_loc(dl), & c_loc(d),c_loc(du),c_loc(x),batchCount,batchStride,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZgtsv2StridedBatch_assumed_rank(handle,m,dl,d,du,x,batchCount,batchStride, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2StridedBatch_assumed_rank type(c_ptr) :: handle integer(c_int) :: m complex(c_double_complex),target,contiguous,dimension(..) :: dl complex(c_double_complex),target,contiguous,dimension(..) :: d complex(c_double_complex),target,contiguous,dimension(..) :: du complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: batchCount integer(c_int) :: batchStride type(c_ptr) :: pBuffer ! hipsparseZgtsv2StridedBatch_assumed_rank = hipsparseZgtsv2StridedBatch_(handle,m,c_loc(dl), & c_loc(d),c_loc(du),c_loc(x),batchCount,batchStride,pBuffer) end function #else function hipsparseZgtsv2StridedBatch_rank_0(handle,m,dl,d,du,x,batchCount,batchStride,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2StridedBatch_rank_0 type(c_ptr) :: handle integer(c_int) :: m complex(c_double_complex),target :: dl complex(c_double_complex),target :: d complex(c_double_complex),target :: du complex(c_double_complex),target :: x integer(c_int) :: batchCount integer(c_int) :: batchStride type(c_ptr) :: pBuffer ! hipsparseZgtsv2StridedBatch_rank_0 = hipsparseZgtsv2StridedBatch_(handle,m,c_loc(dl), & c_loc(d),c_loc(du),c_loc(x),batchCount,batchStride,pBuffer) end function function hipsparseZgtsv2StridedBatch_rank_1(handle,m,dl,d,du,x,batchCount,batchStride,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgtsv2StridedBatch_rank_1 type(c_ptr) :: handle integer(c_int) :: m complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: batchCount integer(c_int) :: batchStride type(c_ptr) :: pBuffer ! hipsparseZgtsv2StridedBatch_rank_1 = hipsparseZgtsv2StridedBatch_(handle,m,c_loc(dl), & c_loc(d),c_loc(du),c_loc(x),batchCount,batchStride,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSbsr2csr_assumed_rank(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsr2csr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC real(c_float),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC ! hipsparseSbsr2csr_assumed_rank = hipsparseSbsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #else function hipsparseSbsr2csr_rank_0(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsr2csr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA real(c_float),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC real(c_float),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC ! hipsparseSbsr2csr_rank_0 = hipsparseSbsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function function hipsparseSbsr2csr_rank_1(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSbsr2csr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC real(c_float),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC ! hipsparseSbsr2csr_rank_1 = hipsparseSbsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDbsr2csr_assumed_rank(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsr2csr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC real(c_double),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC ! hipsparseDbsr2csr_assumed_rank = hipsparseDbsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #else function hipsparseDbsr2csr_rank_0(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsr2csr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA real(c_double),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC real(c_double),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC ! hipsparseDbsr2csr_rank_0 = hipsparseDbsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function function hipsparseDbsr2csr_rank_1(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDbsr2csr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC real(c_double),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC ! hipsparseDbsr2csr_rank_1 = hipsparseDbsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCbsr2csr_assumed_rank(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsr2csr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC complex(c_float_complex),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC ! hipsparseCbsr2csr_assumed_rank = hipsparseCbsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #else function hipsparseCbsr2csr_rank_0(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsr2csr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA complex(c_float_complex),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC complex(c_float_complex),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC ! hipsparseCbsr2csr_rank_0 = hipsparseCbsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function function hipsparseCbsr2csr_rank_1(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCbsr2csr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC complex(c_float_complex),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC ! hipsparseCbsr2csr_rank_1 = hipsparseCbsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZbsr2csr_assumed_rank(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,blockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsr2csr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC complex(c_double_complex),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC ! hipsparseZbsr2csr_assumed_rank = hipsparseZbsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #else function hipsparseZbsr2csr_rank_0(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsr2csr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA complex(c_double_complex),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC complex(c_double_complex),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC ! hipsparseZbsr2csr_rank_0 = hipsparseZbsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function function hipsparseZbsr2csr_rank_1(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & blockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZbsr2csr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC complex(c_double_complex),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC ! hipsparseZbsr2csr_rank_1 = hipsparseZbsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),blockDim,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseXcoo2csr_assumed_rank(handle,cooRowInd,nnz,m,csrRowPtr,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcoo2csr_assumed_rank type(c_ptr) :: handle integer(c_int),target,contiguous,dimension(..) :: cooRowInd integer(c_int) :: nnz integer(c_int) :: m integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseXcoo2csr_assumed_rank = hipsparseXcoo2csr_(handle,c_loc(cooRowInd),nnz,m, & c_loc(csrRowPtr),idxBase) end function #else function hipsparseXcoo2csr_rank_0(handle,cooRowInd,nnz,m,csrRowPtr,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcoo2csr_rank_0 type(c_ptr) :: handle integer(c_int),target :: cooRowInd integer(c_int) :: nnz integer(c_int) :: m integer(c_int),target :: csrRowPtr integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseXcoo2csr_rank_0 = hipsparseXcoo2csr_(handle,c_loc(cooRowInd),nnz,m, & c_loc(csrRowPtr),idxBase) end function function hipsparseXcoo2csr_rank_1(handle,cooRowInd,nnz,m,csrRowPtr,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcoo2csr_rank_1 type(c_ptr) :: handle integer(c_int),target,dimension(:) :: cooRowInd integer(c_int) :: nnz integer(c_int) :: m integer(c_int),target,dimension(:) :: csrRowPtr integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseXcoo2csr_rank_1 = hipsparseXcoo2csr_(handle,c_loc(cooRowInd),nnz,m, & c_loc(csrRowPtr),idxBase) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseXcoosort_bufferSizeExt_assumed_rank(handle,m,n,nnz,cooRows,cooCols, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcoosort_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,contiguous,dimension(..) :: cooRows integer(c_int),target,contiguous,dimension(..) :: cooCols integer(c_size_t) :: pBufferSizeInBytes ! hipsparseXcoosort_bufferSizeExt_assumed_rank = hipsparseXcoosort_bufferSizeExt_(handle,m,n, & nnz,c_loc(cooRows),c_loc(cooCols),pBufferSizeInBytes) end function #else function hipsparseXcoosort_bufferSizeExt_rank_0(handle,m,n,nnz,cooRows,cooCols, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcoosort_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target :: cooRows integer(c_int),target :: cooCols integer(c_size_t) :: pBufferSizeInBytes ! hipsparseXcoosort_bufferSizeExt_rank_0 = hipsparseXcoosort_bufferSizeExt_(handle,m,n,nnz, & c_loc(cooRows),c_loc(cooCols),pBufferSizeInBytes) end function function hipsparseXcoosort_bufferSizeExt_rank_1(handle,m,n,nnz,cooRows,cooCols, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcoosort_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,dimension(:) :: cooRows integer(c_int),target,dimension(:) :: cooCols integer(c_size_t) :: pBufferSizeInBytes ! hipsparseXcoosort_bufferSizeExt_rank_1 = hipsparseXcoosort_bufferSizeExt_(handle,m,n,nnz, & c_loc(cooRows),c_loc(cooCols),pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseXcoosortByRow_assumed_rank(handle,m,n,nnz,cooRows,cooCols,P,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcoosortByRow_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,contiguous,dimension(..) :: cooRows integer(c_int),target,contiguous,dimension(..) :: cooCols integer(c_int),target,contiguous,dimension(..) :: P type(c_ptr) :: pBuffer ! hipsparseXcoosortByRow_assumed_rank = hipsparseXcoosortByRow_(handle,m,n,nnz,c_loc(cooRows), & c_loc(cooCols),c_loc(P),pBuffer) end function #else function hipsparseXcoosortByRow_rank_0(handle,m,n,nnz,cooRows,cooCols,P,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcoosortByRow_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target :: cooRows integer(c_int),target :: cooCols integer(c_int),target :: P type(c_ptr) :: pBuffer ! hipsparseXcoosortByRow_rank_0 = hipsparseXcoosortByRow_(handle,m,n,nnz,c_loc(cooRows), & c_loc(cooCols),c_loc(P),pBuffer) end function function hipsparseXcoosortByRow_rank_1(handle,m,n,nnz,cooRows,cooCols,P,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcoosortByRow_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,dimension(:) :: cooRows integer(c_int),target,dimension(:) :: cooCols integer(c_int),target,dimension(:) :: P type(c_ptr) :: pBuffer ! hipsparseXcoosortByRow_rank_1 = hipsparseXcoosortByRow_(handle,m,n,nnz,c_loc(cooRows), & c_loc(cooCols),c_loc(P),pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseXcoosortByColumn_assumed_rank(handle,m,n,nnz,cooRows,cooCols,P,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcoosortByColumn_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,contiguous,dimension(..) :: cooRows integer(c_int),target,contiguous,dimension(..) :: cooCols integer(c_int),target,contiguous,dimension(..) :: P type(c_ptr) :: pBuffer ! hipsparseXcoosortByColumn_assumed_rank = hipsparseXcoosortByColumn_(handle,m,n,nnz, & c_loc(cooRows),c_loc(cooCols),c_loc(P),pBuffer) end function #else function hipsparseXcoosortByColumn_rank_0(handle,m,n,nnz,cooRows,cooCols,P,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcoosortByColumn_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target :: cooRows integer(c_int),target :: cooCols integer(c_int),target :: P type(c_ptr) :: pBuffer ! hipsparseXcoosortByColumn_rank_0 = hipsparseXcoosortByColumn_(handle,m,n,nnz,c_loc(cooRows), & c_loc(cooCols),c_loc(P),pBuffer) end function function hipsparseXcoosortByColumn_rank_1(handle,m,n,nnz,cooRows,cooCols,P,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcoosortByColumn_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,dimension(:) :: cooRows integer(c_int),target,dimension(:) :: cooCols integer(c_int),target,dimension(:) :: P type(c_ptr) :: pBuffer ! hipsparseXcoosortByColumn_rank_1 = hipsparseXcoosortByColumn_(handle,m,n,nnz,c_loc(cooRows), & c_loc(cooCols),c_loc(P),pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCreateIdentityPermutation_assumed_rank(handle,n,p) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateIdentityPermutation_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int),target,contiguous,dimension(..) :: p ! hipsparseCreateIdentityPermutation_assumed_rank = hipsparseCreateIdentityPermutation_( & handle,n,c_loc(p)) end function #else function hipsparseCreateIdentityPermutation_rank_0(handle,n,p) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateIdentityPermutation_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int),target :: p ! hipsparseCreateIdentityPermutation_rank_0 = hipsparseCreateIdentityPermutation_(handle,n, & c_loc(p)) end function function hipsparseCreateIdentityPermutation_rank_1(handle,n,p) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCreateIdentityPermutation_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int),target,dimension(:) :: p ! hipsparseCreateIdentityPermutation_rank_1 = hipsparseCreateIdentityPermutation_(handle,n, & c_loc(p)) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsc2dense_assumed_rank(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsc2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: cscVal integer(c_int),target,contiguous,dimension(..) :: cscRowInd integer(c_int),target,contiguous,dimension(..) :: cscColPtr real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! hipsparseScsc2dense_assumed_rank = hipsparseScsc2dense_(handle,m,n,descr,c_loc(cscVal), & c_loc(cscRowInd),c_loc(cscColPtr),c_loc(A),ld) end function #else function hipsparseScsc2dense_rank_0(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsc2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target :: cscVal integer(c_int),target :: cscRowInd integer(c_int),target :: cscColPtr real(c_float),target :: A integer(c_int) :: ld ! hipsparseScsc2dense_rank_0 = hipsparseScsc2dense_(handle,m,n,descr,c_loc(cscVal), & c_loc(cscRowInd),c_loc(cscColPtr),c_loc(A),ld) end function function hipsparseScsc2dense_rank_1(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsc2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:) :: cscVal integer(c_int),target,dimension(:) :: cscRowInd integer(c_int),target,dimension(:) :: cscColPtr real(c_float),target,dimension(:) :: A integer(c_int) :: ld ! hipsparseScsc2dense_rank_1 = hipsparseScsc2dense_(handle,m,n,descr,c_loc(cscVal), & c_loc(cscRowInd),c_loc(cscColPtr),c_loc(A),ld) end function function hipsparseScsc2dense_full_rank(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsc2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:) :: cscVal integer(c_int),target,dimension(:) :: cscRowInd integer(c_int),target,dimension(:) :: cscColPtr real(c_float),target,dimension(:,:) :: A integer(c_int) :: ld ! hipsparseScsc2dense_full_rank = hipsparseScsc2dense_(handle,m,n,descr,c_loc(cscVal), & c_loc(cscRowInd),c_loc(cscColPtr),c_loc(A),ld) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsc2dense_assumed_rank(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsc2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: cscVal integer(c_int),target,contiguous,dimension(..) :: cscRowInd integer(c_int),target,contiguous,dimension(..) :: cscColPtr real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! hipsparseDcsc2dense_assumed_rank = hipsparseDcsc2dense_(handle,m,n,descr,c_loc(cscVal), & c_loc(cscRowInd),c_loc(cscColPtr),c_loc(A),ld) end function #else function hipsparseDcsc2dense_rank_0(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsc2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target :: cscVal integer(c_int),target :: cscRowInd integer(c_int),target :: cscColPtr real(c_double),target :: A integer(c_int) :: ld ! hipsparseDcsc2dense_rank_0 = hipsparseDcsc2dense_(handle,m,n,descr,c_loc(cscVal), & c_loc(cscRowInd),c_loc(cscColPtr),c_loc(A),ld) end function function hipsparseDcsc2dense_rank_1(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsc2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:) :: cscVal integer(c_int),target,dimension(:) :: cscRowInd integer(c_int),target,dimension(:) :: cscColPtr real(c_double),target,dimension(:) :: A integer(c_int) :: ld ! hipsparseDcsc2dense_rank_1 = hipsparseDcsc2dense_(handle,m,n,descr,c_loc(cscVal), & c_loc(cscRowInd),c_loc(cscColPtr),c_loc(A),ld) end function function hipsparseDcsc2dense_full_rank(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsc2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:) :: cscVal integer(c_int),target,dimension(:) :: cscRowInd integer(c_int),target,dimension(:) :: cscColPtr real(c_double),target,dimension(:,:) :: A integer(c_int) :: ld ! hipsparseDcsc2dense_full_rank = hipsparseDcsc2dense_(handle,m,n,descr,c_loc(cscVal), & c_loc(cscRowInd),c_loc(cscColPtr),c_loc(A),ld) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsc2dense_assumed_rank(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsc2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: cscVal integer(c_int),target,contiguous,dimension(..) :: cscRowInd integer(c_int),target,contiguous,dimension(..) :: cscColPtr complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! hipsparseCcsc2dense_assumed_rank = hipsparseCcsc2dense_(handle,m,n,descr,c_loc(cscVal), & c_loc(cscRowInd),c_loc(cscColPtr),c_loc(A),ld) end function #else function hipsparseCcsc2dense_rank_0(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsc2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target :: cscVal integer(c_int),target :: cscRowInd integer(c_int),target :: cscColPtr complex(c_float_complex),target :: A integer(c_int) :: ld ! hipsparseCcsc2dense_rank_0 = hipsparseCcsc2dense_(handle,m,n,descr,c_loc(cscVal), & c_loc(cscRowInd),c_loc(cscColPtr),c_loc(A),ld) end function function hipsparseCcsc2dense_rank_1(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsc2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: cscVal integer(c_int),target,dimension(:) :: cscRowInd integer(c_int),target,dimension(:) :: cscColPtr complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: ld ! hipsparseCcsc2dense_rank_1 = hipsparseCcsc2dense_(handle,m,n,descr,c_loc(cscVal), & c_loc(cscRowInd),c_loc(cscColPtr),c_loc(A),ld) end function function hipsparseCcsc2dense_full_rank(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsc2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: cscVal integer(c_int),target,dimension(:) :: cscRowInd integer(c_int),target,dimension(:) :: cscColPtr complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: ld ! hipsparseCcsc2dense_full_rank = hipsparseCcsc2dense_(handle,m,n,descr,c_loc(cscVal), & c_loc(cscRowInd),c_loc(cscColPtr),c_loc(A),ld) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsc2dense_assumed_rank(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsc2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: cscVal integer(c_int),target,contiguous,dimension(..) :: cscRowInd integer(c_int),target,contiguous,dimension(..) :: cscColPtr complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! hipsparseZcsc2dense_assumed_rank = hipsparseZcsc2dense_(handle,m,n,descr,c_loc(cscVal), & c_loc(cscRowInd),c_loc(cscColPtr),c_loc(A),ld) end function #else function hipsparseZcsc2dense_rank_0(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsc2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target :: cscVal integer(c_int),target :: cscRowInd integer(c_int),target :: cscColPtr complex(c_double_complex),target :: A integer(c_int) :: ld ! hipsparseZcsc2dense_rank_0 = hipsparseZcsc2dense_(handle,m,n,descr,c_loc(cscVal), & c_loc(cscRowInd),c_loc(cscColPtr),c_loc(A),ld) end function function hipsparseZcsc2dense_rank_1(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsc2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: cscVal integer(c_int),target,dimension(:) :: cscRowInd integer(c_int),target,dimension(:) :: cscColPtr complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: ld ! hipsparseZcsc2dense_rank_1 = hipsparseZcsc2dense_(handle,m,n,descr,c_loc(cscVal), & c_loc(cscRowInd),c_loc(cscColPtr),c_loc(A),ld) end function function hipsparseZcsc2dense_full_rank(handle,m,n,descr,cscVal,cscRowInd,cscColPtr,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsc2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: cscVal integer(c_int),target,dimension(:) :: cscRowInd integer(c_int),target,dimension(:) :: cscColPtr complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: ld ! hipsparseZcsc2dense_full_rank = hipsparseZcsc2dense_(handle,m,n,descr,c_loc(cscVal), & c_loc(cscRowInd),c_loc(cscColPtr),c_loc(A),ld) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseXcscsort_bufferSizeExt_assumed_rank(handle,m,n,nnz,cscColPtr,cscRowInd, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcscsort_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,contiguous,dimension(..) :: cscColPtr integer(c_int),target,contiguous,dimension(..) :: cscRowInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseXcscsort_bufferSizeExt_assumed_rank = hipsparseXcscsort_bufferSizeExt_(handle,m,n, & nnz,c_loc(cscColPtr),c_loc(cscRowInd),pBufferSizeInBytes) end function #else function hipsparseXcscsort_bufferSizeExt_rank_0(handle,m,n,nnz,cscColPtr,cscRowInd, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcscsort_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target :: cscColPtr integer(c_int),target :: cscRowInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseXcscsort_bufferSizeExt_rank_0 = hipsparseXcscsort_bufferSizeExt_(handle,m,n,nnz, & c_loc(cscColPtr),c_loc(cscRowInd),pBufferSizeInBytes) end function function hipsparseXcscsort_bufferSizeExt_rank_1(handle,m,n,nnz,cscColPtr,cscRowInd, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcscsort_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,dimension(:) :: cscColPtr integer(c_int),target,dimension(:) :: cscRowInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseXcscsort_bufferSizeExt_rank_1 = hipsparseXcscsort_bufferSizeExt_(handle,m,n,nnz, & c_loc(cscColPtr),c_loc(cscRowInd),pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseXcscsort_assumed_rank(handle,m,n,nnz,descrA,cscColPtr,cscRowInd,P,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcscsort_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA integer(c_int),target,contiguous,dimension(..) :: cscColPtr integer(c_int),target,contiguous,dimension(..) :: cscRowInd integer(c_int),target,contiguous,dimension(..) :: P type(c_ptr) :: pBuffer ! hipsparseXcscsort_assumed_rank = hipsparseXcscsort_(handle,m,n,nnz,descrA,c_loc(cscColPtr), & c_loc(cscRowInd),c_loc(P),pBuffer) end function #else function hipsparseXcscsort_rank_0(handle,m,n,nnz,descrA,cscColPtr,cscRowInd,P,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcscsort_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA integer(c_int),target :: cscColPtr integer(c_int),target :: cscRowInd integer(c_int),target :: P type(c_ptr) :: pBuffer ! hipsparseXcscsort_rank_0 = hipsparseXcscsort_(handle,m,n,nnz,descrA,c_loc(cscColPtr), & c_loc(cscRowInd),c_loc(P),pBuffer) end function function hipsparseXcscsort_rank_1(handle,m,n,nnz,descrA,cscColPtr,cscRowInd,P,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcscsort_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA integer(c_int),target,dimension(:) :: cscColPtr integer(c_int),target,dimension(:) :: cscRowInd integer(c_int),target,dimension(:) :: P type(c_ptr) :: pBuffer ! hipsparseXcscsort_rank_1 = hipsparseXcscsort_(handle,m,n,nnz,descrA,c_loc(cscColPtr), & c_loc(cscRowInd),c_loc(P),pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseXcsr2bsrNnz_assumed_rank(handle,dirA,m,n,descrA,csrRowPtrA,csrColIndA, & blockDim,descrC,bsrRowPtrC,bsrNnzb) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsr2bsrNnz_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrC integer(c_int),target,contiguous,dimension(..) :: bsrNnzb ! hipsparseXcsr2bsrNnz_assumed_rank = hipsparseXcsr2bsrNnz_(handle,dirA,m,n,descrA, & c_loc(csrRowPtrA),c_loc(csrColIndA),blockDim,descrC,c_loc(bsrRowPtrC),c_loc(bsrNnzb)) end function #else function hipsparseXcsr2bsrNnz_rank_0(handle,dirA,m,n,descrA,csrRowPtrA,csrColIndA,blockDim, & descrC,bsrRowPtrC,bsrNnzb) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsr2bsrNnz_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC integer(c_int),target :: bsrRowPtrC integer(c_int),target :: bsrNnzb ! hipsparseXcsr2bsrNnz_rank_0 = hipsparseXcsr2bsrNnz_(handle,dirA,m,n,descrA, & c_loc(csrRowPtrA),c_loc(csrColIndA),blockDim,descrC,c_loc(bsrRowPtrC),c_loc(bsrNnzb)) end function function hipsparseXcsr2bsrNnz_rank_1(handle,dirA,m,n,descrA,csrRowPtrA,csrColIndA,blockDim, & descrC,bsrRowPtrC,bsrNnzb) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsr2bsrNnz_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC integer(c_int),target,dimension(:) :: bsrRowPtrC integer(c_int),target,dimension(:) :: bsrNnzb ! hipsparseXcsr2bsrNnz_rank_1 = hipsparseXcsr2bsrNnz_(handle,dirA,m,n,descrA, & c_loc(csrRowPtrA),c_loc(csrColIndA),blockDim,descrC,c_loc(bsrRowPtrC),c_loc(bsrNnzb)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsr2bsr_assumed_rank(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA, & blockDim,descrC,bsrValC,bsrRowPtrC,bsrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2bsr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC real(c_float),target,contiguous,dimension(..) :: bsrValC integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrC integer(c_int),target,contiguous,dimension(..) :: bsrColIndC ! hipsparseScsr2bsr_assumed_rank = hipsparseScsr2bsr_(handle,dirA,m,n,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),blockDim,descrC,c_loc(bsrValC),c_loc(bsrRowPtrC), & c_loc(bsrColIndC)) end function #else function hipsparseScsr2bsr_rank_0(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA, & blockDim,descrC,bsrValC,bsrRowPtrC,bsrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2bsr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_float),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC real(c_float),target :: bsrValC integer(c_int),target :: bsrRowPtrC integer(c_int),target :: bsrColIndC ! hipsparseScsr2bsr_rank_0 = hipsparseScsr2bsr_(handle,dirA,m,n,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),blockDim,descrC,c_loc(bsrValC),c_loc(bsrRowPtrC), & c_loc(bsrColIndC)) end function function hipsparseScsr2bsr_rank_1(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA, & blockDim,descrC,bsrValC,bsrRowPtrC,bsrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2bsr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC real(c_float),target,dimension(:) :: bsrValC integer(c_int),target,dimension(:) :: bsrRowPtrC integer(c_int),target,dimension(:) :: bsrColIndC ! hipsparseScsr2bsr_rank_1 = hipsparseScsr2bsr_(handle,dirA,m,n,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),blockDim,descrC,c_loc(bsrValC),c_loc(bsrRowPtrC), & c_loc(bsrColIndC)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsr2bsr_assumed_rank(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA, & blockDim,descrC,bsrValC,bsrRowPtrC,bsrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2bsr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC real(c_double),target,contiguous,dimension(..) :: bsrValC integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrC integer(c_int),target,contiguous,dimension(..) :: bsrColIndC ! hipsparseDcsr2bsr_assumed_rank = hipsparseDcsr2bsr_(handle,dirA,m,n,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),blockDim,descrC,c_loc(bsrValC),c_loc(bsrRowPtrC), & c_loc(bsrColIndC)) end function #else function hipsparseDcsr2bsr_rank_0(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA, & blockDim,descrC,bsrValC,bsrRowPtrC,bsrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2bsr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_double),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC real(c_double),target :: bsrValC integer(c_int),target :: bsrRowPtrC integer(c_int),target :: bsrColIndC ! hipsparseDcsr2bsr_rank_0 = hipsparseDcsr2bsr_(handle,dirA,m,n,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),blockDim,descrC,c_loc(bsrValC),c_loc(bsrRowPtrC), & c_loc(bsrColIndC)) end function function hipsparseDcsr2bsr_rank_1(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA, & blockDim,descrC,bsrValC,bsrRowPtrC,bsrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2bsr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC real(c_double),target,dimension(:) :: bsrValC integer(c_int),target,dimension(:) :: bsrRowPtrC integer(c_int),target,dimension(:) :: bsrColIndC ! hipsparseDcsr2bsr_rank_1 = hipsparseDcsr2bsr_(handle,dirA,m,n,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),blockDim,descrC,c_loc(bsrValC),c_loc(bsrRowPtrC), & c_loc(bsrColIndC)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsr2bsr_assumed_rank(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA, & blockDim,descrC,bsrValC,bsrRowPtrC,bsrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2bsr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC complex(c_float_complex),target,contiguous,dimension(..) :: bsrValC integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrC integer(c_int),target,contiguous,dimension(..) :: bsrColIndC ! hipsparseCcsr2bsr_assumed_rank = hipsparseCcsr2bsr_(handle,dirA,m,n,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),blockDim,descrC,c_loc(bsrValC),c_loc(bsrRowPtrC), & c_loc(bsrColIndC)) end function #else function hipsparseCcsr2bsr_rank_0(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA, & blockDim,descrC,bsrValC,bsrRowPtrC,bsrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2bsr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_float_complex),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC complex(c_float_complex),target :: bsrValC integer(c_int),target :: bsrRowPtrC integer(c_int),target :: bsrColIndC ! hipsparseCcsr2bsr_rank_0 = hipsparseCcsr2bsr_(handle,dirA,m,n,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),blockDim,descrC,c_loc(bsrValC),c_loc(bsrRowPtrC), & c_loc(bsrColIndC)) end function function hipsparseCcsr2bsr_rank_1(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA, & blockDim,descrC,bsrValC,bsrRowPtrC,bsrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2bsr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC complex(c_float_complex),target,dimension(:) :: bsrValC integer(c_int),target,dimension(:) :: bsrRowPtrC integer(c_int),target,dimension(:) :: bsrColIndC ! hipsparseCcsr2bsr_rank_1 = hipsparseCcsr2bsr_(handle,dirA,m,n,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),blockDim,descrC,c_loc(bsrValC),c_loc(bsrRowPtrC), & c_loc(bsrColIndC)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsr2bsr_assumed_rank(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA, & blockDim,descrC,bsrValC,bsrRowPtrC,bsrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2bsr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC complex(c_double_complex),target,contiguous,dimension(..) :: bsrValC integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrC integer(c_int),target,contiguous,dimension(..) :: bsrColIndC ! hipsparseZcsr2bsr_assumed_rank = hipsparseZcsr2bsr_(handle,dirA,m,n,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),blockDim,descrC,c_loc(bsrValC),c_loc(bsrRowPtrC), & c_loc(bsrColIndC)) end function #else function hipsparseZcsr2bsr_rank_0(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA, & blockDim,descrC,bsrValC,bsrRowPtrC,bsrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2bsr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_double_complex),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC complex(c_double_complex),target :: bsrValC integer(c_int),target :: bsrRowPtrC integer(c_int),target :: bsrColIndC ! hipsparseZcsr2bsr_rank_0 = hipsparseZcsr2bsr_(handle,dirA,m,n,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),blockDim,descrC,c_loc(bsrValC),c_loc(bsrRowPtrC), & c_loc(bsrColIndC)) end function function hipsparseZcsr2bsr_rank_1(handle,dirA,m,n,descrA,csrValA,csrRowPtrA,csrColIndA, & blockDim,descrC,bsrValC,bsrRowPtrC,bsrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2bsr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA integer(c_int) :: blockDim type(c_ptr) :: descrC complex(c_double_complex),target,dimension(:) :: bsrValC integer(c_int),target,dimension(:) :: bsrRowPtrC integer(c_int),target,dimension(:) :: bsrColIndC ! hipsparseZcsr2bsr_rank_1 = hipsparseZcsr2bsr_(handle,dirA,m,n,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),blockDim,descrC,c_loc(bsrValC),c_loc(bsrRowPtrC), & c_loc(bsrColIndC)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseXcsr2coo_assumed_rank(handle,csrRowPtr,nnz,m,cooRowInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsr2coo_assumed_rank type(c_ptr) :: handle integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int) :: nnz integer(c_int) :: m integer(c_int),target,contiguous,dimension(..) :: cooRowInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseXcsr2coo_assumed_rank = hipsparseXcsr2coo_(handle,c_loc(csrRowPtr),nnz,m, & c_loc(cooRowInd),idxBase) end function #else function hipsparseXcsr2coo_rank_0(handle,csrRowPtr,nnz,m,cooRowInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsr2coo_rank_0 type(c_ptr) :: handle integer(c_int),target :: csrRowPtr integer(c_int) :: nnz integer(c_int) :: m integer(c_int),target :: cooRowInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseXcsr2coo_rank_0 = hipsparseXcsr2coo_(handle,c_loc(csrRowPtr),nnz,m, & c_loc(cooRowInd),idxBase) end function function hipsparseXcsr2coo_rank_1(handle,csrRowPtr,nnz,m,cooRowInd,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsr2coo_rank_1 type(c_ptr) :: handle integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int) :: nnz integer(c_int) :: m integer(c_int),target,dimension(:) :: cooRowInd integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseXcsr2coo_rank_1 = hipsparseXcsr2coo_(handle,c_loc(csrRowPtr),nnz,m, & c_loc(cooRowInd),idxBase) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsr2csc_assumed_rank(handle,m,n,nnz,csrSortedVal,csrSortedRowPtr, & csrSortedColInd,cscSortedVal,cscSortedRowInd,cscSortedColPtr,copyValues,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2csc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_float),target,contiguous,dimension(..) :: csrSortedVal integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtr integer(c_int),target,contiguous,dimension(..) :: csrSortedColInd real(c_float),target,contiguous,dimension(..) :: cscSortedVal integer(c_int),target,contiguous,dimension(..) :: cscSortedRowInd integer(c_int),target,contiguous,dimension(..) :: cscSortedColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)) :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseScsr2csc_assumed_rank = hipsparseScsr2csc_(handle,m,n,nnz,c_loc(csrSortedVal), & c_loc(csrSortedRowPtr),c_loc(csrSortedColInd),c_loc(cscSortedVal),c_loc(cscSortedRowInd), & c_loc(cscSortedColPtr),copyValues,idxBase) end function #else function hipsparseScsr2csc_rank_0(handle,m,n,nnz,csrSortedVal,csrSortedRowPtr,csrSortedColInd, & cscSortedVal,cscSortedRowInd,cscSortedColPtr,copyValues,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2csc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_float),target :: csrSortedVal integer(c_int),target :: csrSortedRowPtr integer(c_int),target :: csrSortedColInd real(c_float),target :: cscSortedVal integer(c_int),target :: cscSortedRowInd integer(c_int),target :: cscSortedColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)) :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseScsr2csc_rank_0 = hipsparseScsr2csc_(handle,m,n,nnz,c_loc(csrSortedVal), & c_loc(csrSortedRowPtr),c_loc(csrSortedColInd),c_loc(cscSortedVal),c_loc(cscSortedRowInd), & c_loc(cscSortedColPtr),copyValues,idxBase) end function function hipsparseScsr2csc_rank_1(handle,m,n,nnz,csrSortedVal,csrSortedRowPtr,csrSortedColInd, & cscSortedVal,cscSortedRowInd,cscSortedColPtr,copyValues,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2csc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_float),target,dimension(:) :: csrSortedVal integer(c_int),target,dimension(:) :: csrSortedRowPtr integer(c_int),target,dimension(:) :: csrSortedColInd real(c_float),target,dimension(:) :: cscSortedVal integer(c_int),target,dimension(:) :: cscSortedRowInd integer(c_int),target,dimension(:) :: cscSortedColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)) :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseScsr2csc_rank_1 = hipsparseScsr2csc_(handle,m,n,nnz,c_loc(csrSortedVal), & c_loc(csrSortedRowPtr),c_loc(csrSortedColInd),c_loc(cscSortedVal),c_loc(cscSortedRowInd), & c_loc(cscSortedColPtr),copyValues,idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsr2csc_assumed_rank(handle,m,n,nnz,csrSortedVal,csrSortedRowPtr, & csrSortedColInd,cscSortedVal,cscSortedRowInd,cscSortedColPtr,copyValues,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2csc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_double),target,contiguous,dimension(..) :: csrSortedVal integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtr integer(c_int),target,contiguous,dimension(..) :: csrSortedColInd real(c_double),target,contiguous,dimension(..) :: cscSortedVal integer(c_int),target,contiguous,dimension(..) :: cscSortedRowInd integer(c_int),target,contiguous,dimension(..) :: cscSortedColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)) :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDcsr2csc_assumed_rank = hipsparseDcsr2csc_(handle,m,n,nnz,c_loc(csrSortedVal), & c_loc(csrSortedRowPtr),c_loc(csrSortedColInd),c_loc(cscSortedVal),c_loc(cscSortedRowInd), & c_loc(cscSortedColPtr),copyValues,idxBase) end function #else function hipsparseDcsr2csc_rank_0(handle,m,n,nnz,csrSortedVal,csrSortedRowPtr,csrSortedColInd, & cscSortedVal,cscSortedRowInd,cscSortedColPtr,copyValues,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2csc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_double),target :: csrSortedVal integer(c_int),target :: csrSortedRowPtr integer(c_int),target :: csrSortedColInd real(c_double),target :: cscSortedVal integer(c_int),target :: cscSortedRowInd integer(c_int),target :: cscSortedColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)) :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDcsr2csc_rank_0 = hipsparseDcsr2csc_(handle,m,n,nnz,c_loc(csrSortedVal), & c_loc(csrSortedRowPtr),c_loc(csrSortedColInd),c_loc(cscSortedVal),c_loc(cscSortedRowInd), & c_loc(cscSortedColPtr),copyValues,idxBase) end function function hipsparseDcsr2csc_rank_1(handle,m,n,nnz,csrSortedVal,csrSortedRowPtr,csrSortedColInd, & cscSortedVal,cscSortedRowInd,cscSortedColPtr,copyValues,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2csc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_double),target,dimension(:) :: csrSortedVal integer(c_int),target,dimension(:) :: csrSortedRowPtr integer(c_int),target,dimension(:) :: csrSortedColInd real(c_double),target,dimension(:) :: cscSortedVal integer(c_int),target,dimension(:) :: cscSortedRowInd integer(c_int),target,dimension(:) :: cscSortedColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)) :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseDcsr2csc_rank_1 = hipsparseDcsr2csc_(handle,m,n,nnz,c_loc(csrSortedVal), & c_loc(csrSortedRowPtr),c_loc(csrSortedColInd),c_loc(cscSortedVal),c_loc(cscSortedRowInd), & c_loc(cscSortedColPtr),copyValues,idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsr2csc_assumed_rank(handle,m,n,nnz,csrSortedVal,csrSortedRowPtr, & csrSortedColInd,cscSortedVal,cscSortedRowInd,cscSortedColPtr,copyValues,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2csc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedVal integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtr integer(c_int),target,contiguous,dimension(..) :: csrSortedColInd complex(c_float_complex),target,contiguous,dimension(..) :: cscSortedVal integer(c_int),target,contiguous,dimension(..) :: cscSortedRowInd integer(c_int),target,contiguous,dimension(..) :: cscSortedColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)) :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCcsr2csc_assumed_rank = hipsparseCcsr2csc_(handle,m,n,nnz,c_loc(csrSortedVal), & c_loc(csrSortedRowPtr),c_loc(csrSortedColInd),c_loc(cscSortedVal),c_loc(cscSortedRowInd), & c_loc(cscSortedColPtr),copyValues,idxBase) end function #else function hipsparseCcsr2csc_rank_0(handle,m,n,nnz,csrSortedVal,csrSortedRowPtr,csrSortedColInd, & cscSortedVal,cscSortedRowInd,cscSortedColPtr,copyValues,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2csc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_float_complex),target :: csrSortedVal integer(c_int),target :: csrSortedRowPtr integer(c_int),target :: csrSortedColInd complex(c_float_complex),target :: cscSortedVal integer(c_int),target :: cscSortedRowInd integer(c_int),target :: cscSortedColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)) :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCcsr2csc_rank_0 = hipsparseCcsr2csc_(handle,m,n,nnz,c_loc(csrSortedVal), & c_loc(csrSortedRowPtr),c_loc(csrSortedColInd),c_loc(cscSortedVal),c_loc(cscSortedRowInd), & c_loc(cscSortedColPtr),copyValues,idxBase) end function function hipsparseCcsr2csc_rank_1(handle,m,n,nnz,csrSortedVal,csrSortedRowPtr,csrSortedColInd, & cscSortedVal,cscSortedRowInd,cscSortedColPtr,copyValues,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2csc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_float_complex),target,dimension(:) :: csrSortedVal integer(c_int),target,dimension(:) :: csrSortedRowPtr integer(c_int),target,dimension(:) :: csrSortedColInd complex(c_float_complex),target,dimension(:) :: cscSortedVal integer(c_int),target,dimension(:) :: cscSortedRowInd integer(c_int),target,dimension(:) :: cscSortedColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)) :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseCcsr2csc_rank_1 = hipsparseCcsr2csc_(handle,m,n,nnz,c_loc(csrSortedVal), & c_loc(csrSortedRowPtr),c_loc(csrSortedColInd),c_loc(cscSortedVal),c_loc(cscSortedRowInd), & c_loc(cscSortedColPtr),copyValues,idxBase) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsr2csc_assumed_rank(handle,m,n,nnz,csrSortedVal,csrSortedRowPtr, & csrSortedColInd,cscSortedVal,cscSortedRowInd,cscSortedColPtr,copyValues,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2csc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedVal integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtr integer(c_int),target,contiguous,dimension(..) :: csrSortedColInd complex(c_double_complex),target,contiguous,dimension(..) :: cscSortedVal integer(c_int),target,contiguous,dimension(..) :: cscSortedRowInd integer(c_int),target,contiguous,dimension(..) :: cscSortedColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)) :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZcsr2csc_assumed_rank = hipsparseZcsr2csc_(handle,m,n,nnz,c_loc(csrSortedVal), & c_loc(csrSortedRowPtr),c_loc(csrSortedColInd),c_loc(cscSortedVal),c_loc(cscSortedRowInd), & c_loc(cscSortedColPtr),copyValues,idxBase) end function #else function hipsparseZcsr2csc_rank_0(handle,m,n,nnz,csrSortedVal,csrSortedRowPtr,csrSortedColInd, & cscSortedVal,cscSortedRowInd,cscSortedColPtr,copyValues,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2csc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_double_complex),target :: csrSortedVal integer(c_int),target :: csrSortedRowPtr integer(c_int),target :: csrSortedColInd complex(c_double_complex),target :: cscSortedVal integer(c_int),target :: cscSortedRowInd integer(c_int),target :: cscSortedColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)) :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZcsr2csc_rank_0 = hipsparseZcsr2csc_(handle,m,n,nnz,c_loc(csrSortedVal), & c_loc(csrSortedRowPtr),c_loc(csrSortedColInd),c_loc(cscSortedVal),c_loc(cscSortedRowInd), & c_loc(cscSortedColPtr),copyValues,idxBase) end function function hipsparseZcsr2csc_rank_1(handle,m,n,nnz,csrSortedVal,csrSortedRowPtr,csrSortedColInd, & cscSortedVal,cscSortedRowInd,cscSortedColPtr,copyValues,idxBase) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2csc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_double_complex),target,dimension(:) :: csrSortedVal integer(c_int),target,dimension(:) :: csrSortedRowPtr integer(c_int),target,dimension(:) :: csrSortedColInd complex(c_double_complex),target,dimension(:) :: cscSortedVal integer(c_int),target,dimension(:) :: cscSortedRowInd integer(c_int),target,dimension(:) :: cscSortedColPtr integer(kind(HIPSPARSE_ACTION_SYMBOLIC)) :: copyValues integer(kind(HIPSPARSE_INDEX_BASE_ZERO)) :: idxBase ! hipsparseZcsr2csc_rank_1 = hipsparseZcsr2csc_(handle,m,n,nnz,c_loc(csrSortedVal), & c_loc(csrSortedRowPtr),c_loc(csrSortedColInd),c_loc(cscSortedVal),c_loc(cscSortedRowInd), & c_loc(cscSortedColPtr),copyValues,idxBase) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsr2csr_compress_assumed_rank(handle,m,n,descrA,csrValA,csrColIndA, & csrRowPtrA,nnzA,nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2csr_compress_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrColIndA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int) :: nnzA integer(c_int),target,contiguous,dimension(..) :: nnzPerRow real(c_float),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrColIndC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC real(c_float) :: tol ! hipsparseScsr2csr_compress_assumed_rank = hipsparseScsr2csr_compress_(handle,m,n,descrA, & c_loc(csrValA),c_loc(csrColIndA),c_loc(csrRowPtrA),nnzA,c_loc(nnzPerRow),c_loc(csrValC), & c_loc(csrColIndC),c_loc(csrRowPtrC),tol) end function #else function hipsparseScsr2csr_compress_rank_0(handle,m,n,descrA,csrValA,csrColIndA,csrRowPtrA, & nnzA,nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2csr_compress_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_float),target :: csrValA integer(c_int),target :: csrColIndA integer(c_int),target :: csrRowPtrA integer(c_int) :: nnzA integer(c_int),target :: nnzPerRow real(c_float),target :: csrValC integer(c_int),target :: csrColIndC integer(c_int),target :: csrRowPtrC real(c_float) :: tol ! hipsparseScsr2csr_compress_rank_0 = hipsparseScsr2csr_compress_(handle,m,n,descrA, & c_loc(csrValA),c_loc(csrColIndA),c_loc(csrRowPtrA),nnzA,c_loc(nnzPerRow),c_loc(csrValC), & c_loc(csrColIndC),c_loc(csrRowPtrC),tol) end function function hipsparseScsr2csr_compress_rank_1(handle,m,n,descrA,csrValA,csrColIndA,csrRowPtrA, & nnzA,nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2csr_compress_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrColIndA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int) :: nnzA integer(c_int),target,dimension(:) :: nnzPerRow real(c_float),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrColIndC integer(c_int),target,dimension(:) :: csrRowPtrC real(c_float) :: tol ! hipsparseScsr2csr_compress_rank_1 = hipsparseScsr2csr_compress_(handle,m,n,descrA, & c_loc(csrValA),c_loc(csrColIndA),c_loc(csrRowPtrA),nnzA,c_loc(nnzPerRow),c_loc(csrValC), & c_loc(csrColIndC),c_loc(csrRowPtrC),tol) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsr2csr_compress_assumed_rank(handle,m,n,descrA,csrValA,csrColIndA, & csrRowPtrA,nnzA,nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2csr_compress_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrColIndA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int) :: nnzA integer(c_int),target,contiguous,dimension(..) :: nnzPerRow real(c_double),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrColIndC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC real(c_double) :: tol ! hipsparseDcsr2csr_compress_assumed_rank = hipsparseDcsr2csr_compress_(handle,m,n,descrA, & c_loc(csrValA),c_loc(csrColIndA),c_loc(csrRowPtrA),nnzA,c_loc(nnzPerRow),c_loc(csrValC), & c_loc(csrColIndC),c_loc(csrRowPtrC),tol) end function #else function hipsparseDcsr2csr_compress_rank_0(handle,m,n,descrA,csrValA,csrColIndA,csrRowPtrA, & nnzA,nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2csr_compress_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_double),target :: csrValA integer(c_int),target :: csrColIndA integer(c_int),target :: csrRowPtrA integer(c_int) :: nnzA integer(c_int),target :: nnzPerRow real(c_double),target :: csrValC integer(c_int),target :: csrColIndC integer(c_int),target :: csrRowPtrC real(c_double) :: tol ! hipsparseDcsr2csr_compress_rank_0 = hipsparseDcsr2csr_compress_(handle,m,n,descrA, & c_loc(csrValA),c_loc(csrColIndA),c_loc(csrRowPtrA),nnzA,c_loc(nnzPerRow),c_loc(csrValC), & c_loc(csrColIndC),c_loc(csrRowPtrC),tol) end function function hipsparseDcsr2csr_compress_rank_1(handle,m,n,descrA,csrValA,csrColIndA,csrRowPtrA, & nnzA,nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2csr_compress_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrColIndA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int) :: nnzA integer(c_int),target,dimension(:) :: nnzPerRow real(c_double),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrColIndC integer(c_int),target,dimension(:) :: csrRowPtrC real(c_double) :: tol ! hipsparseDcsr2csr_compress_rank_1 = hipsparseDcsr2csr_compress_(handle,m,n,descrA, & c_loc(csrValA),c_loc(csrColIndA),c_loc(csrRowPtrA),nnzA,c_loc(nnzPerRow),c_loc(csrValC), & c_loc(csrColIndC),c_loc(csrRowPtrC),tol) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsr2csr_compress_assumed_rank(handle,m,n,descrA,csrValA,csrColIndA, & csrRowPtrA,nnzA,nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2csr_compress_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrColIndA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int) :: nnzA integer(c_int),target,contiguous,dimension(..) :: nnzPerRow complex(c_float_complex),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrColIndC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC complex(c_float_complex) :: tol ! hipsparseCcsr2csr_compress_assumed_rank = hipsparseCcsr2csr_compress_(handle,m,n,descrA, & c_loc(csrValA),c_loc(csrColIndA),c_loc(csrRowPtrA),nnzA,c_loc(nnzPerRow),c_loc(csrValC), & c_loc(csrColIndC),c_loc(csrRowPtrC),tol) end function #else function hipsparseCcsr2csr_compress_rank_0(handle,m,n,descrA,csrValA,csrColIndA,csrRowPtrA, & nnzA,nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2csr_compress_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_float_complex),target :: csrValA integer(c_int),target :: csrColIndA integer(c_int),target :: csrRowPtrA integer(c_int) :: nnzA integer(c_int),target :: nnzPerRow complex(c_float_complex),target :: csrValC integer(c_int),target :: csrColIndC integer(c_int),target :: csrRowPtrC complex(c_float_complex) :: tol ! hipsparseCcsr2csr_compress_rank_0 = hipsparseCcsr2csr_compress_(handle,m,n,descrA, & c_loc(csrValA),c_loc(csrColIndA),c_loc(csrRowPtrA),nnzA,c_loc(nnzPerRow),c_loc(csrValC), & c_loc(csrColIndC),c_loc(csrRowPtrC),tol) end function function hipsparseCcsr2csr_compress_rank_1(handle,m,n,descrA,csrValA,csrColIndA,csrRowPtrA, & nnzA,nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2csr_compress_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrColIndA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int) :: nnzA integer(c_int),target,dimension(:) :: nnzPerRow complex(c_float_complex),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrColIndC integer(c_int),target,dimension(:) :: csrRowPtrC complex(c_float_complex) :: tol ! hipsparseCcsr2csr_compress_rank_1 = hipsparseCcsr2csr_compress_(handle,m,n,descrA, & c_loc(csrValA),c_loc(csrColIndA),c_loc(csrRowPtrA),nnzA,c_loc(nnzPerRow),c_loc(csrValC), & c_loc(csrColIndC),c_loc(csrRowPtrC),tol) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsr2csr_compress_assumed_rank(handle,m,n,descrA,csrValA,csrColIndA, & csrRowPtrA,nnzA,nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2csr_compress_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrColIndA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int) :: nnzA integer(c_int),target,contiguous,dimension(..) :: nnzPerRow complex(c_double_complex),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrColIndC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC complex(c_double_complex) :: tol ! hipsparseZcsr2csr_compress_assumed_rank = hipsparseZcsr2csr_compress_(handle,m,n,descrA, & c_loc(csrValA),c_loc(csrColIndA),c_loc(csrRowPtrA),nnzA,c_loc(nnzPerRow),c_loc(csrValC), & c_loc(csrColIndC),c_loc(csrRowPtrC),tol) end function #else function hipsparseZcsr2csr_compress_rank_0(handle,m,n,descrA,csrValA,csrColIndA,csrRowPtrA, & nnzA,nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2csr_compress_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_double_complex),target :: csrValA integer(c_int),target :: csrColIndA integer(c_int),target :: csrRowPtrA integer(c_int) :: nnzA integer(c_int),target :: nnzPerRow complex(c_double_complex),target :: csrValC integer(c_int),target :: csrColIndC integer(c_int),target :: csrRowPtrC complex(c_double_complex) :: tol ! hipsparseZcsr2csr_compress_rank_0 = hipsparseZcsr2csr_compress_(handle,m,n,descrA, & c_loc(csrValA),c_loc(csrColIndA),c_loc(csrRowPtrA),nnzA,c_loc(nnzPerRow),c_loc(csrValC), & c_loc(csrColIndC),c_loc(csrRowPtrC),tol) end function function hipsparseZcsr2csr_compress_rank_1(handle,m,n,descrA,csrValA,csrColIndA,csrRowPtrA, & nnzA,nnzPerRow,csrValC,csrColIndC,csrRowPtrC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2csr_compress_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrColIndA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int) :: nnzA integer(c_int),target,dimension(:) :: nnzPerRow complex(c_double_complex),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrColIndC integer(c_int),target,dimension(:) :: csrRowPtrC complex(c_double_complex) :: tol ! hipsparseZcsr2csr_compress_rank_1 = hipsparseZcsr2csr_compress_(handle,m,n,descrA, & c_loc(csrValA),c_loc(csrColIndA),c_loc(csrRowPtrA),nnzA,c_loc(nnzPerRow),c_loc(csrValC), & c_loc(csrColIndC),c_loc(csrRowPtrC),tol) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsr2csru_assumed_rank(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd, & myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2csru_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseScsr2csru_assumed_rank = hipsparseScsr2csru_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function #else function hipsparseScsr2csru_rank_0(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2csru_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseScsr2csru_rank_0 = hipsparseScsr2csru_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function function hipsparseScsr2csru_rank_1(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2csru_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseScsr2csru_rank_1 = hipsparseScsr2csru_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsr2csru_assumed_rank(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd, & myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2csru_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseDcsr2csru_assumed_rank = hipsparseDcsr2csru_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function #else function hipsparseDcsr2csru_rank_0(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2csru_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseDcsr2csru_rank_0 = hipsparseDcsr2csru_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function function hipsparseDcsr2csru_rank_1(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2csru_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseDcsr2csru_rank_1 = hipsparseDcsr2csru_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsr2csru_assumed_rank(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd, & myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2csru_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseCcsr2csru_assumed_rank = hipsparseCcsr2csru_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function #else function hipsparseCcsr2csru_rank_0(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2csru_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseCcsr2csru_rank_0 = hipsparseCcsr2csru_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function function hipsparseCcsr2csru_rank_1(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2csru_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseCcsr2csru_rank_1 = hipsparseCcsr2csru_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsr2csru_assumed_rank(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd, & myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2csru_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseZcsr2csru_assumed_rank = hipsparseZcsr2csru_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function #else function hipsparseZcsr2csru_rank_0(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2csru_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseZcsr2csru_rank_0 = hipsparseZcsr2csru_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function function hipsparseZcsr2csru_rank_1(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2csru_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseZcsr2csru_rank_1 = hipsparseZcsr2csru_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsr2dense_assumed_rank(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! hipsparseScsr2dense_assumed_rank = hipsparseScsr2dense_(handle,m,n,descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),c_loc(A),ld) end function #else function hipsparseScsr2dense_rank_0(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd real(c_float),target :: A integer(c_int) :: ld ! hipsparseScsr2dense_rank_0 = hipsparseScsr2dense_(handle,m,n,descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),c_loc(A),ld) end function function hipsparseScsr2dense_rank_1(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd real(c_float),target,dimension(:) :: A integer(c_int) :: ld ! hipsparseScsr2dense_rank_1 = hipsparseScsr2dense_(handle,m,n,descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),c_loc(A),ld) end function function hipsparseScsr2dense_full_rank(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd real(c_float),target,dimension(:,:) :: A integer(c_int) :: ld ! hipsparseScsr2dense_full_rank = hipsparseScsr2dense_(handle,m,n,descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),c_loc(A),ld) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsr2dense_assumed_rank(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! hipsparseDcsr2dense_assumed_rank = hipsparseDcsr2dense_(handle,m,n,descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),c_loc(A),ld) end function #else function hipsparseDcsr2dense_rank_0(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd real(c_double),target :: A integer(c_int) :: ld ! hipsparseDcsr2dense_rank_0 = hipsparseDcsr2dense_(handle,m,n,descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),c_loc(A),ld) end function function hipsparseDcsr2dense_rank_1(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd real(c_double),target,dimension(:) :: A integer(c_int) :: ld ! hipsparseDcsr2dense_rank_1 = hipsparseDcsr2dense_(handle,m,n,descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),c_loc(A),ld) end function function hipsparseDcsr2dense_full_rank(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd real(c_double),target,dimension(:,:) :: A integer(c_int) :: ld ! hipsparseDcsr2dense_full_rank = hipsparseDcsr2dense_(handle,m,n,descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),c_loc(A),ld) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsr2dense_assumed_rank(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! hipsparseCcsr2dense_assumed_rank = hipsparseCcsr2dense_(handle,m,n,descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),c_loc(A),ld) end function #else function hipsparseCcsr2dense_rank_0(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd complex(c_float_complex),target :: A integer(c_int) :: ld ! hipsparseCcsr2dense_rank_0 = hipsparseCcsr2dense_(handle,m,n,descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),c_loc(A),ld) end function function hipsparseCcsr2dense_rank_1(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: ld ! hipsparseCcsr2dense_rank_1 = hipsparseCcsr2dense_(handle,m,n,descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),c_loc(A),ld) end function function hipsparseCcsr2dense_full_rank(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: ld ! hipsparseCcsr2dense_full_rank = hipsparseCcsr2dense_(handle,m,n,descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),c_loc(A),ld) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsr2dense_assumed_rank(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! hipsparseZcsr2dense_assumed_rank = hipsparseZcsr2dense_(handle,m,n,descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),c_loc(A),ld) end function #else function hipsparseZcsr2dense_rank_0(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd complex(c_double_complex),target :: A integer(c_int) :: ld ! hipsparseZcsr2dense_rank_0 = hipsparseZcsr2dense_(handle,m,n,descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),c_loc(A),ld) end function function hipsparseZcsr2dense_rank_1(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: ld ! hipsparseZcsr2dense_rank_1 = hipsparseZcsr2dense_(handle,m,n,descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),c_loc(A),ld) end function function hipsparseZcsr2dense_full_rank(handle,m,n,descr,csrVal,csrRowPtr,csrColInd,A,ld) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: ld ! hipsparseZcsr2dense_full_rank = hipsparseZcsr2dense_(handle,m,n,descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),c_loc(A),ld) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsr2gebsr_bufferSize_assumed_rank(handle,dir,m,n,csr_descr,csrVal, & csrRowPtr,csrColInd,rowBlockDim,colBlockDim,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2gebsr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_float),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsr2gebsr_bufferSize_assumed_rank = hipsparseScsr2gebsr_bufferSize_(handle,dir,m, & n,csr_descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),rowBlockDim,colBlockDim, & pBufferSizeInBytes) end function #else function hipsparseScsr2gebsr_bufferSize_rank_0(handle,dir,m,n,csr_descr,csrVal,csrRowPtr, & csrColInd,rowBlockDim,colBlockDim,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2gebsr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_float),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsr2gebsr_bufferSize_rank_0 = hipsparseScsr2gebsr_bufferSize_(handle,dir,m,n, & csr_descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),rowBlockDim,colBlockDim, & pBufferSizeInBytes) end function function hipsparseScsr2gebsr_bufferSize_rank_1(handle,dir,m,n,csr_descr,csrVal,csrRowPtr, & csrColInd,rowBlockDim,colBlockDim,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2gebsr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsr2gebsr_bufferSize_rank_1 = hipsparseScsr2gebsr_bufferSize_(handle,dir,m,n, & csr_descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),rowBlockDim,colBlockDim, & pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsr2gebsr_bufferSize_assumed_rank(handle,dir,m,n,csr_descr,csrVal, & csrRowPtr,csrColInd,rowBlockDim,colBlockDim,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2gebsr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_double),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsr2gebsr_bufferSize_assumed_rank = hipsparseDcsr2gebsr_bufferSize_(handle,dir,m, & n,csr_descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),rowBlockDim,colBlockDim, & pBufferSizeInBytes) end function #else function hipsparseDcsr2gebsr_bufferSize_rank_0(handle,dir,m,n,csr_descr,csrVal,csrRowPtr, & csrColInd,rowBlockDim,colBlockDim,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2gebsr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_double),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsr2gebsr_bufferSize_rank_0 = hipsparseDcsr2gebsr_bufferSize_(handle,dir,m,n, & csr_descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),rowBlockDim,colBlockDim, & pBufferSizeInBytes) end function function hipsparseDcsr2gebsr_bufferSize_rank_1(handle,dir,m,n,csr_descr,csrVal,csrRowPtr, & csrColInd,rowBlockDim,colBlockDim,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2gebsr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsr2gebsr_bufferSize_rank_1 = hipsparseDcsr2gebsr_bufferSize_(handle,dir,m,n, & csr_descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),rowBlockDim,colBlockDim, & pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsr2gebsr_bufferSize_assumed_rank(handle,dir,m,n,csr_descr,csrVal, & csrRowPtr,csrColInd,rowBlockDim,colBlockDim,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2gebsr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_float_complex),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsr2gebsr_bufferSize_assumed_rank = hipsparseCcsr2gebsr_bufferSize_(handle,dir,m, & n,csr_descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),rowBlockDim,colBlockDim, & pBufferSizeInBytes) end function #else function hipsparseCcsr2gebsr_bufferSize_rank_0(handle,dir,m,n,csr_descr,csrVal,csrRowPtr, & csrColInd,rowBlockDim,colBlockDim,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2gebsr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_float_complex),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsr2gebsr_bufferSize_rank_0 = hipsparseCcsr2gebsr_bufferSize_(handle,dir,m,n, & csr_descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),rowBlockDim,colBlockDim, & pBufferSizeInBytes) end function function hipsparseCcsr2gebsr_bufferSize_rank_1(handle,dir,m,n,csr_descr,csrVal,csrRowPtr, & csrColInd,rowBlockDim,colBlockDim,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2gebsr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_float_complex),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsr2gebsr_bufferSize_rank_1 = hipsparseCcsr2gebsr_bufferSize_(handle,dir,m,n, & csr_descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),rowBlockDim,colBlockDim, & pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsr2gebsr_bufferSize_assumed_rank(handle,dir,m,n,csr_descr,csrVal, & csrRowPtr,csrColInd,rowBlockDim,colBlockDim,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2gebsr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_double_complex),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsr2gebsr_bufferSize_assumed_rank = hipsparseZcsr2gebsr_bufferSize_(handle,dir,m, & n,csr_descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),rowBlockDim,colBlockDim, & pBufferSizeInBytes) end function #else function hipsparseZcsr2gebsr_bufferSize_rank_0(handle,dir,m,n,csr_descr,csrVal,csrRowPtr, & csrColInd,rowBlockDim,colBlockDim,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2gebsr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_double_complex),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsr2gebsr_bufferSize_rank_0 = hipsparseZcsr2gebsr_bufferSize_(handle,dir,m,n, & csr_descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),rowBlockDim,colBlockDim, & pBufferSizeInBytes) end function function hipsparseZcsr2gebsr_bufferSize_rank_1(handle,dir,m,n,csr_descr,csrVal,csrRowPtr, & csrColInd,rowBlockDim,colBlockDim,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2gebsr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_double_complex),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsr2gebsr_bufferSize_rank_1 = hipsparseZcsr2gebsr_bufferSize_(handle,dir,m,n, & csr_descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),rowBlockDim,colBlockDim, & pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseXcsr2gebsrNnz_assumed_rank(handle,dir,m,n,csr_descr,csrRowPtr,csrColInd, & bsr_descr,bsrRowPtr,rowBlockDim,colBlockDim,bsrNnzDevhost,pbuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsr2gebsrNnz_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: bsr_descr integer(c_int),target,contiguous,dimension(..) :: bsrRowPtr integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim integer(c_int),target,contiguous,dimension(..) :: bsrNnzDevhost type(c_ptr) :: pbuffer ! hipsparseXcsr2gebsrNnz_assumed_rank = hipsparseXcsr2gebsrNnz_(handle,dir,m,n,csr_descr, & c_loc(csrRowPtr),c_loc(csrColInd),bsr_descr,c_loc(bsrRowPtr),rowBlockDim,colBlockDim, & c_loc(bsrNnzDevhost),pbuffer) end function #else function hipsparseXcsr2gebsrNnz_rank_0(handle,dir,m,n,csr_descr,csrRowPtr,csrColInd,bsr_descr, & bsrRowPtr,rowBlockDim,colBlockDim,bsrNnzDevhost,pbuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsr2gebsrNnz_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: bsr_descr integer(c_int),target :: bsrRowPtr integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim integer(c_int),target :: bsrNnzDevhost type(c_ptr) :: pbuffer ! hipsparseXcsr2gebsrNnz_rank_0 = hipsparseXcsr2gebsrNnz_(handle,dir,m,n,csr_descr, & c_loc(csrRowPtr),c_loc(csrColInd),bsr_descr,c_loc(bsrRowPtr),rowBlockDim,colBlockDim, & c_loc(bsrNnzDevhost),pbuffer) end function function hipsparseXcsr2gebsrNnz_rank_1(handle,dir,m,n,csr_descr,csrRowPtr,csrColInd,bsr_descr, & bsrRowPtr,rowBlockDim,colBlockDim,bsrNnzDevhost,pbuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsr2gebsrNnz_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: bsr_descr integer(c_int),target,dimension(:) :: bsrRowPtr integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim integer(c_int),target,dimension(:) :: bsrNnzDevhost type(c_ptr) :: pbuffer ! hipsparseXcsr2gebsrNnz_rank_1 = hipsparseXcsr2gebsrNnz_(handle,dir,m,n,csr_descr, & c_loc(csrRowPtr),c_loc(csrColInd),bsr_descr,c_loc(bsrRowPtr),rowBlockDim,colBlockDim, & c_loc(bsrNnzDevhost),pbuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsr2gebsr_assumed_rank(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & bsr_descr,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2gebsr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_float),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: bsr_descr real(c_float),target,contiguous,dimension(..) :: bsrVal integer(c_int),target,contiguous,dimension(..) :: bsrRowPtr integer(c_int),target,contiguous,dimension(..) :: bsrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: pbuffer ! hipsparseScsr2gebsr_assumed_rank = hipsparseScsr2gebsr_(handle,dir,m,n,csr_descr, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),bsr_descr,c_loc(bsrVal),c_loc(bsrRowPtr), & c_loc(bsrColInd),rowBlockDim,colBlockDim,pbuffer) end function #else function hipsparseScsr2gebsr_rank_0(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & bsr_descr,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2gebsr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_float),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: bsr_descr real(c_float),target :: bsrVal integer(c_int),target :: bsrRowPtr integer(c_int),target :: bsrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: pbuffer ! hipsparseScsr2gebsr_rank_0 = hipsparseScsr2gebsr_(handle,dir,m,n,csr_descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),bsr_descr,c_loc(bsrVal),c_loc(bsrRowPtr), & c_loc(bsrColInd),rowBlockDim,colBlockDim,pbuffer) end function function hipsparseScsr2gebsr_rank_1(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & bsr_descr,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2gebsr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: bsr_descr real(c_float),target,dimension(:) :: bsrVal integer(c_int),target,dimension(:) :: bsrRowPtr integer(c_int),target,dimension(:) :: bsrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: pbuffer ! hipsparseScsr2gebsr_rank_1 = hipsparseScsr2gebsr_(handle,dir,m,n,csr_descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),bsr_descr,c_loc(bsrVal),c_loc(bsrRowPtr), & c_loc(bsrColInd),rowBlockDim,colBlockDim,pbuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsr2gebsr_assumed_rank(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & bsr_descr,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2gebsr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_double),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: bsr_descr real(c_double),target,contiguous,dimension(..) :: bsrVal integer(c_int),target,contiguous,dimension(..) :: bsrRowPtr integer(c_int),target,contiguous,dimension(..) :: bsrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: pbuffer ! hipsparseDcsr2gebsr_assumed_rank = hipsparseDcsr2gebsr_(handle,dir,m,n,csr_descr, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),bsr_descr,c_loc(bsrVal),c_loc(bsrRowPtr), & c_loc(bsrColInd),rowBlockDim,colBlockDim,pbuffer) end function #else function hipsparseDcsr2gebsr_rank_0(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & bsr_descr,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2gebsr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_double),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: bsr_descr real(c_double),target :: bsrVal integer(c_int),target :: bsrRowPtr integer(c_int),target :: bsrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: pbuffer ! hipsparseDcsr2gebsr_rank_0 = hipsparseDcsr2gebsr_(handle,dir,m,n,csr_descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),bsr_descr,c_loc(bsrVal),c_loc(bsrRowPtr), & c_loc(bsrColInd),rowBlockDim,colBlockDim,pbuffer) end function function hipsparseDcsr2gebsr_rank_1(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & bsr_descr,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2gebsr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: bsr_descr real(c_double),target,dimension(:) :: bsrVal integer(c_int),target,dimension(:) :: bsrRowPtr integer(c_int),target,dimension(:) :: bsrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: pbuffer ! hipsparseDcsr2gebsr_rank_1 = hipsparseDcsr2gebsr_(handle,dir,m,n,csr_descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),bsr_descr,c_loc(bsrVal),c_loc(bsrRowPtr), & c_loc(bsrColInd),rowBlockDim,colBlockDim,pbuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsr2gebsr_assumed_rank(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & bsr_descr,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2gebsr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_float_complex),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: bsr_descr complex(c_float_complex),target,contiguous,dimension(..) :: bsrVal integer(c_int),target,contiguous,dimension(..) :: bsrRowPtr integer(c_int),target,contiguous,dimension(..) :: bsrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: pbuffer ! hipsparseCcsr2gebsr_assumed_rank = hipsparseCcsr2gebsr_(handle,dir,m,n,csr_descr, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),bsr_descr,c_loc(bsrVal),c_loc(bsrRowPtr), & c_loc(bsrColInd),rowBlockDim,colBlockDim,pbuffer) end function #else function hipsparseCcsr2gebsr_rank_0(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & bsr_descr,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2gebsr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_float_complex),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: bsr_descr complex(c_float_complex),target :: bsrVal integer(c_int),target :: bsrRowPtr integer(c_int),target :: bsrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: pbuffer ! hipsparseCcsr2gebsr_rank_0 = hipsparseCcsr2gebsr_(handle,dir,m,n,csr_descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),bsr_descr,c_loc(bsrVal),c_loc(bsrRowPtr), & c_loc(bsrColInd),rowBlockDim,colBlockDim,pbuffer) end function function hipsparseCcsr2gebsr_rank_1(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & bsr_descr,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2gebsr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_float_complex),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: bsr_descr complex(c_float_complex),target,dimension(:) :: bsrVal integer(c_int),target,dimension(:) :: bsrRowPtr integer(c_int),target,dimension(:) :: bsrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: pbuffer ! hipsparseCcsr2gebsr_rank_1 = hipsparseCcsr2gebsr_(handle,dir,m,n,csr_descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),bsr_descr,c_loc(bsrVal),c_loc(bsrRowPtr), & c_loc(bsrColInd),rowBlockDim,colBlockDim,pbuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsr2gebsr_assumed_rank(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & bsr_descr,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2gebsr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_double_complex),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: bsr_descr complex(c_double_complex),target,contiguous,dimension(..) :: bsrVal integer(c_int),target,contiguous,dimension(..) :: bsrRowPtr integer(c_int),target,contiguous,dimension(..) :: bsrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: pbuffer ! hipsparseZcsr2gebsr_assumed_rank = hipsparseZcsr2gebsr_(handle,dir,m,n,csr_descr, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),bsr_descr,c_loc(bsrVal),c_loc(bsrRowPtr), & c_loc(bsrColInd),rowBlockDim,colBlockDim,pbuffer) end function #else function hipsparseZcsr2gebsr_rank_0(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & bsr_descr,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2gebsr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_double_complex),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: bsr_descr complex(c_double_complex),target :: bsrVal integer(c_int),target :: bsrRowPtr integer(c_int),target :: bsrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: pbuffer ! hipsparseZcsr2gebsr_rank_0 = hipsparseZcsr2gebsr_(handle,dir,m,n,csr_descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),bsr_descr,c_loc(bsrVal),c_loc(bsrRowPtr), & c_loc(bsrColInd),rowBlockDim,colBlockDim,pbuffer) end function function hipsparseZcsr2gebsr_rank_1(handle,dir,m,n,csr_descr,csrVal,csrRowPtr,csrColInd, & bsr_descr,bsrVal,bsrRowPtr,bsrColInd,rowBlockDim,colBlockDim,pbuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2gebsr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_double_complex),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: bsr_descr complex(c_double_complex),target,dimension(:) :: bsrVal integer(c_int),target,dimension(:) :: bsrRowPtr integer(c_int),target,dimension(:) :: bsrColInd integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: pbuffer ! hipsparseZcsr2gebsr_rank_1 = hipsparseZcsr2gebsr_(handle,dir,m,n,csr_descr,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),bsr_descr,c_loc(bsrVal),c_loc(bsrRowPtr), & c_loc(bsrColInd),rowBlockDim,colBlockDim,pbuffer) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsr2hyb_assumed_rank(handle,m,n,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,hybA,userEllWidth,partitionType) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2hyb_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: hybA integer(c_int) :: userEllWidth integer(kind(HIPSPARSE_HYB_PARTITION_AUTO)) :: partitionType ! hipsparseScsr2hyb_assumed_rank = hipsparseScsr2hyb_(handle,m,n,descrA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),hybA,userEllWidth,partitionType) end function #else function hipsparseScsr2hyb_rank_0(handle,m,n,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,hybA,userEllWidth,partitionType) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2hyb_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: hybA integer(c_int) :: userEllWidth integer(kind(HIPSPARSE_HYB_PARTITION_AUTO)) :: partitionType ! hipsparseScsr2hyb_rank_0 = hipsparseScsr2hyb_(handle,m,n,descrA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),hybA,userEllWidth,partitionType) end function function hipsparseScsr2hyb_rank_1(handle,m,n,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,hybA,userEllWidth,partitionType) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsr2hyb_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: hybA integer(c_int) :: userEllWidth integer(kind(HIPSPARSE_HYB_PARTITION_AUTO)) :: partitionType ! hipsparseScsr2hyb_rank_1 = hipsparseScsr2hyb_(handle,m,n,descrA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),hybA,userEllWidth,partitionType) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsr2hyb_assumed_rank(handle,m,n,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,hybA,userEllWidth,partitionType) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2hyb_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: hybA integer(c_int) :: userEllWidth integer(kind(HIPSPARSE_HYB_PARTITION_AUTO)) :: partitionType ! hipsparseDcsr2hyb_assumed_rank = hipsparseDcsr2hyb_(handle,m,n,descrA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),hybA,userEllWidth,partitionType) end function #else function hipsparseDcsr2hyb_rank_0(handle,m,n,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,hybA,userEllWidth,partitionType) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2hyb_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: hybA integer(c_int) :: userEllWidth integer(kind(HIPSPARSE_HYB_PARTITION_AUTO)) :: partitionType ! hipsparseDcsr2hyb_rank_0 = hipsparseDcsr2hyb_(handle,m,n,descrA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),hybA,userEllWidth,partitionType) end function function hipsparseDcsr2hyb_rank_1(handle,m,n,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,hybA,userEllWidth,partitionType) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsr2hyb_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: hybA integer(c_int) :: userEllWidth integer(kind(HIPSPARSE_HYB_PARTITION_AUTO)) :: partitionType ! hipsparseDcsr2hyb_rank_1 = hipsparseDcsr2hyb_(handle,m,n,descrA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),hybA,userEllWidth,partitionType) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsr2hyb_assumed_rank(handle,m,n,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,hybA,userEllWidth,partitionType) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2hyb_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: hybA integer(c_int) :: userEllWidth integer(kind(HIPSPARSE_HYB_PARTITION_AUTO)) :: partitionType ! hipsparseCcsr2hyb_assumed_rank = hipsparseCcsr2hyb_(handle,m,n,descrA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),hybA,userEllWidth,partitionType) end function #else function hipsparseCcsr2hyb_rank_0(handle,m,n,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,hybA,userEllWidth,partitionType) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2hyb_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: hybA integer(c_int) :: userEllWidth integer(kind(HIPSPARSE_HYB_PARTITION_AUTO)) :: partitionType ! hipsparseCcsr2hyb_rank_0 = hipsparseCcsr2hyb_(handle,m,n,descrA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),hybA,userEllWidth,partitionType) end function function hipsparseCcsr2hyb_rank_1(handle,m,n,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,hybA,userEllWidth,partitionType) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsr2hyb_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: hybA integer(c_int) :: userEllWidth integer(kind(HIPSPARSE_HYB_PARTITION_AUTO)) :: partitionType ! hipsparseCcsr2hyb_rank_1 = hipsparseCcsr2hyb_(handle,m,n,descrA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),hybA,userEllWidth,partitionType) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsr2hyb_assumed_rank(handle,m,n,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,hybA,userEllWidth,partitionType) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2hyb_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA type(c_ptr) :: hybA integer(c_int) :: userEllWidth integer(kind(HIPSPARSE_HYB_PARTITION_AUTO)) :: partitionType ! hipsparseZcsr2hyb_assumed_rank = hipsparseZcsr2hyb_(handle,m,n,descrA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),hybA,userEllWidth,partitionType) end function #else function hipsparseZcsr2hyb_rank_0(handle,m,n,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,hybA,userEllWidth,partitionType) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2hyb_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA type(c_ptr) :: hybA integer(c_int) :: userEllWidth integer(kind(HIPSPARSE_HYB_PARTITION_AUTO)) :: partitionType ! hipsparseZcsr2hyb_rank_0 = hipsparseZcsr2hyb_(handle,m,n,descrA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),hybA,userEllWidth,partitionType) end function function hipsparseZcsr2hyb_rank_1(handle,m,n,descrA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA,hybA,userEllWidth,partitionType) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsr2hyb_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA type(c_ptr) :: hybA integer(c_int) :: userEllWidth integer(kind(HIPSPARSE_HYB_PARTITION_AUTO)) :: partitionType ! hipsparseZcsr2hyb_rank_1 = hipsparseZcsr2hyb_(handle,m,n,descrA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA),hybA,userEllWidth,partitionType) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseXcsrsort_bufferSizeExt_assumed_rank(handle,m,n,nnz,csrRowPtr,csrColInd, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrsort_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseXcsrsort_bufferSizeExt_assumed_rank = hipsparseXcsrsort_bufferSizeExt_(handle,m,n, & nnz,c_loc(csrRowPtr),c_loc(csrColInd),pBufferSizeInBytes) end function #else function hipsparseXcsrsort_bufferSizeExt_rank_0(handle,m,n,nnz,csrRowPtr,csrColInd, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrsort_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseXcsrsort_bufferSizeExt_rank_0 = hipsparseXcsrsort_bufferSizeExt_(handle,m,n,nnz, & c_loc(csrRowPtr),c_loc(csrColInd),pBufferSizeInBytes) end function function hipsparseXcsrsort_bufferSizeExt_rank_1(handle,m,n,nnz,csrRowPtr,csrColInd, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrsort_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseXcsrsort_bufferSizeExt_rank_1 = hipsparseXcsrsort_bufferSizeExt_(handle,m,n,nnz, & c_loc(csrRowPtr),c_loc(csrColInd),pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseXcsrsort_assumed_rank(handle,m,n,nnz,descrA,csrRowPtr,csrColInd,P,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrsort_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd integer(c_int),target,contiguous,dimension(..) :: P type(c_ptr) :: pBuffer ! hipsparseXcsrsort_assumed_rank = hipsparseXcsrsort_(handle,m,n,nnz,descrA,c_loc(csrRowPtr), & c_loc(csrColInd),c_loc(P),pBuffer) end function #else function hipsparseXcsrsort_rank_0(handle,m,n,nnz,descrA,csrRowPtr,csrColInd,P,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrsort_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd integer(c_int),target :: P type(c_ptr) :: pBuffer ! hipsparseXcsrsort_rank_0 = hipsparseXcsrsort_(handle,m,n,nnz,descrA,c_loc(csrRowPtr), & c_loc(csrColInd),c_loc(P),pBuffer) end function function hipsparseXcsrsort_rank_1(handle,m,n,nnz,descrA,csrRowPtr,csrColInd,P,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXcsrsort_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd integer(c_int),target,dimension(:) :: P type(c_ptr) :: pBuffer ! hipsparseXcsrsort_rank_1 = hipsparseXcsrsort_(handle,m,n,nnz,descrA,c_loc(csrRowPtr), & c_loc(csrColInd),c_loc(P),pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsru2csr_bufferSizeExt_assumed_rank(handle,m,n,nnz,csrVal,csrRowPtr, & csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsru2csr_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_float),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsru2csr_bufferSizeExt_assumed_rank = hipsparseScsru2csr_bufferSizeExt_(handle,m, & n,nnz,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function #else function hipsparseScsru2csr_bufferSizeExt_rank_0(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd, & myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsru2csr_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_float),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsru2csr_bufferSizeExt_rank_0 = hipsparseScsru2csr_bufferSizeExt_(handle,m,n,nnz, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function function hipsparseScsru2csr_bufferSizeExt_rank_1(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd, & myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsru2csr_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseScsru2csr_bufferSizeExt_rank_1 = hipsparseScsru2csr_bufferSizeExt_(handle,m,n,nnz, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsru2csr_bufferSizeExt_assumed_rank(handle,m,n,nnz,csrVal,csrRowPtr, & csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsru2csr_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_double),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsru2csr_bufferSizeExt_assumed_rank = hipsparseDcsru2csr_bufferSizeExt_(handle,m, & n,nnz,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function #else function hipsparseDcsru2csr_bufferSizeExt_rank_0(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd, & myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsru2csr_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_double),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsru2csr_bufferSizeExt_rank_0 = hipsparseDcsru2csr_bufferSizeExt_(handle,m,n,nnz, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function function hipsparseDcsru2csr_bufferSizeExt_rank_1(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd, & myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsru2csr_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDcsru2csr_bufferSizeExt_rank_1 = hipsparseDcsru2csr_bufferSizeExt_(handle,m,n,nnz, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsru2csr_bufferSizeExt_assumed_rank(handle,m,n,nnz,csrVal,csrRowPtr, & csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsru2csr_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_float_complex),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsru2csr_bufferSizeExt_assumed_rank = hipsparseCcsru2csr_bufferSizeExt_(handle,m, & n,nnz,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function #else function hipsparseCcsru2csr_bufferSizeExt_rank_0(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd, & myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsru2csr_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_float_complex),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsru2csr_bufferSizeExt_rank_0 = hipsparseCcsru2csr_bufferSizeExt_(handle,m,n,nnz, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function function hipsparseCcsru2csr_bufferSizeExt_rank_1(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd, & myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsru2csr_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_float_complex),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseCcsru2csr_bufferSizeExt_rank_1 = hipsparseCcsru2csr_bufferSizeExt_(handle,m,n,nnz, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsru2csr_bufferSizeExt_assumed_rank(handle,m,n,nnz,csrVal,csrRowPtr, & csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsru2csr_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_double_complex),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsru2csr_bufferSizeExt_assumed_rank = hipsparseZcsru2csr_bufferSizeExt_(handle,m, & n,nnz,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function #else function hipsparseZcsru2csr_bufferSizeExt_rank_0(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd, & myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsru2csr_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_double_complex),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsru2csr_bufferSizeExt_rank_0 = hipsparseZcsru2csr_bufferSizeExt_(handle,m,n,nnz, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function function hipsparseZcsru2csr_bufferSizeExt_rank_1(handle,m,n,nnz,csrVal,csrRowPtr,csrColInd, & myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsru2csr_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_double_complex),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseZcsru2csr_bufferSizeExt_rank_1 = hipsparseZcsru2csr_bufferSizeExt_(handle,m,n,nnz, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsru2csr_assumed_rank(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd, & myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsru2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseScsru2csr_assumed_rank = hipsparseScsru2csr_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function #else function hipsparseScsru2csr_rank_0(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsru2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseScsru2csr_rank_0 = hipsparseScsru2csr_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function function hipsparseScsru2csr_rank_1(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsru2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseScsru2csr_rank_1 = hipsparseScsru2csr_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsru2csr_assumed_rank(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd, & myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsru2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseDcsru2csr_assumed_rank = hipsparseDcsru2csr_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function #else function hipsparseDcsru2csr_rank_0(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsru2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseDcsru2csr_rank_0 = hipsparseDcsru2csr_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function function hipsparseDcsru2csr_rank_1(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsru2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseDcsru2csr_rank_1 = hipsparseDcsru2csr_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsru2csr_assumed_rank(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd, & myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsru2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseCcsru2csr_assumed_rank = hipsparseCcsru2csr_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function #else function hipsparseCcsru2csr_rank_0(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsru2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseCcsru2csr_rank_0 = hipsparseCcsru2csr_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function function hipsparseCcsru2csr_rank_1(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsru2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseCcsru2csr_rank_1 = hipsparseCcsru2csr_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsru2csr_assumed_rank(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd, & myInfo,pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsru2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseZcsru2csr_assumed_rank = hipsparseZcsru2csr_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function #else function hipsparseZcsru2csr_rank_0(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsru2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseZcsru2csr_rank_0 = hipsparseZcsru2csr_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function function hipsparseZcsru2csr_rank_1(handle,m,n,nnz,descrA,csrVal,csrRowPtr,csrColInd,myInfo, & pBuffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsru2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: pBuffer ! hipsparseZcsru2csr_rank_1 = hipsparseZcsru2csr_(handle,m,n,nnz,descrA,c_loc(csrVal), & c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBuffer) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSdense2csc_assumed_rank(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd, & cscColPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSdense2csc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnzPerColumn real(c_float),target,contiguous,dimension(..) :: cscVal integer(c_int),target,contiguous,dimension(..) :: cscRowInd integer(c_int),target,contiguous,dimension(..) :: cscColPtr ! hipsparseSdense2csc_assumed_rank = hipsparseSdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerColumn),c_loc(cscVal),c_loc(cscRowInd),c_loc(cscColPtr)) end function #else function hipsparseSdense2csc_rank_0(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd, & cscColPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSdense2csc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target :: A integer(c_int) :: ld integer(c_int),target :: nnzPerColumn real(c_float),target :: cscVal integer(c_int),target :: cscRowInd integer(c_int),target :: cscColPtr ! hipsparseSdense2csc_rank_0 = hipsparseSdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerColumn),c_loc(cscVal),c_loc(cscRowInd),c_loc(cscColPtr)) end function function hipsparseSdense2csc_rank_1(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd, & cscColPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSdense2csc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnzPerColumn real(c_float),target,dimension(:) :: cscVal integer(c_int),target,dimension(:) :: cscRowInd integer(c_int),target,dimension(:) :: cscColPtr ! hipsparseSdense2csc_rank_1 = hipsparseSdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerColumn),c_loc(cscVal),c_loc(cscRowInd),c_loc(cscColPtr)) end function function hipsparseSdense2csc_full_rank(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd, & cscColPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSdense2csc_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnzPerColumn real(c_float),target,dimension(:) :: cscVal integer(c_int),target,dimension(:) :: cscRowInd integer(c_int),target,dimension(:) :: cscColPtr ! hipsparseSdense2csc_full_rank = hipsparseSdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerColumn),c_loc(cscVal),c_loc(cscRowInd),c_loc(cscColPtr)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDdense2csc_assumed_rank(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd, & cscColPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDdense2csc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnzPerColumn real(c_double),target,contiguous,dimension(..) :: cscVal integer(c_int),target,contiguous,dimension(..) :: cscRowInd integer(c_int),target,contiguous,dimension(..) :: cscColPtr ! hipsparseDdense2csc_assumed_rank = hipsparseDdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerColumn),c_loc(cscVal),c_loc(cscRowInd),c_loc(cscColPtr)) end function #else function hipsparseDdense2csc_rank_0(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd, & cscColPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDdense2csc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target :: A integer(c_int) :: ld integer(c_int),target :: nnzPerColumn real(c_double),target :: cscVal integer(c_int),target :: cscRowInd integer(c_int),target :: cscColPtr ! hipsparseDdense2csc_rank_0 = hipsparseDdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerColumn),c_loc(cscVal),c_loc(cscRowInd),c_loc(cscColPtr)) end function function hipsparseDdense2csc_rank_1(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd, & cscColPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDdense2csc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnzPerColumn real(c_double),target,dimension(:) :: cscVal integer(c_int),target,dimension(:) :: cscRowInd integer(c_int),target,dimension(:) :: cscColPtr ! hipsparseDdense2csc_rank_1 = hipsparseDdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerColumn),c_loc(cscVal),c_loc(cscRowInd),c_loc(cscColPtr)) end function function hipsparseDdense2csc_full_rank(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd, & cscColPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDdense2csc_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnzPerColumn real(c_double),target,dimension(:) :: cscVal integer(c_int),target,dimension(:) :: cscRowInd integer(c_int),target,dimension(:) :: cscColPtr ! hipsparseDdense2csc_full_rank = hipsparseDdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerColumn),c_loc(cscVal),c_loc(cscRowInd),c_loc(cscColPtr)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCdense2csc_assumed_rank(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd, & cscColPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCdense2csc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnzPerColumn complex(c_float_complex),target,contiguous,dimension(..) :: cscVal integer(c_int),target,contiguous,dimension(..) :: cscRowInd integer(c_int),target,contiguous,dimension(..) :: cscColPtr ! hipsparseCdense2csc_assumed_rank = hipsparseCdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerColumn),c_loc(cscVal),c_loc(cscRowInd),c_loc(cscColPtr)) end function #else function hipsparseCdense2csc_rank_0(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd, & cscColPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCdense2csc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target :: A integer(c_int) :: ld integer(c_int),target :: nnzPerColumn complex(c_float_complex),target :: cscVal integer(c_int),target :: cscRowInd integer(c_int),target :: cscColPtr ! hipsparseCdense2csc_rank_0 = hipsparseCdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerColumn),c_loc(cscVal),c_loc(cscRowInd),c_loc(cscColPtr)) end function function hipsparseCdense2csc_rank_1(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd, & cscColPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCdense2csc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnzPerColumn complex(c_float_complex),target,dimension(:) :: cscVal integer(c_int),target,dimension(:) :: cscRowInd integer(c_int),target,dimension(:) :: cscColPtr ! hipsparseCdense2csc_rank_1 = hipsparseCdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerColumn),c_loc(cscVal),c_loc(cscRowInd),c_loc(cscColPtr)) end function function hipsparseCdense2csc_full_rank(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd, & cscColPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCdense2csc_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnzPerColumn complex(c_float_complex),target,dimension(:) :: cscVal integer(c_int),target,dimension(:) :: cscRowInd integer(c_int),target,dimension(:) :: cscColPtr ! hipsparseCdense2csc_full_rank = hipsparseCdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerColumn),c_loc(cscVal),c_loc(cscRowInd),c_loc(cscColPtr)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZdense2csc_assumed_rank(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd, & cscColPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZdense2csc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnzPerColumn complex(c_double_complex),target,contiguous,dimension(..) :: cscVal integer(c_int),target,contiguous,dimension(..) :: cscRowInd integer(c_int),target,contiguous,dimension(..) :: cscColPtr ! hipsparseZdense2csc_assumed_rank = hipsparseZdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerColumn),c_loc(cscVal),c_loc(cscRowInd),c_loc(cscColPtr)) end function #else function hipsparseZdense2csc_rank_0(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd, & cscColPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZdense2csc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target :: A integer(c_int) :: ld integer(c_int),target :: nnzPerColumn complex(c_double_complex),target :: cscVal integer(c_int),target :: cscRowInd integer(c_int),target :: cscColPtr ! hipsparseZdense2csc_rank_0 = hipsparseZdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerColumn),c_loc(cscVal),c_loc(cscRowInd),c_loc(cscColPtr)) end function function hipsparseZdense2csc_rank_1(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd, & cscColPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZdense2csc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnzPerColumn complex(c_double_complex),target,dimension(:) :: cscVal integer(c_int),target,dimension(:) :: cscRowInd integer(c_int),target,dimension(:) :: cscColPtr ! hipsparseZdense2csc_rank_1 = hipsparseZdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerColumn),c_loc(cscVal),c_loc(cscRowInd),c_loc(cscColPtr)) end function function hipsparseZdense2csc_full_rank(handle,m,n,descr,A,ld,nnzPerColumn,cscVal,cscRowInd, & cscColPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZdense2csc_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnzPerColumn complex(c_double_complex),target,dimension(:) :: cscVal integer(c_int),target,dimension(:) :: cscRowInd integer(c_int),target,dimension(:) :: cscColPtr ! hipsparseZdense2csc_full_rank = hipsparseZdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerColumn),c_loc(cscVal),c_loc(cscRowInd),c_loc(cscColPtr)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSdense2csr_assumed_rank(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr, & csrColInd) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSdense2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnzPerRow real(c_float),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd ! hipsparseSdense2csr_assumed_rank = hipsparseSdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerRow),c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd)) end function #else function hipsparseSdense2csr_rank_0(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr,csrColInd) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSdense2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target :: A integer(c_int) :: ld integer(c_int),target :: nnzPerRow real(c_float),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd ! hipsparseSdense2csr_rank_0 = hipsparseSdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerRow),c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd)) end function function hipsparseSdense2csr_rank_1(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr,csrColInd) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSdense2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnzPerRow real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd ! hipsparseSdense2csr_rank_1 = hipsparseSdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerRow),c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd)) end function function hipsparseSdense2csr_full_rank(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr, & csrColInd) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSdense2csr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnzPerRow real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd ! hipsparseSdense2csr_full_rank = hipsparseSdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerRow),c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDdense2csr_assumed_rank(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr, & csrColInd) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDdense2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnzPerRow real(c_double),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd ! hipsparseDdense2csr_assumed_rank = hipsparseDdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerRow),c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd)) end function #else function hipsparseDdense2csr_rank_0(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr,csrColInd) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDdense2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target :: A integer(c_int) :: ld integer(c_int),target :: nnzPerRow real(c_double),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd ! hipsparseDdense2csr_rank_0 = hipsparseDdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerRow),c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd)) end function function hipsparseDdense2csr_rank_1(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr,csrColInd) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDdense2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnzPerRow real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd ! hipsparseDdense2csr_rank_1 = hipsparseDdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerRow),c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd)) end function function hipsparseDdense2csr_full_rank(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr, & csrColInd) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDdense2csr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnzPerRow real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd ! hipsparseDdense2csr_full_rank = hipsparseDdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerRow),c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCdense2csr_assumed_rank(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr, & csrColInd) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCdense2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnzPerRow complex(c_float_complex),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd ! hipsparseCdense2csr_assumed_rank = hipsparseCdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerRow),c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd)) end function #else function hipsparseCdense2csr_rank_0(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr,csrColInd) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCdense2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target :: A integer(c_int) :: ld integer(c_int),target :: nnzPerRow complex(c_float_complex),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd ! hipsparseCdense2csr_rank_0 = hipsparseCdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerRow),c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd)) end function function hipsparseCdense2csr_rank_1(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr,csrColInd) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCdense2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnzPerRow complex(c_float_complex),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd ! hipsparseCdense2csr_rank_1 = hipsparseCdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerRow),c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd)) end function function hipsparseCdense2csr_full_rank(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr, & csrColInd) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCdense2csr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnzPerRow complex(c_float_complex),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd ! hipsparseCdense2csr_full_rank = hipsparseCdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerRow),c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZdense2csr_assumed_rank(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr, & csrColInd) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZdense2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnzPerRow complex(c_double_complex),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd ! hipsparseZdense2csr_assumed_rank = hipsparseZdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerRow),c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd)) end function #else function hipsparseZdense2csr_rank_0(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr,csrColInd) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZdense2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target :: A integer(c_int) :: ld integer(c_int),target :: nnzPerRow complex(c_double_complex),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd ! hipsparseZdense2csr_rank_0 = hipsparseZdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerRow),c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd)) end function function hipsparseZdense2csr_rank_1(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr,csrColInd) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZdense2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnzPerRow complex(c_double_complex),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd ! hipsparseZdense2csr_rank_1 = hipsparseZdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerRow),c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd)) end function function hipsparseZdense2csr_full_rank(handle,m,n,descr,A,ld,nnzPerRow,csrVal,csrRowPtr, & csrColInd) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZdense2csr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnzPerRow complex(c_double_complex),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd ! hipsparseZdense2csr_full_rank = hipsparseZdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnzPerRow),c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd)) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSgebsr2csr_assumed_rank(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgebsr2csr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: descrC real(c_float),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC ! hipsparseSgebsr2csr_assumed_rank = hipsparseSgebsr2csr_(handle,dirA,mb,nb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDim,colBlockDim,descrC, & c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC)) end function #else function hipsparseSgebsr2csr_rank_0(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgebsr2csr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA real(c_float),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: descrC real(c_float),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC ! hipsparseSgebsr2csr_rank_0 = hipsparseSgebsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDim,colBlockDim,descrC,c_loc(csrValC), & c_loc(csrRowPtrC),c_loc(csrColIndC)) end function function hipsparseSgebsr2csr_rank_1(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgebsr2csr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: descrC real(c_float),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC ! hipsparseSgebsr2csr_rank_1 = hipsparseSgebsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDim,colBlockDim,descrC,c_loc(csrValC), & c_loc(csrRowPtrC),c_loc(csrColIndC)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDgebsr2csr_assumed_rank(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgebsr2csr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: descrC real(c_double),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC ! hipsparseDgebsr2csr_assumed_rank = hipsparseDgebsr2csr_(handle,dirA,mb,nb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDim,colBlockDim,descrC, & c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC)) end function #else function hipsparseDgebsr2csr_rank_0(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgebsr2csr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA real(c_double),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: descrC real(c_double),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC ! hipsparseDgebsr2csr_rank_0 = hipsparseDgebsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDim,colBlockDim,descrC,c_loc(csrValC), & c_loc(csrRowPtrC),c_loc(csrColIndC)) end function function hipsparseDgebsr2csr_rank_1(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgebsr2csr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: descrC real(c_double),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC ! hipsparseDgebsr2csr_rank_1 = hipsparseDgebsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDim,colBlockDim,descrC,c_loc(csrValC), & c_loc(csrRowPtrC),c_loc(csrColIndC)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCgebsr2csr_assumed_rank(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgebsr2csr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: descrC complex(c_float_complex),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC ! hipsparseCgebsr2csr_assumed_rank = hipsparseCgebsr2csr_(handle,dirA,mb,nb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDim,colBlockDim,descrC, & c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC)) end function #else function hipsparseCgebsr2csr_rank_0(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgebsr2csr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA complex(c_float_complex),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: descrC complex(c_float_complex),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC ! hipsparseCgebsr2csr_rank_0 = hipsparseCgebsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDim,colBlockDim,descrC,c_loc(csrValC), & c_loc(csrRowPtrC),c_loc(csrColIndC)) end function function hipsparseCgebsr2csr_rank_1(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgebsr2csr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: descrC complex(c_float_complex),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC ! hipsparseCgebsr2csr_rank_1 = hipsparseCgebsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDim,colBlockDim,descrC,c_loc(csrValC), & c_loc(csrRowPtrC),c_loc(csrColIndC)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZgebsr2csr_assumed_rank(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgebsr2csr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: descrC complex(c_double_complex),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC ! hipsparseZgebsr2csr_assumed_rank = hipsparseZgebsr2csr_(handle,dirA,mb,nb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDim,colBlockDim,descrC, & c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC)) end function #else function hipsparseZgebsr2csr_rank_0(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgebsr2csr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA complex(c_double_complex),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: descrC complex(c_double_complex),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC ! hipsparseZgebsr2csr_rank_0 = hipsparseZgebsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDim,colBlockDim,descrC,c_loc(csrValC), & c_loc(csrRowPtrC),c_loc(csrColIndC)) end function function hipsparseZgebsr2csr_rank_1(handle,dirA,mb,nb,descrA,bsrValA,bsrRowPtrA,bsrColIndA, & rowBlockDim,colBlockDim,descrC,csrValC,csrRowPtrC,csrColIndC) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgebsr2csr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: rowBlockDim integer(c_int) :: colBlockDim type(c_ptr) :: descrC complex(c_double_complex),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC ! hipsparseZgebsr2csr_rank_1 = hipsparseZgebsr2csr_(handle,dirA,mb,nb,descrA,c_loc(bsrValA), & c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDim,colBlockDim,descrC,c_loc(csrValC), & c_loc(csrRowPtrC),c_loc(csrColIndC)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSgebsr2gebsr_bufferSize_assumed_rank(handle,dirA,mb,nb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgebsr2gebsr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC integer(c_int) :: pBufferSizeInBytes ! hipsparseSgebsr2gebsr_bufferSize_assumed_rank = hipsparseSgebsr2gebsr_bufferSize_(handle, & dirA,mb,nb,nnzb,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA, & colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) end function #else function hipsparseSgebsr2gebsr_bufferSize_rank_0(handle,dirA,mb,nb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgebsr2gebsr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC integer(c_int) :: pBufferSizeInBytes ! hipsparseSgebsr2gebsr_bufferSize_rank_0 = hipsparseSgebsr2gebsr_bufferSize_(handle,dirA,mb, & nb,nnzb,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA, & colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) end function function hipsparseSgebsr2gebsr_bufferSize_rank_1(handle,dirA,mb,nb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgebsr2gebsr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC integer(c_int) :: pBufferSizeInBytes ! hipsparseSgebsr2gebsr_bufferSize_rank_1 = hipsparseSgebsr2gebsr_bufferSize_(handle,dirA,mb, & nb,nnzb,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA, & colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDgebsr2gebsr_bufferSize_assumed_rank(handle,dirA,mb,nb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgebsr2gebsr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC integer(c_int) :: pBufferSizeInBytes ! hipsparseDgebsr2gebsr_bufferSize_assumed_rank = hipsparseDgebsr2gebsr_bufferSize_(handle, & dirA,mb,nb,nnzb,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA, & colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) end function #else function hipsparseDgebsr2gebsr_bufferSize_rank_0(handle,dirA,mb,nb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgebsr2gebsr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC integer(c_int) :: pBufferSizeInBytes ! hipsparseDgebsr2gebsr_bufferSize_rank_0 = hipsparseDgebsr2gebsr_bufferSize_(handle,dirA,mb, & nb,nnzb,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA, & colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) end function function hipsparseDgebsr2gebsr_bufferSize_rank_1(handle,dirA,mb,nb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgebsr2gebsr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC integer(c_int) :: pBufferSizeInBytes ! hipsparseDgebsr2gebsr_bufferSize_rank_1 = hipsparseDgebsr2gebsr_bufferSize_(handle,dirA,mb, & nb,nnzb,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA, & colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCgebsr2gebsr_bufferSize_assumed_rank(handle,dirA,mb,nb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgebsr2gebsr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC integer(c_int) :: pBufferSizeInBytes ! hipsparseCgebsr2gebsr_bufferSize_assumed_rank = hipsparseCgebsr2gebsr_bufferSize_(handle, & dirA,mb,nb,nnzb,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA, & colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) end function #else function hipsparseCgebsr2gebsr_bufferSize_rank_0(handle,dirA,mb,nb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgebsr2gebsr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC integer(c_int) :: pBufferSizeInBytes ! hipsparseCgebsr2gebsr_bufferSize_rank_0 = hipsparseCgebsr2gebsr_bufferSize_(handle,dirA,mb, & nb,nnzb,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA, & colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) end function function hipsparseCgebsr2gebsr_bufferSize_rank_1(handle,dirA,mb,nb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgebsr2gebsr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC integer(c_int) :: pBufferSizeInBytes ! hipsparseCgebsr2gebsr_bufferSize_rank_1 = hipsparseCgebsr2gebsr_bufferSize_(handle,dirA,mb, & nb,nnzb,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA, & colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZgebsr2gebsr_bufferSize_assumed_rank(handle,dirA,mb,nb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgebsr2gebsr_bufferSize_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC integer(c_int) :: pBufferSizeInBytes ! hipsparseZgebsr2gebsr_bufferSize_assumed_rank = hipsparseZgebsr2gebsr_bufferSize_(handle, & dirA,mb,nb,nnzb,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA, & colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) end function #else function hipsparseZgebsr2gebsr_bufferSize_rank_0(handle,dirA,mb,nb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgebsr2gebsr_bufferSize_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC integer(c_int) :: pBufferSizeInBytes ! hipsparseZgebsr2gebsr_bufferSize_rank_0 = hipsparseZgebsr2gebsr_bufferSize_(handle,dirA,mb, & nb,nnzb,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA, & colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) end function function hipsparseZgebsr2gebsr_bufferSize_rank_1(handle,dirA,mb,nb,nnzb,descrA,bsrValA, & bsrRowPtrA,bsrColIndA,rowBlockDimA,colBlockDimA,rowBlockDimC,colBlockDimC, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgebsr2gebsr_bufferSize_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC integer(c_int) :: pBufferSizeInBytes ! hipsparseZgebsr2gebsr_bufferSize_rank_1 = hipsparseZgebsr2gebsr_bufferSize_(handle,dirA,mb, & nb,nnzb,descrA,c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA, & colBlockDimA,rowBlockDimC,colBlockDimC,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseXgebsr2gebsrNnz_assumed_rank(handle,dirA,mb,nb,nnzb,descrA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,descrC,bsrRowPtrC,rowBlockDimC,colBlockDimC, & nnzTotalDevHostPtr,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXgebsr2gebsrNnz_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA type(c_ptr) :: descrC integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrC integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: buffer ! hipsparseXgebsr2gebsrNnz_assumed_rank = hipsparseXgebsr2gebsrNnz_(handle,dirA,mb,nb,nnzb, & descrA,c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA,colBlockDimA,descrC, & c_loc(bsrRowPtrC),rowBlockDimC,colBlockDimC,nnzTotalDevHostPtr,buffer) end function #else function hipsparseXgebsr2gebsrNnz_rank_0(handle,dirA,mb,nb,nnzb,descrA,bsrRowPtrA,bsrColIndA, & rowBlockDimA,colBlockDimA,descrC,bsrRowPtrC,rowBlockDimC,colBlockDimC,nnzTotalDevHostPtr, & buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXgebsr2gebsrNnz_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA type(c_ptr) :: descrC integer(c_int),target :: bsrRowPtrC integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: buffer ! hipsparseXgebsr2gebsrNnz_rank_0 = hipsparseXgebsr2gebsrNnz_(handle,dirA,mb,nb,nnzb,descrA, & c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA,colBlockDimA,descrC,c_loc(bsrRowPtrC), & rowBlockDimC,colBlockDimC,nnzTotalDevHostPtr,buffer) end function function hipsparseXgebsr2gebsrNnz_rank_1(handle,dirA,mb,nb,nnzb,descrA,bsrRowPtrA,bsrColIndA, & rowBlockDimA,colBlockDimA,descrC,bsrRowPtrC,rowBlockDimC,colBlockDimC,nnzTotalDevHostPtr, & buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseXgebsr2gebsrNnz_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA type(c_ptr) :: descrC integer(c_int),target,dimension(:) :: bsrRowPtrC integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: buffer ! hipsparseXgebsr2gebsrNnz_rank_1 = hipsparseXgebsr2gebsrNnz_(handle,dirA,mb,nb,nnzb,descrA, & c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA,colBlockDimA,descrC,c_loc(bsrRowPtrC), & rowBlockDimC,colBlockDimC,nnzTotalDevHostPtr,buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSgebsr2gebsr_assumed_rank(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC, & colBlockDimC,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgebsr2gebsr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA type(c_ptr) :: descrC real(c_float),target,contiguous,dimension(..) :: bsrValC integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrC integer(c_int),target,contiguous,dimension(..) :: bsrColIndC integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC type(c_ptr) :: buffer ! hipsparseSgebsr2gebsr_assumed_rank = hipsparseSgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA,colBlockDimA,descrC, & c_loc(bsrValC),c_loc(bsrRowPtrC),c_loc(bsrColIndC),rowBlockDimC,colBlockDimC,buffer) end function #else function hipsparseSgebsr2gebsr_rank_0(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC, & colBlockDimC,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgebsr2gebsr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA type(c_ptr) :: descrC real(c_float),target :: bsrValC integer(c_int),target :: bsrRowPtrC integer(c_int),target :: bsrColIndC integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC type(c_ptr) :: buffer ! hipsparseSgebsr2gebsr_rank_0 = hipsparseSgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA,colBlockDimA,descrC, & c_loc(bsrValC),c_loc(bsrRowPtrC),c_loc(bsrColIndC),rowBlockDimC,colBlockDimC,buffer) end function function hipsparseSgebsr2gebsr_rank_1(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC, & colBlockDimC,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSgebsr2gebsr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_float),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA type(c_ptr) :: descrC real(c_float),target,dimension(:) :: bsrValC integer(c_int),target,dimension(:) :: bsrRowPtrC integer(c_int),target,dimension(:) :: bsrColIndC integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC type(c_ptr) :: buffer ! hipsparseSgebsr2gebsr_rank_1 = hipsparseSgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA,colBlockDimA,descrC, & c_loc(bsrValC),c_loc(bsrRowPtrC),c_loc(bsrColIndC),rowBlockDimC,colBlockDimC,buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDgebsr2gebsr_assumed_rank(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC, & colBlockDimC,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgebsr2gebsr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA type(c_ptr) :: descrC real(c_double),target,contiguous,dimension(..) :: bsrValC integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrC integer(c_int),target,contiguous,dimension(..) :: bsrColIndC integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC type(c_ptr) :: buffer ! hipsparseDgebsr2gebsr_assumed_rank = hipsparseDgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA,colBlockDimA,descrC, & c_loc(bsrValC),c_loc(bsrRowPtrC),c_loc(bsrColIndC),rowBlockDimC,colBlockDimC,buffer) end function #else function hipsparseDgebsr2gebsr_rank_0(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC, & colBlockDimC,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgebsr2gebsr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA type(c_ptr) :: descrC real(c_double),target :: bsrValC integer(c_int),target :: bsrRowPtrC integer(c_int),target :: bsrColIndC integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC type(c_ptr) :: buffer ! hipsparseDgebsr2gebsr_rank_0 = hipsparseDgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA,colBlockDimA,descrC, & c_loc(bsrValC),c_loc(bsrRowPtrC),c_loc(bsrColIndC),rowBlockDimC,colBlockDimC,buffer) end function function hipsparseDgebsr2gebsr_rank_1(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC, & colBlockDimC,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDgebsr2gebsr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA real(c_double),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA type(c_ptr) :: descrC real(c_double),target,dimension(:) :: bsrValC integer(c_int),target,dimension(:) :: bsrRowPtrC integer(c_int),target,dimension(:) :: bsrColIndC integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC type(c_ptr) :: buffer ! hipsparseDgebsr2gebsr_rank_1 = hipsparseDgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA,colBlockDimA,descrC, & c_loc(bsrValC),c_loc(bsrRowPtrC),c_loc(bsrColIndC),rowBlockDimC,colBlockDimC,buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCgebsr2gebsr_assumed_rank(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC, & colBlockDimC,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgebsr2gebsr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA type(c_ptr) :: descrC complex(c_float_complex),target,contiguous,dimension(..) :: bsrValC integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrC integer(c_int),target,contiguous,dimension(..) :: bsrColIndC integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC type(c_ptr) :: buffer ! hipsparseCgebsr2gebsr_assumed_rank = hipsparseCgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA,colBlockDimA,descrC, & c_loc(bsrValC),c_loc(bsrRowPtrC),c_loc(bsrColIndC),rowBlockDimC,colBlockDimC,buffer) end function #else function hipsparseCgebsr2gebsr_rank_0(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC, & colBlockDimC,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgebsr2gebsr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA type(c_ptr) :: descrC complex(c_float_complex),target :: bsrValC integer(c_int),target :: bsrRowPtrC integer(c_int),target :: bsrColIndC integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC type(c_ptr) :: buffer ! hipsparseCgebsr2gebsr_rank_0 = hipsparseCgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA,colBlockDimA,descrC, & c_loc(bsrValC),c_loc(bsrRowPtrC),c_loc(bsrColIndC),rowBlockDimC,colBlockDimC,buffer) end function function hipsparseCgebsr2gebsr_rank_1(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC, & colBlockDimC,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCgebsr2gebsr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA type(c_ptr) :: descrC complex(c_float_complex),target,dimension(:) :: bsrValC integer(c_int),target,dimension(:) :: bsrRowPtrC integer(c_int),target,dimension(:) :: bsrColIndC integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC type(c_ptr) :: buffer ! hipsparseCgebsr2gebsr_rank_1 = hipsparseCgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA,colBlockDimA,descrC, & c_loc(bsrValC),c_loc(bsrRowPtrC),c_loc(bsrColIndC),rowBlockDimC,colBlockDimC,buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZgebsr2gebsr_assumed_rank(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC, & colBlockDimC,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgebsr2gebsr_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: bsrValA integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrA integer(c_int),target,contiguous,dimension(..) :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA type(c_ptr) :: descrC complex(c_double_complex),target,contiguous,dimension(..) :: bsrValC integer(c_int),target,contiguous,dimension(..) :: bsrRowPtrC integer(c_int),target,contiguous,dimension(..) :: bsrColIndC integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC type(c_ptr) :: buffer ! hipsparseZgebsr2gebsr_assumed_rank = hipsparseZgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA,colBlockDimA,descrC, & c_loc(bsrValC),c_loc(bsrRowPtrC),c_loc(bsrColIndC),rowBlockDimC,colBlockDimC,buffer) end function #else function hipsparseZgebsr2gebsr_rank_0(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC, & colBlockDimC,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgebsr2gebsr_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target :: bsrValA integer(c_int),target :: bsrRowPtrA integer(c_int),target :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA type(c_ptr) :: descrC complex(c_double_complex),target :: bsrValC integer(c_int),target :: bsrRowPtrC integer(c_int),target :: bsrColIndC integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC type(c_ptr) :: buffer ! hipsparseZgebsr2gebsr_rank_0 = hipsparseZgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA,colBlockDimA,descrC, & c_loc(bsrValC),c_loc(bsrRowPtrC),c_loc(bsrColIndC),rowBlockDimC,colBlockDimC,buffer) end function function hipsparseZgebsr2gebsr_rank_1(handle,dirA,mb,nb,nnzb,descrA,bsrValA,bsrRowPtrA, & bsrColIndA,rowBlockDimA,colBlockDimA,descrC,bsrValC,bsrRowPtrC,bsrColIndC,rowBlockDimC, & colBlockDimC,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZgebsr2gebsr_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: bsrValA integer(c_int),target,dimension(:) :: bsrRowPtrA integer(c_int),target,dimension(:) :: bsrColIndA integer(c_int) :: rowBlockDimA integer(c_int) :: colBlockDimA type(c_ptr) :: descrC complex(c_double_complex),target,dimension(:) :: bsrValC integer(c_int),target,dimension(:) :: bsrRowPtrC integer(c_int),target,dimension(:) :: bsrColIndC integer(c_int) :: rowBlockDimC integer(c_int) :: colBlockDimC type(c_ptr) :: buffer ! hipsparseZgebsr2gebsr_rank_1 = hipsparseZgebsr2gebsr_(handle,dirA,mb,nb,nnzb,descrA, & c_loc(bsrValA),c_loc(bsrRowPtrA),c_loc(bsrColIndA),rowBlockDimA,colBlockDimA,descrC, & c_loc(bsrValC),c_loc(bsrRowPtrC),c_loc(bsrColIndC),rowBlockDimC,colBlockDimC,buffer) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseShyb2csr_assumed_rank(handle,descrA,hybA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseShyb2csr_assumed_rank type(c_ptr) :: handle type(c_ptr) :: descrA type(c_ptr) :: hybA real(c_float),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA ! hipsparseShyb2csr_assumed_rank = hipsparseShyb2csr_(handle,descrA,hybA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA)) end function #else function hipsparseShyb2csr_rank_0(handle,descrA,hybA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseShyb2csr_rank_0 type(c_ptr) :: handle type(c_ptr) :: descrA type(c_ptr) :: hybA real(c_float),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA ! hipsparseShyb2csr_rank_0 = hipsparseShyb2csr_(handle,descrA,hybA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA)) end function function hipsparseShyb2csr_rank_1(handle,descrA,hybA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseShyb2csr_rank_1 type(c_ptr) :: handle type(c_ptr) :: descrA type(c_ptr) :: hybA real(c_float),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA ! hipsparseShyb2csr_rank_1 = hipsparseShyb2csr_(handle,descrA,hybA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDhyb2csr_assumed_rank(handle,descrA,hybA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDhyb2csr_assumed_rank type(c_ptr) :: handle type(c_ptr) :: descrA type(c_ptr) :: hybA real(c_double),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA ! hipsparseDhyb2csr_assumed_rank = hipsparseDhyb2csr_(handle,descrA,hybA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA)) end function #else function hipsparseDhyb2csr_rank_0(handle,descrA,hybA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDhyb2csr_rank_0 type(c_ptr) :: handle type(c_ptr) :: descrA type(c_ptr) :: hybA real(c_double),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA ! hipsparseDhyb2csr_rank_0 = hipsparseDhyb2csr_(handle,descrA,hybA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA)) end function function hipsparseDhyb2csr_rank_1(handle,descrA,hybA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDhyb2csr_rank_1 type(c_ptr) :: handle type(c_ptr) :: descrA type(c_ptr) :: hybA real(c_double),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA ! hipsparseDhyb2csr_rank_1 = hipsparseDhyb2csr_(handle,descrA,hybA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseChyb2csr_assumed_rank(handle,descrA,hybA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseChyb2csr_assumed_rank type(c_ptr) :: handle type(c_ptr) :: descrA type(c_ptr) :: hybA complex(c_float_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA ! hipsparseChyb2csr_assumed_rank = hipsparseChyb2csr_(handle,descrA,hybA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA)) end function #else function hipsparseChyb2csr_rank_0(handle,descrA,hybA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseChyb2csr_rank_0 type(c_ptr) :: handle type(c_ptr) :: descrA type(c_ptr) :: hybA complex(c_float_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA ! hipsparseChyb2csr_rank_0 = hipsparseChyb2csr_(handle,descrA,hybA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA)) end function function hipsparseChyb2csr_rank_1(handle,descrA,hybA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseChyb2csr_rank_1 type(c_ptr) :: handle type(c_ptr) :: descrA type(c_ptr) :: hybA complex(c_float_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA ! hipsparseChyb2csr_rank_1 = hipsparseChyb2csr_(handle,descrA,hybA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA)) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZhyb2csr_assumed_rank(handle,descrA,hybA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZhyb2csr_assumed_rank type(c_ptr) :: handle type(c_ptr) :: descrA type(c_ptr) :: hybA complex(c_double_complex),target,contiguous,dimension(..) :: csrSortedValA integer(c_int),target,contiguous,dimension(..) :: csrSortedRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrSortedColIndA ! hipsparseZhyb2csr_assumed_rank = hipsparseZhyb2csr_(handle,descrA,hybA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA)) end function #else function hipsparseZhyb2csr_rank_0(handle,descrA,hybA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZhyb2csr_rank_0 type(c_ptr) :: handle type(c_ptr) :: descrA type(c_ptr) :: hybA complex(c_double_complex),target :: csrSortedValA integer(c_int),target :: csrSortedRowPtrA integer(c_int),target :: csrSortedColIndA ! hipsparseZhyb2csr_rank_0 = hipsparseZhyb2csr_(handle,descrA,hybA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA)) end function function hipsparseZhyb2csr_rank_1(handle,descrA,hybA,csrSortedValA,csrSortedRowPtrA, & csrSortedColIndA) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZhyb2csr_rank_1 type(c_ptr) :: handle type(c_ptr) :: descrA type(c_ptr) :: hybA complex(c_double_complex),target,dimension(:) :: csrSortedValA integer(c_int),target,dimension(:) :: csrSortedRowPtrA integer(c_int),target,dimension(:) :: csrSortedColIndA ! hipsparseZhyb2csr_rank_1 = hipsparseZhyb2csr_(handle,descrA,hybA,c_loc(csrSortedValA), & c_loc(csrSortedRowPtrA),c_loc(csrSortedColIndA)) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSnnz_assumed_rank(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn, & nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSnnz_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr ! hipsparseSnnz_assumed_rank = hipsparseSnnz_(handle,dirA,m,n,descrA,c_loc(A),lda, & c_loc(nnzPerRowColumn),nnzTotalDevHostPtr) end function #else function hipsparseSnnz_rank_0(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn,nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSnnz_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_float),target :: A integer(c_int) :: lda integer(c_int),target :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr ! hipsparseSnnz_rank_0 = hipsparseSnnz_(handle,dirA,m,n,descrA,c_loc(A),lda, & c_loc(nnzPerRowColumn),nnzTotalDevHostPtr) end function function hipsparseSnnz_rank_1(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn,nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSnnz_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr ! hipsparseSnnz_rank_1 = hipsparseSnnz_(handle,dirA,m,n,descrA,c_loc(A),lda, & c_loc(nnzPerRowColumn),nnzTotalDevHostPtr) end function function hipsparseSnnz_full_rank(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn, & nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSnnz_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr ! hipsparseSnnz_full_rank = hipsparseSnnz_(handle,dirA,m,n,descrA,c_loc(A),lda, & c_loc(nnzPerRowColumn),nnzTotalDevHostPtr) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDnnz_assumed_rank(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn, & nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDnnz_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr ! hipsparseDnnz_assumed_rank = hipsparseDnnz_(handle,dirA,m,n,descrA,c_loc(A),lda, & c_loc(nnzPerRowColumn),nnzTotalDevHostPtr) end function #else function hipsparseDnnz_rank_0(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn,nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDnnz_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_double),target :: A integer(c_int) :: lda integer(c_int),target :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr ! hipsparseDnnz_rank_0 = hipsparseDnnz_(handle,dirA,m,n,descrA,c_loc(A),lda, & c_loc(nnzPerRowColumn),nnzTotalDevHostPtr) end function function hipsparseDnnz_rank_1(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn,nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDnnz_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr ! hipsparseDnnz_rank_1 = hipsparseDnnz_(handle,dirA,m,n,descrA,c_loc(A),lda, & c_loc(nnzPerRowColumn),nnzTotalDevHostPtr) end function function hipsparseDnnz_full_rank(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn, & nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDnnz_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr ! hipsparseDnnz_full_rank = hipsparseDnnz_(handle,dirA,m,n,descrA,c_loc(A),lda, & c_loc(nnzPerRowColumn),nnzTotalDevHostPtr) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCnnz_assumed_rank(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn, & nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCnnz_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr ! hipsparseCnnz_assumed_rank = hipsparseCnnz_(handle,dirA,m,n,descrA,c_loc(A),lda, & c_loc(nnzPerRowColumn),nnzTotalDevHostPtr) end function #else function hipsparseCnnz_rank_0(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn,nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCnnz_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int),target :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr ! hipsparseCnnz_rank_0 = hipsparseCnnz_(handle,dirA,m,n,descrA,c_loc(A),lda, & c_loc(nnzPerRowColumn),nnzTotalDevHostPtr) end function function hipsparseCnnz_rank_1(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn,nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCnnz_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr ! hipsparseCnnz_rank_1 = hipsparseCnnz_(handle,dirA,m,n,descrA,c_loc(A),lda, & c_loc(nnzPerRowColumn),nnzTotalDevHostPtr) end function function hipsparseCnnz_full_rank(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn, & nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCnnz_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr ! hipsparseCnnz_full_rank = hipsparseCnnz_(handle,dirA,m,n,descrA,c_loc(A),lda, & c_loc(nnzPerRowColumn),nnzTotalDevHostPtr) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZnnz_assumed_rank(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn, & nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZnnz_assumed_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr ! hipsparseZnnz_assumed_rank = hipsparseZnnz_(handle,dirA,m,n,descrA,c_loc(A),lda, & c_loc(nnzPerRowColumn),nnzTotalDevHostPtr) end function #else function hipsparseZnnz_rank_0(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn,nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZnnz_rank_0 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int),target :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr ! hipsparseZnnz_rank_0 = hipsparseZnnz_(handle,dirA,m,n,descrA,c_loc(A),lda, & c_loc(nnzPerRowColumn),nnzTotalDevHostPtr) end function function hipsparseZnnz_rank_1(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn,nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZnnz_rank_1 type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr ! hipsparseZnnz_rank_1 = hipsparseZnnz_(handle,dirA,m,n,descrA,c_loc(A),lda, & c_loc(nnzPerRowColumn),nnzTotalDevHostPtr) end function function hipsparseZnnz_full_rank(handle,dirA,m,n,descrA,A,lda,nnzPerRowColumn, & nnzTotalDevHostPtr) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZnnz_full_rank type(c_ptr) :: handle integer(kind(HIPSPARSE_DIRECTION_ROW)) :: dirA integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: nnzPerRowColumn integer(c_int) :: nnzTotalDevHostPtr ! hipsparseZnnz_full_rank = hipsparseZnnz_(handle,dirA,m,n,descrA,c_loc(A),lda, & c_loc(nnzPerRowColumn),nnzTotalDevHostPtr) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSnnz_compress_assumed_rank(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow, & nnzC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSnnz_compress_assumed_rank type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: nnzPerRow integer(c_int),target,contiguous,dimension(..) :: nnzC real(c_float) :: tol ! hipsparseSnnz_compress_assumed_rank = hipsparseSnnz_compress_(handle,m,descrA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(nnzPerRow),c_loc(nnzC),tol) end function #else function hipsparseSnnz_compress_rank_0(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow,nnzC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSnnz_compress_rank_0 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descrA real(c_float),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: nnzPerRow integer(c_int),target :: nnzC real(c_float) :: tol ! hipsparseSnnz_compress_rank_0 = hipsparseSnnz_compress_(handle,m,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(nnzPerRow),c_loc(nnzC),tol) end function function hipsparseSnnz_compress_rank_1(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow,nnzC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSnnz_compress_rank_1 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: nnzPerRow integer(c_int),target,dimension(:) :: nnzC real(c_float) :: tol ! hipsparseSnnz_compress_rank_1 = hipsparseSnnz_compress_(handle,m,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(nnzPerRow),c_loc(nnzC),tol) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDnnz_compress_assumed_rank(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow, & nnzC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDnnz_compress_assumed_rank type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: nnzPerRow integer(c_int),target,contiguous,dimension(..) :: nnzC real(c_double) :: tol ! hipsparseDnnz_compress_assumed_rank = hipsparseDnnz_compress_(handle,m,descrA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(nnzPerRow),c_loc(nnzC),tol) end function #else function hipsparseDnnz_compress_rank_0(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow,nnzC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDnnz_compress_rank_0 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descrA real(c_double),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: nnzPerRow integer(c_int),target :: nnzC real(c_double) :: tol ! hipsparseDnnz_compress_rank_0 = hipsparseDnnz_compress_(handle,m,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(nnzPerRow),c_loc(nnzC),tol) end function function hipsparseDnnz_compress_rank_1(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow,nnzC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDnnz_compress_rank_1 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: nnzPerRow integer(c_int),target,dimension(:) :: nnzC real(c_double) :: tol ! hipsparseDnnz_compress_rank_1 = hipsparseDnnz_compress_(handle,m,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(nnzPerRow),c_loc(nnzC),tol) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCnnz_compress_assumed_rank(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow, & nnzC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCnnz_compress_assumed_rank type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: nnzPerRow integer(c_int),target,contiguous,dimension(..) :: nnzC complex(c_float_complex) :: tol ! hipsparseCnnz_compress_assumed_rank = hipsparseCnnz_compress_(handle,m,descrA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(nnzPerRow),c_loc(nnzC),tol) end function #else function hipsparseCnnz_compress_rank_0(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow,nnzC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCnnz_compress_rank_0 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descrA complex(c_float_complex),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: nnzPerRow integer(c_int),target :: nnzC complex(c_float_complex) :: tol ! hipsparseCnnz_compress_rank_0 = hipsparseCnnz_compress_(handle,m,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(nnzPerRow),c_loc(nnzC),tol) end function function hipsparseCnnz_compress_rank_1(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow,nnzC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCnnz_compress_rank_1 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: nnzPerRow integer(c_int),target,dimension(:) :: nnzC complex(c_float_complex) :: tol ! hipsparseCnnz_compress_rank_1 = hipsparseCnnz_compress_(handle,m,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(nnzPerRow),c_loc(nnzC),tol) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZnnz_compress_assumed_rank(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow, & nnzC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZnnz_compress_assumed_rank type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: nnzPerRow integer(c_int),target,contiguous,dimension(..) :: nnzC complex(c_double_complex) :: tol ! hipsparseZnnz_compress_assumed_rank = hipsparseZnnz_compress_(handle,m,descrA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(nnzPerRow),c_loc(nnzC),tol) end function #else function hipsparseZnnz_compress_rank_0(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow,nnzC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZnnz_compress_rank_0 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descrA complex(c_double_complex),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: nnzPerRow integer(c_int),target :: nnzC complex(c_double_complex) :: tol ! hipsparseZnnz_compress_rank_0 = hipsparseZnnz_compress_(handle,m,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(nnzPerRow),c_loc(nnzC),tol) end function function hipsparseZnnz_compress_rank_1(handle,m,descrA,csrValA,csrRowPtrA,nnzPerRow,nnzC,tol) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZnnz_compress_rank_1 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: nnzPerRow integer(c_int),target,dimension(:) :: nnzC complex(c_double_complex) :: tol ! hipsparseZnnz_compress_rank_1 = hipsparseZnnz_compress_(handle,m,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(nnzPerRow),c_loc(nnzC),tol) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSpruneCsr2csr_bufferSize_assumed_rank(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csr_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA real(c_float),target,contiguous,dimension(..) :: threshold type(c_ptr) :: descrC real(c_float),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneCsr2csr_bufferSize_assumed_rank = hipsparseSpruneCsr2csr_bufferSize_(handle, & m,n,nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),c_loc(threshold), & descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),pBufferSizeInBytes) end function #else function hipsparseSpruneCsr2csr_bufferSize_rank_0(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csr_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA real(c_float),target :: threshold type(c_ptr) :: descrC real(c_float),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneCsr2csr_bufferSize_rank_0 = hipsparseSpruneCsr2csr_bufferSize_(handle,m,n, & nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),c_loc(threshold),descrC, & c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),pBufferSizeInBytes) end function function hipsparseSpruneCsr2csr_bufferSize_rank_1(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csr_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA real(c_float),target,dimension(:) :: threshold type(c_ptr) :: descrC real(c_float),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneCsr2csr_bufferSize_rank_1 = hipsparseSpruneCsr2csr_bufferSize_(handle,m,n, & nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),c_loc(threshold),descrC, & c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDpruneCsr2csr_bufferSize_assumed_rank(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csr_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA real(c_double),target,contiguous,dimension(..) :: threshold type(c_ptr) :: descrC real(c_double),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneCsr2csr_bufferSize_assumed_rank = hipsparseDpruneCsr2csr_bufferSize_(handle, & m,n,nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),c_loc(threshold), & descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),pBufferSizeInBytes) end function #else function hipsparseDpruneCsr2csr_bufferSize_rank_0(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csr_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA real(c_double),target :: threshold type(c_ptr) :: descrC real(c_double),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneCsr2csr_bufferSize_rank_0 = hipsparseDpruneCsr2csr_bufferSize_(handle,m,n, & nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),c_loc(threshold),descrC, & c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),pBufferSizeInBytes) end function function hipsparseDpruneCsr2csr_bufferSize_rank_1(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csr_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA real(c_double),target,dimension(:) :: threshold type(c_ptr) :: descrC real(c_double),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneCsr2csr_bufferSize_rank_1 = hipsparseDpruneCsr2csr_bufferSize_(handle,m,n, & nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),c_loc(threshold),descrC, & c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),pBufferSizeInBytes) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSpruneCsr2csr_bufferSizeExt_assumed_rank(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csr_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA real(c_float),target,contiguous,dimension(..) :: threshold type(c_ptr) :: descrC real(c_float),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneCsr2csr_bufferSizeExt_assumed_rank = hipsparseSpruneCsr2csr_bufferSizeExt_( & handle,m,n,nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA), & c_loc(threshold),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC), & pBufferSizeInBytes) end function #else function hipsparseSpruneCsr2csr_bufferSizeExt_rank_0(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csr_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA real(c_float),target :: threshold type(c_ptr) :: descrC real(c_float),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneCsr2csr_bufferSizeExt_rank_0 = hipsparseSpruneCsr2csr_bufferSizeExt_(handle, & m,n,nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),c_loc(threshold), & descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),pBufferSizeInBytes) end function function hipsparseSpruneCsr2csr_bufferSizeExt_rank_1(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csr_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA real(c_float),target,dimension(:) :: threshold type(c_ptr) :: descrC real(c_float),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneCsr2csr_bufferSizeExt_rank_1 = hipsparseSpruneCsr2csr_bufferSizeExt_(handle, & m,n,nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),c_loc(threshold), & descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDpruneCsr2csr_bufferSizeExt_assumed_rank(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csr_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA real(c_double),target,contiguous,dimension(..) :: threshold type(c_ptr) :: descrC real(c_double),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneCsr2csr_bufferSizeExt_assumed_rank = hipsparseDpruneCsr2csr_bufferSizeExt_( & handle,m,n,nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA), & c_loc(threshold),descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC), & pBufferSizeInBytes) end function #else function hipsparseDpruneCsr2csr_bufferSizeExt_rank_0(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csr_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA real(c_double),target :: threshold type(c_ptr) :: descrC real(c_double),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneCsr2csr_bufferSizeExt_rank_0 = hipsparseDpruneCsr2csr_bufferSizeExt_(handle, & m,n,nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),c_loc(threshold), & descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),pBufferSizeInBytes) end function function hipsparseDpruneCsr2csr_bufferSizeExt_rank_1(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csr_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA real(c_double),target,dimension(:) :: threshold type(c_ptr) :: descrC real(c_double),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneCsr2csr_bufferSizeExt_rank_1 = hipsparseDpruneCsr2csr_bufferSizeExt_(handle, & m,n,nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),c_loc(threshold), & descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSpruneCsr2csrNnz_assumed_rank(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,threshold,descrC,csrRowPtrC,nnzTotalDevHostPtr,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrNnz_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA real(c_float) :: threshold type(c_ptr) :: descrC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: buffer ! hipsparseSpruneCsr2csrNnz_assumed_rank = hipsparseSpruneCsr2csrNnz_(handle,m,n,nnzA,descrA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),threshold,descrC,c_loc(csrRowPtrC), & nnzTotalDevHostPtr,buffer) end function #else function hipsparseSpruneCsr2csrNnz_rank_0(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,threshold,descrC,csrRowPtrC,nnzTotalDevHostPtr,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrNnz_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA real(c_float) :: threshold type(c_ptr) :: descrC integer(c_int),target :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: buffer ! hipsparseSpruneCsr2csrNnz_rank_0 = hipsparseSpruneCsr2csrNnz_(handle,m,n,nnzA,descrA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),threshold,descrC,c_loc(csrRowPtrC), & nnzTotalDevHostPtr,buffer) end function function hipsparseSpruneCsr2csrNnz_rank_1(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,threshold,descrC,csrRowPtrC,nnzTotalDevHostPtr,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrNnz_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA real(c_float) :: threshold type(c_ptr) :: descrC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: buffer ! hipsparseSpruneCsr2csrNnz_rank_1 = hipsparseSpruneCsr2csrNnz_(handle,m,n,nnzA,descrA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),threshold,descrC,c_loc(csrRowPtrC), & nnzTotalDevHostPtr,buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDpruneCsr2csrNnz_assumed_rank(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,threshold,descrC,csrRowPtrC,nnzTotalDevHostPtr,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrNnz_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA real(c_double) :: threshold type(c_ptr) :: descrC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: buffer ! hipsparseDpruneCsr2csrNnz_assumed_rank = hipsparseDpruneCsr2csrNnz_(handle,m,n,nnzA,descrA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),threshold,descrC,c_loc(csrRowPtrC), & nnzTotalDevHostPtr,buffer) end function #else function hipsparseDpruneCsr2csrNnz_rank_0(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,threshold,descrC,csrRowPtrC,nnzTotalDevHostPtr,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrNnz_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA real(c_double) :: threshold type(c_ptr) :: descrC integer(c_int),target :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: buffer ! hipsparseDpruneCsr2csrNnz_rank_0 = hipsparseDpruneCsr2csrNnz_(handle,m,n,nnzA,descrA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),threshold,descrC,c_loc(csrRowPtrC), & nnzTotalDevHostPtr,buffer) end function function hipsparseDpruneCsr2csrNnz_rank_1(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,threshold,descrC,csrRowPtrC,nnzTotalDevHostPtr,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrNnz_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA real(c_double) :: threshold type(c_ptr) :: descrC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: buffer ! hipsparseDpruneCsr2csrNnz_rank_1 = hipsparseDpruneCsr2csrNnz_(handle,m,n,nnzA,descrA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),threshold,descrC,c_loc(csrRowPtrC), & nnzTotalDevHostPtr,buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSpruneCsr2csr_assumed_rank(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA real(c_float) :: threshold type(c_ptr) :: descrC real(c_float),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC type(c_ptr) :: buffer ! hipsparseSpruneCsr2csr_assumed_rank = hipsparseSpruneCsr2csr_(handle,m,n,nnzA,descrA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),threshold,descrC,c_loc(csrValC), & c_loc(csrRowPtrC),c_loc(csrColIndC),buffer) end function #else function hipsparseSpruneCsr2csr_rank_0(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA,csrColIndA, & threshold,descrC,csrValC,csrRowPtrC,csrColIndC,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA real(c_float) :: threshold type(c_ptr) :: descrC real(c_float),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC type(c_ptr) :: buffer ! hipsparseSpruneCsr2csr_rank_0 = hipsparseSpruneCsr2csr_(handle,m,n,nnzA,descrA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),threshold,descrC,c_loc(csrValC), & c_loc(csrRowPtrC),c_loc(csrColIndC),buffer) end function function hipsparseSpruneCsr2csr_rank_1(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA,csrColIndA, & threshold,descrC,csrValC,csrRowPtrC,csrColIndC,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA real(c_float) :: threshold type(c_ptr) :: descrC real(c_float),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC type(c_ptr) :: buffer ! hipsparseSpruneCsr2csr_rank_1 = hipsparseSpruneCsr2csr_(handle,m,n,nnzA,descrA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),threshold,descrC,c_loc(csrValC), & c_loc(csrRowPtrC),c_loc(csrColIndC),buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDpruneCsr2csr_assumed_rank(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,threshold,descrC,csrValC,csrRowPtrC,csrColIndC,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA real(c_double) :: threshold type(c_ptr) :: descrC real(c_double),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC type(c_ptr) :: buffer ! hipsparseDpruneCsr2csr_assumed_rank = hipsparseDpruneCsr2csr_(handle,m,n,nnzA,descrA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),threshold,descrC,c_loc(csrValC), & c_loc(csrRowPtrC),c_loc(csrColIndC),buffer) end function #else function hipsparseDpruneCsr2csr_rank_0(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA,csrColIndA, & threshold,descrC,csrValC,csrRowPtrC,csrColIndC,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA real(c_double) :: threshold type(c_ptr) :: descrC real(c_double),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC type(c_ptr) :: buffer ! hipsparseDpruneCsr2csr_rank_0 = hipsparseDpruneCsr2csr_(handle,m,n,nnzA,descrA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),threshold,descrC,c_loc(csrValC), & c_loc(csrRowPtrC),c_loc(csrColIndC),buffer) end function function hipsparseDpruneCsr2csr_rank_1(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA,csrColIndA, & threshold,descrC,csrValC,csrRowPtrC,csrColIndC,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA real(c_double) :: threshold type(c_ptr) :: descrC real(c_double),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC type(c_ptr) :: buffer ! hipsparseDpruneCsr2csr_rank_1 = hipsparseDpruneCsr2csr_(handle,m,n,nnzA,descrA, & c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),threshold,descrC,c_loc(csrValC), & c_loc(csrRowPtrC),c_loc(csrColIndC),buffer) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSpruneCsr2csrByPercentage_bufferSize_assumed_rank(handle,m,n,nnzA,descrA, & csrValA,csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrByPercentage_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA real(c_float) :: percentage type(c_ptr) :: descrC real(c_float),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneCsr2csrByPercentage_bufferSize_assumed_rank = & hipsparseSpruneCsr2csrByPercentage_bufferSize_(handle,m,n,nnzA,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),percentage,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC),myInfo,pBufferSizeInBytes) end function #else function hipsparseSpruneCsr2csrByPercentage_bufferSize_rank_0(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrByPercentage_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA real(c_float) :: percentage type(c_ptr) :: descrC real(c_float),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneCsr2csrByPercentage_bufferSize_rank_0 = & hipsparseSpruneCsr2csrByPercentage_bufferSize_(handle,m,n,nnzA,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),percentage,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC),myInfo,pBufferSizeInBytes) end function function hipsparseSpruneCsr2csrByPercentage_bufferSize_rank_1(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrByPercentage_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA real(c_float) :: percentage type(c_ptr) :: descrC real(c_float),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneCsr2csrByPercentage_bufferSize_rank_1 = & hipsparseSpruneCsr2csrByPercentage_bufferSize_(handle,m,n,nnzA,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),percentage,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC),myInfo,pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDpruneCsr2csrByPercentage_bufferSize_assumed_rank(handle,m,n,nnzA,descrA, & csrValA,csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrByPercentage_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA real(c_double) :: percentage type(c_ptr) :: descrC real(c_double),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneCsr2csrByPercentage_bufferSize_assumed_rank = & hipsparseDpruneCsr2csrByPercentage_bufferSize_(handle,m,n,nnzA,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),percentage,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC),myInfo,pBufferSizeInBytes) end function #else function hipsparseDpruneCsr2csrByPercentage_bufferSize_rank_0(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrByPercentage_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA real(c_double) :: percentage type(c_ptr) :: descrC real(c_double),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneCsr2csrByPercentage_bufferSize_rank_0 = & hipsparseDpruneCsr2csrByPercentage_bufferSize_(handle,m,n,nnzA,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),percentage,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC),myInfo,pBufferSizeInBytes) end function function hipsparseDpruneCsr2csrByPercentage_bufferSize_rank_1(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrByPercentage_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA real(c_double) :: percentage type(c_ptr) :: descrC real(c_double),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneCsr2csrByPercentage_bufferSize_rank_1 = & hipsparseDpruneCsr2csrByPercentage_bufferSize_(handle,m,n,nnzA,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),percentage,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC),myInfo,pBufferSizeInBytes) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSpruneCsr2csrByPercentage_bufferSizeExt_assumed_rank(handle,m,n,nnzA,descrA, & csrValA,csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrByPercentage_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA real(c_float) :: percentage type(c_ptr) :: descrC real(c_float),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneCsr2csrByPercentage_bufferSizeExt_assumed_rank = & hipsparseSpruneCsr2csrByPercentage_bufferSizeExt_(handle,m,n,nnzA,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),percentage,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC),myInfo,pBufferSizeInBytes) end function #else function hipsparseSpruneCsr2csrByPercentage_bufferSizeExt_rank_0(handle,m,n,nnzA,descrA, & csrValA,csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrByPercentage_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA real(c_float) :: percentage type(c_ptr) :: descrC real(c_float),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneCsr2csrByPercentage_bufferSizeExt_rank_0 = & hipsparseSpruneCsr2csrByPercentage_bufferSizeExt_(handle,m,n,nnzA,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),percentage,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC),myInfo,pBufferSizeInBytes) end function function hipsparseSpruneCsr2csrByPercentage_bufferSizeExt_rank_1(handle,m,n,nnzA,descrA, & csrValA,csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrByPercentage_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA real(c_float) :: percentage type(c_ptr) :: descrC real(c_float),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneCsr2csrByPercentage_bufferSizeExt_rank_1 = & hipsparseSpruneCsr2csrByPercentage_bufferSizeExt_(handle,m,n,nnzA,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),percentage,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC),myInfo,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDpruneCsr2csrByPercentage_bufferSizeExt_assumed_rank(handle,m,n,nnzA,descrA, & csrValA,csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrByPercentage_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA real(c_double) :: percentage type(c_ptr) :: descrC real(c_double),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneCsr2csrByPercentage_bufferSizeExt_assumed_rank = & hipsparseDpruneCsr2csrByPercentage_bufferSizeExt_(handle,m,n,nnzA,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),percentage,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC),myInfo,pBufferSizeInBytes) end function #else function hipsparseDpruneCsr2csrByPercentage_bufferSizeExt_rank_0(handle,m,n,nnzA,descrA, & csrValA,csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrByPercentage_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA real(c_double) :: percentage type(c_ptr) :: descrC real(c_double),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneCsr2csrByPercentage_bufferSizeExt_rank_0 = & hipsparseDpruneCsr2csrByPercentage_bufferSizeExt_(handle,m,n,nnzA,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),percentage,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC),myInfo,pBufferSizeInBytes) end function function hipsparseDpruneCsr2csrByPercentage_bufferSizeExt_rank_1(handle,m,n,nnzA,descrA, & csrValA,csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo, & pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrByPercentage_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA real(c_double) :: percentage type(c_ptr) :: descrC real(c_double),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneCsr2csrByPercentage_bufferSizeExt_rank_1 = & hipsparseDpruneCsr2csrByPercentage_bufferSizeExt_(handle,m,n,nnzA,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),percentage,descrC,c_loc(csrValC),c_loc(csrRowPtrC), & c_loc(csrColIndC),myInfo,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSpruneCsr2csrNnzByPercentage_assumed_rank(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,percentage,descrC,csrRowPtrC,nnzTotalDevHostPtr,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrNnzByPercentage_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA real(c_float) :: percentage type(c_ptr) :: descrC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseSpruneCsr2csrNnzByPercentage_assumed_rank = hipsparseSpruneCsr2csrNnzByPercentage_( & handle,m,n,nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),percentage, & descrC,c_loc(csrRowPtrC),nnzTotalDevHostPtr,myInfo,buffer) end function #else function hipsparseSpruneCsr2csrNnzByPercentage_rank_0(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,percentage,descrC,csrRowPtrC,nnzTotalDevHostPtr,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrNnzByPercentage_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA real(c_float) :: percentage type(c_ptr) :: descrC integer(c_int),target :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseSpruneCsr2csrNnzByPercentage_rank_0 = hipsparseSpruneCsr2csrNnzByPercentage_( & handle,m,n,nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),percentage, & descrC,c_loc(csrRowPtrC),nnzTotalDevHostPtr,myInfo,buffer) end function function hipsparseSpruneCsr2csrNnzByPercentage_rank_1(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,percentage,descrC,csrRowPtrC,nnzTotalDevHostPtr,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrNnzByPercentage_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA real(c_float) :: percentage type(c_ptr) :: descrC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseSpruneCsr2csrNnzByPercentage_rank_1 = hipsparseSpruneCsr2csrNnzByPercentage_( & handle,m,n,nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),percentage, & descrC,c_loc(csrRowPtrC),nnzTotalDevHostPtr,myInfo,buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDpruneCsr2csrNnzByPercentage_assumed_rank(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,percentage,descrC,csrRowPtrC,nnzTotalDevHostPtr,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrNnzByPercentage_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA real(c_double) :: percentage type(c_ptr) :: descrC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseDpruneCsr2csrNnzByPercentage_assumed_rank = hipsparseDpruneCsr2csrNnzByPercentage_( & handle,m,n,nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),percentage, & descrC,c_loc(csrRowPtrC),nnzTotalDevHostPtr,myInfo,buffer) end function #else function hipsparseDpruneCsr2csrNnzByPercentage_rank_0(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,percentage,descrC,csrRowPtrC,nnzTotalDevHostPtr,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrNnzByPercentage_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA real(c_double) :: percentage type(c_ptr) :: descrC integer(c_int),target :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseDpruneCsr2csrNnzByPercentage_rank_0 = hipsparseDpruneCsr2csrNnzByPercentage_( & handle,m,n,nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),percentage, & descrC,c_loc(csrRowPtrC),nnzTotalDevHostPtr,myInfo,buffer) end function function hipsparseDpruneCsr2csrNnzByPercentage_rank_1(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,percentage,descrC,csrRowPtrC,nnzTotalDevHostPtr,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrNnzByPercentage_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA real(c_double) :: percentage type(c_ptr) :: descrC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseDpruneCsr2csrNnzByPercentage_rank_1 = hipsparseDpruneCsr2csrNnzByPercentage_( & handle,m,n,nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),percentage, & descrC,c_loc(csrRowPtrC),nnzTotalDevHostPtr,myInfo,buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSpruneCsr2csrByPercentage_assumed_rank(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrByPercentage_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA real(c_float) :: percentage type(c_ptr) :: descrC real(c_float),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseSpruneCsr2csrByPercentage_assumed_rank = hipsparseSpruneCsr2csrByPercentage_( & handle,m,n,nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),percentage, & descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),myInfo,buffer) end function #else function hipsparseSpruneCsr2csrByPercentage_rank_0(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrByPercentage_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA real(c_float) :: percentage type(c_ptr) :: descrC real(c_float),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseSpruneCsr2csrByPercentage_rank_0 = hipsparseSpruneCsr2csrByPercentage_(handle,m,n, & nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),percentage,descrC, & c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),myInfo,buffer) end function function hipsparseSpruneCsr2csrByPercentage_rank_1(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneCsr2csrByPercentage_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA real(c_float) :: percentage type(c_ptr) :: descrC real(c_float),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseSpruneCsr2csrByPercentage_rank_1 = hipsparseSpruneCsr2csrByPercentage_(handle,m,n, & nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),percentage,descrC, & c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),myInfo,buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDpruneCsr2csrByPercentage_assumed_rank(handle,m,n,nnzA,descrA,csrValA, & csrRowPtrA,csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrByPercentage_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA real(c_double) :: percentage type(c_ptr) :: descrC real(c_double),target,contiguous,dimension(..) :: csrValC integer(c_int),target,contiguous,dimension(..) :: csrRowPtrC integer(c_int),target,contiguous,dimension(..) :: csrColIndC type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseDpruneCsr2csrByPercentage_assumed_rank = hipsparseDpruneCsr2csrByPercentage_( & handle,m,n,nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),percentage, & descrC,c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),myInfo,buffer) end function #else function hipsparseDpruneCsr2csrByPercentage_rank_0(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrByPercentage_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA real(c_double) :: percentage type(c_ptr) :: descrC real(c_double),target :: csrValC integer(c_int),target :: csrRowPtrC integer(c_int),target :: csrColIndC type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseDpruneCsr2csrByPercentage_rank_0 = hipsparseDpruneCsr2csrByPercentage_(handle,m,n, & nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),percentage,descrC, & c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),myInfo,buffer) end function function hipsparseDpruneCsr2csrByPercentage_rank_1(handle,m,n,nnzA,descrA,csrValA,csrRowPtrA, & csrColIndA,percentage,descrC,csrValC,csrRowPtrC,csrColIndC,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneCsr2csrByPercentage_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnzA type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA real(c_double) :: percentage type(c_ptr) :: descrC real(c_double),target,dimension(:) :: csrValC integer(c_int),target,dimension(:) :: csrRowPtrC integer(c_int),target,dimension(:) :: csrColIndC type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseDpruneCsr2csrByPercentage_rank_1 = hipsparseDpruneCsr2csrByPercentage_(handle,m,n, & nnzA,descrA,c_loc(csrValA),c_loc(csrRowPtrA),c_loc(csrColIndA),percentage,descrC, & c_loc(csrValC),c_loc(csrRowPtrC),c_loc(csrColIndC),myInfo,buffer) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSpruneDense2csr_bufferSize_assumed_rank(handle,m,n,A,lda,threshold,descr, & csrVal,csrRowPtr,csrColInd,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csr_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: threshold type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneDense2csr_bufferSize_assumed_rank = hipsparseSpruneDense2csr_bufferSize_( & handle,m,n,c_loc(A),lda,c_loc(threshold),descr,c_loc(csrVal),c_loc(csrRowPtr), & c_loc(csrColInd),pBufferSizeInBytes) end function #else function hipsparseSpruneDense2csr_bufferSize_rank_0(handle,m,n,A,lda,threshold,descr,csrVal, & csrRowPtr,csrColInd,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csr_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: threshold type(c_ptr) :: descr real(c_float),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneDense2csr_bufferSize_rank_0 = hipsparseSpruneDense2csr_bufferSize_(handle,m, & n,c_loc(A),lda,c_loc(threshold),descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd), & pBufferSizeInBytes) end function function hipsparseSpruneDense2csr_bufferSize_rank_1(handle,m,n,A,lda,threshold,descr,csrVal, & csrRowPtr,csrColInd,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csr_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: threshold type(c_ptr) :: descr real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneDense2csr_bufferSize_rank_1 = hipsparseSpruneDense2csr_bufferSize_(handle,m, & n,c_loc(A),lda,c_loc(threshold),descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd), & pBufferSizeInBytes) end function function hipsparseSpruneDense2csr_bufferSize_full_rank(handle,m,n,A,lda,threshold,descr, & csrVal,csrRowPtr,csrColInd,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csr_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: threshold type(c_ptr) :: descr real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneDense2csr_bufferSize_full_rank = hipsparseSpruneDense2csr_bufferSize_(handle, & m,n,c_loc(A),lda,c_loc(threshold),descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd), & pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDpruneDense2csr_bufferSize_assumed_rank(handle,m,n,A,lda,threshold,descr, & csrVal,csrRowPtr,csrColInd,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csr_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: threshold type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneDense2csr_bufferSize_assumed_rank = hipsparseDpruneDense2csr_bufferSize_( & handle,m,n,c_loc(A),lda,c_loc(threshold),descr,c_loc(csrVal),c_loc(csrRowPtr), & c_loc(csrColInd),pBufferSizeInBytes) end function #else function hipsparseDpruneDense2csr_bufferSize_rank_0(handle,m,n,A,lda,threshold,descr,csrVal, & csrRowPtr,csrColInd,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csr_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: threshold type(c_ptr) :: descr real(c_double),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneDense2csr_bufferSize_rank_0 = hipsparseDpruneDense2csr_bufferSize_(handle,m, & n,c_loc(A),lda,c_loc(threshold),descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd), & pBufferSizeInBytes) end function function hipsparseDpruneDense2csr_bufferSize_rank_1(handle,m,n,A,lda,threshold,descr,csrVal, & csrRowPtr,csrColInd,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csr_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: threshold type(c_ptr) :: descr real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneDense2csr_bufferSize_rank_1 = hipsparseDpruneDense2csr_bufferSize_(handle,m, & n,c_loc(A),lda,c_loc(threshold),descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd), & pBufferSizeInBytes) end function function hipsparseDpruneDense2csr_bufferSize_full_rank(handle,m,n,A,lda,threshold,descr, & csrVal,csrRowPtr,csrColInd,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csr_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: threshold type(c_ptr) :: descr real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneDense2csr_bufferSize_full_rank = hipsparseDpruneDense2csr_bufferSize_(handle, & m,n,c_loc(A),lda,c_loc(threshold),descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd), & pBufferSizeInBytes) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSpruneDense2csr_bufferSizeExt_assumed_rank(handle,m,n,A,lda,threshold,descr, & csrVal,csrRowPtr,csrColInd,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csr_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: threshold type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneDense2csr_bufferSizeExt_assumed_rank = & hipsparseSpruneDense2csr_bufferSizeExt_(handle,m,n,c_loc(A),lda,c_loc(threshold),descr, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),pBufferSizeInBytes) end function #else function hipsparseSpruneDense2csr_bufferSizeExt_rank_0(handle,m,n,A,lda,threshold,descr, & csrVal,csrRowPtr,csrColInd,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csr_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: threshold type(c_ptr) :: descr real(c_float),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneDense2csr_bufferSizeExt_rank_0 = hipsparseSpruneDense2csr_bufferSizeExt_( & handle,m,n,c_loc(A),lda,c_loc(threshold),descr,c_loc(csrVal),c_loc(csrRowPtr), & c_loc(csrColInd),pBufferSizeInBytes) end function function hipsparseSpruneDense2csr_bufferSizeExt_rank_1(handle,m,n,A,lda,threshold,descr, & csrVal,csrRowPtr,csrColInd,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csr_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: threshold type(c_ptr) :: descr real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneDense2csr_bufferSizeExt_rank_1 = hipsparseSpruneDense2csr_bufferSizeExt_( & handle,m,n,c_loc(A),lda,c_loc(threshold),descr,c_loc(csrVal),c_loc(csrRowPtr), & c_loc(csrColInd),pBufferSizeInBytes) end function function hipsparseSpruneDense2csr_bufferSizeExt_full_rank(handle,m,n,A,lda,threshold,descr, & csrVal,csrRowPtr,csrColInd,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csr_bufferSizeExt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: threshold type(c_ptr) :: descr real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneDense2csr_bufferSizeExt_full_rank = hipsparseSpruneDense2csr_bufferSizeExt_( & handle,m,n,c_loc(A),lda,c_loc(threshold),descr,c_loc(csrVal),c_loc(csrRowPtr), & c_loc(csrColInd),pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDpruneDense2csr_bufferSizeExt_assumed_rank(handle,m,n,A,lda,threshold,descr, & csrVal,csrRowPtr,csrColInd,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csr_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: threshold type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneDense2csr_bufferSizeExt_assumed_rank = & hipsparseDpruneDense2csr_bufferSizeExt_(handle,m,n,c_loc(A),lda,c_loc(threshold),descr, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),pBufferSizeInBytes) end function #else function hipsparseDpruneDense2csr_bufferSizeExt_rank_0(handle,m,n,A,lda,threshold,descr, & csrVal,csrRowPtr,csrColInd,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csr_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: threshold type(c_ptr) :: descr real(c_double),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneDense2csr_bufferSizeExt_rank_0 = hipsparseDpruneDense2csr_bufferSizeExt_( & handle,m,n,c_loc(A),lda,c_loc(threshold),descr,c_loc(csrVal),c_loc(csrRowPtr), & c_loc(csrColInd),pBufferSizeInBytes) end function function hipsparseDpruneDense2csr_bufferSizeExt_rank_1(handle,m,n,A,lda,threshold,descr, & csrVal,csrRowPtr,csrColInd,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csr_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: threshold type(c_ptr) :: descr real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneDense2csr_bufferSizeExt_rank_1 = hipsparseDpruneDense2csr_bufferSizeExt_( & handle,m,n,c_loc(A),lda,c_loc(threshold),descr,c_loc(csrVal),c_loc(csrRowPtr), & c_loc(csrColInd),pBufferSizeInBytes) end function function hipsparseDpruneDense2csr_bufferSizeExt_full_rank(handle,m,n,A,lda,threshold,descr, & csrVal,csrRowPtr,csrColInd,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csr_bufferSizeExt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: threshold type(c_ptr) :: descr real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneDense2csr_bufferSizeExt_full_rank = hipsparseDpruneDense2csr_bufferSizeExt_( & handle,m,n,c_loc(A),lda,c_loc(threshold),descr,c_loc(csrVal),c_loc(csrRowPtr), & c_loc(csrColInd),pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSpruneDense2csrNnz_assumed_rank(handle,m,n,A,lda,threshold,descr,csrRowPtr, & nnzTotalDevHostPtr,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrNnz_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: buffer ! hipsparseSpruneDense2csrNnz_assumed_rank = hipsparseSpruneDense2csrNnz_(handle,m,n,c_loc(A), & lda,threshold,descr,c_loc(csrRowPtr),nnzTotalDevHostPtr,buffer) end function #else function hipsparseSpruneDense2csrNnz_rank_0(handle,m,n,A,lda,threshold,descr,csrRowPtr, & nnzTotalDevHostPtr,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrNnz_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr integer(c_int),target :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: buffer ! hipsparseSpruneDense2csrNnz_rank_0 = hipsparseSpruneDense2csrNnz_(handle,m,n,c_loc(A),lda, & threshold,descr,c_loc(csrRowPtr),nnzTotalDevHostPtr,buffer) end function function hipsparseSpruneDense2csrNnz_rank_1(handle,m,n,A,lda,threshold,descr,csrRowPtr, & nnzTotalDevHostPtr,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrNnz_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: buffer ! hipsparseSpruneDense2csrNnz_rank_1 = hipsparseSpruneDense2csrNnz_(handle,m,n,c_loc(A),lda, & threshold,descr,c_loc(csrRowPtr),nnzTotalDevHostPtr,buffer) end function function hipsparseSpruneDense2csrNnz_full_rank(handle,m,n,A,lda,threshold,descr,csrRowPtr, & nnzTotalDevHostPtr,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrNnz_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: buffer ! hipsparseSpruneDense2csrNnz_full_rank = hipsparseSpruneDense2csrNnz_(handle,m,n,c_loc(A), & lda,threshold,descr,c_loc(csrRowPtr),nnzTotalDevHostPtr,buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDpruneDense2csrNnz_assumed_rank(handle,m,n,A,lda,threshold,descr,csrRowPtr, & nnzTotalDevHostPtr,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrNnz_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: buffer ! hipsparseDpruneDense2csrNnz_assumed_rank = hipsparseDpruneDense2csrNnz_(handle,m,n,c_loc(A), & lda,threshold,descr,c_loc(csrRowPtr),nnzTotalDevHostPtr,buffer) end function #else function hipsparseDpruneDense2csrNnz_rank_0(handle,m,n,A,lda,threshold,descr,csrRowPtr, & nnzTotalDevHostPtr,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrNnz_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr integer(c_int),target :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: buffer ! hipsparseDpruneDense2csrNnz_rank_0 = hipsparseDpruneDense2csrNnz_(handle,m,n,c_loc(A),lda, & threshold,descr,c_loc(csrRowPtr),nnzTotalDevHostPtr,buffer) end function function hipsparseDpruneDense2csrNnz_rank_1(handle,m,n,A,lda,threshold,descr,csrRowPtr, & nnzTotalDevHostPtr,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrNnz_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: buffer ! hipsparseDpruneDense2csrNnz_rank_1 = hipsparseDpruneDense2csrNnz_(handle,m,n,c_loc(A),lda, & threshold,descr,c_loc(csrRowPtr),nnzTotalDevHostPtr,buffer) end function function hipsparseDpruneDense2csrNnz_full_rank(handle,m,n,A,lda,threshold,descr,csrRowPtr, & nnzTotalDevHostPtr,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrNnz_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: buffer ! hipsparseDpruneDense2csrNnz_full_rank = hipsparseDpruneDense2csrNnz_(handle,m,n,c_loc(A), & lda,threshold,descr,c_loc(csrRowPtr),nnzTotalDevHostPtr,buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSpruneDense2csr_assumed_rank(handle,m,n,A,lda,threshold,descr,csrVal, & csrRowPtr,csrColInd,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: buffer ! hipsparseSpruneDense2csr_assumed_rank = hipsparseSpruneDense2csr_(handle,m,n,c_loc(A),lda, & threshold,descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),buffer) end function #else function hipsparseSpruneDense2csr_rank_0(handle,m,n,A,lda,threshold,descr,csrVal,csrRowPtr, & csrColInd,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr real(c_float),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: buffer ! hipsparseSpruneDense2csr_rank_0 = hipsparseSpruneDense2csr_(handle,m,n,c_loc(A),lda, & threshold,descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),buffer) end function function hipsparseSpruneDense2csr_rank_1(handle,m,n,A,lda,threshold,descr,csrVal,csrRowPtr, & csrColInd,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: buffer ! hipsparseSpruneDense2csr_rank_1 = hipsparseSpruneDense2csr_(handle,m,n,c_loc(A),lda, & threshold,descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),buffer) end function function hipsparseSpruneDense2csr_full_rank(handle,m,n,A,lda,threshold,descr,csrVal,csrRowPtr, & csrColInd,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: buffer ! hipsparseSpruneDense2csr_full_rank = hipsparseSpruneDense2csr_(handle,m,n,c_loc(A),lda, & threshold,descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDpruneDense2csr_assumed_rank(handle,m,n,A,lda,threshold,descr,csrVal, & csrRowPtr,csrColInd,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: buffer ! hipsparseDpruneDense2csr_assumed_rank = hipsparseDpruneDense2csr_(handle,m,n,c_loc(A),lda, & threshold,descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),buffer) end function #else function hipsparseDpruneDense2csr_rank_0(handle,m,n,A,lda,threshold,descr,csrVal,csrRowPtr, & csrColInd,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr real(c_double),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: buffer ! hipsparseDpruneDense2csr_rank_0 = hipsparseDpruneDense2csr_(handle,m,n,c_loc(A),lda, & threshold,descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),buffer) end function function hipsparseDpruneDense2csr_rank_1(handle,m,n,A,lda,threshold,descr,csrVal,csrRowPtr, & csrColInd,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: buffer ! hipsparseDpruneDense2csr_rank_1 = hipsparseDpruneDense2csr_(handle,m,n,c_loc(A),lda, & threshold,descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),buffer) end function function hipsparseDpruneDense2csr_full_rank(handle,m,n,A,lda,threshold,descr,csrVal,csrRowPtr, & csrColInd,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: buffer ! hipsparseDpruneDense2csr_full_rank = hipsparseDpruneDense2csr_(handle,m,n,c_loc(A),lda, & threshold,descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),buffer) end function #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSpruneDense2csrByPercentage_bufferSize_assumed_rank(handle,m,n,A,lda, & percentage,descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrByPercentage_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneDense2csrByPercentage_bufferSize_assumed_rank = & hipsparseSpruneDense2csrByPercentage_bufferSize_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function #else function hipsparseSpruneDense2csrByPercentage_bufferSize_rank_0(handle,m,n,A,lda,percentage, & descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrByPercentage_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneDense2csrByPercentage_bufferSize_rank_0 = & hipsparseSpruneDense2csrByPercentage_bufferSize_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function function hipsparseSpruneDense2csrByPercentage_bufferSize_rank_1(handle,m,n,A,lda,percentage, & descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrByPercentage_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneDense2csrByPercentage_bufferSize_rank_1 = & hipsparseSpruneDense2csrByPercentage_bufferSize_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function function hipsparseSpruneDense2csrByPercentage_bufferSize_full_rank(handle,m,n,A,lda, & percentage,descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrByPercentage_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneDense2csrByPercentage_bufferSize_full_rank = & hipsparseSpruneDense2csrByPercentage_bufferSize_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function #endif #endif #ifndef USE_CUDA_NAMES #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDpruneDense2csrByPercentage_bufferSize_assumed_rank(handle,m,n,A,lda, & percentage,descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrByPercentage_bufferSize_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneDense2csrByPercentage_bufferSize_assumed_rank = & hipsparseDpruneDense2csrByPercentage_bufferSize_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function #else function hipsparseDpruneDense2csrByPercentage_bufferSize_rank_0(handle,m,n,A,lda,percentage, & descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrByPercentage_bufferSize_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneDense2csrByPercentage_bufferSize_rank_0 = & hipsparseDpruneDense2csrByPercentage_bufferSize_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function function hipsparseDpruneDense2csrByPercentage_bufferSize_rank_1(handle,m,n,A,lda,percentage, & descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrByPercentage_bufferSize_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneDense2csrByPercentage_bufferSize_rank_1 = & hipsparseDpruneDense2csrByPercentage_bufferSize_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function function hipsparseDpruneDense2csrByPercentage_bufferSize_full_rank(handle,m,n,A,lda, & percentage,descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrByPercentage_bufferSize_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneDense2csrByPercentage_bufferSize_full_rank = & hipsparseDpruneDense2csrByPercentage_bufferSize_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function #endif #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSpruneDense2csrByPercentage_bufferSizeExt_assumed_rank(handle,m,n,A,lda, & percentage,descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrByPercentage_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneDense2csrByPercentage_bufferSizeExt_assumed_rank = & hipsparseSpruneDense2csrByPercentage_bufferSizeExt_(handle,m,n,c_loc(A),lda,percentage, & descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function #else function hipsparseSpruneDense2csrByPercentage_bufferSizeExt_rank_0(handle,m,n,A,lda, & percentage,descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrByPercentage_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneDense2csrByPercentage_bufferSizeExt_rank_0 = & hipsparseSpruneDense2csrByPercentage_bufferSizeExt_(handle,m,n,c_loc(A),lda,percentage, & descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function function hipsparseSpruneDense2csrByPercentage_bufferSizeExt_rank_1(handle,m,n,A,lda, & percentage,descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrByPercentage_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneDense2csrByPercentage_bufferSizeExt_rank_1 = & hipsparseSpruneDense2csrByPercentage_bufferSizeExt_(handle,m,n,c_loc(A),lda,percentage, & descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function function hipsparseSpruneDense2csrByPercentage_bufferSizeExt_full_rank(handle,m,n,A,lda, & percentage,descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrByPercentage_bufferSizeExt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseSpruneDense2csrByPercentage_bufferSizeExt_full_rank = & hipsparseSpruneDense2csrByPercentage_bufferSizeExt_(handle,m,n,c_loc(A),lda,percentage, & descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDpruneDense2csrByPercentage_bufferSizeExt_assumed_rank(handle,m,n,A,lda, & percentage,descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrByPercentage_bufferSizeExt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneDense2csrByPercentage_bufferSizeExt_assumed_rank = & hipsparseDpruneDense2csrByPercentage_bufferSizeExt_(handle,m,n,c_loc(A),lda,percentage, & descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function #else function hipsparseDpruneDense2csrByPercentage_bufferSizeExt_rank_0(handle,m,n,A,lda, & percentage,descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrByPercentage_bufferSizeExt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneDense2csrByPercentage_bufferSizeExt_rank_0 = & hipsparseDpruneDense2csrByPercentage_bufferSizeExt_(handle,m,n,c_loc(A),lda,percentage, & descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function function hipsparseDpruneDense2csrByPercentage_bufferSizeExt_rank_1(handle,m,n,A,lda, & percentage,descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrByPercentage_bufferSizeExt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneDense2csrByPercentage_bufferSizeExt_rank_1 = & hipsparseDpruneDense2csrByPercentage_bufferSizeExt_(handle,m,n,c_loc(A),lda,percentage, & descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function function hipsparseDpruneDense2csrByPercentage_bufferSizeExt_full_rank(handle,m,n,A,lda, & percentage,descr,csrVal,csrRowPtr,csrColInd,myInfo,pBufferSizeInBytes) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrByPercentage_bufferSizeExt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo integer(c_size_t) :: pBufferSizeInBytes ! hipsparseDpruneDense2csrByPercentage_bufferSizeExt_full_rank = & hipsparseDpruneDense2csrByPercentage_bufferSizeExt_(handle,m,n,c_loc(A),lda,percentage, & descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo,pBufferSizeInBytes) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSpruneDense2csrNnzByPercentage_assumed_rank(handle,m,n,A,lda,percentage, & descr,csrRowPtr,nnzTotalDevHostPtr,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrNnzByPercentage_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseSpruneDense2csrNnzByPercentage_assumed_rank = & hipsparseSpruneDense2csrNnzByPercentage_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csrRowPtr),nnzTotalDevHostPtr,myInfo,buffer) end function #else function hipsparseSpruneDense2csrNnzByPercentage_rank_0(handle,m,n,A,lda,percentage,descr, & csrRowPtr,nnzTotalDevHostPtr,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrNnzByPercentage_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr integer(c_int),target :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseSpruneDense2csrNnzByPercentage_rank_0 = hipsparseSpruneDense2csrNnzByPercentage_( & handle,m,n,c_loc(A),lda,percentage,descr,c_loc(csrRowPtr),nnzTotalDevHostPtr,myInfo,buffer) end function function hipsparseSpruneDense2csrNnzByPercentage_rank_1(handle,m,n,A,lda,percentage,descr, & csrRowPtr,nnzTotalDevHostPtr,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrNnzByPercentage_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseSpruneDense2csrNnzByPercentage_rank_1 = hipsparseSpruneDense2csrNnzByPercentage_( & handle,m,n,c_loc(A),lda,percentage,descr,c_loc(csrRowPtr),nnzTotalDevHostPtr,myInfo,buffer) end function function hipsparseSpruneDense2csrNnzByPercentage_full_rank(handle,m,n,A,lda,percentage,descr, & csrRowPtr,nnzTotalDevHostPtr,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrNnzByPercentage_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseSpruneDense2csrNnzByPercentage_full_rank = & hipsparseSpruneDense2csrNnzByPercentage_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csrRowPtr),nnzTotalDevHostPtr,myInfo,buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDpruneDense2csrNnzByPercentage_assumed_rank(handle,m,n,A,lda,percentage, & descr,csrRowPtr,nnzTotalDevHostPtr,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrNnzByPercentage_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseDpruneDense2csrNnzByPercentage_assumed_rank = & hipsparseDpruneDense2csrNnzByPercentage_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csrRowPtr),nnzTotalDevHostPtr,myInfo,buffer) end function #else function hipsparseDpruneDense2csrNnzByPercentage_rank_0(handle,m,n,A,lda,percentage,descr, & csrRowPtr,nnzTotalDevHostPtr,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrNnzByPercentage_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr integer(c_int),target :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseDpruneDense2csrNnzByPercentage_rank_0 = hipsparseDpruneDense2csrNnzByPercentage_( & handle,m,n,c_loc(A),lda,percentage,descr,c_loc(csrRowPtr),nnzTotalDevHostPtr,myInfo,buffer) end function function hipsparseDpruneDense2csrNnzByPercentage_rank_1(handle,m,n,A,lda,percentage,descr, & csrRowPtr,nnzTotalDevHostPtr,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrNnzByPercentage_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseDpruneDense2csrNnzByPercentage_rank_1 = hipsparseDpruneDense2csrNnzByPercentage_( & handle,m,n,c_loc(A),lda,percentage,descr,c_loc(csrRowPtr),nnzTotalDevHostPtr,myInfo,buffer) end function function hipsparseDpruneDense2csrNnzByPercentage_full_rank(handle,m,n,A,lda,percentage,descr, & csrRowPtr,nnzTotalDevHostPtr,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrNnzByPercentage_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int) :: nnzTotalDevHostPtr type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseDpruneDense2csrNnzByPercentage_full_rank = & hipsparseDpruneDense2csrNnzByPercentage_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csrRowPtr),nnzTotalDevHostPtr,myInfo,buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseSpruneDense2csrByPercentage_assumed_rank(handle,m,n,A,lda,percentage,descr, & csrVal,csrRowPtr,csrColInd,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrByPercentage_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseSpruneDense2csrByPercentage_assumed_rank = hipsparseSpruneDense2csrByPercentage_( & handle,m,n,c_loc(A),lda,percentage,descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd), & myInfo,buffer) end function #else function hipsparseSpruneDense2csrByPercentage_rank_0(handle,m,n,A,lda,percentage,descr,csrVal, & csrRowPtr,csrColInd,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrByPercentage_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseSpruneDense2csrByPercentage_rank_0 = hipsparseSpruneDense2csrByPercentage_(handle, & m,n,c_loc(A),lda,percentage,descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo, & buffer) end function function hipsparseSpruneDense2csrByPercentage_rank_1(handle,m,n,A,lda,percentage,descr,csrVal, & csrRowPtr,csrColInd,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrByPercentage_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseSpruneDense2csrByPercentage_rank_1 = hipsparseSpruneDense2csrByPercentage_(handle, & m,n,c_loc(A),lda,percentage,descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo, & buffer) end function function hipsparseSpruneDense2csrByPercentage_full_rank(handle,m,n,A,lda,percentage,descr, & csrVal,csrRowPtr,csrColInd,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseSpruneDense2csrByPercentage_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseSpruneDense2csrByPercentage_full_rank = hipsparseSpruneDense2csrByPercentage_( & handle,m,n,c_loc(A),lda,percentage,descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd), & myInfo,buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDpruneDense2csrByPercentage_assumed_rank(handle,m,n,A,lda,percentage,descr, & csrVal,csrRowPtr,csrColInd,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrByPercentage_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csrVal integer(c_int),target,contiguous,dimension(..) :: csrRowPtr integer(c_int),target,contiguous,dimension(..) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseDpruneDense2csrByPercentage_assumed_rank = hipsparseDpruneDense2csrByPercentage_( & handle,m,n,c_loc(A),lda,percentage,descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd), & myInfo,buffer) end function #else function hipsparseDpruneDense2csrByPercentage_rank_0(handle,m,n,A,lda,percentage,descr,csrVal, & csrRowPtr,csrColInd,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrByPercentage_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target :: csrVal integer(c_int),target :: csrRowPtr integer(c_int),target :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseDpruneDense2csrByPercentage_rank_0 = hipsparseDpruneDense2csrByPercentage_(handle, & m,n,c_loc(A),lda,percentage,descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo, & buffer) end function function hipsparseDpruneDense2csrByPercentage_rank_1(handle,m,n,A,lda,percentage,descr,csrVal, & csrRowPtr,csrColInd,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrByPercentage_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseDpruneDense2csrByPercentage_rank_1 = hipsparseDpruneDense2csrByPercentage_(handle, & m,n,c_loc(A),lda,percentage,descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd),myInfo, & buffer) end function function hipsparseDpruneDense2csrByPercentage_full_rank(handle,m,n,A,lda,percentage,descr, & csrVal,csrRowPtr,csrColInd,myInfo,buffer) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDpruneDense2csrByPercentage_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target,dimension(:) :: csrVal integer(c_int),target,dimension(:) :: csrRowPtr integer(c_int),target,dimension(:) :: csrColInd type(c_ptr) :: myInfo type(c_ptr) :: buffer ! hipsparseDpruneDense2csrByPercentage_full_rank = hipsparseDpruneDense2csrByPercentage_( & handle,m,n,c_loc(A),lda,percentage,descr,c_loc(csrVal),c_loc(csrRowPtr),c_loc(csrColInd), & myInfo,buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseScsrcolor_assumed_rank(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrcolor_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA type(c_ptr) :: fractionToColor integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! hipsparseScsrcolor_assumed_rank = hipsparseScsrcolor_(handle,m,nnz,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),fractionToColor,ncolors,coloring,reordering,myInfo) end function #else function hipsparseScsrcolor_rank_0(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrcolor_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA type(c_ptr) :: fractionToColor integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! hipsparseScsrcolor_rank_0 = hipsparseScsrcolor_(handle,m,nnz,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),fractionToColor,ncolors,coloring,reordering,myInfo) end function function hipsparseScsrcolor_rank_1(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseScsrcolor_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_float),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA type(c_ptr) :: fractionToColor integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! hipsparseScsrcolor_rank_1 = hipsparseScsrcolor_(handle,m,nnz,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),fractionToColor,ncolors,coloring,reordering,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseDcsrcolor_assumed_rank(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrcolor_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA type(c_ptr) :: fractionToColor integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! hipsparseDcsrcolor_assumed_rank = hipsparseDcsrcolor_(handle,m,nnz,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),fractionToColor,ncolors,coloring,reordering,myInfo) end function #else function hipsparseDcsrcolor_rank_0(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrcolor_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA type(c_ptr) :: fractionToColor integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! hipsparseDcsrcolor_rank_0 = hipsparseDcsrcolor_(handle,m,nnz,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),fractionToColor,ncolors,coloring,reordering,myInfo) end function function hipsparseDcsrcolor_rank_1(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseDcsrcolor_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA real(c_double),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA type(c_ptr) :: fractionToColor integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! hipsparseDcsrcolor_rank_1 = hipsparseDcsrcolor_(handle,m,nnz,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),fractionToColor,ncolors,coloring,reordering,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseCcsrcolor_assumed_rank(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrcolor_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA type(c_ptr) :: fractionToColor integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! hipsparseCcsrcolor_assumed_rank = hipsparseCcsrcolor_(handle,m,nnz,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),fractionToColor,ncolors,coloring,reordering,myInfo) end function #else function hipsparseCcsrcolor_rank_0(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrcolor_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA type(c_ptr) :: fractionToColor integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! hipsparseCcsrcolor_rank_0 = hipsparseCcsrcolor_(handle,m,nnz,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),fractionToColor,ncolors,coloring,reordering,myInfo) end function function hipsparseCcsrcolor_rank_1(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseCcsrcolor_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_float_complex),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA type(c_ptr) :: fractionToColor integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! hipsparseCcsrcolor_rank_1 = hipsparseCcsrcolor_(handle,m,nnz,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),fractionToColor,ncolors,coloring,reordering,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function hipsparseZcsrcolor_assumed_rank(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrcolor_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,contiguous,dimension(..) :: csrValA integer(c_int),target,contiguous,dimension(..) :: csrRowPtrA integer(c_int),target,contiguous,dimension(..) :: csrColIndA type(c_ptr) :: fractionToColor integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! hipsparseZcsrcolor_assumed_rank = hipsparseZcsrcolor_(handle,m,nnz,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),fractionToColor,ncolors,coloring,reordering,myInfo) end function #else function hipsparseZcsrcolor_rank_0(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrcolor_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target :: csrValA integer(c_int),target :: csrRowPtrA integer(c_int),target :: csrColIndA type(c_ptr) :: fractionToColor integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! hipsparseZcsrcolor_rank_0 = hipsparseZcsrcolor_(handle,m,nnz,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),fractionToColor,ncolors,coloring,reordering,myInfo) end function function hipsparseZcsrcolor_rank_1(handle,m,nnz,descrA,csrValA,csrRowPtrA,csrColIndA, & fractionToColor,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_hipsparse_enums implicit none integer(kind(HIPSPARSE_STATUS_SUCCESS)) :: hipsparseZcsrcolor_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descrA complex(c_double_complex),target,dimension(:) :: csrValA integer(c_int),target,dimension(:) :: csrRowPtrA integer(c_int),target,dimension(:) :: csrColIndA type(c_ptr) :: fractionToColor integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! hipsparseZcsrcolor_rank_1 = hipsparseZcsrcolor_(handle,m,nnz,descrA,c_loc(csrValA), & c_loc(csrRowPtrA),c_loc(csrColIndA),fractionToColor,ncolors,coloring,reordering,myInfo) end function #endif #endif end module hipfort_hipsparse hipfort-rocm-10.0.0/lib/hipfort/hipfort_hipsparse_enums.F90000066400000000000000000000172061524740623400236570ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_hipsparse_enums use, intrinsic :: iso_c_binding implicit none ! hipsparseStatus_t enum, bind(c) enumerator :: HIPSPARSE_STATUS_SUCCESS = 0 enumerator :: HIPSPARSE_STATUS_NOT_INITIALIZED = 1 enumerator :: HIPSPARSE_STATUS_ALLOC_FAILED = 2 enumerator :: HIPSPARSE_STATUS_INVALID_VALUE = 3 enumerator :: HIPSPARSE_STATUS_ARCH_MISMATCH = 4 enumerator :: HIPSPARSE_STATUS_MAPPING_ERROR = 5 enumerator :: HIPSPARSE_STATUS_EXECUTION_FAILED = 6 enumerator :: HIPSPARSE_STATUS_INTERNAL_ERROR = 7 enumerator :: HIPSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED = 8 enumerator :: HIPSPARSE_STATUS_ZERO_PIVOT = 9 enumerator :: HIPSPARSE_STATUS_NOT_SUPPORTED = 10 enumerator :: HIPSPARSE_STATUS_INSUFFICIENT_RESOURCES = 11 end enum ! hipsparsePointerMode_t enum, bind(c) enumerator :: HIPSPARSE_POINTER_MODE_HOST = 0 enumerator :: HIPSPARSE_POINTER_MODE_DEVICE = 1 end enum ! hipsparseAction_t enum, bind(c) enumerator :: HIPSPARSE_ACTION_SYMBOLIC = 0 enumerator :: HIPSPARSE_ACTION_NUMERIC = 1 end enum ! hipsparseMatrixType_t enum, bind(c) enumerator :: HIPSPARSE_MATRIX_TYPE_GENERAL = 0 enumerator :: HIPSPARSE_MATRIX_TYPE_SYMMETRIC = 1 enumerator :: HIPSPARSE_MATRIX_TYPE_HERMITIAN = 2 enumerator :: HIPSPARSE_MATRIX_TYPE_TRIANGULAR = 3 end enum ! hipsparseFillMode_t enum, bind(c) enumerator :: HIPSPARSE_FILL_MODE_LOWER = 0 enumerator :: HIPSPARSE_FILL_MODE_UPPER = 1 end enum ! hipsparseDiagType_t enum, bind(c) enumerator :: HIPSPARSE_DIAG_TYPE_NON_UNIT = 0 enumerator :: HIPSPARSE_DIAG_TYPE_UNIT = 1 end enum ! hipsparseIndexBase_t enum, bind(c) enumerator :: HIPSPARSE_INDEX_BASE_ZERO = 0 enumerator :: HIPSPARSE_INDEX_BASE_ONE = 1 end enum ! hipsparseOperation_t enum, bind(c) enumerator :: HIPSPARSE_OPERATION_NON_TRANSPOSE = 0 enumerator :: HIPSPARSE_OPERATION_TRANSPOSE = 1 enumerator :: HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE = 2 end enum ! hipsparseHybPartition_t enum, bind(c) enumerator :: HIPSPARSE_HYB_PARTITION_AUTO = 0 enumerator :: HIPSPARSE_HYB_PARTITION_USER = 1 enumerator :: HIPSPARSE_HYB_PARTITION_MAX = 2 end enum ! hipsparseSolvePolicy_t enum, bind(c) enumerator :: HIPSPARSE_SOLVE_POLICY_NO_LEVEL = 0 enumerator :: HIPSPARSE_SOLVE_POLICY_USE_LEVEL = 1 end enum ! hipsparseSideMode_t enum, bind(c) enumerator :: HIPSPARSE_SIDE_LEFT = 0 enumerator :: HIPSPARSE_SIDE_RIGHT = 1 end enum ! hipsparseDirection_t enum, bind(c) enumerator :: HIPSPARSE_DIRECTION_ROW = 0 enumerator :: HIPSPARSE_DIRECTION_COLUMN = 1 end enum ! hipsparseCsr2CscAlg_t enum, bind(c) #ifdef USE_CUDA_NAMES enumerator :: HIPSPARSE_CSR2CSC_ALG_DEFAULT = 1 #else enumerator :: HIPSPARSE_CSR2CSC_ALG_DEFAULT = 0 #endif enumerator :: HIPSPARSE_CSR2CSC_ALG1 = 1 enumerator :: HIPSPARSE_CSR2CSC_ALG2 = 2 end enum ! hipsparseFormat_t enum, bind(c) enumerator :: HIPSPARSE_FORMAT_CSR = 1 enumerator :: HIPSPARSE_FORMAT_CSC = 2 enumerator :: HIPSPARSE_FORMAT_COO = 3 enumerator :: HIPSPARSE_FORMAT_COO_AOS = 4 enumerator :: HIPSPARSE_FORMAT_BLOCKED_ELL = 5 enumerator :: HIPSPARSE_FORMAT_SLICED_ELL = 6 enumerator :: HIPSPARSE_FORMAT_BSR = 7 end enum ! hipsparseOrder_t enum, bind(c) enumerator :: HIPSPARSE_ORDER_COLUMN = 1 enumerator :: HIPSPARSE_ORDER_COL = 1 enumerator :: HIPSPARSE_ORDER_ROW = 2 end enum ! hipsparseIndexType_t enum, bind(c) enumerator :: HIPSPARSE_INDEX_16U = 1 enumerator :: HIPSPARSE_INDEX_32I = 2 enumerator :: HIPSPARSE_INDEX_64I = 3 end enum ! hipsparseSpMVAlg_t enum, bind(c) enumerator :: HIPSPARSE_MV_ALG_DEFAULT = 0 enumerator :: HIPSPARSE_COOMV_ALG = 1 enumerator :: HIPSPARSE_CSRMV_ALG1 = 2 enumerator :: HIPSPARSE_CSRMV_ALG2 = 3 enumerator :: HIPSPARSE_SPMV_ALG_DEFAULT = 0 enumerator :: HIPSPARSE_SPMV_COO_ALG1 = 1 enumerator :: HIPSPARSE_SPMV_CSR_ALG1 = 2 enumerator :: HIPSPARSE_SPMV_CSR_ALG2 = 3 enumerator :: HIPSPARSE_SPMV_COO_ALG2 = 4 enumerator :: HIPSPARSE_SPMV_SELL_ALG1 = 5 enumerator :: HIPSPARSE_SPMV_CSR_ALG3 = 7 enumerator :: HIPSPARSE_SPMV_BSR_ALG1 = 6 end enum ! hipsparseSpMMAlg_t enum, bind(c) enumerator :: HIPSPARSE_MM_ALG_DEFAULT = 0 enumerator :: HIPSPARSE_COOMM_ALG1 = 1 enumerator :: HIPSPARSE_COOMM_ALG2 = 2 enumerator :: HIPSPARSE_COOMM_ALG3 = 3 enumerator :: HIPSPARSE_CSRMM_ALG1 = 4 enumerator :: HIPSPARSE_SPMM_ALG_DEFAULT = 0 enumerator :: HIPSPARSE_SPMM_COO_ALG1 = 1 enumerator :: HIPSPARSE_SPMM_COO_ALG2 = 2 enumerator :: HIPSPARSE_SPMM_COO_ALG3 = 3 enumerator :: HIPSPARSE_SPMM_COO_ALG4 = 5 enumerator :: HIPSPARSE_SPMM_CSR_ALG1 = 4 enumerator :: HIPSPARSE_SPMM_CSR_ALG2 = 6 enumerator :: HIPSPARSE_SPMM_CSR_ALG3 = 12 enumerator :: HIPSPARSE_SPMM_BLOCKED_ELL_ALG1 = 13 enumerator :: HIPSPARSE_SPMM_BSR_ALG1 = 14 end enum ! hipsparseSparseToDenseAlg_t enum, bind(c) enumerator :: HIPSPARSE_SPARSETODENSE_ALG_DEFAULT = 0 end enum ! hipsparseDenseToSparseAlg_t enum, bind(c) enumerator :: HIPSPARSE_DENSETOSPARSE_ALG_DEFAULT = 0 end enum ! hipsparseSDDMMAlg_t enum, bind(c) enumerator :: HIPSPARSE_SDDMM_ALG_DEFAULT = 0 end enum ! hipsparseSpSVAlg_t enum, bind(c) enumerator :: HIPSPARSE_SPSV_ALG_DEFAULT = 0 end enum ! hipsparseSpSMAlg_t enum, bind(c) enumerator :: HIPSPARSE_SPSM_ALG_DEFAULT = 0 end enum ! hipsparseSpMatAttribute_t enum, bind(c) enumerator :: HIPSPARSE_SPMAT_FILL_MODE = 0 enumerator :: HIPSPARSE_SPMAT_DIAG_TYPE = 1 end enum ! hipsparseSpGEMMAlg_t enum, bind(c) enumerator :: HIPSPARSE_SPGEMM_DEFAULT = 0 enumerator :: HIPSPARSE_SPGEMM_CSR_ALG_DETERMINISTIC = 1 enumerator :: HIPSPARSE_SPGEMM_CSR_ALG_NONDETERMINISTIC = 2 enumerator :: HIPSPARSE_SPGEMM_ALG1 = 3 enumerator :: HIPSPARSE_SPGEMM_ALG2 = 4 enumerator :: HIPSPARSE_SPGEMM_ALG3 = 5 end enum integer(c_int), parameter :: hipsparseVersionMajor = 4 integer(c_int), parameter :: hipsparseVersionMinor = 7 integer(c_int), parameter :: hipsparseVersionPatch = 0 end module hipfort_hipsparse_enums hipfort-rocm-10.0.0/lib/hipfort/hipfort_rocblas.F90000066400000000000000000117342711524740623400221110ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_rocblas use hipfort_rocblas_enums implicit none !> \brief Create handle. interface rocblas_create_handle function rocblas_create_handle_(handle) bind(c, name="rocblas_create_handle") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_create_handle_ type(c_ptr) :: handle end function end interface !> \brief Destroy handle. interface rocblas_destroy_handle function rocblas_destroy_handle_(handle) bind(c, name="rocblas_destroy_handle") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_destroy_handle_ type(c_ptr),value :: handle end function end interface !> \brief Set stream for handle. interface rocblas_set_stream function rocblas_set_stream_(handle,stream) bind(c, name="rocblas_set_stream") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_set_stream_ type(c_ptr),value :: handle type(c_ptr),value :: stream end function end interface !> \brief Get stream [0] from handle. interface rocblas_get_stream function rocblas_get_stream_(handle,stream) bind(c, name="rocblas_get_stream") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_get_stream_ type(c_ptr),value :: handle type(c_ptr) :: stream end function end interface !> \brief Set ``rocblas_pointer_mode``. interface rocblas_set_pointer_mode function rocblas_set_pointer_mode_(handle,pointer_mode) bind(c, name="rocblas_set_pointer_mode") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_set_pointer_mode_ type(c_ptr),value :: handle integer(kind(rocblas_pointer_mode_host)),value :: pointer_mode end function end interface !> \brief Get ``rocblas_pointer_mode``. interface rocblas_get_pointer_mode function rocblas_get_pointer_mode_(handle,pointer_mode) bind(c, name="rocblas_get_pointer_mode") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_get_pointer_mode_ type(c_ptr),value :: handle type(c_ptr),value :: pointer_mode end function end interface !> \brief Set ``rocblas_atomics_mode`` !> \details !> Some rocBLAS functions have implementations which use atomic operations to increase !> performance. !> By using atomic operations, results are not guaranteed to be identical between multiple runs. !> Results are accurate with or without atomic operations. Atomic operations in rocBLAS are !> turned !> off by default. They can be turned on or off on a per-handle basis by calling !> ``rocblas_set_atomics_mode``. interface rocblas_set_atomics_mode function rocblas_set_atomics_mode_(handle,atomics_mode) bind(c, name="rocblas_set_atomics_mode") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_set_atomics_mode_ type(c_ptr),value :: handle integer(kind(rocblas_atomics_not_allowed)),value :: atomics_mode end function end interface !> \brief Get ``rocblas_atomics_mode``. interface rocblas_get_atomics_mode function rocblas_get_atomics_mode_(handle,atomics_mode) bind(c, name="rocblas_get_atomics_mode") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_get_atomics_mode_ type(c_ptr),value :: handle type(c_ptr),value :: atomics_mode end function end interface !> \brief Set alpha stride for limited set of batched and strided_batched functions to specify !> the stride for alpha between successive batch elements. !> Only applies to rocblas_pointer_mode_device and thus device side allocations. !> It enables interpretation of the alpha pointer for both batched and strided_batched functions !> as a pointer to a vector of values. !> Default value is 0 which treats it as a pointer to a single scalar. Support is denoted with !> specific function documentation. !> Warning this is a modal like state in the handle. Restore to value 0 if no longer applicable to !> later function calls. interface rocblas_set_batch_alpha_stride function rocblas_set_batch_alpha_stride_(handle,alpha_stride) & bind(c, name="rocblas_set_batch_alpha_stride") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_set_batch_alpha_stride_ type(c_ptr),value :: handle integer(c_int64_t),value :: alpha_stride end function end interface !> \brief Get batch alpha stride from the handle. interface rocblas_get_batch_alpha_stride function rocblas_get_batch_alpha_stride_(handle,alpha_stride) & bind(c, name="rocblas_get_batch_alpha_stride") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_get_batch_alpha_stride_ type(c_ptr),value :: handle type(c_ptr),value :: alpha_stride end function end interface !> \brief Set beta stride for limited set of batched and strided_batched functions to specify the !> stride for beta between successive batch elements. !> Only applies to rocblas_pointer_mode_device and thus device side allocations. !> It enables interpretation of the beta pointer for both batched and strided_batched functions as !> a pointer to a vector of values. !> Default value is 0 which treats it as a pointer to a single scalar. Support is denoted with !> specific function documentation. !> Warning this is a modal like state in the handle. Restore to value 0 if no longer applicable to !> later function calls. interface rocblas_set_batch_beta_stride function rocblas_set_batch_beta_stride_(handle,beta_stride) & bind(c, name="rocblas_set_batch_beta_stride") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_set_batch_beta_stride_ type(c_ptr),value :: handle integer(c_int64_t),value :: beta_stride end function end interface !> \brief Get batch beta stride from the handle. interface rocblas_get_batch_beta_stride function rocblas_get_batch_beta_stride_(handle,beta_stride) & bind(c, name="rocblas_get_batch_beta_stride") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_get_batch_beta_stride_ type(c_ptr),value :: handle type(c_ptr),value :: beta_stride end function end interface !> \brief Set ``rocblas_math_mode``. interface rocblas_set_math_mode function rocblas_set_math_mode_(handle,math_mode) bind(c, name="rocblas_set_math_mode") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_set_math_mode_ type(c_ptr),value :: handle integer(kind(rocblas_default_math)),value :: math_mode end function end interface !> \brief Get ``rocblas_math_mode``. interface rocblas_get_math_mode function rocblas_get_math_mode_(handle,math_mode) bind(c, name="rocblas_get_math_mode") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_get_math_mode_ type(c_ptr),value :: handle type(c_ptr),value :: math_mode end function end interface !> \brief Indicates whether the pointer is on the host or device. interface rocblas_pointer_to_mode function rocblas_pointer_to_mode_(ptr) bind(c, name="rocblas_pointer_to_mode") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_pointer_mode_host)) :: rocblas_pointer_to_mode_ type(c_ptr),value :: ptr end function end interface interface rocblas_set_vector_64 function rocblas_set_vector_64_(n,elem_size,x,incx,y,incy) bind(c, name="rocblas_set_vector_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_set_vector_64_ integer(c_int64_t),value :: n integer(c_int64_t),value :: elem_size type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_get_vector_64 function rocblas_get_vector_64_(n,elem_size,x,incx,y,incy) bind(c, name="rocblas_get_vector_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_get_vector_64_ integer(c_int64_t),value :: n integer(c_int64_t),value :: elem_size type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_set_matrix_64 function rocblas_set_matrix_64_(rows,cols,elem_size,a,lda,b,ldb) & bind(c, name="rocblas_set_matrix_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_set_matrix_64_ integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: elem_size type(c_ptr),value :: a integer(c_int64_t),value :: lda type(c_ptr),value :: b integer(c_int64_t),value :: ldb end function end interface interface rocblas_get_matrix_64 function rocblas_get_matrix_64_(rows,cols,elem_size,a,lda,b,ldb) & bind(c, name="rocblas_get_matrix_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_get_matrix_64_ integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: elem_size type(c_ptr),value :: a integer(c_int64_t),value :: lda type(c_ptr),value :: b integer(c_int64_t),value :: ldb end function end interface interface rocblas_set_vector_async_64 function rocblas_set_vector_async_64_(n,elem_size,x,incx,y,incy,stream) & bind(c, name="rocblas_set_vector_async_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_set_vector_async_64_ integer(c_int64_t),value :: n integer(c_int64_t),value :: elem_size type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: stream end function end interface interface rocblas_get_vector_async_64 function rocblas_get_vector_async_64_(n,elem_size,x,incx,y,incy,stream) & bind(c, name="rocblas_get_vector_async_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_get_vector_async_64_ integer(c_int64_t),value :: n integer(c_int64_t),value :: elem_size type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: stream end function end interface interface rocblas_set_matrix_async_64 function rocblas_set_matrix_async_64_(rows,cols,elem_size,a,lda,b,ldb,stream) & bind(c, name="rocblas_set_matrix_async_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_set_matrix_async_64_ integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: elem_size type(c_ptr),value :: a integer(c_int64_t),value :: lda type(c_ptr),value :: b integer(c_int64_t),value :: ldb type(c_ptr),value :: stream end function end interface interface rocblas_get_matrix_async_64 function rocblas_get_matrix_async_64_(rows,cols,elem_size,a,lda,b,ldb,stream) & bind(c, name="rocblas_get_matrix_async_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_get_matrix_async_64_ integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: elem_size type(c_ptr),value :: a integer(c_int64_t),value :: lda type(c_ptr),value :: b integer(c_int64_t),value :: ldb type(c_ptr),value :: stream end function end interface !> Function to set start/stop event handlers (for internal use only) interface rocblas_set_start_stop_events function rocblas_set_start_stop_events_(handle,startEvent,stopEvent) & bind(c, name="rocblas_set_start_stop_events") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_set_start_stop_events_ type(c_ptr),value :: handle type(c_ptr),value :: startEvent type(c_ptr),value :: stopEvent end function end interface interface rocblas_set_solution_fitness_query function rocblas_set_solution_fitness_query_(handle,fitness) & bind(c, name="rocblas_set_solution_fitness_query") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_set_solution_fitness_query_ type(c_ptr),value :: handle real(c_double) :: fitness end function end interface !> \brief specifies the performance metric that solution selection uses !> \details !> Determines which performance metric will be used by Tensile when selecting the optimal !> solution !> for gemm problems. If a valid solution benchmarked for this performance metric does not !> exist !> for a problem, Tensile will default to a solution benchmarked for overall performance !> instead. !> @param[in] handle - [rocblas_handle] !> the handle of device !> @param[in] metric - [rocblas_performance_metric] !> the performance metric to be used interface rocblas_set_performance_metric function rocblas_set_performance_metric_(handle,metric) & bind(c, name="rocblas_set_performance_metric") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_set_performance_metric_ type(c_ptr),value :: handle integer(kind(rocblas_default_performance_metric)),value :: metric end function end interface !> \brief returns the performance metric being used for solution selection !> \details !> Returns the performance metric used by Tensile to select the optimal solution for gemm !> problems. !> @param[in] handle - [rocblas_handle] !> the handle of device !> @param[out] metric - [rocblas_performance_metric*] !> pointer to where the metric will be stored interface rocblas_get_performance_metric function rocblas_get_performance_metric_(handle,metric) & bind(c, name="rocblas_get_performance_metric") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_get_performance_metric_ type(c_ptr),value :: handle type(c_ptr),value :: metric end function end interface !> \brief BLAS Level 1 API !> !> \details !> The scal functions scale each element of vector ``x`` with scalar ``alpha``: !> !> x := alpha * x !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in x. !> @param[in] alpha - device pointer or host pointer for the scalar alpha. !> @param[in, out] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. interface rocblas_sscal function rocblas_sscal_(handle,n,alpha,x,incx) bind(c, name="rocblas_sscal") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sscal_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sscal_assumed_rank #else module procedure & rocblas_sscal_rank_0,& rocblas_sscal_rank_1 #endif #endif end interface interface rocblas_dscal function rocblas_dscal_(handle,n,alpha,x,incx) bind(c, name="rocblas_dscal") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dscal_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dscal_assumed_rank #else module procedure & rocblas_dscal_rank_0,& rocblas_dscal_rank_1 #endif #endif end interface interface rocblas_cscal function rocblas_cscal_(handle,n,alpha,x,incx) bind(c, name="rocblas_cscal") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cscal_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cscal_assumed_rank #else module procedure & rocblas_cscal_rank_0,& rocblas_cscal_rank_1 #endif #endif end interface interface rocblas_zscal function rocblas_zscal_(handle,n,alpha,x,incx) bind(c, name="rocblas_zscal") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zscal_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zscal_assumed_rank #else module procedure & rocblas_zscal_rank_0,& rocblas_zscal_rank_1 #endif #endif end interface interface rocblas_csscal function rocblas_csscal_(handle,n,alpha,x,incx) bind(c, name="rocblas_csscal") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csscal_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_csscal_assumed_rank #else module procedure & rocblas_csscal_rank_0,& rocblas_csscal_rank_1 #endif #endif end interface interface rocblas_zdscal function rocblas_zdscal_(handle,n,alpha,x,incx) bind(c, name="rocblas_zdscal") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdscal_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zdscal_assumed_rank #else module procedure & rocblas_zdscal_rank_0,& rocblas_zdscal_rank_1 #endif #endif end interface interface rocblas_sscal_64 function rocblas_sscal_64_(handle,n,alpha,x,incx) bind(c, name="rocblas_sscal_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sscal_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_dscal_64 function rocblas_dscal_64_(handle,n,alpha,x,incx) bind(c, name="rocblas_dscal_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dscal_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_cscal_64 function rocblas_cscal_64_(handle,n,alpha,x,incx) bind(c, name="rocblas_cscal_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cscal_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_zscal_64 function rocblas_zscal_64_(handle,n,alpha,x,incx) bind(c, name="rocblas_zscal_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zscal_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_csscal_64 function rocblas_csscal_64_(handle,n,alpha,x,incx) bind(c, name="rocblas_csscal_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csscal_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_zdscal_64 function rocblas_zdscal_64_(handle,n,alpha,x,incx) bind(c, name="rocblas_zdscal_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdscal_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface !> \brief BLAS Level 1 API !> !> \details !> The scal_batched functions scale each element of vector ``x_i`` with scalar ``alpha``, for !> ``i`` = 1, ... , ``batch_count``: !> !> x_i := alpha * x_i, !> !> where (``x_i``) is the i-th instance of the batch. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in each x_i. !> @param[in] alpha - host pointer or device pointer for the scalar alpha. !> @param[in, out] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] batch_count - [rocblas_int] !> specifies the number of batches in x. interface rocblas_sscal_batched function rocblas_sscal_batched_(handle,n,alpha,x,incx,batch_count) & bind(c, name="rocblas_sscal_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sscal_batched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_dscal_batched function rocblas_dscal_batched_(handle,n,alpha,x,incx,batch_count) & bind(c, name="rocblas_dscal_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dscal_batched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_cscal_batched function rocblas_cscal_batched_(handle,n,alpha,x,incx,batch_count) & bind(c, name="rocblas_cscal_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cscal_batched_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_zscal_batched function rocblas_zscal_batched_(handle,n,alpha,x,incx,batch_count) & bind(c, name="rocblas_zscal_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zscal_batched_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_csscal_batched function rocblas_csscal_batched_(handle,n,alpha,x,incx,batch_count) & bind(c, name="rocblas_csscal_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csscal_batched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_zdscal_batched function rocblas_zdscal_batched_(handle,n,alpha,x,incx,batch_count) & bind(c, name="rocblas_zdscal_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdscal_batched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_sscal_batched_64 function rocblas_sscal_batched_64_(handle,n,alpha,x,incx,batch_count) & bind(c, name="rocblas_sscal_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sscal_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dscal_batched_64 function rocblas_dscal_batched_64_(handle,n,alpha,x,incx,batch_count) & bind(c, name="rocblas_dscal_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dscal_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cscal_batched_64 function rocblas_cscal_batched_64_(handle,n,alpha,x,incx,batch_count) & bind(c, name="rocblas_cscal_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cscal_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zscal_batched_64 function rocblas_zscal_batched_64_(handle,n,alpha,x,incx,batch_count) & bind(c, name="rocblas_zscal_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zscal_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_csscal_batched_64 function rocblas_csscal_batched_64_(handle,n,alpha,x,incx,batch_count) & bind(c, name="rocblas_csscal_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csscal_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zdscal_batched_64 function rocblas_zdscal_batched_64_(handle,n,alpha,x,incx,batch_count) & bind(c, name="rocblas_zdscal_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdscal_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 1 API !> !> \details !> The scal_strided_batched functions scale each element of vector ``x_i`` with scalar !> ``alpha``, for ``i`` = 1, ... , ``batch_count``: !> !> x_i := alpha * x_i, !> !> where (``x_i``) is the i-th instance of the batch. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in each x_i. !> @param[in] alpha - host pointer or device pointer for the scalar alpha. !> @param[in, out] x - device pointer to the first vector (x_1) in the batch. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in] stride_x - [rocblas_stride] !> stride from the start of one vector (x_i) and the next one (x_i+1). !> There are no restrictions placed on stride_x. However, ensure that stride_x is !> of an appropriate size. For a typical !> case, this means stride_x >= n * incx. !> @param[in] batch_count - [rocblas_int] !> specifies the number of batches in x. interface rocblas_sscal_strided_batched function rocblas_sscal_strided_batched_(handle,n,alpha,x,incx,stride_x,batch_count) & bind(c, name="rocblas_sscal_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sscal_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sscal_strided_batched_assumed_rank #else module procedure & rocblas_sscal_strided_batched_rank_0,& rocblas_sscal_strided_batched_rank_1 #endif #endif end interface interface rocblas_dscal_strided_batched function rocblas_dscal_strided_batched_(handle,n,alpha,x,incx,stride_x,batch_count) & bind(c, name="rocblas_dscal_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dscal_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dscal_strided_batched_assumed_rank #else module procedure & rocblas_dscal_strided_batched_rank_0,& rocblas_dscal_strided_batched_rank_1 #endif #endif end interface interface rocblas_cscal_strided_batched function rocblas_cscal_strided_batched_(handle,n,alpha,x,incx,stride_x,batch_count) & bind(c, name="rocblas_cscal_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cscal_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cscal_strided_batched_assumed_rank #else module procedure & rocblas_cscal_strided_batched_rank_0,& rocblas_cscal_strided_batched_rank_1 #endif #endif end interface interface rocblas_zscal_strided_batched function rocblas_zscal_strided_batched_(handle,n,alpha,x,incx,stride_x,batch_count) & bind(c, name="rocblas_zscal_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zscal_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zscal_strided_batched_assumed_rank #else module procedure & rocblas_zscal_strided_batched_rank_0,& rocblas_zscal_strided_batched_rank_1 #endif #endif end interface interface rocblas_csscal_strided_batched function rocblas_csscal_strided_batched_(handle,n,alpha,x,incx,stride_x,batch_count) & bind(c, name="rocblas_csscal_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csscal_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_csscal_strided_batched_assumed_rank #else module procedure & rocblas_csscal_strided_batched_rank_0,& rocblas_csscal_strided_batched_rank_1 #endif #endif end interface interface rocblas_zdscal_strided_batched function rocblas_zdscal_strided_batched_(handle,n,alpha,x,incx,stride_x,batch_count) & bind(c, name="rocblas_zdscal_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdscal_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zdscal_strided_batched_assumed_rank #else module procedure & rocblas_zdscal_strided_batched_rank_0,& rocblas_zdscal_strided_batched_rank_1 #endif #endif end interface interface rocblas_sscal_strided_batched_64 function rocblas_sscal_strided_batched_64_(handle,n,alpha,x,incx,stride_x,batch_count) & bind(c, name="rocblas_sscal_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sscal_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dscal_strided_batched_64 function rocblas_dscal_strided_batched_64_(handle,n,alpha,x,incx,stride_x,batch_count) & bind(c, name="rocblas_dscal_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dscal_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cscal_strided_batched_64 function rocblas_cscal_strided_batched_64_(handle,n,alpha,x,incx,stride_x,batch_count) & bind(c, name="rocblas_cscal_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cscal_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zscal_strided_batched_64 function rocblas_zscal_strided_batched_64_(handle,n,alpha,x,incx,stride_x,batch_count) & bind(c, name="rocblas_zscal_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zscal_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_csscal_strided_batched_64 function rocblas_csscal_strided_batched_64_(handle,n,alpha,x,incx,stride_x,batch_count) & bind(c, name="rocblas_csscal_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csscal_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zdscal_strided_batched_64 function rocblas_zdscal_strided_batched_64_(handle,n,alpha,x,incx,stride_x,batch_count) & bind(c, name="rocblas_zdscal_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdscal_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 1 API !> !> \details !> The copy functions copy each element x[i] into y[i], for ``i`` = 1 , ... , ``n``: !> !> y := x !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in x to be copied to y. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[out] y - device pointer storing vector y. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. interface rocblas_scopy function rocblas_scopy_(handle,n,x,incx,y,incy) bind(c, name="rocblas_scopy") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scopy_ 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 end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_scopy_assumed_rank #else module procedure & rocblas_scopy_rank_0,& rocblas_scopy_rank_1 #endif #endif end interface interface rocblas_dcopy function rocblas_dcopy_(handle,n,x,incx,y,incy) bind(c, name="rocblas_dcopy") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dcopy_ 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 end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dcopy_assumed_rank #else module procedure & rocblas_dcopy_rank_0,& rocblas_dcopy_rank_1 #endif #endif end interface interface rocblas_ccopy function rocblas_ccopy_(handle,n,x,incx,y,incy) bind(c, name="rocblas_ccopy") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ccopy_ 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 end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ccopy_assumed_rank #else module procedure & rocblas_ccopy_rank_0,& rocblas_ccopy_rank_1 #endif #endif end interface interface rocblas_zcopy function rocblas_zcopy_(handle,n,x,incx,y,incy) bind(c, name="rocblas_zcopy") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zcopy_ 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 end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zcopy_assumed_rank #else module procedure & rocblas_zcopy_rank_0,& rocblas_zcopy_rank_1 #endif #endif end interface interface rocblas_scopy_64 function rocblas_scopy_64_(handle,n,x,incx,y,incy) bind(c, name="rocblas_scopy_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scopy_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_dcopy_64 function rocblas_dcopy_64_(handle,n,x,incx,y,incy) bind(c, name="rocblas_dcopy_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dcopy_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_ccopy_64 function rocblas_ccopy_64_(handle,n,x,incx,y,incy) bind(c, name="rocblas_ccopy_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ccopy_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_zcopy_64 function rocblas_zcopy_64_(handle,n,x,incx,y,incy) bind(c, name="rocblas_zcopy_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zcopy_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 1 API !> !> \details !> The copy_batched functions copy each element x_i[j] into y_i[j], for ``j`` = 1 , ... , !> ``n``; ``i`` = 1 , ... , ``batch_count``: !> !> y_i := x_i, !> !> where (``x_i``, ``y_i``) is the i-th instance of the batch and !> ``x_i`` and``y_i`` are vectors. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in each x_i to be copied to y_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each vector x_i. !> @param[out] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each vector y_i. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_scopy_batched function rocblas_scopy_batched_(handle,n,x,incx,y,incy,batch_count) & bind(c, name="rocblas_scopy_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scopy_batched_ 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),value :: batch_count end function end interface interface rocblas_dcopy_batched function rocblas_dcopy_batched_(handle,n,x,incx,y,incy,batch_count) & bind(c, name="rocblas_dcopy_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dcopy_batched_ 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),value :: batch_count end function end interface interface rocblas_ccopy_batched function rocblas_ccopy_batched_(handle,n,x,incx,y,incy,batch_count) & bind(c, name="rocblas_ccopy_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ccopy_batched_ 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),value :: batch_count end function end interface interface rocblas_zcopy_batched function rocblas_zcopy_batched_(handle,n,x,incx,y,incy,batch_count) & bind(c, name="rocblas_zcopy_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zcopy_batched_ 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),value :: batch_count end function end interface interface rocblas_scopy_batched_64 function rocblas_scopy_batched_64_(handle,n,x,incx,y,incy,batch_count) & bind(c, name="rocblas_scopy_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scopy_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dcopy_batched_64 function rocblas_dcopy_batched_64_(handle,n,x,incx,y,incy,batch_count) & bind(c, name="rocblas_dcopy_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dcopy_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ccopy_batched_64 function rocblas_ccopy_batched_64_(handle,n,x,incx,y,incy,batch_count) & bind(c, name="rocblas_ccopy_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ccopy_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zcopy_batched_64 function rocblas_zcopy_batched_64_(handle,n,x,incx,y,incy,batch_count) & bind(c, name="rocblas_zcopy_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zcopy_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 1 API !> !> \details !> The copy_strided_batched functions copy each element x_i[j] into y_i[j], for ``j`` = 1 , !> ... , ``n``; ``i`` = 1 , ... , ``batch_count``: !> !> y_i := x_i, !> !> where (``x_i``, ``y_i``) is the i-th instance of the batch and !> ``x_i`` and ``y_i`` are vectors. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in each x_i to be copied to y_i. !> @param[in] x - device pointer to the first vector (x_1) in the batch. !> @param[in] incx - [rocblas_int] !> specifies the increments for the elements of vectors x_i. !> @param[in] stridex - [rocblas_stride] !> stride from the start of one vector (x_i) and the next one (x_i+1). !> There are no restrictions placed on stride_x. However, !> ensure that stride_x is of an appropriate size. For a typical !> case, this means stride_x >= n * incx. !> @param[out] y - device pointer to the first vector (y_1) in the batch. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of vectors y_i. !> @param[in] stridey - [rocblas_stride] !> stride from the start of one vector (y_i) and the next one (y_i+1). !> There are no restrictions placed on stride_y, However, ensure that stride_y is !> of an appropriate size. For a typical !> case, this means stride_y >= n * incy. stridey should be non zero. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_scopy_strided_batched function rocblas_scopy_strided_batched_(handle,n,x,incx,stridex,y,incy,stridey,batch_count) & bind(c, name="rocblas_scopy_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scopy_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_scopy_strided_batched_assumed_rank #else module procedure & rocblas_scopy_strided_batched_rank_0,& rocblas_scopy_strided_batched_rank_1 #endif #endif end interface interface rocblas_dcopy_strided_batched function rocblas_dcopy_strided_batched_(handle,n,x,incx,stridex,y,incy,stridey,batch_count) & bind(c, name="rocblas_dcopy_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dcopy_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dcopy_strided_batched_assumed_rank #else module procedure & rocblas_dcopy_strided_batched_rank_0,& rocblas_dcopy_strided_batched_rank_1 #endif #endif end interface interface rocblas_ccopy_strided_batched function rocblas_ccopy_strided_batched_(handle,n,x,incx,stridex,y,incy,stridey,batch_count) & bind(c, name="rocblas_ccopy_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ccopy_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ccopy_strided_batched_assumed_rank #else module procedure & rocblas_ccopy_strided_batched_rank_0,& rocblas_ccopy_strided_batched_rank_1 #endif #endif end interface interface rocblas_zcopy_strided_batched function rocblas_zcopy_strided_batched_(handle,n,x,incx,stridex,y,incy,stridey,batch_count) & bind(c, name="rocblas_zcopy_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zcopy_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zcopy_strided_batched_assumed_rank #else module procedure & rocblas_zcopy_strided_batched_rank_0,& rocblas_zcopy_strided_batched_rank_1 #endif #endif end interface interface rocblas_scopy_strided_batched_64 function rocblas_scopy_strided_batched_64_(handle,n,x,incx,stridex,y,incy,stridey,batch_count) & bind(c, name="rocblas_scopy_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scopy_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dcopy_strided_batched_64 function rocblas_dcopy_strided_batched_64_(handle,n,x,incx,stridex,y,incy,stridey,batch_count) & bind(c, name="rocblas_dcopy_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dcopy_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ccopy_strided_batched_64 function rocblas_ccopy_strided_batched_64_(handle,n,x,incx,stridex,y,incy,stridey,batch_count) & bind(c, name="rocblas_ccopy_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ccopy_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zcopy_strided_batched_64 function rocblas_zcopy_strided_batched_64_(handle,n,x,incx,stridex,y,incy,stridey,batch_count) & bind(c, name="rocblas_zcopy_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zcopy_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 1 API !> !> \details !> The dot(u) functions perform the dot product of vectors ``x`` and ``y``: !> !> result = x * y; !> !> The dotc functions perform the dot product of the conjugate of complex vector ``x`` and !> complex vector ``y``. !> !> result = conjugate (x) * y; !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in x and y. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in] y - device pointer storing vector y. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in, out] myResult !> device pointer or host pointer to store the dot product. !> Return value is 0.0 if n <= 0. interface rocblas_sdot function rocblas_sdot_(handle,n,x,incx,y,incy,myResult) bind(c, name="rocblas_sdot") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdot_ 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 type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sdot_assumed_rank #else module procedure & rocblas_sdot_rank_0,& rocblas_sdot_rank_1 #endif #endif end interface interface rocblas_ddot function rocblas_ddot_(handle,n,x,incx,y,incy,myResult) bind(c, name="rocblas_ddot") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddot_ 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 type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ddot_assumed_rank #else module procedure & rocblas_ddot_rank_0,& rocblas_ddot_rank_1 #endif #endif end interface interface rocblas_hdot function rocblas_hdot_(handle,n,x,incx,y,incy,myResult) bind(c, name="rocblas_hdot") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hdot_ 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 type(c_ptr),value :: myResult end function end interface interface rocblas_bfdot function rocblas_bfdot_(handle,n,x,incx,y,incy,myResult) bind(c, name="rocblas_bfdot") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_bfdot_ 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 type(c_ptr),value :: myResult end function end interface interface rocblas_cdotu function rocblas_cdotu_(handle,n,x,incx,y,incy,myResult) bind(c, name="rocblas_cdotu") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotu_ 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 type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cdotu_assumed_rank #else module procedure & rocblas_cdotu_rank_0,& rocblas_cdotu_rank_1 #endif #endif end interface interface rocblas_zdotu function rocblas_zdotu_(handle,n,x,incx,y,incy,myResult) bind(c, name="rocblas_zdotu") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotu_ 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 type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zdotu_assumed_rank #else module procedure & rocblas_zdotu_rank_0,& rocblas_zdotu_rank_1 #endif #endif end interface interface rocblas_cdotc function rocblas_cdotc_(handle,n,x,incx,y,incy,myResult) bind(c, name="rocblas_cdotc") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotc_ 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 type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cdotc_assumed_rank #else module procedure & rocblas_cdotc_rank_0,& rocblas_cdotc_rank_1 #endif #endif end interface interface rocblas_zdotc function rocblas_zdotc_(handle,n,x,incx,y,incy,myResult) bind(c, name="rocblas_zdotc") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotc_ 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 type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zdotc_assumed_rank #else module procedure & rocblas_zdotc_rank_0,& rocblas_zdotc_rank_1 #endif #endif end interface interface rocblas_sdot_64 function rocblas_sdot_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="rocblas_sdot_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: myResult end function end interface interface rocblas_ddot_64 function rocblas_ddot_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="rocblas_ddot_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: myResult end function end interface interface rocblas_hdot_64 function rocblas_hdot_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="rocblas_hdot_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hdot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: myResult end function end interface interface rocblas_bfdot_64 function rocblas_bfdot_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="rocblas_bfdot_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_bfdot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: myResult end function end interface interface rocblas_cdotu_64 function rocblas_cdotu_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="rocblas_cdotu_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotu_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: myResult end function end interface interface rocblas_zdotu_64 function rocblas_zdotu_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="rocblas_zdotu_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotu_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: myResult end function end interface interface rocblas_cdotc_64 function rocblas_cdotc_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="rocblas_cdotc_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotc_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: myResult end function end interface interface rocblas_zdotc_64 function rocblas_zdotc_64_(handle,n,x,incx,y,incy,myResult) bind(c, name="rocblas_zdotc_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotc_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: myResult end function end interface !> \brief BLAS Level 1 API !> !> \details !> The dot_batched(u) functions perform a batch of dot products of vectors ``x`` and ``y``: !> !> result_i = x_i * y_i; !> !> The dotc_batched functions performs a batch of dot products of the conjugate of complex !> vector ``x`` and complex vector`` y``: !> !> result_i = conjugate (x_i) * y_i; !> !> where (``x_i``, ``y_i``) is the i-th instance of the batch and !> ``x_i`` and ``y_i`` are vectors, for ``i`` = 1, ..., ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in each x_i and y_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each y_i. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. !> @param[in, out] myResult !> device array or host array of batch_count size to store the dot products of each !> batch. !> Return 0.0 for each element if n <= 0. interface rocblas_sdot_batched function rocblas_sdot_batched_(handle,n,x,incx,y,incy,batch_count,myResult) & bind(c, name="rocblas_sdot_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdot_batched_ 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),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_ddot_batched function rocblas_ddot_batched_(handle,n,x,incx,y,incy,batch_count,myResult) & bind(c, name="rocblas_ddot_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddot_batched_ 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),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_hdot_batched function rocblas_hdot_batched_(handle,n,x,incx,y,incy,batch_count,myResult) & bind(c, name="rocblas_hdot_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hdot_batched_ 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),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_bfdot_batched function rocblas_bfdot_batched_(handle,n,x,incx,y,incy,batch_count,myResult) & bind(c, name="rocblas_bfdot_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_bfdot_batched_ 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),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_cdotu_batched function rocblas_cdotu_batched_(handle,n,x,incx,y,incy,batch_count,myResult) & bind(c, name="rocblas_cdotu_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotu_batched_ 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),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_zdotu_batched function rocblas_zdotu_batched_(handle,n,x,incx,y,incy,batch_count,myResult) & bind(c, name="rocblas_zdotu_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotu_batched_ 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),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_cdotc_batched function rocblas_cdotc_batched_(handle,n,x,incx,y,incy,batch_count,myResult) & bind(c, name="rocblas_cdotc_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotc_batched_ 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),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_zdotc_batched function rocblas_zdotc_batched_(handle,n,x,incx,y,incy,batch_count,myResult) & bind(c, name="rocblas_zdotc_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotc_batched_ 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),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_sdot_batched_64 function rocblas_sdot_batched_64_(handle,n,x,incx,y,incy,batch_count,myResult) & bind(c, name="rocblas_sdot_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdot_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_ddot_batched_64 function rocblas_ddot_batched_64_(handle,n,x,incx,y,incy,batch_count,myResult) & bind(c, name="rocblas_ddot_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddot_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_hdot_batched_64 function rocblas_hdot_batched_64_(handle,n,x,incx,y,incy,batch_count,myResult) & bind(c, name="rocblas_hdot_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hdot_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_bfdot_batched_64 function rocblas_bfdot_batched_64_(handle,n,x,incx,y,incy,batch_count,myResult) & bind(c, name="rocblas_bfdot_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_bfdot_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_cdotu_batched_64 function rocblas_cdotu_batched_64_(handle,n,x,incx,y,incy,batch_count,myResult) & bind(c, name="rocblas_cdotu_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotu_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_zdotu_batched_64 function rocblas_zdotu_batched_64_(handle,n,x,incx,y,incy,batch_count,myResult) & bind(c, name="rocblas_zdotu_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotu_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_cdotc_batched_64 function rocblas_cdotc_batched_64_(handle,n,x,incx,y,incy,batch_count,myResult) & bind(c, name="rocblas_cdotc_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotc_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_zdotc_batched_64 function rocblas_zdotc_batched_64_(handle,n,x,incx,y,incy,batch_count,myResult) & bind(c, name="rocblas_zdotc_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotc_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface !> \brief BLAS Level 1 API !> !> \details !> The dot_strided_batched(u) functions perform a batch of dot products of vectors ``x`` and !> ``y``: !> !> result_i = x_i * y_i; !> !> The dotc_strided_batched functions perform a batch of dot products of the conjugate of !> complex vector ``x`` and complex vector ``y``: !> !> result_i = conjugate (x_i) * y_i; !> !> where (``x_i``, ``y_i``) is the i-th instance of the batch. !> ``x_i`` and ``y_i`` are vectors, for ``i`` = 1, ..., ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in each x_i and y_i. !> @param[in] x - device pointer to the first vector (x_1) in the batch. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [rocblas_stride] !> stride from the start of one vector (x_i) and the next one (x_i+1). !> @param[in] y - device pointer to the first vector (y_1) in the batch. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each y_i. !> @param[in] stridey - [rocblas_stride] !> stride from the start of one vector (y_i) and the next one (y_i+1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. !> @param[in, out] myResult !> device array or host array of batch_count size to store the dot products of each !> batch. !> Return 0.0 for each element if n <= 0. interface rocblas_sdot_strided_batched function rocblas_sdot_strided_batched_(handle,n,x,incx,stridex,y,incy,stridey,batch_count, & myResult) & bind(c, name="rocblas_sdot_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdot_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sdot_strided_batched_assumed_rank #else module procedure & rocblas_sdot_strided_batched_rank_0,& rocblas_sdot_strided_batched_rank_1 #endif #endif end interface interface rocblas_ddot_strided_batched function rocblas_ddot_strided_batched_(handle,n,x,incx,stridex,y,incy,stridey,batch_count, & myResult) & bind(c, name="rocblas_ddot_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddot_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ddot_strided_batched_assumed_rank #else module procedure & rocblas_ddot_strided_batched_rank_0,& rocblas_ddot_strided_batched_rank_1 #endif #endif end interface interface rocblas_hdot_strided_batched function rocblas_hdot_strided_batched_(handle,n,x,incx,stridex,y,incy,stridey,batch_count, & myResult) & bind(c, name="rocblas_hdot_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hdot_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_bfdot_strided_batched function rocblas_bfdot_strided_batched_(handle,n,x,incx,stridex,y,incy,stridey,batch_count, & myResult) & bind(c, name="rocblas_bfdot_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_bfdot_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_cdotu_strided_batched function rocblas_cdotu_strided_batched_(handle,n,x,incx,stridex,y,incy,stridey,batch_count, & myResult) & bind(c, name="rocblas_cdotu_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotu_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cdotu_strided_batched_assumed_rank #else module procedure & rocblas_cdotu_strided_batched_rank_0,& rocblas_cdotu_strided_batched_rank_1 #endif #endif end interface interface rocblas_zdotu_strided_batched function rocblas_zdotu_strided_batched_(handle,n,x,incx,stridex,y,incy,stridey,batch_count, & myResult) & bind(c, name="rocblas_zdotu_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotu_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zdotu_strided_batched_assumed_rank #else module procedure & rocblas_zdotu_strided_batched_rank_0,& rocblas_zdotu_strided_batched_rank_1 #endif #endif end interface interface rocblas_cdotc_strided_batched function rocblas_cdotc_strided_batched_(handle,n,x,incx,stridex,y,incy,stridey,batch_count, & myResult) & bind(c, name="rocblas_cdotc_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotc_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cdotc_strided_batched_assumed_rank #else module procedure & rocblas_cdotc_strided_batched_rank_0,& rocblas_cdotc_strided_batched_rank_1 #endif #endif end interface interface rocblas_zdotc_strided_batched function rocblas_zdotc_strided_batched_(handle,n,x,incx,stridex,y,incy,stridey,batch_count, & myResult) & bind(c, name="rocblas_zdotc_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotc_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zdotc_strided_batched_assumed_rank #else module procedure & rocblas_zdotc_strided_batched_rank_0,& rocblas_zdotc_strided_batched_rank_1 #endif #endif end interface interface rocblas_sdot_strided_batched_64 function rocblas_sdot_strided_batched_64_(handle,n,x,incx,stridex,y,incy,stridey,batch_count, & myResult) & bind(c, name="rocblas_sdot_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdot_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_ddot_strided_batched_64 function rocblas_ddot_strided_batched_64_(handle,n,x,incx,stridex,y,incy,stridey,batch_count, & myResult) & bind(c, name="rocblas_ddot_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddot_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_hdot_strided_batched_64 function rocblas_hdot_strided_batched_64_(handle,n,x,incx,stridex,y,incy,stridey,batch_count, & myResult) & bind(c, name="rocblas_hdot_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hdot_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_bfdot_strided_batched_64 function rocblas_bfdot_strided_batched_64_(handle,n,x,incx,stridex,y,incy,stridey,batch_count, & myResult) & bind(c, name="rocblas_bfdot_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_bfdot_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_cdotu_strided_batched_64 function rocblas_cdotu_strided_batched_64_(handle,n,x,incx,stridex,y,incy,stridey,batch_count, & myResult) & bind(c, name="rocblas_cdotu_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotu_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_zdotu_strided_batched_64 function rocblas_zdotu_strided_batched_64_(handle,n,x,incx,stridex,y,incy,stridey,batch_count, & myResult) & bind(c, name="rocblas_zdotu_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotu_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_cdotc_strided_batched_64 function rocblas_cdotc_strided_batched_64_(handle,n,x,incx,stridex,y,incy,stridey,batch_count, & myResult) & bind(c, name="rocblas_cdotc_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotc_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_zdotc_strided_batched_64 function rocblas_zdotc_strided_batched_64_(handle,n,x,incx,stridex,y,incy,stridey,batch_count, & myResult) & bind(c, name="rocblas_zdotc_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotc_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface !> \brief BLAS Level 1 API !> !> \details !> The swap functions interchange vectors ``x`` and ``y``: !> !> y := x; !> x := y !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in x and y. !> @param[in, out] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in, out] y - device pointer storing vector y. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. interface rocblas_sswap function rocblas_sswap_(handle,n,x,incx,y,incy) bind(c, name="rocblas_sswap") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sswap_ 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 end function end interface interface rocblas_dswap function rocblas_dswap_(handle,n,x,incx,y,incy) bind(c, name="rocblas_dswap") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dswap_ 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 end function end interface interface rocblas_cswap function rocblas_cswap_(handle,n,x,incx,y,incy) bind(c, name="rocblas_cswap") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cswap_ 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 end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cswap_assumed_rank #else module procedure & rocblas_cswap_rank_0,& rocblas_cswap_rank_1 #endif #endif end interface interface rocblas_zswap function rocblas_zswap_(handle,n,x,incx,y,incy) bind(c, name="rocblas_zswap") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zswap_ 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 end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zswap_assumed_rank #else module procedure & rocblas_zswap_rank_0,& rocblas_zswap_rank_1 #endif #endif end interface interface rocblas_sswap_64 function rocblas_sswap_64_(handle,n,x,incx,y,incy) bind(c, name="rocblas_sswap_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sswap_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_dswap_64 function rocblas_dswap_64_(handle,n,x,incx,y,incy) bind(c, name="rocblas_dswap_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dswap_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_cswap_64 function rocblas_cswap_64_(handle,n,x,incx,y,incy) bind(c, name="rocblas_cswap_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cswap_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_zswap_64 function rocblas_zswap_64_(handle,n,x,incx,y,incy) bind(c, name="rocblas_zswap_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zswap_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 1 API !> !> \details !> The swap_batched functions interchange vectors ``x_i`` and ``y_i``, for ``i`` = 1 , ... , !> ``batch_count``: !> !> y_i := x_i; !> x_i := y_i !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in each x_i and y_i. !> @param[in, out] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in, out] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each y_i. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_sswap_batched function rocblas_sswap_batched_(handle,n,x,incx,y,incy,batch_count) & bind(c, name="rocblas_sswap_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sswap_batched_ 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),value :: batch_count end function end interface interface rocblas_dswap_batched function rocblas_dswap_batched_(handle,n,x,incx,y,incy,batch_count) & bind(c, name="rocblas_dswap_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dswap_batched_ 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),value :: batch_count end function end interface interface rocblas_cswap_batched function rocblas_cswap_batched_(handle,n,x,incx,y,incy,batch_count) & bind(c, name="rocblas_cswap_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cswap_batched_ 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),value :: batch_count end function end interface interface rocblas_zswap_batched function rocblas_zswap_batched_(handle,n,x,incx,y,incy,batch_count) & bind(c, name="rocblas_zswap_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zswap_batched_ 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),value :: batch_count end function end interface interface rocblas_sswap_batched_64 function rocblas_sswap_batched_64_(handle,n,x,incx,y,incy,batch_count) & bind(c, name="rocblas_sswap_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sswap_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dswap_batched_64 function rocblas_dswap_batched_64_(handle,n,x,incx,y,incy,batch_count) & bind(c, name="rocblas_dswap_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dswap_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cswap_batched_64 function rocblas_cswap_batched_64_(handle,n,x,incx,y,incy,batch_count) & bind(c, name="rocblas_cswap_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cswap_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zswap_batched_64 function rocblas_zswap_batched_64_(handle,n,x,incx,y,incy,batch_count) & bind(c, name="rocblas_zswap_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zswap_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 1 API !> !> \details !> The swap_strided_batched functions interchange vectors ``x_i`` and ``y_i``, for ``i`` = 1 , !> ... , ``batch_count``: !> !> y_i := x_i; !> x_i := y_i !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in each x_i and y_i. !> @param[in, out] x - device pointer to the first vector x_1. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in] stridex - [rocblas_stride] !> stride from the start of one vector (x_i) and the next one (x_i+1). !> There are no restrictions placed on stride_x. However, ensure that stride_x is of !> an appropriate size. For a typical !> case, this means stride_x >= n * incx. !> @param[in, out] y - device pointer to the first vector y_1. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in] stridey - [rocblas_stride] !> stride from the start of one vector (y_i) and the next one (y_i+1). !> There are no restrictions placed on stride_x. However, ensure that stride_y is of !> an appropriate size. For a typical !> case, this means stride_y >= n * incy. stridey should be non zero. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_sswap_strided_batched function rocblas_sswap_strided_batched_(handle,n,x,incx,stridex,y,incy,stridey,batch_count) & bind(c, name="rocblas_sswap_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sswap_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sswap_strided_batched_assumed_rank #else module procedure & rocblas_sswap_strided_batched_rank_0,& rocblas_sswap_strided_batched_rank_1 #endif #endif end interface interface rocblas_dswap_strided_batched function rocblas_dswap_strided_batched_(handle,n,x,incx,stridex,y,incy,stridey,batch_count) & bind(c, name="rocblas_dswap_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dswap_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dswap_strided_batched_assumed_rank #else module procedure & rocblas_dswap_strided_batched_rank_0,& rocblas_dswap_strided_batched_rank_1 #endif #endif end interface interface rocblas_cswap_strided_batched function rocblas_cswap_strided_batched_(handle,n,x,incx,stridex,y,incy,stridey,batch_count) & bind(c, name="rocblas_cswap_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cswap_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cswap_strided_batched_assumed_rank #else module procedure & rocblas_cswap_strided_batched_rank_0,& rocblas_cswap_strided_batched_rank_1 #endif #endif end interface interface rocblas_zswap_strided_batched function rocblas_zswap_strided_batched_(handle,n,x,incx,stridex,y,incy,stridey,batch_count) & bind(c, name="rocblas_zswap_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zswap_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zswap_strided_batched_assumed_rank #else module procedure & rocblas_zswap_strided_batched_rank_0,& rocblas_zswap_strided_batched_rank_1 #endif #endif end interface interface rocblas_sswap_strided_batched_64 function rocblas_sswap_strided_batched_64_(handle,n,x,incx,stridex,y,incy,stridey,batch_count) & bind(c, name="rocblas_sswap_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sswap_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dswap_strided_batched_64 function rocblas_dswap_strided_batched_64_(handle,n,x,incx,stridex,y,incy,stridey,batch_count) & bind(c, name="rocblas_dswap_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dswap_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cswap_strided_batched_64 function rocblas_cswap_strided_batched_64_(handle,n,x,incx,stridex,y,incy,stridey,batch_count) & bind(c, name="rocblas_cswap_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cswap_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zswap_strided_batched_64 function rocblas_zswap_strided_batched_64_(handle,n,x,incx,stridex,y,incy,stridey,batch_count) & bind(c, name="rocblas_zswap_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zswap_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 1 API !> !> \details !> The axpy functions compute a constant ``alpha`` multiplied by vector ``x``, plus vector !> ``y``: !> !> y := alpha * x + y !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in x and y. !> @param[in] alpha - device pointer or host pointer to specify the scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[out] y - device pointer storing vector y. !> @param[in, out] incy - [rocblas_int] !> specifies the increment for the elements of y. interface rocblas_haxpy function rocblas_haxpy_(handle,n,alpha,x,incx,y,incy) bind(c, name="rocblas_haxpy") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_haxpy_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_short) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function end interface interface rocblas_saxpy function rocblas_saxpy_(handle,n,alpha,x,incx,y,incy) bind(c, name="rocblas_saxpy") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_saxpy_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_saxpy_assumed_rank #else module procedure & rocblas_saxpy_rank_0,& rocblas_saxpy_rank_1 #endif #endif end interface interface rocblas_daxpy function rocblas_daxpy_(handle,n,alpha,x,incx,y,incy) bind(c, name="rocblas_daxpy") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_daxpy_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_daxpy_assumed_rank #else module procedure & rocblas_daxpy_rank_0,& rocblas_daxpy_rank_1 #endif #endif end interface interface rocblas_caxpy function rocblas_caxpy_(handle,n,alpha,x,incx,y,incy) bind(c, name="rocblas_caxpy") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_caxpy_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_caxpy_assumed_rank #else module procedure & rocblas_caxpy_rank_0,& rocblas_caxpy_rank_1 #endif #endif end interface interface rocblas_zaxpy function rocblas_zaxpy_(handle,n,alpha,x,incx,y,incy) bind(c, name="rocblas_zaxpy") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zaxpy_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zaxpy_assumed_rank #else module procedure & rocblas_zaxpy_rank_0,& rocblas_zaxpy_rank_1 #endif #endif end interface interface rocblas_haxpy_64 function rocblas_haxpy_64_(handle,n,alpha,x,incx,y,incy) bind(c, name="rocblas_haxpy_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_haxpy_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n integer(c_short) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_saxpy_64 function rocblas_saxpy_64_(handle,n,alpha,x,incx,y,incy) bind(c, name="rocblas_saxpy_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_saxpy_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_daxpy_64 function rocblas_daxpy_64_(handle,n,alpha,x,incx,y,incy) bind(c, name="rocblas_daxpy_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_daxpy_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_caxpy_64 function rocblas_caxpy_64_(handle,n,alpha,x,incx,y,incy) bind(c, name="rocblas_caxpy_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_caxpy_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_zaxpy_64 function rocblas_zaxpy_64_(handle,n,alpha,x,incx,y,incy) bind(c, name="rocblas_zaxpy_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zaxpy_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 1 API !> !> \details !> The axpy_batched functions compute ``y := alpha * x + y`` over a set of batched vectors. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> @param[in] alpha - specifies the scalar alpha. !> @param[in] x - pointer storing vector x on the GPU. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[out] y - pointer storing vector y on the GPU. !> @param[in, out] incy - [rocblas_int] !> specifies the increment for the elements of y. !> !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_haxpy_batched function rocblas_haxpy_batched_(handle,n,alpha,x,incx,y,incy,batch_count) & bind(c, name="rocblas_haxpy_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_haxpy_batched_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_short) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_saxpy_batched function rocblas_saxpy_batched_(handle,n,alpha,x,incx,y,incy,batch_count) & bind(c, name="rocblas_saxpy_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_saxpy_batched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_daxpy_batched function rocblas_daxpy_batched_(handle,n,alpha,x,incx,y,incy,batch_count) & bind(c, name="rocblas_daxpy_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_daxpy_batched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_caxpy_batched function rocblas_caxpy_batched_(handle,n,alpha,x,incx,y,incy,batch_count) & bind(c, name="rocblas_caxpy_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_caxpy_batched_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_zaxpy_batched function rocblas_zaxpy_batched_(handle,n,alpha,x,incx,y,incy,batch_count) & bind(c, name="rocblas_zaxpy_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zaxpy_batched_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_haxpy_batched_64 function rocblas_haxpy_batched_64_(handle,n,alpha,x,incx,y,incy,batch_count) & bind(c, name="rocblas_haxpy_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_haxpy_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n integer(c_short) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_saxpy_batched_64 function rocblas_saxpy_batched_64_(handle,n,alpha,x,incx,y,incy,batch_count) & bind(c, name="rocblas_saxpy_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_saxpy_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_daxpy_batched_64 function rocblas_daxpy_batched_64_(handle,n,alpha,x,incx,y,incy,batch_count) & bind(c, name="rocblas_daxpy_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_daxpy_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_caxpy_batched_64 function rocblas_caxpy_batched_64_(handle,n,alpha,x,incx,y,incy,batch_count) & bind(c, name="rocblas_caxpy_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_caxpy_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zaxpy_batched_64 function rocblas_zaxpy_batched_64_(handle,n,alpha,x,incx,y,incy,batch_count) & bind(c, name="rocblas_zaxpy_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zaxpy_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 1 API !> !> \details !> The axpy_strided_batched functions compute ``y := alpha * x + y`` over a set of strided !> batched vectors. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> @param[in] alpha - specifies the scalar alpha. !> @param[in] x - pointer storing vector x on the GPU. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in] stridex - [rocblas_stride] !> specifies the increment between vectors of x. !> @param[out] y - pointer storing vector y on the GPU. !> @param[in, out] incy - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in] stridey - [rocblas_stride] !> specifies the increment between vectors of y. !> !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_haxpy_strided_batched function rocblas_haxpy_strided_batched_(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batch_count) & bind(c, name="rocblas_haxpy_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_haxpy_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_short) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function end interface interface rocblas_saxpy_strided_batched function rocblas_saxpy_strided_batched_(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batch_count) & bind(c, name="rocblas_saxpy_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_saxpy_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_saxpy_strided_batched_assumed_rank #else module procedure & rocblas_saxpy_strided_batched_rank_0,& rocblas_saxpy_strided_batched_rank_1 #endif #endif end interface interface rocblas_daxpy_strided_batched function rocblas_daxpy_strided_batched_(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batch_count) & bind(c, name="rocblas_daxpy_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_daxpy_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_daxpy_strided_batched_assumed_rank #else module procedure & rocblas_daxpy_strided_batched_rank_0,& rocblas_daxpy_strided_batched_rank_1 #endif #endif end interface interface rocblas_caxpy_strided_batched function rocblas_caxpy_strided_batched_(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batch_count) & bind(c, name="rocblas_caxpy_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_caxpy_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_caxpy_strided_batched_assumed_rank #else module procedure & rocblas_caxpy_strided_batched_rank_0,& rocblas_caxpy_strided_batched_rank_1 #endif #endif end interface interface rocblas_zaxpy_strided_batched function rocblas_zaxpy_strided_batched_(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batch_count) & bind(c, name="rocblas_zaxpy_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zaxpy_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zaxpy_strided_batched_assumed_rank #else module procedure & rocblas_zaxpy_strided_batched_rank_0,& rocblas_zaxpy_strided_batched_rank_1 #endif #endif end interface interface rocblas_haxpy_strided_batched_64 function rocblas_haxpy_strided_batched_64_(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batch_count) & bind(c, name="rocblas_haxpy_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_haxpy_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n integer(c_short) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_saxpy_strided_batched_64 function rocblas_saxpy_strided_batched_64_(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batch_count) & bind(c, name="rocblas_saxpy_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_saxpy_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_daxpy_strided_batched_64 function rocblas_daxpy_strided_batched_64_(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batch_count) & bind(c, name="rocblas_daxpy_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_daxpy_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_caxpy_strided_batched_64 function rocblas_caxpy_strided_batched_64_(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batch_count) & bind(c, name="rocblas_caxpy_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_caxpy_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zaxpy_strided_batched_64 function rocblas_zaxpy_strided_batched_64_(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batch_count) & bind(c, name="rocblas_zaxpy_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zaxpy_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 1 API !> !> \details !> The asum functions compute the sum of the magnitudes of elements of a real vector ``x`` !> or the sum of magnitudes of the real and imaginary parts of elements if ``x`` is a complex !> vector. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in x and y. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. incx must be > 0. !> @param[in, out] myResult !> device pointer or host pointer to store the asum product. !> Return value is 0.0 if n <= 0. interface rocblas_sasum function rocblas_sasum_(handle,n,x,incx,myResult) bind(c, name="rocblas_sasum") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sasum_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_dasum function rocblas_dasum_(handle,n,x,incx,myResult) bind(c, name="rocblas_dasum") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dasum_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_scasum function rocblas_scasum_(handle,n,x,incx,myResult) bind(c, name="rocblas_scasum") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scasum_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_scasum_assumed_rank #else module procedure & rocblas_scasum_rank_0,& rocblas_scasum_rank_1 #endif #endif end interface interface rocblas_dzasum function rocblas_dzasum_(handle,n,x,incx,myResult) bind(c, name="rocblas_dzasum") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dzasum_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dzasum_assumed_rank #else module procedure & rocblas_dzasum_rank_0,& rocblas_dzasum_rank_1 #endif #endif end interface interface rocblas_sasum_64 function rocblas_sasum_64_(handle,n,x,incx,myResult) bind(c, name="rocblas_sasum_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sasum_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_dasum_64 function rocblas_dasum_64_(handle,n,x,incx,myResult) bind(c, name="rocblas_dasum_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dasum_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_scasum_64 function rocblas_scasum_64_(handle,n,x,incx,myResult) bind(c, name="rocblas_scasum_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scasum_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_dzasum_64 function rocblas_dzasum_64_(handle,n,x,incx,myResult) bind(c, name="rocblas_dzasum_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dzasum_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface !> \brief BLAS Level 1 API !> !> \details !> The asum_batched functions compute the sum of the magnitudes of the elements in a batch of !> real vectors ``x_i`` !> or the sum of magnitudes of the real and imaginary parts of elements if ``x_i`` is a !> complex !> vector, for ``i`` = 1, ..., ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> number of elements in each vector x_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. !> @param[out] results !> device array or host array of batch_count size for results. !> Return value is 0.0 if n, incx<=0. interface rocblas_sasum_batched function rocblas_sasum_batched_(handle,n,x,incx,batch_count,results) & bind(c, name="rocblas_sasum_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sasum_batched_ 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 :: results end function end interface interface rocblas_dasum_batched function rocblas_dasum_batched_(handle,n,x,incx,batch_count,results) & bind(c, name="rocblas_dasum_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dasum_batched_ 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 :: results end function end interface interface rocblas_scasum_batched function rocblas_scasum_batched_(handle,n,x,incx,batch_count,results) & bind(c, name="rocblas_scasum_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scasum_batched_ 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 :: results end function end interface interface rocblas_dzasum_batched function rocblas_dzasum_batched_(handle,n,x,incx,batch_count,results) & bind(c, name="rocblas_dzasum_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dzasum_batched_ 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 :: results end function end interface interface rocblas_sasum_batched_64 function rocblas_sasum_batched_64_(handle,n,x,incx,batch_count,results) & bind(c, name="rocblas_sasum_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sasum_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count type(c_ptr),value :: results end function end interface interface rocblas_dasum_batched_64 function rocblas_dasum_batched_64_(handle,n,x,incx,batch_count,results) & bind(c, name="rocblas_dasum_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dasum_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count type(c_ptr),value :: results end function end interface interface rocblas_scasum_batched_64 function rocblas_scasum_batched_64_(handle,n,x,incx,batch_count,results) & bind(c, name="rocblas_scasum_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scasum_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count type(c_ptr),value :: results end function end interface interface rocblas_dzasum_batched_64 function rocblas_dzasum_batched_64_(handle,n,x,incx,batch_count,results) & bind(c, name="rocblas_dzasum_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dzasum_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count type(c_ptr),value :: results end function end interface !> \brief BLAS Level 1 API !> !> \details !> The asum_strided_batched functions compute the sum of the magnitudes of elements of real !> vectors ``x_i`` !> or the sum of magnitudes of the real and imaginary parts of elements if ``x_i`` is a !> complex !> vector, for ``i`` = 1, ..., ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> number of elements in each vector x_i. !> @param[in] x - device pointer to the first vector x_1. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] stridex - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stride_x. However, ensure that stride_x is of !> an appropriate size. For a typical !> case, this means stride_x >= n * incx. !> @param[out] results !> device pointer or host pointer to array for storing contiguous batch_count !> results. !> Return value is 0.0 if n, incx<=0. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_sasum_strided_batched function rocblas_sasum_strided_batched_(handle,n,x,incx,stridex,batch_count,results) & bind(c, name="rocblas_sasum_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sasum_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batch_count type(c_ptr),value :: results end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sasum_strided_batched_assumed_rank #else module procedure & rocblas_sasum_strided_batched_rank_0,& rocblas_sasum_strided_batched_rank_1 #endif #endif end interface interface rocblas_dasum_strided_batched function rocblas_dasum_strided_batched_(handle,n,x,incx,stridex,batch_count,results) & bind(c, name="rocblas_dasum_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dasum_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batch_count type(c_ptr),value :: results end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dasum_strided_batched_assumed_rank #else module procedure & rocblas_dasum_strided_batched_rank_0,& rocblas_dasum_strided_batched_rank_1 #endif #endif end interface interface rocblas_scasum_strided_batched function rocblas_scasum_strided_batched_(handle,n,x,incx,stridex,batch_count,results) & bind(c, name="rocblas_scasum_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scasum_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batch_count type(c_ptr),value :: results end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_scasum_strided_batched_assumed_rank #else module procedure & rocblas_scasum_strided_batched_rank_0,& rocblas_scasum_strided_batched_rank_1 #endif #endif end interface interface rocblas_dzasum_strided_batched function rocblas_dzasum_strided_batched_(handle,n,x,incx,stridex,batch_count,results) & bind(c, name="rocblas_dzasum_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dzasum_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batch_count type(c_ptr),value :: results end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dzasum_strided_batched_assumed_rank #else module procedure & rocblas_dzasum_strided_batched_rank_0,& rocblas_dzasum_strided_batched_rank_1 #endif #endif end interface interface rocblas_sasum_strided_batched_64 function rocblas_sasum_strided_batched_64_(handle,n,x,incx,stridex,batch_count,results) & bind(c, name="rocblas_sasum_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sasum_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batch_count type(c_ptr),value :: results end function end interface interface rocblas_dasum_strided_batched_64 function rocblas_dasum_strided_batched_64_(handle,n,x,incx,stridex,batch_count,results) & bind(c, name="rocblas_dasum_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dasum_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batch_count type(c_ptr),value :: results end function end interface interface rocblas_scasum_strided_batched_64 function rocblas_scasum_strided_batched_64_(handle,n,x,incx,stridex,batch_count,results) & bind(c, name="rocblas_scasum_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scasum_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batch_count type(c_ptr),value :: results end function end interface interface rocblas_dzasum_strided_batched_64 function rocblas_dzasum_strided_batched_64_(handle,n,x,incx,stridex,batch_count,results) & bind(c, name="rocblas_dzasum_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dzasum_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batch_count type(c_ptr),value :: results end function end interface !> \brief BLAS Level 1 API !> !> \details !> The nrm2 functions compute the Euclidean norm of a real or complex vector: !> !> result := sqrt( x'*x ) for real vectors !> result := sqrt( x**H*x ) for complex vectors !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in x. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in, out] myResult !> device pointer or host pointer to store the nrm2 product. !> Return value is 0.0 if n, incx<=0. interface rocblas_snrm2 function rocblas_snrm2_(handle,n,x,incx,myResult) bind(c, name="rocblas_snrm2") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_snrm2_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_dnrm2 function rocblas_dnrm2_(handle,n,x,incx,myResult) bind(c, name="rocblas_dnrm2") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dnrm2_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_scnrm2 function rocblas_scnrm2_(handle,n,x,incx,myResult) bind(c, name="rocblas_scnrm2") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scnrm2_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_scnrm2_assumed_rank #else module procedure & rocblas_scnrm2_rank_0,& rocblas_scnrm2_rank_1 #endif #endif end interface interface rocblas_dznrm2 function rocblas_dznrm2_(handle,n,x,incx,myResult) bind(c, name="rocblas_dznrm2") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dznrm2_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dznrm2_assumed_rank #else module procedure & rocblas_dznrm2_rank_0,& rocblas_dznrm2_rank_1 #endif #endif end interface interface rocblas_snrm2_64 function rocblas_snrm2_64_(handle,n,x,incx,myResult) bind(c, name="rocblas_snrm2_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_snrm2_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_dnrm2_64 function rocblas_dnrm2_64_(handle,n,x,incx,myResult) bind(c, name="rocblas_dnrm2_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dnrm2_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_scnrm2_64 function rocblas_scnrm2_64_(handle,n,x,incx,myResult) bind(c, name="rocblas_scnrm2_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scnrm2_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_dznrm2_64 function rocblas_dznrm2_64_(handle,n,x,incx,myResult) bind(c, name="rocblas_dznrm2_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dznrm2_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface !> \brief BLAS Level 1 API !> !> \details !> The nrm2_batched functions compute the Euclidean norm over a batch of real or complex !> vectors: !> !> result := sqrt( x_i'*x_i ) for real vectors x, for i = 1, ..., batch_count !> result := sqrt( x_i**H*x_i ) for complex vectors x, for i = 1, ..., batch_count !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> number of elements in each x_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. !> @param[out] results !> device pointer or host pointer to array of batch_count size for nrm2 results. !> Return value is 0.0 for each element if n <= 0, incx<=0. interface rocblas_snrm2_batched function rocblas_snrm2_batched_(handle,n,x,incx,batch_count,results) & bind(c, name="rocblas_snrm2_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_snrm2_batched_ 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 :: results end function end interface interface rocblas_dnrm2_batched function rocblas_dnrm2_batched_(handle,n,x,incx,batch_count,results) & bind(c, name="rocblas_dnrm2_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dnrm2_batched_ 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 :: results end function end interface interface rocblas_scnrm2_batched function rocblas_scnrm2_batched_(handle,n,x,incx,batch_count,results) & bind(c, name="rocblas_scnrm2_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scnrm2_batched_ 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 :: results end function end interface interface rocblas_dznrm2_batched function rocblas_dznrm2_batched_(handle,n,x,incx,batch_count,results) & bind(c, name="rocblas_dznrm2_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dznrm2_batched_ 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 :: results end function end interface interface rocblas_snrm2_batched_64 function rocblas_snrm2_batched_64_(handle,n,x,incx,batch_count,results) & bind(c, name="rocblas_snrm2_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_snrm2_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count type(c_ptr),value :: results end function end interface interface rocblas_dnrm2_batched_64 function rocblas_dnrm2_batched_64_(handle,n,x,incx,batch_count,results) & bind(c, name="rocblas_dnrm2_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dnrm2_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count type(c_ptr),value :: results end function end interface interface rocblas_scnrm2_batched_64 function rocblas_scnrm2_batched_64_(handle,n,x,incx,batch_count,results) & bind(c, name="rocblas_scnrm2_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scnrm2_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count type(c_ptr),value :: results end function end interface interface rocblas_dznrm2_batched_64 function rocblas_dznrm2_batched_64_(handle,n,x,incx,batch_count,results) & bind(c, name="rocblas_dznrm2_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dznrm2_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count type(c_ptr),value :: results end function end interface !> \brief BLAS Level 1 API !> !> \details !> The nrm2_strided_batched functions compute the Euclidean norm over a batch of real or !> complex vectors: !> !> result := sqrt( x_i'*x_i ) for real vectors x, for i = 1, ..., batch_count !> result := sqrt( x_i**H*x_i ) for complex vectors, for i = 1, ..., batch_count !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> number of elements in each x_i. !> @param[in] x - device pointer to the first vector x_1. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] stridex - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stride_x. However, ensure that stride_x is of !> an appropriate size. For a typical !> case, this means stride_x >= n * incx. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. !> @param[out] results !> device pointer or host pointer to array for storing contiguous batch_count !> results. !> Return value is 0.0 for each element if n <= 0, incx<=0. interface rocblas_snrm2_strided_batched function rocblas_snrm2_strided_batched_(handle,n,x,incx,stridex,batch_count,results) & bind(c, name="rocblas_snrm2_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_snrm2_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batch_count type(c_ptr),value :: results end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_snrm2_strided_batched_assumed_rank #else module procedure & rocblas_snrm2_strided_batched_rank_0,& rocblas_snrm2_strided_batched_rank_1 #endif #endif end interface interface rocblas_dnrm2_strided_batched function rocblas_dnrm2_strided_batched_(handle,n,x,incx,stridex,batch_count,results) & bind(c, name="rocblas_dnrm2_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dnrm2_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batch_count type(c_ptr),value :: results end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dnrm2_strided_batched_assumed_rank #else module procedure & rocblas_dnrm2_strided_batched_rank_0,& rocblas_dnrm2_strided_batched_rank_1 #endif #endif end interface interface rocblas_scnrm2_strided_batched function rocblas_scnrm2_strided_batched_(handle,n,x,incx,stridex,batch_count,results) & bind(c, name="rocblas_scnrm2_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scnrm2_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batch_count type(c_ptr),value :: results end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_scnrm2_strided_batched_assumed_rank #else module procedure & rocblas_scnrm2_strided_batched_rank_0,& rocblas_scnrm2_strided_batched_rank_1 #endif #endif end interface interface rocblas_dznrm2_strided_batched function rocblas_dznrm2_strided_batched_(handle,n,x,incx,stridex,batch_count,results) & bind(c, name="rocblas_dznrm2_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dznrm2_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batch_count type(c_ptr),value :: results end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dznrm2_strided_batched_assumed_rank #else module procedure & rocblas_dznrm2_strided_batched_rank_0,& rocblas_dznrm2_strided_batched_rank_1 #endif #endif end interface interface rocblas_snrm2_strided_batched_64 function rocblas_snrm2_strided_batched_64_(handle,n,x,incx,stridex,batch_count,results) & bind(c, name="rocblas_snrm2_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_snrm2_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batch_count type(c_ptr),value :: results end function end interface interface rocblas_dnrm2_strided_batched_64 function rocblas_dnrm2_strided_batched_64_(handle,n,x,incx,stridex,batch_count,results) & bind(c, name="rocblas_dnrm2_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dnrm2_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batch_count type(c_ptr),value :: results end function end interface interface rocblas_scnrm2_strided_batched_64 function rocblas_scnrm2_strided_batched_64_(handle,n,x,incx,stridex,batch_count,results) & bind(c, name="rocblas_scnrm2_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scnrm2_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batch_count type(c_ptr),value :: results end function end interface interface rocblas_dznrm2_strided_batched_64 function rocblas_dznrm2_strided_batched_64_(handle,n,x,incx,stridex,batch_count,results) & bind(c, name="rocblas_dznrm2_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dznrm2_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batch_count type(c_ptr),value :: results end function end interface !> \brief BLAS Level 1 API !> !> \details !> The amax functions find the first index of the element of maximum magnitude of a vector !> ``x``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocblas library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in x. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in, out] myResult !> device pointer or host pointer to store the amax index. !> Return value is 0.0 if n, incx<=0. interface rocblas_isamax function rocblas_isamax_(handle,n,x,incx,myResult) bind(c, name="rocblas_isamax") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_isamax_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_idamax function rocblas_idamax_(handle,n,x,incx,myResult) bind(c, name="rocblas_idamax") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_idamax_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_icamax function rocblas_icamax_(handle,n,x,incx,myResult) bind(c, name="rocblas_icamax") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamax_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_icamax_assumed_rank #else module procedure & rocblas_icamax_rank_0,& rocblas_icamax_rank_1 #endif #endif end interface interface rocblas_izamax function rocblas_izamax_(handle,n,x,incx,myResult) bind(c, name="rocblas_izamax") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamax_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_izamax_assumed_rank #else module procedure & rocblas_izamax_rank_0,& rocblas_izamax_rank_1 #endif #endif end interface interface rocblas_isamax_64 function rocblas_isamax_64_(handle,n,x,incx,myResult) bind(c, name="rocblas_isamax_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_isamax_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_idamax_64 function rocblas_idamax_64_(handle,n,x,incx,myResult) bind(c, name="rocblas_idamax_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_idamax_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_icamax_64 function rocblas_icamax_64_(handle,n,x,incx,myResult) bind(c, name="rocblas_icamax_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamax_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_izamax_64 function rocblas_izamax_64_(handle,n,x,incx,myResult) bind(c, name="rocblas_izamax_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamax_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface !> \brief BLAS Level 1 API !> !> \details !> The amax_batched functions find the first index of the element of maximum magnitude of !> each vector ``x_i`` in a batch, for ``i`` = 1, ..., ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> number of elements in each vector x_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. Must be > 0. !> @param[out] myResult !> device or host array of pointers of batch_count size for results. !> Return is 0 if n, incx<=0. interface rocblas_isamax_batched function rocblas_isamax_batched_(handle,n,x,incx,batch_count,myResult) & bind(c, name="rocblas_isamax_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_isamax_batched_ 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 :: myResult end function end interface interface rocblas_idamax_batched function rocblas_idamax_batched_(handle,n,x,incx,batch_count,myResult) & bind(c, name="rocblas_idamax_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_idamax_batched_ 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 :: myResult end function end interface interface rocblas_icamax_batched function rocblas_icamax_batched_(handle,n,x,incx,batch_count,myResult) & bind(c, name="rocblas_icamax_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamax_batched_ 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 :: myResult end function end interface interface rocblas_izamax_batched function rocblas_izamax_batched_(handle,n,x,incx,batch_count,myResult) & bind(c, name="rocblas_izamax_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamax_batched_ 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 :: myResult end function end interface interface rocblas_isamax_batched_64 function rocblas_isamax_batched_64_(handle,n,x,incx,batch_count,myResult) & bind(c, name="rocblas_isamax_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_isamax_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_idamax_batched_64 function rocblas_idamax_batched_64_(handle,n,x,incx,batch_count,myResult) & bind(c, name="rocblas_idamax_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_idamax_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_icamax_batched_64 function rocblas_icamax_batched_64_(handle,n,x,incx,batch_count,myResult) & bind(c, name="rocblas_icamax_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamax_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_izamax_batched_64 function rocblas_izamax_batched_64_(handle,n,x,incx,batch_count,myResult) & bind(c, name="rocblas_izamax_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamax_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface !> \brief BLAS Level 1 API !> !> \details !> The amax_strided_batched functions find the first index of the element of maximum !> magnitude of each vector ``x_i`` in a batch, for ``i`` = 1, ..., ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> number of elements in each vector x_i. !> @param[in] x - device pointer to the first vector x_1. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] stridex - [rocblas_stride] !> specifies the pointer increment between one x_i and the next x_(i + 1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. !> @param[out] myResult !> device or host pointer for storing contiguous batch_count results. !> Return is 0 if n <= 0, incx<=0. interface rocblas_isamax_strided_batched function rocblas_isamax_strided_batched_(handle,n,x,incx,stridex,batch_count,myResult) & bind(c, name="rocblas_isamax_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_isamax_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batch_count type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_isamax_strided_batched_assumed_rank #else module procedure & rocblas_isamax_strided_batched_rank_0,& rocblas_isamax_strided_batched_rank_1 #endif #endif end interface interface rocblas_idamax_strided_batched function rocblas_idamax_strided_batched_(handle,n,x,incx,stridex,batch_count,myResult) & bind(c, name="rocblas_idamax_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_idamax_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batch_count type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_idamax_strided_batched_assumed_rank #else module procedure & rocblas_idamax_strided_batched_rank_0,& rocblas_idamax_strided_batched_rank_1 #endif #endif end interface interface rocblas_icamax_strided_batched function rocblas_icamax_strided_batched_(handle,n,x,incx,stridex,batch_count,myResult) & bind(c, name="rocblas_icamax_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamax_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batch_count type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_icamax_strided_batched_assumed_rank #else module procedure & rocblas_icamax_strided_batched_rank_0,& rocblas_icamax_strided_batched_rank_1 #endif #endif end interface interface rocblas_izamax_strided_batched function rocblas_izamax_strided_batched_(handle,n,x,incx,stridex,batch_count,myResult) & bind(c, name="rocblas_izamax_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamax_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batch_count type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_izamax_strided_batched_assumed_rank #else module procedure & rocblas_izamax_strided_batched_rank_0,& rocblas_izamax_strided_batched_rank_1 #endif #endif end interface interface rocblas_isamax_strided_batched_64 function rocblas_isamax_strided_batched_64_(handle,n,x,incx,stridex,batch_count,myResult) & bind(c, name="rocblas_isamax_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_isamax_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_idamax_strided_batched_64 function rocblas_idamax_strided_batched_64_(handle,n,x,incx,stridex,batch_count,myResult) & bind(c, name="rocblas_idamax_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_idamax_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_icamax_strided_batched_64 function rocblas_icamax_strided_batched_64_(handle,n,x,incx,stridex,batch_count,myResult) & bind(c, name="rocblas_icamax_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamax_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_izamax_strided_batched_64 function rocblas_izamax_strided_batched_64_(handle,n,x,incx,stridex,batch_count,myResult) & bind(c, name="rocblas_izamax_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamax_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface !> \brief BLAS Level 1 API !> !> \details !> The amin functions find the first index of the element of minimum magnitude of a vector !> ``x``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in x. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in, out] myResult !> device pointer or host pointer to store the amin index. !> Return value is 0.0 if n, incx<=0. interface rocblas_isamin function rocblas_isamin_(handle,n,x,incx,myResult) bind(c, name="rocblas_isamin") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_isamin_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_idamin function rocblas_idamin_(handle,n,x,incx,myResult) bind(c, name="rocblas_idamin") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_idamin_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_icamin function rocblas_icamin_(handle,n,x,incx,myResult) bind(c, name="rocblas_icamin") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamin_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_icamin_assumed_rank #else module procedure & rocblas_icamin_rank_0,& rocblas_icamin_rank_1 #endif #endif end interface interface rocblas_izamin function rocblas_izamin_(handle,n,x,incx,myResult) bind(c, name="rocblas_izamin") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamin_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_izamin_assumed_rank #else module procedure & rocblas_izamin_rank_0,& rocblas_izamin_rank_1 #endif #endif end interface interface rocblas_isamin_64 function rocblas_isamin_64_(handle,n,x,incx,myResult) bind(c, name="rocblas_isamin_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_isamin_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_idamin_64 function rocblas_idamin_64_(handle,n,x,incx,myResult) bind(c, name="rocblas_idamin_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_idamin_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_icamin_64 function rocblas_icamin_64_(handle,n,x,incx,myResult) bind(c, name="rocblas_icamin_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamin_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface interface rocblas_izamin_64 function rocblas_izamin_64_(handle,n,x,incx,myResult) bind(c, name="rocblas_izamin_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamin_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: myResult end function end interface !> \brief BLAS Level 1 API !> !> \details !> The amin_batched functions find the first index of the element of minimum magnitude of each !> vector ``x_i`` in a batch, for ``i`` = 1, ..., ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> number of elements in each vector x_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. Must be > 0. !> @param[out] myResult !> device or host pointers to array of batch_count size for results. !> Return is 0 if n, incx<=0. interface rocblas_isamin_batched function rocblas_isamin_batched_(handle,n,x,incx,batch_count,myResult) & bind(c, name="rocblas_isamin_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_isamin_batched_ 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 :: myResult end function end interface interface rocblas_idamin_batched function rocblas_idamin_batched_(handle,n,x,incx,batch_count,myResult) & bind(c, name="rocblas_idamin_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_idamin_batched_ 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 :: myResult end function end interface interface rocblas_icamin_batched function rocblas_icamin_batched_(handle,n,x,incx,batch_count,myResult) & bind(c, name="rocblas_icamin_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamin_batched_ 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 :: myResult end function end interface interface rocblas_izamin_batched function rocblas_izamin_batched_(handle,n,x,incx,batch_count,myResult) & bind(c, name="rocblas_izamin_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamin_batched_ 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 :: myResult end function end interface interface rocblas_isamin_batched_64 function rocblas_isamin_batched_64_(handle,n,x,incx,batch_count,myResult) & bind(c, name="rocblas_isamin_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_isamin_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_idamin_batched_64 function rocblas_idamin_batched_64_(handle,n,x,incx,batch_count,myResult) & bind(c, name="rocblas_idamin_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_idamin_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_icamin_batched_64 function rocblas_icamin_batched_64_(handle,n,x,incx,batch_count,myResult) & bind(c, name="rocblas_icamin_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamin_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_izamin_batched_64 function rocblas_izamin_batched_64_(handle,n,x,incx,batch_count,myResult) & bind(c, name="rocblas_izamin_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamin_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface !> \brief BLAS Level 1 API !> !> \details !> The amin_strided_batched functions find the first index of the element of minimum !> magnitude of each vector ``x_i`` in a batch, for ``i`` = 1, ..., ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> number of elements in each vector x_i. !> @param[in] x - device pointer to the first vector x_1. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] stridex - [rocblas_stride] !> specifies the pointer increment between one x_i and the next x_(i + 1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. !> @param[out] myResult !> device or host pointer to array for storing contiguous batch_count results. !> Return is 0 if n <= 0, incx<=0. interface rocblas_isamin_strided_batched function rocblas_isamin_strided_batched_(handle,n,x,incx,stridex,batch_count,myResult) & bind(c, name="rocblas_isamin_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_isamin_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batch_count type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_isamin_strided_batched_assumed_rank #else module procedure & rocblas_isamin_strided_batched_rank_0,& rocblas_isamin_strided_batched_rank_1 #endif #endif end interface interface rocblas_idamin_strided_batched function rocblas_idamin_strided_batched_(handle,n,x,incx,stridex,batch_count,myResult) & bind(c, name="rocblas_idamin_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_idamin_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batch_count type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_idamin_strided_batched_assumed_rank #else module procedure & rocblas_idamin_strided_batched_rank_0,& rocblas_idamin_strided_batched_rank_1 #endif #endif end interface interface rocblas_icamin_strided_batched function rocblas_icamin_strided_batched_(handle,n,x,incx,stridex,batch_count,myResult) & bind(c, name="rocblas_icamin_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamin_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batch_count type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_icamin_strided_batched_assumed_rank #else module procedure & rocblas_icamin_strided_batched_rank_0,& rocblas_icamin_strided_batched_rank_1 #endif #endif end interface interface rocblas_izamin_strided_batched function rocblas_izamin_strided_batched_(handle,n,x,incx,stridex,batch_count,myResult) & bind(c, name="rocblas_izamin_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamin_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batch_count type(c_ptr),value :: myResult end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_izamin_strided_batched_assumed_rank #else module procedure & rocblas_izamin_strided_batched_rank_0,& rocblas_izamin_strided_batched_rank_1 #endif #endif end interface interface rocblas_isamin_strided_batched_64 function rocblas_isamin_strided_batched_64_(handle,n,x,incx,stridex,batch_count,myResult) & bind(c, name="rocblas_isamin_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_isamin_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_idamin_strided_batched_64 function rocblas_idamin_strided_batched_64_(handle,n,x,incx,stridex,batch_count,myResult) & bind(c, name="rocblas_idamin_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_idamin_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_icamin_strided_batched_64 function rocblas_icamin_strided_batched_64_(handle,n,x,incx,stridex,batch_count,myResult) & bind(c, name="rocblas_icamin_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamin_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface interface rocblas_izamin_strided_batched_64 function rocblas_izamin_strided_batched_64_(handle,n,x,incx,stridex,batch_count,myResult) & bind(c, name="rocblas_izamin_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamin_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult end function end interface !> \brief BLAS Level 1 API !> !> \details !> The rot functions apply the Givens rotation matrix defined by ``c=cos(alpha)`` and !> ``s=sin(alpha)`` to vectors ``x`` and ``y``. !> Scalars ``c`` and ``s`` can be stored in either host or device memory. The location is !> specified by calling ``rocblas_set_pointer_mode``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> number of elements in the x and y vectors. !> @param[in, out] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment between elements of x. !> @param[in, out] y - device pointer storing vector y. !> @param[in] incy - [rocblas_int] !> specifies the increment between elements of y. !> @param[in] c - device pointer or host pointer storing the scalar cosine component of the !> rotation matrix. !> @param[in] s - device pointer or host pointer storing the scalar sine component of the !> rotation matrix. interface rocblas_srot function rocblas_srot_(handle,n,x,incx,y,incy,c,s) bind(c, name="rocblas_srot") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srot_ 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 real(c_float) :: c real(c_float) :: s end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_srot_assumed_rank #else module procedure & rocblas_srot_rank_0,& rocblas_srot_rank_1 #endif #endif end interface interface rocblas_drot function rocblas_drot_(handle,n,x,incx,y,incy,c,s) bind(c, name="rocblas_drot") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drot_ 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 real(c_double) :: c real(c_double) :: s end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_drot_assumed_rank #else module procedure & rocblas_drot_rank_0,& rocblas_drot_rank_1 #endif #endif end interface interface rocblas_crot function rocblas_crot_(handle,n,x,incx,y,incy,c,s) bind(c, name="rocblas_crot") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_crot_ 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 real(c_float) :: c complex(c_float_complex) :: s end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_crot_assumed_rank #else module procedure & rocblas_crot_rank_0,& rocblas_crot_rank_1 #endif #endif end interface interface rocblas_csrot function rocblas_csrot_(handle,n,x,incx,y,incy,c,s) bind(c, name="rocblas_csrot") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csrot_ 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 real(c_float) :: c real(c_float) :: s end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_csrot_assumed_rank #else module procedure & rocblas_csrot_rank_0,& rocblas_csrot_rank_1 #endif #endif end interface interface rocblas_zrot function rocblas_zrot_(handle,n,x,incx,y,incy,c,s) bind(c, name="rocblas_zrot") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zrot_ 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 real(c_double) :: c complex(c_double_complex) :: s end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zrot_assumed_rank #else module procedure & rocblas_zrot_rank_0,& rocblas_zrot_rank_1 #endif #endif end interface interface rocblas_zdrot function rocblas_zdrot_(handle,n,x,incx,y,incy,c,s) bind(c, name="rocblas_zdrot") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdrot_ 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 real(c_double) :: c real(c_double) :: s end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zdrot_assumed_rank #else module procedure & rocblas_zdrot_rank_0,& rocblas_zdrot_rank_1 #endif #endif end interface interface rocblas_srot_64 function rocblas_srot_64_(handle,n,x,incx,y,incy,c,s) bind(c, name="rocblas_srot_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy real(c_float) :: c real(c_float) :: s end function end interface interface rocblas_drot_64 function rocblas_drot_64_(handle,n,x,incx,y,incy,c,s) bind(c, name="rocblas_drot_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy real(c_double) :: c real(c_double) :: s end function end interface interface rocblas_crot_64 function rocblas_crot_64_(handle,n,x,incx,y,incy,c,s) bind(c, name="rocblas_crot_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_crot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy real(c_float) :: c complex(c_float_complex) :: s end function end interface interface rocblas_csrot_64 function rocblas_csrot_64_(handle,n,x,incx,y,incy,c,s) bind(c, name="rocblas_csrot_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csrot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy real(c_float) :: c real(c_float) :: s end function end interface interface rocblas_zrot_64 function rocblas_zrot_64_(handle,n,x,incx,y,incy,c,s) bind(c, name="rocblas_zrot_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zrot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy real(c_double) :: c complex(c_double_complex) :: s end function end interface interface rocblas_zdrot_64 function rocblas_zdrot_64_(handle,n,x,incx,y,incy,c,s) bind(c, name="rocblas_zdrot_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdrot_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy real(c_double) :: c real(c_double) :: s end function end interface !> \brief BLAS Level 1 API !> !> \details !> The rot_batched functions apply the Givens rotation matrix defined by ``c=cos(alpha)`` and !> ``s=sin(alpha)`` to batched vectors ``x_i`` and ``y_i``, for ``i`` = 1, ..., !> ``batch_count``. !> Scalars ``c`` and ``s`` can be stored in either host or device memory. The location is !> specified by calling ``rocblas_set_pointer_mode``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> number of elements in each x_i and y_i vectors. !> @param[in, out] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment between elements of each x_i. !> @param[in, out] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment between elements of each y_i. !> @param[in] c - device pointer or host pointer to scalar cosine component of the rotation !> matrix. !> @param[in] s - device pointer or host pointer to scalar sine component of the rotation !> matrix. !> @param[in] batch_count - [rocblas_int] !> the number of x and y arrays, that is, the number of batches. interface rocblas_srot_batched function rocblas_srot_batched_(handle,n,x,incx,y,incy,c,s,batch_count) & bind(c, name="rocblas_srot_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srot_batched_ 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 real(c_float) :: c real(c_float) :: s integer(c_int),value :: batch_count end function end interface interface rocblas_drot_batched function rocblas_drot_batched_(handle,n,x,incx,y,incy,c,s,batch_count) & bind(c, name="rocblas_drot_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drot_batched_ 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 real(c_double) :: c real(c_double) :: s integer(c_int),value :: batch_count end function end interface interface rocblas_crot_batched function rocblas_crot_batched_(handle,n,x,incx,y,incy,c,s,batch_count) & bind(c, name="rocblas_crot_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_crot_batched_ 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 real(c_float) :: c complex(c_float_complex) :: s integer(c_int),value :: batch_count end function end interface interface rocblas_csrot_batched function rocblas_csrot_batched_(handle,n,x,incx,y,incy,c,s,batch_count) & bind(c, name="rocblas_csrot_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csrot_batched_ 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 real(c_float) :: c real(c_float) :: s integer(c_int),value :: batch_count end function end interface interface rocblas_zrot_batched function rocblas_zrot_batched_(handle,n,x,incx,y,incy,c,s,batch_count) & bind(c, name="rocblas_zrot_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zrot_batched_ 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 real(c_double) :: c complex(c_double_complex) :: s integer(c_int),value :: batch_count end function end interface interface rocblas_zdrot_batched function rocblas_zdrot_batched_(handle,n,x,incx,y,incy,c,s,batch_count) & bind(c, name="rocblas_zdrot_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdrot_batched_ 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 real(c_double) :: c real(c_double) :: s integer(c_int),value :: batch_count end function end interface interface rocblas_srot_batched_64 function rocblas_srot_batched_64_(handle,n,x,incx,y,incy,c,s,batch_count) & bind(c, name="rocblas_srot_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srot_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy real(c_float) :: c real(c_float) :: s integer(c_int64_t),value :: batch_count end function end interface interface rocblas_drot_batched_64 function rocblas_drot_batched_64_(handle,n,x,incx,y,incy,c,s,batch_count) & bind(c, name="rocblas_drot_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drot_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy real(c_double) :: c real(c_double) :: s integer(c_int64_t),value :: batch_count end function end interface interface rocblas_crot_batched_64 function rocblas_crot_batched_64_(handle,n,x,incx,y,incy,c,s,batch_count) & bind(c, name="rocblas_crot_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_crot_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy real(c_float) :: c complex(c_float_complex) :: s integer(c_int64_t),value :: batch_count end function end interface interface rocblas_csrot_batched_64 function rocblas_csrot_batched_64_(handle,n,x,incx,y,incy,c,s,batch_count) & bind(c, name="rocblas_csrot_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csrot_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy real(c_float) :: c real(c_float) :: s integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zrot_batched_64 function rocblas_zrot_batched_64_(handle,n,x,incx,y,incy,c,s,batch_count) & bind(c, name="rocblas_zrot_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zrot_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy real(c_double) :: c complex(c_double_complex) :: s integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zdrot_batched_64 function rocblas_zdrot_batched_64_(handle,n,x,incx,y,incy,c,s,batch_count) & bind(c, name="rocblas_zdrot_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdrot_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy real(c_double) :: c real(c_double) :: s integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 1 API !> !> \details !> The rot_strided_batched functions apply the Givens rotation matrix defined by !> ``c=cos(alpha)`` and ``s=sin(alpha)`` to strided batched vectors ``x_i`` and ``y_i``, for !> ``i`` = 1, ..., ``batch_count``. !> Scalars ``c`` and ``s`` can be stored in either host or device memory. The location is !> specified by calling ``rocblas_set_pointer_mode``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> number of elements in each x_i and y_i vectors. !> @param[in, out] x - device pointer to the first vector x_1. !> @param[in] incx - [rocblas_int] !> specifies the increment between elements of each x_i. !> @param[in] stride_x - [rocblas_stride] !> specifies the increment from the beginning of x_i to the beginning of x_(i+1). !> @param[in, out] y - device pointer to the first vector y_1. !> @param[in] incy - [rocblas_int] !> specifies the increment between elements of each y_i. !> @param[in] stride_y - [rocblas_stride] !> specifies the increment from the beginning of y_i to the beginning of y_(i+1) !> @param[in] c - device pointer or host pointer to scalar cosine component of the rotation !> matrix. !> @param[in] s - device pointer or host pointer to scalar sine component of the rotation !> matrix. !> @param[in] batch_count - [rocblas_int] !> the number of x and y arrays, that is, the number of batches. interface rocblas_srot_strided_batched function rocblas_srot_strided_batched_(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) & bind(c, name="rocblas_srot_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srot_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y real(c_float) :: c real(c_float) :: s integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_srot_strided_batched_assumed_rank #else module procedure & rocblas_srot_strided_batched_rank_0,& rocblas_srot_strided_batched_rank_1 #endif #endif end interface interface rocblas_drot_strided_batched function rocblas_drot_strided_batched_(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) & bind(c, name="rocblas_drot_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drot_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y real(c_double) :: c real(c_double) :: s integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_drot_strided_batched_assumed_rank #else module procedure & rocblas_drot_strided_batched_rank_0,& rocblas_drot_strided_batched_rank_1 #endif #endif end interface interface rocblas_crot_strided_batched function rocblas_crot_strided_batched_(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) & bind(c, name="rocblas_crot_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_crot_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y real(c_float) :: c complex(c_float_complex) :: s integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_crot_strided_batched_assumed_rank #else module procedure & rocblas_crot_strided_batched_rank_0,& rocblas_crot_strided_batched_rank_1 #endif #endif end interface interface rocblas_csrot_strided_batched function rocblas_csrot_strided_batched_(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) & bind(c, name="rocblas_csrot_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csrot_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y real(c_float) :: c real(c_float) :: s integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_csrot_strided_batched_assumed_rank #else module procedure & rocblas_csrot_strided_batched_rank_0,& rocblas_csrot_strided_batched_rank_1 #endif #endif end interface interface rocblas_zrot_strided_batched function rocblas_zrot_strided_batched_(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) & bind(c, name="rocblas_zrot_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zrot_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y real(c_double) :: c complex(c_double_complex) :: s integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zrot_strided_batched_assumed_rank #else module procedure & rocblas_zrot_strided_batched_rank_0,& rocblas_zrot_strided_batched_rank_1 #endif #endif end interface interface rocblas_zdrot_strided_batched function rocblas_zdrot_strided_batched_(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) & bind(c, name="rocblas_zdrot_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdrot_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y real(c_double) :: c real(c_double) :: s integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zdrot_strided_batched_assumed_rank #else module procedure & rocblas_zdrot_strided_batched_rank_0,& rocblas_zdrot_strided_batched_rank_1 #endif #endif end interface interface rocblas_srot_strided_batched_64 function rocblas_srot_strided_batched_64_(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) & bind(c, name="rocblas_srot_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srot_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y real(c_float) :: c real(c_float) :: s integer(c_int64_t),value :: batch_count end function end interface interface rocblas_drot_strided_batched_64 function rocblas_drot_strided_batched_64_(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) & bind(c, name="rocblas_drot_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drot_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y real(c_double) :: c real(c_double) :: s integer(c_int64_t),value :: batch_count end function end interface interface rocblas_crot_strided_batched_64 function rocblas_crot_strided_batched_64_(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) & bind(c, name="rocblas_crot_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_crot_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y real(c_float) :: c complex(c_float_complex) :: s integer(c_int64_t),value :: batch_count end function end interface interface rocblas_csrot_strided_batched_64 function rocblas_csrot_strided_batched_64_(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) & bind(c, name="rocblas_csrot_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csrot_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y real(c_float) :: c real(c_float) :: s integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zrot_strided_batched_64 function rocblas_zrot_strided_batched_64_(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) & bind(c, name="rocblas_zrot_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zrot_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y real(c_double) :: c complex(c_double_complex) :: s integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zdrot_strided_batched_64 function rocblas_zdrot_strided_batched_64_(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) & bind(c, name="rocblas_zdrot_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdrot_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y real(c_double) :: c real(c_double) :: s integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 1 API !> !> \details !> The rotg functions create the Givens rotation matrix for the vector ``(a b)``. !> Scalars ``a``, ``b``, ``c``, and ``s`` can be stored in either host or device memory. The !> location is specified by !> calling ``rocblas_set_pointer_mode``. The computation uses the formulas: !> !> sigma = sgn(a) if |a| > |b| !> = sgn(b) if |b| >= |a| !> r = sigma*sqrt( a**2 + b**2 ) !> c = 1; s = 0 if r = 0 !> c = a/r; s = b/r if r != 0 !> !> The subroutine also computes: !> !> z = s if |a| > |b|, !> = 1/c if |b| >= |a| and c != 0 !> = 1 if c = 0 !> !> This allows ``c`` and ``s`` to be reconstructed from ``z`` as follows: !> !> If z = 1, set c = 0, s = 1. !> If |z| < 1, set c = sqrt(1 - z**2) and s = z. !> If |z| > 1, set c = 1/z and s = sqrt( 1 - c**2). !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in, out] a - pointer to a, an element in vector (a,b), overwritten with r. !> @param[in, out] b - pointer to b, an element in vector (a,b), overwritten with z. !> @param[out] c - pointer to c, cosine element of the Givens rotation. !> @param[out] s - pointer to s, sine element of the Givens rotation. interface rocblas_srotg function rocblas_srotg_(handle,a,b,c,s) bind(c, name="rocblas_srotg") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotg_ 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 end function end interface interface rocblas_drotg function rocblas_drotg_(handle,a,b,c,s) bind(c, name="rocblas_drotg") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotg_ 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 end function end interface interface rocblas_crotg function rocblas_crotg_(handle,a,b,c,s) bind(c, name="rocblas_crotg") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_crotg_ 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 end function end interface interface rocblas_zrotg function rocblas_zrotg_(handle,a,b,c,s) bind(c, name="rocblas_zrotg") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zrotg_ 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 end function end interface interface rocblas_srotg_64 function rocblas_srotg_64_(handle,a,b,c,s) bind(c, name="rocblas_srotg_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotg_64_ 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 end function end interface interface rocblas_drotg_64 function rocblas_drotg_64_(handle,a,b,c,s) bind(c, name="rocblas_drotg_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotg_64_ 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 end function end interface interface rocblas_crotg_64 function rocblas_crotg_64_(handle,a,b,c,s) bind(c, name="rocblas_crotg_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_crotg_64_ 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 end function end interface interface rocblas_zrotg_64 function rocblas_zrotg_64_(handle,a,b,c,s) bind(c, name="rocblas_zrotg_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zrotg_64_ 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 end function end interface !> \brief BLAS Level 1 API !> !> \details !> The rotg_batched functions create the Givens rotation matrix for the batched vectors !> ``(a_i b_i)``, for ``i`` = 1, ..., ``batch_count``. !> ``a``, ``b``, ``c``, and ``s`` are host pointers to an array of device pointers on the !> device, where each device pointer points !> to a scalar value of ``a_i``, ``b_i``, ``c_i``, or ``s_i``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in, out] a - a, overwritten with r. !> @param[in, out] b - b overwritten with z. !> @param[out] c - cosine element of the Givens rotation for the batch. !> @param[out] s - sine element of the Givens rotation for the batch. !> @param[in] batch_count - [rocblas_int] !> number of batches (length of arrays a, b, c, and s). interface rocblas_srotg_batched function rocblas_srotg_batched_(handle,a,b,c,s,batch_count) & bind(c, name="rocblas_srotg_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotg_batched_ 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 end function end interface interface rocblas_drotg_batched function rocblas_drotg_batched_(handle,a,b,c,s,batch_count) & bind(c, name="rocblas_drotg_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotg_batched_ 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 end function end interface interface rocblas_crotg_batched function rocblas_crotg_batched_(handle,a,b,c,s,batch_count) & bind(c, name="rocblas_crotg_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_crotg_batched_ 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 end function end interface interface rocblas_zrotg_batched function rocblas_zrotg_batched_(handle,a,b,c,s,batch_count) & bind(c, name="rocblas_zrotg_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zrotg_batched_ 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 end function end interface interface rocblas_srotg_batched_64 function rocblas_srotg_batched_64_(handle,a,b,c,s,batch_count) & bind(c, name="rocblas_srotg_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotg_batched_64_ 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_int64_t),value :: batch_count end function end interface interface rocblas_drotg_batched_64 function rocblas_drotg_batched_64_(handle,a,b,c,s,batch_count) & bind(c, name="rocblas_drotg_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotg_batched_64_ 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_int64_t),value :: batch_count end function end interface interface rocblas_crotg_batched_64 function rocblas_crotg_batched_64_(handle,a,b,c,s,batch_count) & bind(c, name="rocblas_crotg_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_crotg_batched_64_ 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_int64_t),value :: batch_count end function end interface interface rocblas_zrotg_batched_64 function rocblas_zrotg_batched_64_(handle,a,b,c,s,batch_count) & bind(c, name="rocblas_zrotg_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zrotg_batched_64_ 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_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 1 API !> !> \details !> The rotg_strided_batched functions create the Givens rotation matrix for the strided !> batched vectors ``(a_i b_i)``, for ``i`` = 1, ..., ``batch_count``. !> ``a``, ``b``, ``c``, and ``s`` are host pointers to arrays ``a``, ``b``, ``c``, and ``s`` !> on the device. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in, out] a - host pointer to first single input vector element a_1 on the device, !> overwritten with r. !> @param[in] stride_a - [rocblas_stride] !> distance between elements of a in batch (distance between a_i and a_(i + 1)). !> @param[in, out] b - host pointer to first single input vector element b_1 on the device, !> overwritten with z. !> @param[in] stride_b - [rocblas_stride] !> distance between elements of b in batch (distance between b_i and b_(i + 1)). !> @param[out] c - host pointer to first single cosine element of the Givens rotations c_1 on !> the device. !> @param[in] stride_c - [rocblas_stride] !> distance between elements of c in batch (distance between c_i and c_(i + 1)). !> @param[out] s - host pointer to first single sine element of the Givens rotations s_1 on !> the device. !> @param[in] stride_s - [rocblas_stride] !> distance between elements of s in batch (distance between s_i and s_(i + 1)). !> @param[in] batch_count - [rocblas_int] !> number of batches (length of arrays a, b, c, and s). interface rocblas_srotg_strided_batched function rocblas_srotg_strided_batched_(handle,a,stride_a,b,stride_b,c,stride_c,s,stride_s, & batch_count) & bind(c, name="rocblas_srotg_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotg_strided_batched_ type(c_ptr),value :: handle type(c_ptr),value :: a integer(c_int64_t),value :: stride_a type(c_ptr),value :: b integer(c_int64_t),value :: stride_b type(c_ptr),value :: c integer(c_int64_t),value :: stride_c type(c_ptr),value :: s integer(c_int64_t),value :: stride_s integer(c_int),value :: batch_count end function end interface interface rocblas_drotg_strided_batched function rocblas_drotg_strided_batched_(handle,a,stride_a,b,stride_b,c,stride_c,s,stride_s, & batch_count) & bind(c, name="rocblas_drotg_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotg_strided_batched_ type(c_ptr),value :: handle type(c_ptr),value :: a integer(c_int64_t),value :: stride_a type(c_ptr),value :: b integer(c_int64_t),value :: stride_b type(c_ptr),value :: c integer(c_int64_t),value :: stride_c type(c_ptr),value :: s integer(c_int64_t),value :: stride_s integer(c_int),value :: batch_count end function end interface interface rocblas_crotg_strided_batched function rocblas_crotg_strided_batched_(handle,a,stride_a,b,stride_b,c,stride_c,s,stride_s, & batch_count) & bind(c, name="rocblas_crotg_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_crotg_strided_batched_ type(c_ptr),value :: handle type(c_ptr),value :: a integer(c_int64_t),value :: stride_a type(c_ptr),value :: b integer(c_int64_t),value :: stride_b type(c_ptr),value :: c integer(c_int64_t),value :: stride_c type(c_ptr),value :: s integer(c_int64_t),value :: stride_s integer(c_int),value :: batch_count end function end interface interface rocblas_zrotg_strided_batched function rocblas_zrotg_strided_batched_(handle,a,stride_a,b,stride_b,c,stride_c,s,stride_s, & batch_count) & bind(c, name="rocblas_zrotg_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zrotg_strided_batched_ type(c_ptr),value :: handle type(c_ptr),value :: a integer(c_int64_t),value :: stride_a type(c_ptr),value :: b integer(c_int64_t),value :: stride_b type(c_ptr),value :: c integer(c_int64_t),value :: stride_c type(c_ptr),value :: s integer(c_int64_t),value :: stride_s integer(c_int),value :: batch_count end function end interface interface rocblas_srotg_strided_batched_64 function rocblas_srotg_strided_batched_64_(handle,a,stride_a,b,stride_b,c,stride_c,s,stride_s, & batch_count) & bind(c, name="rocblas_srotg_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotg_strided_batched_64_ type(c_ptr),value :: handle type(c_ptr),value :: a integer(c_int64_t),value :: stride_a type(c_ptr),value :: b integer(c_int64_t),value :: stride_b type(c_ptr),value :: c integer(c_int64_t),value :: stride_c type(c_ptr),value :: s integer(c_int64_t),value :: stride_s integer(c_int64_t),value :: batch_count end function end interface interface rocblas_drotg_strided_batched_64 function rocblas_drotg_strided_batched_64_(handle,a,stride_a,b,stride_b,c,stride_c,s,stride_s, & batch_count) & bind(c, name="rocblas_drotg_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotg_strided_batched_64_ type(c_ptr),value :: handle type(c_ptr),value :: a integer(c_int64_t),value :: stride_a type(c_ptr),value :: b integer(c_int64_t),value :: stride_b type(c_ptr),value :: c integer(c_int64_t),value :: stride_c type(c_ptr),value :: s integer(c_int64_t),value :: stride_s integer(c_int64_t),value :: batch_count end function end interface interface rocblas_crotg_strided_batched_64 function rocblas_crotg_strided_batched_64_(handle,a,stride_a,b,stride_b,c,stride_c,s,stride_s, & batch_count) & bind(c, name="rocblas_crotg_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_crotg_strided_batched_64_ type(c_ptr),value :: handle type(c_ptr),value :: a integer(c_int64_t),value :: stride_a type(c_ptr),value :: b integer(c_int64_t),value :: stride_b type(c_ptr),value :: c integer(c_int64_t),value :: stride_c type(c_ptr),value :: s integer(c_int64_t),value :: stride_s integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zrotg_strided_batched_64 function rocblas_zrotg_strided_batched_64_(handle,a,stride_a,b,stride_b,c,stride_c,s,stride_s, & batch_count) & bind(c, name="rocblas_zrotg_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zrotg_strided_batched_64_ type(c_ptr),value :: handle type(c_ptr),value :: a integer(c_int64_t),value :: stride_a type(c_ptr),value :: b integer(c_int64_t),value :: stride_b type(c_ptr),value :: c integer(c_int64_t),value :: stride_c type(c_ptr),value :: s integer(c_int64_t),value :: stride_s integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 1 API !> !> \details !> The rotm functions apply the modified Givens rotation matrix defined by ``param`` to !> vectors ``x`` and ``y``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> number of elements in the x and y vectors. !> @param[in, out] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment between elements of x. !> @param[in, out] y - device pointer storing vector y. !> @param[in] incy - [rocblas_int] !> specifies the increment between elements of y. !> @param[in] param - device vector or host vector of five elements defining the rotation. !> !> param[0] = flag !> param[1] = H11 !> param[2] = H21 !> param[3] = H12 !> param[4] = H22 !> !> The flag parameter defines the form of H: !> !> flag = -1 => H = ( H11 H12 H21 H22 ) !> flag = 0 => H = ( 1.0 H12 H21 1.0 ) !> flag = 1 => H = ( H11 1.0 -1.0 H22 ) !> flag = -2 => H = ( 1.0 0.0 0.0 1.0 ) !> !> param can be stored in either host or device memory. !> The location is specified by calling rocblas_set_pointer_mode. interface rocblas_srotm function rocblas_srotm_(handle,n,x,incx,y,incy,param) bind(c, name="rocblas_srotm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotm_ 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 type(c_ptr),value :: param end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_srotm_assumed_rank #else module procedure & rocblas_srotm_rank_0,& rocblas_srotm_rank_1 #endif #endif end interface interface rocblas_drotm function rocblas_drotm_(handle,n,x,incx,y,incy,param) bind(c, name="rocblas_drotm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotm_ 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 type(c_ptr),value :: param end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_drotm_assumed_rank #else module procedure & rocblas_drotm_rank_0,& rocblas_drotm_rank_1 #endif #endif end interface interface rocblas_srotm_64 function rocblas_srotm_64_(handle,n,x,incx,y,incy,param) bind(c, name="rocblas_srotm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotm_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: param end function end interface interface rocblas_drotm_64 function rocblas_drotm_64_(handle,n,x,incx,y,incy,param) bind(c, name="rocblas_drotm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotm_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: param end function end interface !> \brief BLAS Level 1 API !> !> \details !> The rotm_batched functions apply the modified Givens rotation matrix defined by ``param_i`` !> to batched vectors ``x_i`` and ``y_i``, for ``i`` = 1, ..., ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> number of elements in the x and y vectors. !> @param[in, out] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment between elements of each x_i. !> @param[in, out] y - device array of device pointers storing each vector y_1. !> @param[in] incy - [rocblas_int] !> specifies the increment between elements of each y_i. !> @param[in] param - device array of device vectors of five elements defining the rotation. !> !> param[0] = flag !> param[1] = H11 !> param[2] = H21 !> param[3] = H12 !> param[4] = H22 !> !> The flag parameter defines the form of H: !> !> flag = -1 => H = ( H11 H12 H21 H22 ) !> flag = 0 => H = ( 1.0 H12 H21 1.0 ) !> flag = 1 => H = ( H11 1.0 -1.0 H22 ) !> flag = -2 => H = ( 1.0 0.0 0.0 1.0 ) !> !> param can **only** be stored on the device for the batched version of this function. !> !> @param[in] batch_count - [rocblas_int] !> the number of x and y arrays, that is, the number of batches. interface rocblas_srotm_batched function rocblas_srotm_batched_(handle,n,x,incx,y,incy,param,batch_count) & bind(c, name="rocblas_srotm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotm_batched_ 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 type(c_ptr),value :: param integer(c_int),value :: batch_count end function end interface interface rocblas_drotm_batched function rocblas_drotm_batched_(handle,n,x,incx,y,incy,param,batch_count) & bind(c, name="rocblas_drotm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotm_batched_ 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 type(c_ptr),value :: param integer(c_int),value :: batch_count end function end interface interface rocblas_srotm_batched_64 function rocblas_srotm_batched_64_(handle,n,x,incx,y,incy,param,batch_count) & bind(c, name="rocblas_srotm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotm_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: param integer(c_int64_t),value :: batch_count end function end interface interface rocblas_drotm_batched_64 function rocblas_drotm_batched_64_(handle,n,x,incx,y,incy,param,batch_count) & bind(c, name="rocblas_drotm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotm_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: param integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 1 API !> !> \details !> The rotm_strided_batched functions apply the modified Givens rotation matrix defined by !> ``param_i`` to strided batched vectors ``x_i`` and ``y_i``, for ``i`` = 1, ..., !> ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> number of elements in the x and y vectors. !> @param[in, out] x - device pointer pointing to first strided batched vector x_1. !> @param[in] incx - [rocblas_int] !> specifies the increment between elements of each x_i. !> @param[in] stride_x - [rocblas_stride] !> specifies the increment between the beginning of x_i and x_(i + 1) !> @param[in, out] y - device pointer pointing to first strided batched vector y_1. !> @param[in] incy - [rocblas_int] !> specifies the increment between elements of each y_i. !> @param[in] stride_y - [rocblas_stride] !> specifies the increment between the beginning of y_i and y_(i + 1). !> @param[in] param - device pointer pointing to the first array of five elements defining the !> rotation (param_1). !> !> param[0] = flag !> param[1] = H11 !> param[2] = H21 !> param[3] = H12 !> param[4] = H22 !> !> The flag parameter defines the form of H: !> !> flag = -1 => H = ( H11 H12 H21 H22 ) !> flag = 0 => H = ( 1.0 H12 H21 1.0 ) !> flag = 1 => H = ( H11 1.0 -1.0 H22 ) !> flag = -2 => H = ( 1.0 0.0 0.0 1.0 ) !> !> param can **only** be stored on the device for the strided_batched !> version of this function. !> !> @param[in] stride_param - [rocblas_stride] !> specifies the increment between the beginning of param_i and param_(i + 1). !> @param[in] batch_count - [rocblas_int] !> the number of x and y arrays, that is, the number of batches. interface rocblas_srotm_strided_batched function rocblas_srotm_strided_batched_(handle,n,x,incx,stride_x,y,incy,stride_y,param, & stride_param,batch_count) & bind(c, name="rocblas_srotm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotm_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y type(c_ptr),value :: param integer(c_int64_t),value :: stride_param integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_srotm_strided_batched_assumed_rank #else module procedure & rocblas_srotm_strided_batched_rank_0,& rocblas_srotm_strided_batched_rank_1 #endif #endif end interface interface rocblas_drotm_strided_batched function rocblas_drotm_strided_batched_(handle,n,x,incx,stride_x,y,incy,stride_y,param, & stride_param,batch_count) & bind(c, name="rocblas_drotm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotm_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y type(c_ptr),value :: param integer(c_int64_t),value :: stride_param integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_drotm_strided_batched_assumed_rank #else module procedure & rocblas_drotm_strided_batched_rank_0,& rocblas_drotm_strided_batched_rank_1 #endif #endif end interface interface rocblas_srotm_strided_batched_64 function rocblas_srotm_strided_batched_64_(handle,n,x,incx,stride_x,y,incy,stride_y,param, & stride_param,batch_count) & bind(c, name="rocblas_srotm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotm_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y type(c_ptr),value :: param integer(c_int64_t),value :: stride_param integer(c_int64_t),value :: batch_count end function end interface interface rocblas_drotm_strided_batched_64 function rocblas_drotm_strided_batched_64_(handle,n,x,incx,stride_x,y,incy,stride_y,param, & stride_param,batch_count) & bind(c, name="rocblas_drotm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotm_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y type(c_ptr),value :: param integer(c_int64_t),value :: stride_param integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 1 API !> !> \details !> The rotmg functions create the modified Givens rotation matrix for the vector (``d1 * x1``, !> ``d2 * y1`` ). !> Parameters can be stored in either host or device memory. The location is specified !> by calling ``rocblas_set_pointer_mode``: !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in, out] d1 - device pointer or host pointer to input scalar that is overwritten. !> @param[in, out] d2 - device pointer or host pointer to input scalar that is overwritten. !> @param[in, out] x1 - device pointer or host pointer to input scalar that is overwritten. !> @param[in] y1 - device pointer or host pointer to input scalar. !> @param[out] param - device vector or host vector of five elements defining the rotation. !> !> param[0] = flag !> param[1] = H11 !> param[2] = H21 !> param[3] = H12 !> param[4] = H22 !> !> The flag parameter defines the form of H: !> !> flag = -1 => H = ( H11 H12 H21 H22 ) !> flag = 0 => H = ( 1.0 H12 H21 1.0 ) !> flag = 1 => H = ( H11 1.0 -1.0 H22 ) !> flag = -2 => H = ( 1.0 0.0 0.0 1.0 ) !> !> param can be stored in either host or device memory. !> The location is specified by calling rocblas_set_pointer_mode. interface rocblas_srotmg function rocblas_srotmg_(handle,d1,d2,x1,y1,param) bind(c, name="rocblas_srotmg") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotmg_ 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 end function end interface interface rocblas_drotmg function rocblas_drotmg_(handle,d1,d2,x1,y1,param) bind(c, name="rocblas_drotmg") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotmg_ 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 end function end interface interface rocblas_srotmg_64 function rocblas_srotmg_64_(handle,d1,d2,x1,y1,param) bind(c, name="rocblas_srotmg_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotmg_64_ 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 end function end interface interface rocblas_drotmg_64 function rocblas_drotmg_64_(handle,d1,d2,x1,y1,param) bind(c, name="rocblas_drotmg_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotmg_64_ 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 end function end interface !> \brief BLAS Level 1 API !> !> \details !> The rotmg_batched functions create the modified Givens rotation matrix for the batched !> vectors (``d1_i * x1_i``, ``d2_i * y1_i`` ), for ``i`` = 1, ..., ``batch_count``. !> Parameters can be stored in either host or device memory. The location is specified !> by calling ``rocblas_set_pointer_mode``: !> !> - If the pointer mode is set to ``rocblas_pointer_mode_host``, then this function blocks !> the CPU until the GPU has finished and the results are available in host memory. !> - If the pointer mode is set to ``rocblas_pointer_mode_device``, then this function returns !> immediately and synchronization is required to read the results. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in, out] d1 - device batched array or host batched array of input scalars that is !> overwritten. !> @param[in, out] d2 - device batched array or host batched array of input scalars that is !> overwritten. !> @param[in, out] x1 - device batched array or host batched array of input scalars that is !> overwritten. !> @param[in] y1 - device batched array or host batched array of input scalars. !> @param[out] param - device batched array or host batched array of vectors of five elements !> defining the rotation. !> !> param[0] = flag !> param[1] = H11 !> param[2] = H21 !> param[3] = H12 !> param[4] = H22 !> !> The flag parameter defines the form of H: !> !> flag = -1 => H = ( H11 H12 H21 H22 ) !> flag = 0 => H = ( 1.0 H12 H21 1.0 ) !> flag = 1 => H = ( H11 1.0 -1.0 H22 ) !> flag = -2 => H = ( 1.0 0.0 0.0 1.0 ) !> !> param can be stored in either host or device memory. !> The location is specified by calling rocblas_set_pointer_mode. !> !> @param[in] batch_count - [rocblas_int] !> the number of instances in the batch. interface rocblas_srotmg_batched function rocblas_srotmg_batched_(handle,d1,d2,x1,y1,param,batch_count) & bind(c, name="rocblas_srotmg_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotmg_batched_ 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),value :: batch_count end function end interface interface rocblas_drotmg_batched function rocblas_drotmg_batched_(handle,d1,d2,x1,y1,param,batch_count) & bind(c, name="rocblas_drotmg_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotmg_batched_ 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),value :: batch_count end function end interface interface rocblas_srotmg_batched_64 function rocblas_srotmg_batched_64_(handle,d1,d2,x1,y1,param,batch_count) & bind(c, name="rocblas_srotmg_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotmg_batched_64_ 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_int64_t),value :: batch_count end function end interface interface rocblas_drotmg_batched_64 function rocblas_drotmg_batched_64_(handle,d1,d2,x1,y1,param,batch_count) & bind(c, name="rocblas_drotmg_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotmg_batched_64_ 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_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 1 API !> !> \details !> The rotmg_strided_batched functions create the modified Givens rotation matrix for the !> strided batched vectors (``d1_i * x1_i``, ``d2_i * y1_i`` ), for ``i`` = 1, ..., !> ``batch_count``. !> Parameters can be stored in either host or device memory. The location is specified !> by calling ``rocblas_set_pointer_mode``: !> !> - If the pointer mode is set to ``rocblas_pointer_mode_host``, then this function blocks !> the CPU until the GPU has finished and the results are available in host memory. !> - If the pointer mode is set to ``rocblas_pointer_mode_device``, then this function returns !> immediately and synchronization is required to read the results. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in, out] d1 - device strided_batched array or host strided_batched array of input !> scalars that is overwritten. !> @param[in] stride_d1 - [rocblas_stride] !> specifies the increment between the beginning of d1_i and d1_(i+1). !> @param[in, out] d2 - device strided_batched array or host strided_batched array of input !> scalars that is overwritten. !> @param[in] stride_d2 - [rocblas_stride] !> specifies the increment between the beginning of d2_i and d2_(i+1). !> @param[in, out] x1 - device strided_batched array or host strided_batched array of input !> scalars that is overwritten. !> @param[in] stride_x1 - [rocblas_stride] !> specifies the increment between the beginning of x1_i and x1_(i+1). !> @param[in] y1 - device strided_batched array or host strided_batched array of input !> scalars. !> @param[in] stride_y1 - [rocblas_stride] !> specifies the increment between the beginning of y1_i and y1_(i+1). !> @param[out] param - device strided_batched array or host strided_batched array of vectors !> of five elements defining the rotation. !> !> param[0] = flag !> param[1] = H11 !> param[2] = H21 !> param[3] = H12 !> param[4] = H22 !> !> The flag parameter defines the form of H: !> !> flag = -1 => H = ( H11 H12 H21 H22 ) !> flag = 0 => H = ( 1.0 H12 H21 1.0 ) !> flag = 1 => H = ( H11 1.0 -1.0 H22 ) !> flag = -2 => H = ( 1.0 0.0 0.0 1.0 ) !> !> param can be stored in either host or device memory. !> The location is specified by calling rocblas_set_pointer_mode. !> !> @param[in] stride_param - [rocblas_stride] !> specifies the increment between the beginning of param_i and param_(i + 1). !> @param[in] batch_count - [rocblas_int] !> the number of instances in the batch. interface rocblas_srotmg_strided_batched function rocblas_srotmg_strided_batched_(handle,d1,stride_d1,d2,stride_d2,x1,stride_x1,y1, & stride_y1,param,stride_param,batch_count) & bind(c, name="rocblas_srotmg_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotmg_strided_batched_ type(c_ptr),value :: handle type(c_ptr),value :: d1 integer(c_int64_t),value :: stride_d1 type(c_ptr),value :: d2 integer(c_int64_t),value :: stride_d2 type(c_ptr),value :: x1 integer(c_int64_t),value :: stride_x1 type(c_ptr),value :: y1 integer(c_int64_t),value :: stride_y1 type(c_ptr),value :: param integer(c_int64_t),value :: stride_param integer(c_int),value :: batch_count end function end interface interface rocblas_drotmg_strided_batched function rocblas_drotmg_strided_batched_(handle,d1,stride_d1,d2,stride_d2,x1,stride_x1,y1, & stride_y1,param,stride_param,batch_count) & bind(c, name="rocblas_drotmg_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotmg_strided_batched_ type(c_ptr),value :: handle type(c_ptr),value :: d1 integer(c_int64_t),value :: stride_d1 type(c_ptr),value :: d2 integer(c_int64_t),value :: stride_d2 type(c_ptr),value :: x1 integer(c_int64_t),value :: stride_x1 type(c_ptr),value :: y1 integer(c_int64_t),value :: stride_y1 type(c_ptr),value :: param integer(c_int64_t),value :: stride_param integer(c_int),value :: batch_count end function end interface interface rocblas_srotmg_strided_batched_64 function rocblas_srotmg_strided_batched_64_(handle,d1,stride_d1,d2,stride_d2,x1,stride_x1,y1, & stride_y1,param,stride_param,batch_count) & bind(c, name="rocblas_srotmg_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotmg_strided_batched_64_ type(c_ptr),value :: handle type(c_ptr),value :: d1 integer(c_int64_t),value :: stride_d1 type(c_ptr),value :: d2 integer(c_int64_t),value :: stride_d2 type(c_ptr),value :: x1 integer(c_int64_t),value :: stride_x1 type(c_ptr),value :: y1 integer(c_int64_t),value :: stride_y1 type(c_ptr),value :: param integer(c_int64_t),value :: stride_param integer(c_int64_t),value :: batch_count end function end interface interface rocblas_drotmg_strided_batched_64 function rocblas_drotmg_strided_batched_64_(handle,d1,stride_d1,d2,stride_d2,x1,stride_x1,y1, & stride_y1,param,stride_param,batch_count) & bind(c, name="rocblas_drotmg_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotmg_strided_batched_64_ type(c_ptr),value :: handle type(c_ptr),value :: d1 integer(c_int64_t),value :: stride_d1 type(c_ptr),value :: d2 integer(c_int64_t),value :: stride_d2 type(c_ptr),value :: x1 integer(c_int64_t),value :: stride_x1 type(c_ptr),value :: y1 integer(c_int64_t),value :: stride_y1 type(c_ptr),value :: param integer(c_int64_t),value :: stride_param integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The gbmv functions perform one of the following matrix-vector operations: !> !> y := alpha*A*x + beta*y, or !> y := alpha*A**T*x + beta*y, or !> y := alpha*A**H*x + beta*y, !> !> where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are vectors, and ``A`` is an !> ``m`` by ``n`` banded matrix with ``kl`` sub-diagonals and ``ku`` super-diagonals. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] trans - [rocblas_operation] !> indicates whether matrix A is tranposed (conjugated) or not. !> @param[in] m - [rocblas_int] !> number of rows of matrix A. !> @param[in] n - [rocblas_int] !> number of columns of matrix A. !> @param[in] kl - [rocblas_int] !> number of sub-diagonals of A. !> @param[in] ku - [rocblas_int] !> number of super-diagonals of A. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] A - device pointer storing banded matrix A. !> The leading (kl + ku + 1) by n part of the matrix contains the coefficients !> of the banded matrix. The leading diagonal resides in row (ku + 1) with !> the first super-diagonal above on the RHS of row ku. The first sub-diagonal !> resides below on the LHS of row ku + 2. This propagates up and down across !> sub/super-diagonals. !> !> Ex: (m = n = 7; ku = 2, kl = 2) !> 1 2 3 0 0 0 0 0 0 3 3 3 3 3 !> 4 1 2 3 0 0 0 0 2 2 2 2 2 2 !> 5 4 1 2 3 0 0 ----> 1 1 1 1 1 1 1 !> 0 5 4 1 2 3 0 4 4 4 4 4 4 0 !> 0 0 5 4 1 2 3 5 5 5 5 5 0 0 !> 0 0 0 5 4 1 2 0 0 0 0 0 0 0 !> 0 0 0 0 5 4 1 0 0 0 0 0 0 0 !> !> Note that empty elements that do not correspond to data will not !> be referenced. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. Must be >= (kl + ku + 1). !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[in, out] y - device pointer storing vector y. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. interface rocblas_sgbmv function rocblas_sgbmv_(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_sgbmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgbmv_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sgbmv_assumed_rank #else module procedure & rocblas_sgbmv_rank_0,& rocblas_sgbmv_rank_1,& rocblas_sgbmv_full_rank #endif #endif end interface interface rocblas_dgbmv function rocblas_dgbmv_(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_dgbmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgbmv_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dgbmv_assumed_rank #else module procedure & rocblas_dgbmv_rank_0,& rocblas_dgbmv_rank_1,& rocblas_dgbmv_full_rank #endif #endif end interface interface rocblas_cgbmv function rocblas_cgbmv_(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_cgbmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgbmv_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cgbmv_assumed_rank #else module procedure & rocblas_cgbmv_rank_0,& rocblas_cgbmv_rank_1,& rocblas_cgbmv_full_rank #endif #endif end interface interface rocblas_zgbmv function rocblas_zgbmv_(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_zgbmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgbmv_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zgbmv_assumed_rank #else module procedure & rocblas_zgbmv_rank_0,& rocblas_zgbmv_rank_1,& rocblas_zgbmv_full_rank #endif #endif end interface interface rocblas_sgbmv_64 function rocblas_sgbmv_64_(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_sgbmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgbmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_dgbmv_64 function rocblas_dgbmv_64_(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_dgbmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgbmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_cgbmv_64 function rocblas_cgbmv_64_(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_cgbmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgbmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_zgbmv_64 function rocblas_zgbmv_64_(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_zgbmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgbmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 2 API !> !> \details !> The gbmv_batched functions perform one of the matrix-vector operations: !> !> y_i := alpha*A_i*x_i + beta*y_i, or !> y_i := alpha*A_i**T*x_i + beta*y_i, or !> y_i := alpha*A_i**H*x_i + beta*y_i, !> !> where (``A_i``, ``x_i``, ``y_i``) is the i-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``m`` by ``n`` banded matrix with ``kl`` sub-diagonals and ``ku`` super-diagonals, !> for ``i`` = 1, ..., ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] trans - [rocblas_operation] !> indicates whether matrix A is tranposed (conjugated) or not. !> @param[in] m - [rocblas_int] !> number of rows of each matrix A_i. !> @param[in] n - [rocblas_int] !> number of columns of each matrix A_i. !> @param[in] kl - [rocblas_int] !> number of sub-diagonals of each A_i. !> @param[in] ku - [rocblas_int] !> number of super-diagonals of each A_i. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] A - device array of device pointers storing each banded matrix A_i. !> The leading (kl + ku + 1) by n part of the matrix contains the coefficients !> of the banded matrix. The leading diagonal resides in row (ku + 1) with !> the first super-diagonal above on the RHS of row ku. The first sub-diagonal !> resides below on the LHS of row ku + 2. This propagates up and down across !> sub/super-diagonals. !> !> Ex: (m = n = 7; ku = 2, kl = 2) !> 1 2 3 0 0 0 0 0 0 3 3 3 3 3 !> 4 1 2 3 0 0 0 0 2 2 2 2 2 2 !> 5 4 1 2 3 0 0 ----> 1 1 1 1 1 1 1 !> 0 5 4 1 2 3 0 4 4 4 4 4 4 0 !> 0 0 5 4 1 2 3 5 5 5 5 5 0 0 !> 0 0 0 5 4 1 2 0 0 0 0 0 0 0 !> 0 0 0 0 5 4 1 0 0 0 0 0 0 0 !> !> Note that empty elements that do not correspond to data will not !> be referenced. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. Must be >= (kl + ku + 1) !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[in, out] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each y_i. !> @param[in] batch_count - [rocblas_int] !> specifies the number of instances in the batch. interface rocblas_sgbmv_batched function rocblas_sgbmv_batched_(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy, & batch_count) & bind(c, name="rocblas_sgbmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgbmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_dgbmv_batched function rocblas_dgbmv_batched_(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy, & batch_count) & bind(c, name="rocblas_dgbmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgbmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_cgbmv_batched function rocblas_cgbmv_batched_(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy, & batch_count) & bind(c, name="rocblas_cgbmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgbmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_zgbmv_batched function rocblas_zgbmv_batched_(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy, & batch_count) & bind(c, name="rocblas_zgbmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgbmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_sgbmv_batched_64 function rocblas_sgbmv_batched_64_(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy, & batch_count) & bind(c, name="rocblas_sgbmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgbmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dgbmv_batched_64 function rocblas_dgbmv_batched_64_(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy, & batch_count) & bind(c, name="rocblas_dgbmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgbmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cgbmv_batched_64 function rocblas_cgbmv_batched_64_(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy, & batch_count) & bind(c, name="rocblas_cgbmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgbmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zgbmv_batched_64 function rocblas_zgbmv_batched_64_(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy, & batch_count) & bind(c, name="rocblas_zgbmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgbmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The gbmv_strided_batched functions perform one of the matrix-vector operations: !> !> y_i := alpha*A_i*x_i + beta*y_i, or !> y_i := alpha*A_i**T*x_i + beta*y_i, or !> y_i := alpha*A_i**H*x_i + beta*y_i, !> !> where (``A_i``, ``x_i``, ``y_i``) is the i-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``m`` by ``n`` banded matrix with ``kl`` sub-diagonals and ``ku`` super-diagonals, !> for ``i`` = 1, ..., ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] trans - [rocblas_operation] !> indicates whether matrix A is tranposed (conjugated) or not. !> @param[in] m - [rocblas_int] !> number of rows of matrix A. !> @param[in] n - [rocblas_int] !> number of columns of matrix A. !> @param[in] kl - [rocblas_int] !> number of sub-diagonals of A. !> @param[in] ku - [rocblas_int] !> number of super-diagonals of A. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] A - device pointer to first banded matrix (A_1). !> The leading (kl + ku + 1) by n part of the matrix contains the coefficients !> of the banded matrix. The leading diagonal resides in row (ku + 1) with !> the first super-diagonal above on the RHS of row ku. The first sub-diagonal !> resides below on the LHS of row ku + 2. This propagates up and down across !> sub/super-diagonals. !> !> Ex: (m = n = 7; ku = 2, kl = 2) !> 1 2 3 0 0 0 0 0 0 3 3 3 3 3 !> 4 1 2 3 0 0 0 0 2 2 2 2 2 2 !> 5 4 1 2 3 0 0 ----> 1 1 1 1 1 1 1 !> 0 5 4 1 2 3 0 4 4 4 4 4 4 0 !> 0 0 5 4 1 2 3 5 5 5 5 5 0 0 !> 0 0 0 5 4 1 2 0 0 0 0 0 0 0 !> 0 0 0 0 5 4 1 0 0 0 0 0 0 0 !> !> Note that empty elements that do not correspond to data will not !> be referenced. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. Must be >= (kl + ku + 1). !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> @param[in] x - device pointer to first vector (x_1). !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in] stride_x - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[in, out] y - device pointer to first vector (y_1). !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in] stride_y - [rocblas_stride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> @param[in] batch_count - [rocblas_int] !> specifies the number of instances in the batch. interface rocblas_sgbmv_strided_batched function rocblas_sgbmv_strided_batched_(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) & bind(c, name="rocblas_sgbmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgbmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sgbmv_strided_batched_assumed_rank #else module procedure & rocblas_sgbmv_strided_batched_rank_0,& rocblas_sgbmv_strided_batched_rank_1,& rocblas_sgbmv_strided_batched_full_rank #endif #endif end interface interface rocblas_dgbmv_strided_batched function rocblas_dgbmv_strided_batched_(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) & bind(c, name="rocblas_dgbmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgbmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dgbmv_strided_batched_assumed_rank #else module procedure & rocblas_dgbmv_strided_batched_rank_0,& rocblas_dgbmv_strided_batched_rank_1,& rocblas_dgbmv_strided_batched_full_rank #endif #endif end interface interface rocblas_cgbmv_strided_batched function rocblas_cgbmv_strided_batched_(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) & bind(c, name="rocblas_cgbmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgbmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cgbmv_strided_batched_assumed_rank #else module procedure & rocblas_cgbmv_strided_batched_rank_0,& rocblas_cgbmv_strided_batched_rank_1,& rocblas_cgbmv_strided_batched_full_rank #endif #endif end interface interface rocblas_zgbmv_strided_batched function rocblas_zgbmv_strided_batched_(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) & bind(c, name="rocblas_zgbmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgbmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: kl integer(c_int),value :: ku complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zgbmv_strided_batched_assumed_rank #else module procedure & rocblas_zgbmv_strided_batched_rank_0,& rocblas_zgbmv_strided_batched_rank_1,& rocblas_zgbmv_strided_batched_full_rank #endif #endif end interface interface rocblas_sgbmv_strided_batched_64 function rocblas_sgbmv_strided_batched_64_(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) & bind(c, name="rocblas_sgbmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgbmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dgbmv_strided_batched_64 function rocblas_dgbmv_strided_batched_64_(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) & bind(c, name="rocblas_dgbmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgbmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cgbmv_strided_batched_64 function rocblas_cgbmv_strided_batched_64_(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) & bind(c, name="rocblas_cgbmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgbmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zgbmv_strided_batched_64 function rocblas_zgbmv_strided_batched_64_(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) & bind(c, name="rocblas_zgbmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgbmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: kl integer(c_int64_t),value :: ku complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The gemv functions perform one of the matrix-vector operations: !> !> y := alpha*A*x + beta*y, or !> y := alpha*A**T*x + beta*y, or !> y := alpha*A**H*x + beta*y, !> !> where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are vectors, and ``A`` is an !> ``m`` by ``n`` matrix. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] trans - [rocblas_operation] !> indicates whether matrix A is tranposed (conjugated) or not. !> @param[in] m - [rocblas_int] !> number of rows of matrix A. !> @param[in] n - [rocblas_int] !> number of columns of matrix A. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] A - device pointer storing matrix A. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[in, out] y - device pointer storing vector y. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. interface rocblas_sgemv function rocblas_sgemv_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_sgemv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemv_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sgemv_assumed_rank #else module procedure & rocblas_sgemv_rank_0,& rocblas_sgemv_rank_1,& rocblas_sgemv_full_rank #endif #endif end interface interface rocblas_dgemv function rocblas_dgemv_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_dgemv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemv_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dgemv_assumed_rank #else module procedure & rocblas_dgemv_rank_0,& rocblas_dgemv_rank_1,& rocblas_dgemv_full_rank #endif #endif end interface interface rocblas_cgemv function rocblas_cgemv_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_cgemv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemv_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cgemv_assumed_rank #else module procedure & rocblas_cgemv_rank_0,& rocblas_cgemv_rank_1,& rocblas_cgemv_full_rank #endif #endif end interface interface rocblas_zgemv function rocblas_zgemv_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_zgemv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemv_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zgemv_assumed_rank #else module procedure & rocblas_zgemv_rank_0,& rocblas_zgemv_rank_1,& rocblas_zgemv_full_rank #endif #endif end interface interface rocblas_sgemv_64 function rocblas_sgemv_64_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_sgemv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemv_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_dgemv_64 function rocblas_dgemv_64_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_dgemv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemv_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_cgemv_64 function rocblas_cgemv_64_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_cgemv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemv_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_zgemv_64 function rocblas_zgemv_64_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_zgemv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemv_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 2 API !> !> \details !> The gemv_batched functions perform a batch of matrix-vector operations: !> !> y_i := alpha*A_i*x_i + beta*y_i, or !> y_i := alpha*A_i**T*x_i + beta*y_i, or !> y_i := alpha*A_i**H*x_i + beta*y_i, !> !> where (``A_i``, ``x_i``, ``y_i``) is the i-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``m`` by ``n`` matrix, for ``i`` = 1, ..., ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] trans - [rocblas_operation] !> indicates whether matrices A_i are tranposed (conjugated) or not. !> @param[in] m - [rocblas_int] !> number of rows of each matrix A_i. !> @param[in] n - [rocblas_int] !> number of columns of each matrix A_i. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] A - device array of device pointers storing each matrix A_i. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each matrix A_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each vector x_i. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[in, out] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each vector y_i. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_sgemv_batched function rocblas_sgemv_batched_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_sgemv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_dgemv_batched function rocblas_dgemv_batched_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_dgemv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_cgemv_batched function rocblas_cgemv_batched_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_cgemv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_zgemv_batched function rocblas_zgemv_batched_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_zgemv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_hshgemv_batched function rocblas_hshgemv_batched_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_hshgemv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hshgemv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_hssgemv_batched function rocblas_hssgemv_batched_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_hssgemv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hssgemv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_tstgemv_batched function rocblas_tstgemv_batched_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_tstgemv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_tstgemv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_tssgemv_batched function rocblas_tssgemv_batched_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_tssgemv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_tssgemv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_sgemv_batched_64 function rocblas_sgemv_batched_64_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy, & batch_count) & bind(c, name="rocblas_sgemv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dgemv_batched_64 function rocblas_dgemv_batched_64_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy, & batch_count) & bind(c, name="rocblas_dgemv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cgemv_batched_64 function rocblas_cgemv_batched_64_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy, & batch_count) & bind(c, name="rocblas_cgemv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zgemv_batched_64 function rocblas_zgemv_batched_64_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy, & batch_count) & bind(c, name="rocblas_zgemv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_hshgemv_batched_64 function rocblas_hshgemv_batched_64_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy, & batch_count) & bind(c, name="rocblas_hshgemv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hshgemv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_hssgemv_batched_64 function rocblas_hssgemv_batched_64_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy, & batch_count) & bind(c, name="rocblas_hssgemv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hssgemv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_tstgemv_batched_64 function rocblas_tstgemv_batched_64_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy, & batch_count) & bind(c, name="rocblas_tstgemv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_tstgemv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_tssgemv_batched_64 function rocblas_tssgemv_batched_64_(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy, & batch_count) & bind(c, name="rocblas_tssgemv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_tssgemv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The gemv_strided_batched functions perform a batch of matrix-vector operations: !> !> y_i := alpha*A_i*x_i + beta*y_i, or !> y_i := alpha*A_i**T*x_i + beta*y_i, or !> y_i := alpha*A_i**H*x_i + beta*y_i, !> !> where (``A_i``, ``x_i``, ``y_i``) is the i-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``m`` by ``n`` matrix, for ``i`` = 1, ..., ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] transA - [rocblas_operation] !> indicates whether matrices A_i are tranposed (conjugated) or not. !> @param[in] m - [rocblas_int] !> number of rows of matrices A_i. !> @param[in] n - [rocblas_int] !> number of columns of matrices A_i. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] A - device pointer to the first matrix (A_1) in the batch. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of matrices A_i. !> @param[in] strideA - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> @param[in] x - device pointer to the first vector (x_1) in the batch. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of vectors x_i. !> @param[in] stridex - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stride_x. However, ensure that stride_x is !> of an appropriate size. When trans equals rocblas_operation_none, !> this typically means stride_x >= n * incx. Otherwise, stride_x >= m * incx. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[in, out] y - device pointer to the first vector (y_1) in the batch. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of vectors y_i. !> @param[in] stridey - [rocblas_stride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> There are no restrictions placed on stride_y. However, ensure that stride_y is !> of an appropriate size. When trans equals rocblas_operation_none, !> this typically means stride_y >= m * incy. Otherwise, stride_y >= n * incy. !> stridey should be non zero. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_sgemv_strided_batched function rocblas_sgemv_strided_batched_(handle,transA,m,n,alpha,A,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_sgemv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sgemv_strided_batched_assumed_rank #else module procedure & rocblas_sgemv_strided_batched_rank_0,& rocblas_sgemv_strided_batched_rank_1,& rocblas_sgemv_strided_batched_full_rank #endif #endif end interface interface rocblas_dgemv_strided_batched function rocblas_dgemv_strided_batched_(handle,transA,m,n,alpha,A,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_dgemv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dgemv_strided_batched_assumed_rank #else module procedure & rocblas_dgemv_strided_batched_rank_0,& rocblas_dgemv_strided_batched_rank_1,& rocblas_dgemv_strided_batched_full_rank #endif #endif end interface interface rocblas_cgemv_strided_batched function rocblas_cgemv_strided_batched_(handle,transA,m,n,alpha,A,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_cgemv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cgemv_strided_batched_assumed_rank #else module procedure & rocblas_cgemv_strided_batched_rank_0,& rocblas_cgemv_strided_batched_rank_1,& rocblas_cgemv_strided_batched_full_rank #endif #endif end interface interface rocblas_zgemv_strided_batched function rocblas_zgemv_strided_batched_(handle,transA,m,n,alpha,A,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_zgemv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zgemv_strided_batched_assumed_rank #else module procedure & rocblas_zgemv_strided_batched_rank_0,& rocblas_zgemv_strided_batched_rank_1,& rocblas_zgemv_strided_batched_full_rank #endif #endif end interface interface rocblas_hshgemv_strided_batched function rocblas_hshgemv_strided_batched_(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_hshgemv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hshgemv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function end interface interface rocblas_hssgemv_strided_batched function rocblas_hssgemv_strided_batched_(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_hssgemv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hssgemv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function end interface interface rocblas_tstgemv_strided_batched function rocblas_tstgemv_strided_batched_(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_tstgemv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_tstgemv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function end interface interface rocblas_tssgemv_strided_batched function rocblas_tssgemv_strided_batched_(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_tssgemv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_tssgemv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function end interface interface rocblas_sgemv_strided_batched_64 function rocblas_sgemv_strided_batched_64_(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_sgemv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dgemv_strided_batched_64 function rocblas_dgemv_strided_batched_64_(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_dgemv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cgemv_strided_batched_64 function rocblas_cgemv_strided_batched_64_(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_cgemv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zgemv_strided_batched_64 function rocblas_zgemv_strided_batched_64_(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_zgemv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_hshgemv_strided_batched_64 function rocblas_hshgemv_strided_batched_64_(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_hshgemv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hshgemv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_hssgemv_strided_batched_64 function rocblas_hssgemv_strided_batched_64_(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_hssgemv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hssgemv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_tstgemv_strided_batched_64 function rocblas_tstgemv_strided_batched_64_(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_tstgemv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_tstgemv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_tssgemv_strided_batched_64 function rocblas_tssgemv_strided_batched_64_(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_tssgemv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_tssgemv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hbmv functions perform the matrix-vector operations: !> !> y := alpha*A*x + beta*y !> !> where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are ``n`` -element vectors, and !> ``A`` is an !> ``n`` by ``n`` Hermitian band matrix, with ``k`` super-diagonals. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: The upper triangular part of A is being supplied. !> - rocblas_fill_lower: The lower triangular part of A is being supplied. !> @param[in] n - [rocblas_int] !> the order of the matrix A. !> @param[in] k - [rocblas_int] !> the number of super-diagonals of the matrix A. Must be >= 0. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] A - device pointer storing matrix A. Of dimension (lda, n). !> !> if uplo == rocblas_fill_upper: !> The leading (k + 1) by n part of A must contain the upper !> triangular band part of the Hermitian matrix, with the leading !> diagonal in row (k + 1), the first super-diagonal on the RHS !> of row k, and so forth. !> The top left k by x triangle of A will not be referenced. !> Ex (upper, lda = n = 4, k = 1): !> A Represented matrix !> (0,0) (5,9) (6,8) (7,7) (1, 0) (5, 9) (0, 0) (0, 0) !> (1,0) (2,0) (3,0) (4,0) (5,-9) (2, 0) (6, 8) (0, 0) !> (0,0) (0,0) (0,0) (0,0) (0, 0) (6,-8) (3, 0) (7, 7) !> (0,0) (0,0) (0,0) (0,0) (0, 0) (0, 0) (7,-7) (4, 0) !> !> if uplo == rocblas_fill_lower: !> The leading (k + 1) by n part of A must contain the lower !> triangular band part of the Hermitian matrix, with the leading !> diagonal in row (1), the first sub-diagonal on the LHS of !> row 2, and so forth. !> The bottom right k by k triangle of A will not be referenced. !> Ex (lower, lda = 2, n = 4, k = 1): !> A Represented matrix !> (1,0) (2,0) (3,0) (4,0) (1, 0) (5,-9) (0, 0) (0, 0) !> (5,9) (6,8) (7,7) (0,0) (5, 9) (2, 0) (6,-8) (0, 0) !> (0, 0) (6, 8) (3, 0) (7,-7) !> (0, 0) (0, 0) (7, 7) (4, 0) !> !> As a Hermitian matrix, the imaginary part of the main diagonal !> of A will not be referenced and is assumed to be == 0. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. Must be >= k + 1. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[in, out] y - device pointer storing vector y. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. interface rocblas_chbmv function rocblas_chbmv_(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_chbmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chbmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_chbmv_assumed_rank #else module procedure & rocblas_chbmv_rank_0,& rocblas_chbmv_rank_1,& rocblas_chbmv_full_rank #endif #endif end interface interface rocblas_zhbmv function rocblas_zhbmv_(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_zhbmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhbmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zhbmv_assumed_rank #else module procedure & rocblas_zhbmv_rank_0,& rocblas_zhbmv_rank_1,& rocblas_zhbmv_full_rank #endif #endif end interface interface rocblas_chbmv_64 function rocblas_chbmv_64_(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_chbmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chbmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_zhbmv_64 function rocblas_zhbmv_64_(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_zhbmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhbmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hbmv_batched functions perform one of the matrix-vector operations: !> !> y_i := alpha*A_i*x_i + beta*y_i !> !> where ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are ``n`` -element vectors, !> and ``A_i`` is an !> ``n`` by ``n`` Hermitian band matrix with ``k`` super-diagonals, for each batch in !> ``i = [1, batch_count`` ]. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: The upper triangular part of each A_i is being supplied. !> - rocblas_fill_lower: The lower triangular part of each A_i is being supplied. !> @param[in] n - [rocblas_int] !> the order of each matrix A_i. !> @param[in] k - [rocblas_int] !> the number of super-diagonals of each matrix A_i. Must be >= 0. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] A - device array of device pointers storing each matrix A_i of dimension (lda, !> n). !> !> if uplo == rocblas_fill_upper: !> The leading (k + 1) by n part of each A_i must contain the upper !> triangular band part of the Hermitian matrix, with the leading !> diagonal in row (k + 1), the first super-diagonal on the RHS !> of row k, and so forth. !> The top left k by x triangle of each A_i will not be referenced. !> Ex (upper, lda = n = 4, k = 1): !> A Represented matrix !> (0,0) (5,9) (6,8) (7,7) (1, 0) (5, 9) (0, 0) (0, 0) !> (1,0) (2,0) (3,0) (4,0) (5,-9) (2, 0) (6, 8) (0, 0) !> (0,0) (0,0) (0,0) (0,0) (0, 0) (6,-8) (3, 0) (7, 7) !> (0,0) (0,0) (0,0) (0,0) (0, 0) (0, 0) (7,-7) (4, 0) !> !> if uplo == rocblas_fill_lower: !> The leading (k + 1) by n part of each A_i must contain the lower !> triangular band part of the Hermitian matrix, with the leading !> diagonal in row (1), the first sub-diagonal on the LHS of !> row 2, and so forth. !> The bottom right k by k triangle of each A_i will not be referenced. !> Ex (lower, lda = 2, n = 4, k = 1): !> A Represented matrix !> (1,0) (2,0) (3,0) (4,0) (1, 0) (5,-9) (0, 0) (0, 0) !> (5,9) (6,8) (7,7) (0,0) (5, 9) (2, 0) (6,-8) (0, 0) !> (0, 0) (6, 8) (3, 0) (7,-7) !> (0, 0) (0, 0) (7, 7) (4, 0) !> !> As a Hermitian matrix, the imaginary part of the main diagonal !> of each A_i will not be referenced and is assumed to be == 0. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. Must be >= max(1, n). !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[in, out] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_chbmv_batched function rocblas_chbmv_batched_(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_chbmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chbmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_zhbmv_batched function rocblas_zhbmv_batched_(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_zhbmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhbmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_chbmv_batched_64 function rocblas_chbmv_batched_64_(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_chbmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chbmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zhbmv_batched_64 function rocblas_zhbmv_batched_64_(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_zhbmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhbmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hbmv_strided_batched functions perform one of the matrix-vector operations: !> !> y_i := alpha*A_i*x_i + beta*y_i !> !> where ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are ``n`` -element vectors, !> and ``A_i`` is an !> ``n`` by ``n`` Hermitian band matrix with ``k`` super-diagonals, for each batch in !> ``i = [1, batch_count`` ]. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: The upper triangular part of each A_i is being supplied. !> - rocblas_fill_lower: The lower triangular part of each A_i is being supplied. !> @param[in] n - [rocblas_int] !> the order of each matrix A_i. !> @param[in] k - [rocblas_int] !> the number of super-diagonals of each matrix A_i. Must be >= 0. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] A - device array pointing to the first matrix A_1. Each A_i is of dimension !> (lda, n). !> !> if uplo == rocblas_fill_upper: !> The leading (k + 1) by n part of each A_i must contain the upper !> triangular band part of the Hermitian matrix, with the leading !> diagonal in row (k + 1), the first super-diagonal on the RHS !> of row k, and so forth. !> The top left k by x triangle of each A_i will not be referenced. !> Ex (upper, lda = n = 4, k = 1): !> A Represented matrix !> (0,0) (5,9) (6,8) (7,7) (1, 0) (5, 9) (0, 0) (0, 0) !> (1,0) (2,0) (3,0) (4,0) (5,-9) (2, 0) (6, 8) (0, 0) !> (0,0) (0,0) (0,0) (0,0) (0, 0) (6,-8) (3, 0) (7, 7) !> (0,0) (0,0) (0,0) (0,0) (0, 0) (0, 0) (7,-7) (4, 0) !> !> if uplo == rocblas_fill_lower: !> The leading (k + 1) by n part of each A_i must contain the lower !> triangular band part of the Hermitian matrix, with the leading !> diagonal in row (1), the first sub-diagonal on the LHS of !> row 2, and so forth. !> The bottom right k by k triangle of each A_i will not be referenced. !> Ex (lower, lda = 2, n = 4, k = 1): !> A Represented matrix !> (1,0) (2,0) (3,0) (4,0) (1, 0) (5,-9) (0, 0) (0, 0) !> (5,9) (6,8) (7,7) (0,0) (5, 9) (2, 0) (6,-8) (0, 0) !> (0, 0) (6, 8) (3, 0) (7,-7) !> (0, 0) (0, 0) (7, 7) (4, 0) !> !> As a Hermitian matrix, the imaginary part of the main diagonal !> of each A_i will not be referenced and is assumed to be == 0. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. Must be >= max(1, n). !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> @param[in] x - device array pointing to the first vector y_1. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] stride_x - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[in, out] y - device array pointing to the first vector y_1. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in] stride_y - [rocblas_stride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_chbmv_strided_batched function rocblas_chbmv_strided_batched_(handle,uplo,n,k,alpha,A,lda,stride_A,x,incx,stride_x, & beta,y,incy,stride_y,batch_count) & bind(c, name="rocblas_chbmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chbmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_chbmv_strided_batched_assumed_rank #else module procedure & rocblas_chbmv_strided_batched_rank_0,& rocblas_chbmv_strided_batched_rank_1,& rocblas_chbmv_strided_batched_full_rank #endif #endif end interface interface rocblas_zhbmv_strided_batched function rocblas_zhbmv_strided_batched_(handle,uplo,n,k,alpha,A,lda,stride_A,x,incx,stride_x, & beta,y,incy,stride_y,batch_count) & bind(c, name="rocblas_zhbmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhbmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zhbmv_strided_batched_assumed_rank #else module procedure & rocblas_zhbmv_strided_batched_rank_0,& rocblas_zhbmv_strided_batched_rank_1,& rocblas_zhbmv_strided_batched_full_rank #endif #endif end interface interface rocblas_chbmv_strided_batched_64 function rocblas_chbmv_strided_batched_64_(handle,uplo,n,k,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) & bind(c, name="rocblas_chbmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chbmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zhbmv_strided_batched_64 function rocblas_zhbmv_strided_batched_64_(handle,uplo,n,k,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) & bind(c, name="rocblas_zhbmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhbmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hemv functions perform one of the matrix-vector operations: !> !> y := alpha*A*x + beta*y !> !> where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are ``n`` -element vectors, and !> ``A`` is an !> ``n`` by ``n`` Hermitian matrix. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: the upper triangular part of the Hermitian matrix A is !> supplied. !> - rocblas_fill_lower: the lower triangular part of the Hermitian matrix A is !> supplied. !> @param[in] n - [rocblas_int] !> the order of the matrix A. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] A - device pointer storing matrix A. Of dimension (lda, n). !> !> if uplo == rocblas_fill_upper: !> The upper triangular part of A must contain !> the upper triangular part of a Hermitian matrix. The lower !> triangular part of A will not be referenced. !> !> if uplo == rocblas_fill_lower: !> The lower triangular part of A must contain !> the lower triangular part of a Hermitian matrix. The upper !> triangular part of A will not be referenced. !> As a Hermitian matrix, the imaginary part of the main diagonal !> of A will not be referenced and is assumed to be == 0. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. Must be >= max(1, n). !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[in, out] y - device pointer storing vector y. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. interface rocblas_chemv function rocblas_chemv_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_chemv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_chemv_assumed_rank #else module procedure & rocblas_chemv_rank_0,& rocblas_chemv_rank_1,& rocblas_chemv_full_rank #endif #endif end interface interface rocblas_zhemv function rocblas_zhemv_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_zhemv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zhemv_assumed_rank #else module procedure & rocblas_zhemv_rank_0,& rocblas_zhemv_rank_1,& rocblas_zhemv_full_rank #endif #endif end interface interface rocblas_chemv_64 function rocblas_chemv_64_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_chemv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_zhemv_64 function rocblas_zhemv_64_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_zhemv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hemv_batched functions perform one of the matrix-vector operations: !> !> y_i := alpha*A_i*x_i + beta*y_i !> !> where ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are ``n`` -element vectors, !> and ``A_i`` is an !> ``n`` by ``n`` Hermitian matrix, for each batch in ``i = [1, batch_count``]. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: the upper triangular part of the Hermitian matrix A is !> supplied. !> - rocblas_fill_lower: the lower triangular part of the Hermitian matrix A is !> supplied. !> @param[in] n - [rocblas_int] !> the order of each matrix A_i. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] A - device array of device pointers storing each matrix A_i of dimension (lda, !> n). !> !> if uplo == rocblas_fill_upper: !> The upper triangular part of each A_i must contain !> the upper triangular part of a Hermitian matrix. The lower !> triangular part of each A_i will not be referenced. !> !> if uplo == rocblas_fill_lower: !> The lower triangular part of each A_i must contain !> the lower triangular part of a Hermitian matrix. The upper !> triangular part of each A_i will not be referenced. !> As a Hermitian matrix, the imaginary part of the main diagonal !> of each A_i will not be referenced and is assumed to be == 0. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. Must be >= max(1, n). !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[in, out] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_chemv_batched function rocblas_chemv_batched_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_chemv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_zhemv_batched function rocblas_zhemv_batched_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_zhemv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_chemv_batched_64 function rocblas_chemv_batched_64_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_chemv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zhemv_batched_64 function rocblas_zhemv_batched_64_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_zhemv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hemv_strided_batched functions perform one of the matrix-vector operations: !> !> y_i := alpha*A_i*x_i + beta*y_i !> !> where ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are ``n`` -element vectors, !> and ``A_i`` is an !> ``n`` by ``n`` Hermitian matrix, for each batch in ``i = [1, batch_count``]. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: the upper triangular part of the Hermitian matrix A is !> supplied. !> - rocblas_fill_lower: the lower triangular part of the Hermitian matrix A is !> supplied. !> @param[in] n - [rocblas_int] !> the order of each matrix A_i. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] A - device array of device pointers storing each matrix A_i of dimension (lda, !> n). !> !> if uplo == rocblas_fill_upper: !> The upper triangular part of each A_i must contain !> the upper triangular part of a Hermitian matrix. The lower !> triangular part of each A_i will not be referenced. !> !> if uplo == rocblas_fill_lower: !> The lower triangular part of each A_i must contain !> the lower triangular part of a Hermitian matrix. The upper !> triangular part of each A_i will not be referenced. !> As a Hermitian matrix, the imaginary part of the main diagonal !> of each A_i will not be referenced and is assumed to be == 0. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. Must be >= max(1, n). !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one (A_i) to the next (A_i+1). !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] stride_x - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[in, out] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in] stride_y - [rocblas_stride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_chemv_strided_batched function rocblas_chemv_strided_batched_(handle,uplo,n,alpha,A,lda,stride_A,x,incx,stride_x, & beta,y,incy,stride_y,batch_count) & bind(c, name="rocblas_chemv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_chemv_strided_batched_assumed_rank #else module procedure & rocblas_chemv_strided_batched_rank_0,& rocblas_chemv_strided_batched_rank_1,& rocblas_chemv_strided_batched_full_rank #endif #endif end interface interface rocblas_zhemv_strided_batched function rocblas_zhemv_strided_batched_(handle,uplo,n,alpha,A,lda,stride_A,x,incx,stride_x, & beta,y,incy,stride_y,batch_count) & bind(c, name="rocblas_zhemv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zhemv_strided_batched_assumed_rank #else module procedure & rocblas_zhemv_strided_batched_rank_0,& rocblas_zhemv_strided_batched_rank_1,& rocblas_zhemv_strided_batched_full_rank #endif #endif end interface interface rocblas_chemv_strided_batched_64 function rocblas_chemv_strided_batched_64_(handle,uplo,n,alpha,A,lda,stride_A,x,incx,stride_x, & beta,y,incy,stride_y,batch_count) & bind(c, name="rocblas_chemv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zhemv_strided_batched_64 function rocblas_zhemv_strided_batched_64_(handle,uplo,n,alpha,A,lda,stride_A,x,incx,stride_x, & beta,y,incy,stride_y,batch_count) & bind(c, name="rocblas_zhemv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The her functions perform the matrix-vector operations: !> !> A := A + alpha*x*x**H !> !> where ``alpha`` is a real scalar, ``x`` is a vector, and ``A`` is an !> ``n`` by ``n`` Hermitian matrix. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - rocblas_fill_upper: The upper triangular part of A is supplied in A. !> - rocblas_fill_lower: The lower triangular part of A is supplied in A. !> @param[in] n - [rocblas_int] !> the number of rows and columns of matrix A. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in, out] A - device pointer storing the specified triangular portion of the !> Hermitian matrix A. !> Of size (lda * n). !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of the Hermitian matrix A is supplied. !> The lower triangluar portion will not be touched. !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of the Hermitian matrix A is supplied. !> The upper triangular portion will not be touched. !> Note that the imaginary parts of the diagonal elements are not accessed !> and are assumed to be 0. !> !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. Must be at least max(1, n). interface rocblas_cher function rocblas_cher_(handle,uplo,n,alpha,x,incx,A,lda) bind(c, name="rocblas_cher") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cher_assumed_rank #else module procedure & rocblas_cher_rank_0,& rocblas_cher_rank_1,& rocblas_cher_full_rank #endif #endif end interface interface rocblas_zher function rocblas_zher_(handle,uplo,n,alpha,x,incx,A,lda) bind(c, name="rocblas_zher") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zher_assumed_rank #else module procedure & rocblas_zher_rank_0,& rocblas_zher_rank_1,& rocblas_zher_full_rank #endif #endif end interface interface rocblas_cher_64 function rocblas_cher_64_(handle,uplo,n,alpha,x,incx,A,lda) bind(c, name="rocblas_cher_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface interface rocblas_zher_64 function rocblas_zher_64_(handle,uplo,n,alpha,x,incx,A,lda) bind(c, name="rocblas_zher_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface !> \brief BLAS Level 2 API !> !> \details !> The her_batched functions performs the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*x_i**H !> !> where ``alpha`` is a real scalar, ``x_i`` is a vector, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, for ``i`` = 1, ..., ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - rocblas_fill_upper: The upper triangular part of each A_i is supplied in A. !> - rocblas_fill_lower: The lower triangular part of each A_i is supplied in A. !> @param[in] n - [rocblas_int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in, out] A - device array of device pointers storing the specified triangular !> portion of !> each Hermitian matrix A_i of at least size ((n * (n + 1)) / 2). Array is of at !> least size batch_count. !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of each Hermitian matrix A_i is supplied. !> The lower triangular portion of each A_i will not be touched. !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of each Hermitian matrix A_i is supplied. !> The upper triangular portion of each A_i will not be touched. !> Note that the imaginary parts of the diagonal elements are not accessed !> and are assumed to be 0. !> !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. Must be at least max(1, n). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_cher_batched function rocblas_cher_batched_(handle,uplo,n,alpha,x,incx,A,lda,batch_count) & bind(c, name="rocblas_cher_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: batch_count end function end interface interface rocblas_zher_batched function rocblas_zher_batched_(handle,uplo,n,alpha,x,incx,A,lda,batch_count) & bind(c, name="rocblas_zher_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: batch_count end function end interface interface rocblas_cher_batched_64 function rocblas_cher_batched_64_(handle,uplo,n,alpha,x,incx,A,lda,batch_count) & bind(c, name="rocblas_cher_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zher_batched_64 function rocblas_zher_batched_64_(handle,uplo,n,alpha,x,incx,A,lda,batch_count) & bind(c, name="rocblas_zher_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The her_strided_batched functions perform the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*x_i**H !> !> where ``alpha`` is a real scalar, ``x_i`` is a vector, and ``A_i`` is an !> ``n`` by ``n`` Hermitian matrix, for ``i`` = 1, ..., ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - rocblas_fill_upper: The upper triangular part of each A_i is supplied in A. !> - rocblas_fill_lower: The lower triangular part of each A_i is supplied in A. !> @param[in] n - [rocblas_int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer pointing to the first vector (x_1). !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] stride_x - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[in, out] A - device array of device pointers storing the specified triangular !> portion of !> each Hermitian matrix A_i. Points to the first matrix (A_1). !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of each Hermitian matrix A_i is supplied. !> The lower triangular portion of each A_i will not be touched. !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of each Hermitian matrix A_i is supplied. !> The upper triangular portion of each A_i will not be touched. !> Note that the imaginary parts of the diagonal elements are not accessed !> and are assumed to be 0. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one (A_i) to the next (A_i+1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_cher_strided_batched function rocblas_cher_strided_batched_(handle,uplo,n,alpha,x,incx,stride_x,A,lda,stride_A, & batch_count) & bind(c, name="rocblas_cher_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cher_strided_batched_assumed_rank #else module procedure & rocblas_cher_strided_batched_rank_0,& rocblas_cher_strided_batched_rank_1,& rocblas_cher_strided_batched_full_rank #endif #endif end interface interface rocblas_zher_strided_batched function rocblas_zher_strided_batched_(handle,uplo,n,alpha,x,incx,stride_x,A,lda,stride_A, & batch_count) & bind(c, name="rocblas_zher_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zher_strided_batched_assumed_rank #else module procedure & rocblas_zher_strided_batched_rank_0,& rocblas_zher_strided_batched_rank_1,& rocblas_zher_strided_batched_full_rank #endif #endif end interface interface rocblas_cher_strided_batched_64 function rocblas_cher_strided_batched_64_(handle,uplo,n,alpha,x,incx,stride_x,A,lda,stride_A, & batch_count) & bind(c, name="rocblas_cher_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zher_strided_batched_64 function rocblas_zher_strided_batched_64_(handle,uplo,n,alpha,x,incx,stride_x,A,lda,stride_A, & batch_count) & bind(c, name="rocblas_zher_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The her2 functions perform the matrix-vector operations: !> !> A := A + alpha*x*y**H + conj(alpha)*y*x**H !> !> where ``alpha`` is a complex scalar, ``x`` and ``y`` are vectors, and ``A`` is an !> ``n`` by ``n`` Hermitian matrix. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - rocblas_fill_upper: The upper triangular part of A is supplied. !> - rocblas_fill_lower: The lower triangular part of A is supplied. !> @param[in] n - [rocblas_int] !> the number of rows and columns of matrix A. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in] y - device pointer storing vector y. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in, out] A - device pointer storing the specified triangular portion of !> the Hermitian matrix A. Of size (lda, n). !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of the Hermitian matrix A is supplied. !> The lower triangular portion of A will not be touched. !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of the Hermitian matrix A is supplied. !> The upper triangular portion of A will not be touched. !> Note that the imaginary parts of the diagonal elements are not accessed !> and are assumed to be 0. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. Must be at least max(lda, 1). interface rocblas_cher2 function rocblas_cher2_(handle,uplo,n,alpha,x,incx,y,incy,A,lda) bind(c, name="rocblas_cher2") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cher2_assumed_rank #else module procedure & rocblas_cher2_rank_0,& rocblas_cher2_rank_1,& rocblas_cher2_full_rank #endif #endif end interface interface rocblas_zher2 function rocblas_zher2_(handle,uplo,n,alpha,x,incx,y,incy,A,lda) bind(c, name="rocblas_zher2") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zher2_assumed_rank #else module procedure & rocblas_zher2_rank_0,& rocblas_zher2_rank_1,& rocblas_zher2_full_rank #endif #endif end interface interface rocblas_cher2_64 function rocblas_cher2_64_(handle,uplo,n,alpha,x,incx,y,incy,A,lda) & bind(c, name="rocblas_cher2_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface interface rocblas_zher2_64 function rocblas_zher2_64_(handle,uplo,n,alpha,x,incx,y,incy,A,lda) & bind(c, name="rocblas_zher2_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface !> \brief BLAS Level 2 API !> !> \details !> The her2_batched functions perform the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*y_i**H + conj(alpha)*y_i*x_i**H !> !> where ``alpha`` is a complex scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` Hermitian matrix for each batch in ``i = [1, batch_count``]. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - rocblas_fill_upper: The upper triangular part of each A_i is supplied. !> - rocblas_fill_lower: The lower triangular part of each A_i is supplied. !> @param[in] n - [rocblas_int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each y_i. !> @param[in, out] A - device array of device pointers storing the specified triangular !> portion of !> each Hermitian matrix A_i of size (lda, n). !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of each Hermitian matrix A_i is supplied. !> The lower triangular portion of each A_i will not be touched. !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of each Hermitian matrix A_i is supplied. !> The upper triangular portion of each A_i will not be touched. !> Note that the imaginary parts of the diagonal elements are not accessed !> and are assumed to be 0. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. Must be at least max(lda, 1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_cher2_batched function rocblas_cher2_batched_(handle,uplo,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_cher2_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: batch_count end function end interface interface rocblas_zher2_batched function rocblas_zher2_batched_(handle,uplo,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_zher2_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: batch_count end function end interface interface rocblas_cher2_batched_64 function rocblas_cher2_batched_64_(handle,uplo,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_cher2_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zher2_batched_64 function rocblas_zher2_batched_64_(handle,uplo,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_zher2_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The her2_strided_batched functions perform the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*y_i**H + conj(alpha)*y_i*x_i**H !> !> where ``alpha`` is a complex scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` Hermitian matrix for each batch in ``i = [1, batch_count``]. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - rocblas_fill_upper: The upper triangular part of each A_i is supplied. !> - rocblas_fill_lower: The lower triangular part of each A_i is supplied. !> @param[in] n - [rocblas_int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer pointing to the first vector x_1. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] stride_x - [rocblas_stride] !> specifies the stride between the beginning of one vector (x_i) and the next !> (x_i+1). !> @param[in] y - device pointer pointing to the first vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each y_i. !> @param[in] stride_y - [rocblas_stride] !> specifies the stride between the beginning of one vector (y_i) and the next !> (y_i+1). !> @param[in, out] A - device pointer pointing to the first matrix (A_1). Stores the specified !> triangular portion of !> each Hermitian matrix A_i. !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of each Hermitian matrix A_i is supplied. !> The lower triangular portion of each A_i will not be touched. !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of each Hermitian matrix A_i is supplied. !> The upper triangular portion of each A_i will not be touched. !> Note that the imaginary parts of the diagonal elements are not accessed !> and are assumed to be 0. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. Must be at least max(lda, 1). !> @param[in] stride_A - [rocblas_stride] !> specifies the stride between the beginning of one matrix (A_i) and the next !> (A_i+1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_cher2_strided_batched function rocblas_cher2_strided_batched_(handle,uplo,n,alpha,x,incx,stride_x,y,incy,stride_y,A, & lda,stride_A,batch_count) & bind(c, name="rocblas_cher2_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cher2_strided_batched_assumed_rank #else module procedure & rocblas_cher2_strided_batched_rank_0,& rocblas_cher2_strided_batched_rank_1,& rocblas_cher2_strided_batched_full_rank #endif #endif end interface interface rocblas_zher2_strided_batched function rocblas_zher2_strided_batched_(handle,uplo,n,alpha,x,incx,stride_x,y,incy,stride_y,A, & lda,stride_A,batch_count) & bind(c, name="rocblas_zher2_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zher2_strided_batched_assumed_rank #else module procedure & rocblas_zher2_strided_batched_rank_0,& rocblas_zher2_strided_batched_rank_1,& rocblas_zher2_strided_batched_full_rank #endif #endif end interface interface rocblas_cher2_strided_batched_64 function rocblas_cher2_strided_batched_64_(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,A,lda,stride_A,batch_count) & bind(c, name="rocblas_cher2_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zher2_strided_batched_64 function rocblas_zher2_strided_batched_64_(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,A,lda,stride_A,batch_count) & bind(c, name="rocblas_zher2_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hpmv functions perform the matrix-vector operation: !> !> y := alpha*A*x + beta*y !> !> where ``alpha`` and ``beta`` are scalars, ``x`` and ``y`` are ``n`` -element vectors and A !> is an !> ``n`` by ``n`` Hermitian matrix, supplied in packed form (see description below). !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: the upper triangular part of the Hermitian matrix A is !> supplied in AP. !> - rocblas_fill_lower: the lower triangular part of the Hermitian matrix A is !> supplied in AP. !> @param[in] n - [rocblas_int] !> the order of the matrix A. Must be >= 0. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] AP - device pointer storing the packed version of the specified triangular !> portion of !> the Hermitian matrix A. Of at least size ((n * (n + 1)) / 2). !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of the Hermitian matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), etc. !> Ex: (rocblas_fill_upper; n = 3) !> (1, 0) (2, 1) (3, 2) !> (2,-1) (4, 0) (5,-1) ---> [(1,0),(2,1),(4,0),(3,2),(5,-1),(6,0)] !> (3,-2) (5, 1) (6, 0) !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of the Hermitian matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), etc. !> Ex: (rocblas_fill_lower; n = 3) !> (1, 0) (2, 1) (3, 2) !> (2,-1) (4, 0) (5,-1) ---> [(1,0),(2,-1),(3,-2),(4,0),(5,1),(6,0)] !> (3,-2) (5, 1) (6, 0) !> Note that the imaginary parts of the diagonal elements are not accessed !> and are assumed to be 0. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[in, out] y - device pointer storing vector y. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. interface rocblas_chpmv function rocblas_chpmv_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) bind(c, name="rocblas_chpmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_chpmv_assumed_rank #else module procedure & rocblas_chpmv_rank_0,& rocblas_chpmv_rank_1 #endif #endif end interface interface rocblas_zhpmv function rocblas_zhpmv_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) bind(c, name="rocblas_zhpmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zhpmv_assumed_rank #else module procedure & rocblas_zhpmv_rank_0,& rocblas_zhpmv_rank_1 #endif #endif end interface interface rocblas_chpmv_64 function rocblas_chpmv_64_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) & bind(c, name="rocblas_chpmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_zhpmv_64 function rocblas_zhpmv_64_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) & bind(c, name="rocblas_zhpmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hpmv_batched functions perform the matrix-vector operation: !> !> y_i := alpha*A_i*x_i + beta*y_i !> !> where ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are ``n`` -element vectors !> and ``A_i`` is an !> ``n`` by ``n`` Hermitian matrix, supplied in packed form (see description below), !> for each batch in ``i = [1, batch_count``]. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: the upper triangular part of each Hermitian matrix A_i is !> supplied in AP. !> - rocblas_fill_lower: the lower triangular part of each Hermitian matrix A_i is !> supplied in AP. !> @param[in] n - [rocblas_int] !> the order of each matrix A_i. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] AP - device pointer of device pointers storing the packed version of the !> specified triangular !> portion of each Hermitian matrix A_i. Each A_i is of at least size ((n * (n + 1)) / !> 2). !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that each AP_i contains the triangular !> portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), etc. !> Ex: (rocblas_fill_upper; n = 3) !> (1, 0) (2, 1) (3, 2) !> (2,-1) (4, 0) (5,-1) ---> [(1,0),(2,1),(4,0),(3,2),(5,-1),(6,0)] !> (3,-2) (5, 1) (6, 0) !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that each AP_i contains the triangular !> portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), etc. !> Ex: (rocblas_fill_lower; n = 3) !> (1, 0) (2, 1) (3, 2) !> (2,-1) (4, 0) (5,-1) ---> [(1,0),(2,-1),(3,-2),(4,0),(5,1),(6,0)] !> (3,-2) (5, 1) (6, 0) !> Note that the imaginary parts of the diagonal elements are not accessed !> and are assumed to be 0. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[in, out] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_chpmv_batched function rocblas_chpmv_batched_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_chpmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_zhpmv_batched function rocblas_zhpmv_batched_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_zhpmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_chpmv_batched_64 function rocblas_chpmv_batched_64_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_chpmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zhpmv_batched_64 function rocblas_zhpmv_batched_64_(handle,uplo,n,alpha,AP,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_zhpmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hpmv_strided_batched functions perform the matrix-vector operation: !> !> y_i := alpha*A_i*x_i + beta*y_i !> !> where ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are ``n`` -element vectors !> and ``A_i`` is an !> ``n`` by ``n`` Hermitian matrix, supplied in packed form (see description below), !> for each batch in ``i = [1, batch_count``]. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: the upper triangular part of each Hermitian matrix A_i is !> supplied in AP. !> - rocblas_fill_lower: the lower triangular part of each Hermitian matrix A_i is !> supplied in AP. !> @param[in] n - [rocblas_int] !> the order of each matrix A_i. !> @param[in] alpha - device pointer or host pointer to scalar alpha. !> @param[in] AP - device pointer pointing to the beginning of the first matrix (AP_1). Stores !> the packed !> version of the specified triangular portion of each Hermitian matrix AP_i of size !> ((n * (n + 1)) / 2). !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that each AP_i contains the triangular !> portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), etc. !> Ex: (rocblas_fill_upper; n = 3) !> (1, 0) (2, 1) (3, 2) !> (2,-1) (4, 0) (5,-1) ---> [(1,0),(2,1),(4,0),(3,2),(5,-1),(6,0)] !> (3,-2) (5, 1) (6, 0) !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that each AP_i contains the triangular !> portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), etc. !> Ex: (rocblas_fill_lower; n = 3) !> (1, 0) (2, 1) (3, 2) !> (2,-1) (4, 0) (5,-1) ---> [(1,0),(2,-1),(3,-2),(4,0),(5,1),(6,0)] !> (3,-2) (5, 1) (6, 0) !> Note that the imaginary parts of the diagonal elements are not accessed !> and are assumed to be 0. !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one matrix (AP_i) to the next one (AP_i+1). !> @param[in] x - device array pointing to the beginning of the first vector (x_1). !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] stride_x - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[in, out] y - device array pointing to the beginning of the first vector (y_1). !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in] stride_y - [rocblas_stride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_chpmv_strided_batched function rocblas_chpmv_strided_batched_(handle,uplo,n,alpha,AP,stride_A,x,incx,stride_x,beta, & y,incy,stride_y,batch_count) & bind(c, name="rocblas_chpmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_chpmv_strided_batched_assumed_rank #else module procedure & rocblas_chpmv_strided_batched_rank_0,& rocblas_chpmv_strided_batched_rank_1 #endif #endif end interface interface rocblas_zhpmv_strided_batched function rocblas_zhpmv_strided_batched_(handle,uplo,n,alpha,AP,stride_A,x,incx,stride_x,beta, & y,incy,stride_y,batch_count) & bind(c, name="rocblas_zhpmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zhpmv_strided_batched_assumed_rank #else module procedure & rocblas_zhpmv_strided_batched_rank_0,& rocblas_zhpmv_strided_batched_rank_1 #endif #endif end interface interface rocblas_chpmv_strided_batched_64 function rocblas_chpmv_strided_batched_64_(handle,uplo,n,alpha,AP,stride_A,x,incx,stride_x, & beta,y,incy,stride_y,batch_count) & bind(c, name="rocblas_chpmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zhpmv_strided_batched_64 function rocblas_zhpmv_strided_batched_64_(handle,uplo,n,alpha,AP,stride_A,x,incx,stride_x, & beta,y,incy,stride_y,batch_count) & bind(c, name="rocblas_zhpmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hpr functions perform the matrix-vector operations: !> !> A := A + alpha*x*x**H !> !> where ``alpha`` is a real scalar, ``x`` is a vector, and ``A`` is an !> ``n`` by ``n`` Hermitian matrix, supplied in packed form. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - rocblas_fill_upper: The upper triangular part of A is supplied in AP. !> - rocblas_fill_lower: The lower triangular part of A is supplied in AP. !> @param[in] n - [rocblas_int] !> the number of rows and columns of matrix A. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in, out] AP - device pointer storing the packed version of the specified triangular !> portion of !> the Hermitian matrix A. Of at least size ((n * (n + 1)) / 2). !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of the Hermitian matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), etc. !> Ex: (rocblas_fill_upper; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) ---> [(1,0),(2,1),(3,0),(4,9),(5,3),(6,0)] !> (4,-9) (5,-3) (6,0) !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of the Hermitian matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), etc. !> Ex: (rocblas_fill_lower; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) ---> [(1,0),(2,-1),(4,-9),(3,0),(5,-3),(6,0)] !> (4,-9) (5,-3) (6,0) !> Note that the imaginary parts of the diagonal elements are not accessed !> and are assumed to be 0. interface rocblas_chpr function rocblas_chpr_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="rocblas_chpr") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_chpr_assumed_rank #else module procedure & rocblas_chpr_rank_0,& rocblas_chpr_rank_1 #endif #endif end interface interface rocblas_zhpr function rocblas_zhpr_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="rocblas_zhpr") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zhpr_assumed_rank #else module procedure & rocblas_zhpr_rank_0,& rocblas_zhpr_rank_1 #endif #endif end interface interface rocblas_chpr_64 function rocblas_chpr_64_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="rocblas_chpr_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP end function end interface interface rocblas_zhpr_64 function rocblas_zhpr_64_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="rocblas_zhpr_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hpr_batched functions perform the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*x_i**H !> !> where ``alpha`` is a real scalar, ``x_i`` is a vector, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., !> ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - rocblas_fill_upper: The upper triangular part of each A_i is supplied in AP. !> - rocblas_fill_lower: The lower triangular part of each A_i is supplied in AP. !> @param[in] n - [rocblas_int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in, out] AP - device array of device pointers storing the packed version of the !> specified triangular portion of !> each Hermitian matrix A_i of at least size ((n * (n + 1)) / 2). Array is of at !> least size batch_count. !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), etc. !> Ex: (rocblas_fill_upper; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) ---> [(1,0),(2,1),(3,0),(4,9),(5,3),(6,0)] !> (4,-9) (5,-3) (6,0) !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), etc. !> Ex: (rocblas_fill_lower; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) ---> [(1,0),(2,-1),(4,-9),(3,0),(5,-3),(6,0)] !> (4,-9) (5,-3) (6,0) !> Note that the imaginary parts of the diagonal elements are not accessed !> and are assumed to be 0. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_chpr_batched function rocblas_chpr_batched_(handle,uplo,n,alpha,x,incx,AP,batch_count) & bind(c, name="rocblas_chpr_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: batch_count end function end interface interface rocblas_zhpr_batched function rocblas_zhpr_batched_(handle,uplo,n,alpha,x,incx,AP,batch_count) & bind(c, name="rocblas_zhpr_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: batch_count end function end interface interface rocblas_chpr_batched_64 function rocblas_chpr_batched_64_(handle,uplo,n,alpha,x,incx,AP,batch_count) & bind(c, name="rocblas_chpr_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zhpr_batched_64 function rocblas_zhpr_batched_64_(handle,uplo,n,alpha,x,incx,AP,batch_count) & bind(c, name="rocblas_zhpr_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hpr_strided_batched functions perform the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*x_i**H !> !> where ``alpha`` is a real scalar, ``x_i`` is a vector, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., !> ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - rocblas_fill_upper: The upper triangular part of each A_i is supplied in AP. !> - rocblas_fill_lower: The lower triangular part of each A_i is supplied in AP. !> @param[in] n - [rocblas_int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer pointing to the first vector (x_1). !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] stride_x - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[in, out] AP - device array of device pointers storing the packed version of the !> specified triangular portion of !> each Hermitian matrix A_i. Points to the first matrix (A_1). !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), etc. !> Ex: (rocblas_fill_upper; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) ---> [(1,0),(2,1),(3,0),(4,9),(5,3),(6,0)] !> (4,-9) (5,-3) (6,0) !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), etc. !> Ex: (rocblas_fill_lower; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) ---> [(1,0),(2,-1),(4,-9),(3,0),(5,-3),(6,0)] !> (4,-9) (5,-3) (6,0) !> Note that the imaginary parts of the diagonal elements are not accessed !> and are assumed to be 0. !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one (A_i) to the next (A_i+1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_chpr_strided_batched function rocblas_chpr_strided_batched_(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) & bind(c, name="rocblas_chpr_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_chpr_strided_batched_assumed_rank #else module procedure & rocblas_chpr_strided_batched_rank_0,& rocblas_chpr_strided_batched_rank_1 #endif #endif end interface interface rocblas_zhpr_strided_batched function rocblas_zhpr_strided_batched_(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) & bind(c, name="rocblas_zhpr_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zhpr_strided_batched_assumed_rank #else module procedure & rocblas_zhpr_strided_batched_rank_0,& rocblas_zhpr_strided_batched_rank_1 #endif #endif end interface interface rocblas_chpr_strided_batched_64 function rocblas_chpr_strided_batched_64_(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) & bind(c, name="rocblas_chpr_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zhpr_strided_batched_64 function rocblas_zhpr_strided_batched_64_(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) & bind(c, name="rocblas_zhpr_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hpr2 functions perform the matrix-vector operations: !> !> A := A + alpha*x*y**H + conj(alpha)*y*x**H !> !> where ``alpha`` is a complex scalar, ``x`` and ``y`` are vectors, and ``A`` is an !> ``n`` by ``n`` Hermitian matrix, supplied in packed form. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - rocblas_fill_upper: The upper triangular part of A is supplied in AP. !> - rocblas_fill_lower: The lower triangular part of A is supplied in AP. !> @param[in] n - [rocblas_int] !> the number of rows and columns of matrix A. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in] y - device pointer storing vector y. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in, out] AP - device pointer storing the packed version of the specified triangular !> portion of !> the Hermitian matrix A. Of at least size ((n * (n + 1)) / 2). !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of the Hermitian matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), etc. !> Ex: (rocblas_fill_upper; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) ---> [(1,0),(2,1),(3,0),(4,9),(5,3),(6,0)] !> (4,-9) (5,-3) (6,0) !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of the Hermitian matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), etc. !> Ex: (rocblas_fill_lower; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) ---> [(1,0),(2,-1),(4,-9),(3,0),(5,-3),(6,0)] !> (4,-9) (5,-3) (6,0) !> Note that the imaginary parts of the diagonal elements are not accessed !> and are assumed to be 0. interface rocblas_chpr2 function rocblas_chpr2_(handle,uplo,n,alpha,x,incx,y,incy,AP) bind(c, name="rocblas_chpr2") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_chpr2_assumed_rank #else module procedure & rocblas_chpr2_rank_0,& rocblas_chpr2_rank_1 #endif #endif end interface interface rocblas_zhpr2 function rocblas_zhpr2_(handle,uplo,n,alpha,x,incx,y,incy,AP) bind(c, name="rocblas_zhpr2") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zhpr2_assumed_rank #else module procedure & rocblas_zhpr2_rank_0,& rocblas_zhpr2_rank_1 #endif #endif end interface interface rocblas_chpr2_64 function rocblas_chpr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP) & bind(c, name="rocblas_chpr2_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr2_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP end function end interface interface rocblas_zhpr2_64 function rocblas_zhpr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP) & bind(c, name="rocblas_zhpr2_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr2_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hpr2_batched functions perform the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*y_i**H + conj(alpha)*y_i*x_i**H !> !> where ``alpha`` is a complex scalar, ``x_i`` and``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., !> ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - rocblas_fill_upper: The upper triangular part of each A_i is supplied in AP. !> - rocblas_fill_lower: The lower triangular part of each A_i is supplied in AP. !> @param[in] n - [rocblas_int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each y_i. !> @param[in, out] AP - device array of device pointers storing the packed version of the !> specified triangular portion of !> each Hermitian matrix A_i of at least size ((n * (n + 1)) / 2). Array is of at !> least size batch_count. !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), etc. !> Ex: (rocblas_fill_upper; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) ---> [(1,0),(2,1),(3,0),(4,9),(5,3),(6,0)] !> (4,-9) (5,-3) (6,0) !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), etc. !> Ex: (rocblas_fill_lower; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) --> [(1,0),(2,-1),(4,-9),(3,0),(5,-3),(6,0)] !> (4,-9) (5,-3) (6,0) !> Note that the imaginary parts of the diagonal elements are not accessed !> and are assumed to be 0. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_chpr2_batched function rocblas_chpr2_batched_(handle,uplo,n,alpha,x,incx,y,incy,AP,batch_count) & bind(c, name="rocblas_chpr2_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: batch_count end function end interface interface rocblas_zhpr2_batched function rocblas_zhpr2_batched_(handle,uplo,n,alpha,x,incx,y,incy,AP,batch_count) & bind(c, name="rocblas_zhpr2_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: batch_count end function end interface interface rocblas_chpr2_batched_64 function rocblas_chpr2_batched_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,batch_count) & bind(c, name="rocblas_chpr2_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr2_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zhpr2_batched_64 function rocblas_zhpr2_batched_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,batch_count) & bind(c, name="rocblas_zhpr2_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr2_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The hpr2_strided_batched functions perform the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*y_i**H + conj(alpha)*y_i*x_i**H !> !> where ``alpha`` is a complex scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., !> ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - rocblas_fill_upper: The upper triangular part of each A_i is supplied in AP. !> - rocblas_fill_lower: The lower triangular part of each A_i is supplied in AP. !> @param[in] n - [rocblas_int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer pointing to the first vector (x_1). !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] stride_x - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[in] y - device pointer pointing to the first vector (y_1). !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each y_i. !> @param[in] stride_y - [rocblas_stride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> @param[in, out] AP - device array of device pointers storing the packed version of the !> specified triangular portion of !> each Hermitian matrix A_i. Points to the first matrix (A_1). !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), etc. !> Ex: (rocblas_fill_upper; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) ---> [(1,0),(2,1),(3,0),(4,9),(5,3),(6,0)] !> (4,-9) (5,-3) (6,0) !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of each Hermitian matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), etc. !> Ex: (rocblas_fill_lower; n = 3) !> (1, 0) (2, 1) (4,9) !> (2,-1) (3, 0) (5,3) ---> !> [(1,0),(2,-1),(4,-9),(3,0),(5,-3),(6,0)] !> (4,-9) (5,-3) (6,0) !> Note that the imaginary parts of the diagonal elements are not accessed !> and are assumed to be 0. !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one (A_i) to the next (A_i+1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_chpr2_strided_batched function rocblas_chpr2_strided_batched_(handle,uplo,n,alpha,x,incx,stride_x,y,incy,stride_y, & AP,stride_A,batch_count) & bind(c, name="rocblas_chpr2_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_chpr2_strided_batched_assumed_rank #else module procedure & rocblas_chpr2_strided_batched_rank_0,& rocblas_chpr2_strided_batched_rank_1 #endif #endif end interface interface rocblas_zhpr2_strided_batched function rocblas_zhpr2_strided_batched_(handle,uplo,n,alpha,x,incx,stride_x,y,incy,stride_y, & AP,stride_A,batch_count) & bind(c, name="rocblas_zhpr2_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zhpr2_strided_batched_assumed_rank #else module procedure & rocblas_zhpr2_strided_batched_rank_0,& rocblas_zhpr2_strided_batched_rank_1 #endif #endif end interface interface rocblas_chpr2_strided_batched_64 function rocblas_chpr2_strided_batched_64_(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,AP,stride_A,batch_count) & bind(c, name="rocblas_chpr2_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr2_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zhpr2_strided_batched_64 function rocblas_zhpr2_strided_batched_64_(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,AP,stride_A,batch_count) & bind(c, name="rocblas_zhpr2_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr2_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The trmv functions perform one of the matrix-vector operations: !> !> x = A*x or !> x = A**T*x or !> x = A**H*x !> !> where ``x`` is an ``n`` -element vector and ``A`` is an ``n`` by ``n`` unit, or non-unit, !> upper or lower triangular matrix. !> The vector ``x`` is overwritten. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A is an upper triangular matrix. !> - rocblas_fill_lower: A is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_none: op(A) = A. !> - rocblas_operation_transpose: op(A) = A^T. !> - rocblas_operation_conjugate_transpose: op(A) = A^H. !> !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: A is assumed to be unit triangular. !> - rocblas_diagonal_non_unit: A is not assumed to be unit triangular. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows of A. n >= 0. !> !> @param[in] A - device pointer storing matrix A, of dimension ( lda, n ). If uplo == !> rocblas_fill_upper, the upper triangular part of the leading n-by-n array contains the !> matrix A. Otherwise, the lower triangular part of the leading n-by-n array contains the !> matrix A. !> !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. lda must be at least max( 1, n ). !> !> @param[in, out] x - device pointer storing vector x. On exit, x is overwritten with the !> transformed vector x. !> !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. interface rocblas_strmv function rocblas_strmv_(handle,uplo,transA,diag,n,A,lda,x,incx) bind(c, name="rocblas_strmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_strmv_assumed_rank #else module procedure & rocblas_strmv_rank_0,& rocblas_strmv_rank_1,& rocblas_strmv_full_rank #endif #endif end interface interface rocblas_dtrmv function rocblas_dtrmv_(handle,uplo,transA,diag,n,A,lda,x,incx) bind(c, name="rocblas_dtrmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dtrmv_assumed_rank #else module procedure & rocblas_dtrmv_rank_0,& rocblas_dtrmv_rank_1,& rocblas_dtrmv_full_rank #endif #endif end interface interface rocblas_ctrmv function rocblas_ctrmv_(handle,uplo,transA,diag,n,A,lda,x,incx) bind(c, name="rocblas_ctrmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ctrmv_assumed_rank #else module procedure & rocblas_ctrmv_rank_0,& rocblas_ctrmv_rank_1,& rocblas_ctrmv_full_rank #endif #endif end interface interface rocblas_ztrmv function rocblas_ztrmv_(handle,uplo,transA,diag,n,A,lda,x,incx) bind(c, name="rocblas_ztrmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ztrmv_assumed_rank #else module procedure & rocblas_ztrmv_rank_0,& rocblas_ztrmv_rank_1,& rocblas_ztrmv_full_rank #endif #endif end interface interface rocblas_strmv_64 function rocblas_strmv_64_(handle,uplo,transA,diag,n,A,lda,x,incx) & bind(c, name="rocblas_strmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_dtrmv_64 function rocblas_dtrmv_64_(handle,uplo,transA,diag,n,A,lda,x,incx) & bind(c, name="rocblas_dtrmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_ctrmv_64 function rocblas_ctrmv_64_(handle,uplo,transA,diag,n,A,lda,x,incx) & bind(c, name="rocblas_ctrmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_ztrmv_64 function rocblas_ztrmv_64_(handle,uplo,transA,diag,n,A,lda,x,incx) & bind(c, name="rocblas_ztrmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface !> \brief BLAS Level 2 API !> !> \details !> The trmv_batched functions perform one of the matrix-vector operations: !> !> x_i = A_i*x_i or !> x_i = A_i**T*x_i or !> x_i = A_i**H*x_i, 0 < i < batch_count !> !> where ``x_i`` is an ``n`` -element vector and ``A_i`` is an ``n`` by ``n`` (unit, or !> non-unit, upper or lower triangular matrix). !> The vectors ``x_i`` are overwritten. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A_i is an upper triangular matrix. !> - rocblas_fill_lower: A_i is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_none: op(A) = A. !> - rocblas_operation_transpose: op(A) = A^T. !> - rocblas_operation_conjugate_transpose: op(A) = A^H. !> !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: A_i is assumed to be unit triangular. !> - rocblas_diagonal_non_unit: A_i is not assumed to be unit triangular. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows of matrices A_i. n >= 0. !> !> @param[in] A - device pointer to an array of device pointers to the A_i matrices, of !> dimension ( lda, n ). If uplo == rocblas_fill_upper, the upper triangular part of the !> leading n-by-n array contains the matrix A_i. Otherwise the lower triangular part of the !> leading n-by-n array contains the matrix A_i. !> !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A_i. lda must be at least max( 1, n ). !> !> @param[in, out] x - device pointer to an array of device pointers to the x_i vectors. On !> exit, each x_i is overwritten with the transformed vector x_i. !> !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of vectors x_i. !> !> @param[in] batch_count - [rocblas_int] !> The number of batched matrices/vectors. interface rocblas_strmv_batched function rocblas_strmv_batched_(handle,uplo,transA,diag,n,A,lda,x,incx,batch_count) & bind(c, name="rocblas_strmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr) :: A integer(c_int),value :: lda type(c_ptr) :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_dtrmv_batched function rocblas_dtrmv_batched_(handle,uplo,transA,diag,n,A,lda,x,incx,batch_count) & bind(c, name="rocblas_dtrmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr) :: A integer(c_int),value :: lda type(c_ptr) :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_ctrmv_batched function rocblas_ctrmv_batched_(handle,uplo,transA,diag,n,A,lda,x,incx,batch_count) & bind(c, name="rocblas_ctrmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr) :: A integer(c_int),value :: lda type(c_ptr) :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_ztrmv_batched function rocblas_ztrmv_batched_(handle,uplo,transA,diag,n,A,lda,x,incx,batch_count) & bind(c, name="rocblas_ztrmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr) :: A integer(c_int),value :: lda type(c_ptr) :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_strmv_batched_64 function rocblas_strmv_batched_64_(handle,uplo,transA,diag,n,A,lda,x,incx,batch_count) & bind(c, name="rocblas_strmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr) :: A integer(c_int64_t),value :: lda type(c_ptr) :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dtrmv_batched_64 function rocblas_dtrmv_batched_64_(handle,uplo,transA,diag,n,A,lda,x,incx,batch_count) & bind(c, name="rocblas_dtrmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr) :: A integer(c_int64_t),value :: lda type(c_ptr) :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ctrmv_batched_64 function rocblas_ctrmv_batched_64_(handle,uplo,transA,diag,n,A,lda,x,incx,batch_count) & bind(c, name="rocblas_ctrmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr) :: A integer(c_int64_t),value :: lda type(c_ptr) :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ztrmv_batched_64 function rocblas_ztrmv_batched_64_(handle,uplo,transA,diag,n,A,lda,x,incx,batch_count) & bind(c, name="rocblas_ztrmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr) :: A integer(c_int64_t),value :: lda type(c_ptr) :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The trmv_strided_batched functions perform one of the matrix-vector operations: !> !> x_i = A_i*x_i or !> x_i = A_i**T*x_i, or !> x_i = A_i**H*x_i, 0 < i < batch_count !> !> where ``x_i`` is an ``n`` -element vector and ``A_i`` is an ``n`` by ``n`` (unit, or !> non-unit, upper or lower triangular matrix) !> with strides specifying how to retrieve ``$x_i$`` (resp. ``$A_i$`` ) from ``$x_{i-1}$`` !> (resp. ``$A_i$`` ). !> !> The vectors ``x_i`` are overwritten. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A_i is an upper triangular matrix. !> - rocblas_fill_lower: A_i is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_none: op(A) = A. !> - rocblas_operation_transpose: op(A) = A^T. !> - rocblas_operation_conjugate_transpose: op(A) = A^H. !> !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: A_i is assumed to be unit triangular. !> - rocblas_diagonal_non_unit: A_i is not assumed to be unit triangular. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows of matrices A_i. n >= 0. !> !> @param[in] A - device pointer to the matrix A_1 of the batch, of dimension ( lda, n ). If !> uplo == rocblas_fill_upper, the upper triangular part of the leading n-by-n array contains !> the matrix A_i. Otherwise, the lower triangular part of the leading n-by-n array contains !> the matrix A_i. !> !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A_i. lda must be at least max( 1, n ). !> !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one A_i matrix to the next A_{i + 1}. !> !> @param[in, out] x - device pointer to the vector x_1 of the batch. On exit, each x_i is !> overwritten with the transformed vector x_i. !> !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of one vector x. !> !> @param[in] stride_x - [rocblas_stride] !> stride from the start of one x_i vector to the next x_{i + 1}. !> !> @param[in] batch_count - [rocblas_int] !> The number of batched matrices/vectors. interface rocblas_strmv_strided_batched function rocblas_strmv_strided_batched_(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_strmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_strmv_strided_batched_assumed_rank #else module procedure & rocblas_strmv_strided_batched_rank_0,& rocblas_strmv_strided_batched_rank_1,& rocblas_strmv_strided_batched_full_rank #endif #endif end interface interface rocblas_dtrmv_strided_batched function rocblas_dtrmv_strided_batched_(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_dtrmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dtrmv_strided_batched_assumed_rank #else module procedure & rocblas_dtrmv_strided_batched_rank_0,& rocblas_dtrmv_strided_batched_rank_1,& rocblas_dtrmv_strided_batched_full_rank #endif #endif end interface interface rocblas_ctrmv_strided_batched function rocblas_ctrmv_strided_batched_(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ctrmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ctrmv_strided_batched_assumed_rank #else module procedure & rocblas_ctrmv_strided_batched_rank_0,& rocblas_ctrmv_strided_batched_rank_1,& rocblas_ctrmv_strided_batched_full_rank #endif #endif end interface interface rocblas_ztrmv_strided_batched function rocblas_ztrmv_strided_batched_(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ztrmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ztrmv_strided_batched_assumed_rank #else module procedure & rocblas_ztrmv_strided_batched_rank_0,& rocblas_ztrmv_strided_batched_rank_1,& rocblas_ztrmv_strided_batched_full_rank #endif #endif end interface interface rocblas_strmv_strided_batched_64 function rocblas_strmv_strided_batched_64_(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_strmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dtrmv_strided_batched_64 function rocblas_dtrmv_strided_batched_64_(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_dtrmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ctrmv_strided_batched_64 function rocblas_ctrmv_strided_batched_64_(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ctrmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ztrmv_strided_batched_64 function rocblas_ztrmv_strided_batched_64_(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ztrmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The tpmv functions perform one of the matrix-vector operations: !> !> x = A*x or !> x = A**T*x or !> x = A**H*x !> !> where ``x`` is an ``n`` element vector and ``A`` is an ``n`` by ``n`` unit, or non-unit, !> upper or lower triangular matrix, supplied in the pack form. !> The vector ``x`` is overwritten. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A is an upper triangular matrix. !> - rocblas_fill_lower: A is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_none: op(A) = A. !> - rocblas_operation_transpose: op(A) = A^T !> - rocblas_operation_conjugate_transpose: op(A) = A^H !> !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: A is assumed to be unit triangular. !> - rocblas_diagonal_non_unit: A is not assumed to be unit triangular. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows of A. n >= 0. !> !> @param[in] A - device pointer storing matrix A, !> of dimension at leat ( n * ( n + 1 ) / 2 ). !> - Before entry with uplo = rocblas_fill_upper, the array A !> must contain the upper triangular matrix packed sequentially, !> column by column, so that !> A[0] contains a_{0,0}, A[1] and A[2] contain !> a_{0,1} and a_{1, 1}, respectively, and so on. !> !> - Before entry with uplo = rocblas_fill_lower, the array A !> must contain the lower triangular matrix packed sequentially, !> column by column, so that !> A[0] contains a_{0,0}, A[1] and A[2] contain !> a_{1,0} and a_{2,0}, respectively, and so on. !> !> Note that when DIAG = rocblas_diagonal_unit, the diagonal elements of A are !> not referenced, but are assumed to be unity. !> !> @param[in, out] x - device pointer storing vector x. On exit, x is overwritten with the !> transformed vector x. !> !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. incx must not be zero. interface rocblas_stpmv function rocblas_stpmv_(handle,uplo,transA,diag,n,A,x,incx) bind(c, name="rocblas_stpmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_stpmv_assumed_rank #else module procedure & rocblas_stpmv_rank_0,& rocblas_stpmv_rank_1 #endif #endif end interface interface rocblas_dtpmv function rocblas_dtpmv_(handle,uplo,transA,diag,n,A,x,incx) bind(c, name="rocblas_dtpmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dtpmv_assumed_rank #else module procedure & rocblas_dtpmv_rank_0,& rocblas_dtpmv_rank_1 #endif #endif end interface interface rocblas_ctpmv function rocblas_ctpmv_(handle,uplo,transA,diag,n,A,x,incx) bind(c, name="rocblas_ctpmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ctpmv_assumed_rank #else module procedure & rocblas_ctpmv_rank_0,& rocblas_ctpmv_rank_1 #endif #endif end interface interface rocblas_ztpmv function rocblas_ztpmv_(handle,uplo,transA,diag,n,A,x,incx) bind(c, name="rocblas_ztpmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ztpmv_assumed_rank #else module procedure & rocblas_ztpmv_rank_0,& rocblas_ztpmv_rank_1 #endif #endif end interface interface rocblas_stpmv_64 function rocblas_stpmv_64_(handle,uplo,transA,diag,n,A,x,incx) bind(c, name="rocblas_stpmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_dtpmv_64 function rocblas_dtpmv_64_(handle,uplo,transA,diag,n,A,x,incx) bind(c, name="rocblas_dtpmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_ctpmv_64 function rocblas_ctpmv_64_(handle,uplo,transA,diag,n,A,x,incx) bind(c, name="rocblas_ctpmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_ztpmv_64 function rocblas_ztpmv_64_(handle,uplo,transA,diag,n,A,x,incx) bind(c, name="rocblas_ztpmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface !> \brief BLAS Level 2 API !> !> \details !> The tpmv_batched functions perform one of the matrix-vector operations: !> !> x_i = A_i*x_i or !> x_i = A_i**T*x_i or !> x_i = A_i**H*x_i, 0 < i < batch_count !> !> where ``x_i`` is an ``n`` -element vector and ``A_i`` is an ``n`` by ``n`` (unit, or !> non-unit, upper or lower triangular matrix). !> The vectors ``x_i`` are overwritten. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A_i is an upper triangular matrix. !> - rocblas_fill_lower: A_i is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_none: op(A) = A. !> - rocblas_operation_transpose: op(A) = A^T !> - rocblas_operation_conjugate_transpose: op(A) = A^H !> !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: A_i is assumed to be unit triangular. !> - rocblas_diagonal_non_unit: A_i is not assumed to be unit triangular. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows of matrices A_i. n >= 0. !> !> @param[in] A - device pointer to an array of device pointers to the A_i matrices, of !> dimension ( lda, n ). If uplo == rocblas_fill_upper, the upper triangular part of the !> leading n-by-n array contains the matrix A_i. Otherwise the lower triangular part of the !> leading n-by-n array contains the matrix A_i. !> !> @param[in, out] x - device pointer to an array of device pointers to the x_i vectors. On !> exit, each x_i is overwritten with the transformed vector x_i. !> !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of vectors x_i. !> !> @param[in] batch_count - [rocblas_int] !> The number of batched matrices/vectors. interface rocblas_stpmv_batched function rocblas_stpmv_batched_(handle,uplo,transA,diag,n,A,x,incx,batch_count) & bind(c, name="rocblas_stpmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr) :: A type(c_ptr) :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_dtpmv_batched function rocblas_dtpmv_batched_(handle,uplo,transA,diag,n,A,x,incx,batch_count) & bind(c, name="rocblas_dtpmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr) :: A type(c_ptr) :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_ctpmv_batched function rocblas_ctpmv_batched_(handle,uplo,transA,diag,n,A,x,incx,batch_count) & bind(c, name="rocblas_ctpmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr) :: A type(c_ptr) :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_ztpmv_batched function rocblas_ztpmv_batched_(handle,uplo,transA,diag,n,A,x,incx,batch_count) & bind(c, name="rocblas_ztpmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr) :: A type(c_ptr) :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_stpmv_batched_64 function rocblas_stpmv_batched_64_(handle,uplo,transA,diag,n,A,x,incx,batch_count) & bind(c, name="rocblas_stpmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr) :: A type(c_ptr) :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dtpmv_batched_64 function rocblas_dtpmv_batched_64_(handle,uplo,transA,diag,n,A,x,incx,batch_count) & bind(c, name="rocblas_dtpmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr) :: A type(c_ptr) :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ctpmv_batched_64 function rocblas_ctpmv_batched_64_(handle,uplo,transA,diag,n,A,x,incx,batch_count) & bind(c, name="rocblas_ctpmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr) :: A type(c_ptr) :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ztpmv_batched_64 function rocblas_ztpmv_batched_64_(handle,uplo,transA,diag,n,A,x,incx,batch_count) & bind(c, name="rocblas_ztpmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr) :: A type(c_ptr) :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The tpmv_strided_batched functions perform one of the matrix-vector operations: !> !> x_i = A_i*x_i or !> x_i = A_i**T*x_i or !> x_i = A_i**H*x_i, 0 < i < batch_count !> !> where ``x_i`` is an ``n`` -element vector and ``A_i`` is an ``n`` by ``n`` (unit, or !> non-unit, upper or lower triangular) matrix !> with strides specifying how to retrieve ``$x_i$`` (resp. $``A_i$``) from ``$x_{i-1}$`` !> (resp. ``$A_i$`` ). !> The vectors ``x_i`` are overwritten. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A_i is an upper triangular matrix. !> - rocblas_fill_lower: A_i is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_none: op(A) = A. !> - rocblas_operation_transpose: op(A) = A^T !> - rocblas_operation_conjugate_transpose: op(A) = A^H !> !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: A_i is assumed to be unit triangular. !> - rocblas_diagonal_non_unit: A_i is not assumed to be unit triangular. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows of matrices A_i. n >= 0. !> !> @param[in] A - device pointer to the matrix A_1 of the batch, of dimension ( lda, n ). If !> uplo == rocblas_fill_upper, the upper triangular part of the leading n-by-n array contains !> the matrix A_i. Otherwise, the lower triangular part of the leading n-by-n array contains !> the matrix A_i. !> !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one A_i matrix to the next A_{i + 1}. !> !> @param[in, out] x - device pointer to the vector x_1 of the batch. On exit, each x_i is !> overwritten with the transformed vector x_i. !> !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of one vector x. !> !> @param[in] stride_x - [rocblas_stride] !> stride from the start of one x_i vector to the next x_{i + 1}. !> !> @param[in] batch_count - [rocblas_int] !> The number of batched matrices/vectors. interface rocblas_stpmv_strided_batched function rocblas_stpmv_strided_batched_(handle,uplo,transA,diag,n,A,stride_A,x,incx,stride_x, & batch_count) & bind(c, name="rocblas_stpmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_stpmv_strided_batched_assumed_rank #else module procedure & rocblas_stpmv_strided_batched_rank_0,& rocblas_stpmv_strided_batched_rank_1 #endif #endif end interface interface rocblas_dtpmv_strided_batched function rocblas_dtpmv_strided_batched_(handle,uplo,transA,diag,n,A,stride_A,x,incx,stride_x, & batch_count) & bind(c, name="rocblas_dtpmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dtpmv_strided_batched_assumed_rank #else module procedure & rocblas_dtpmv_strided_batched_rank_0,& rocblas_dtpmv_strided_batched_rank_1 #endif #endif end interface interface rocblas_ctpmv_strided_batched function rocblas_ctpmv_strided_batched_(handle,uplo,transA,diag,n,A,stride_A,x,incx,stride_x, & batch_count) & bind(c, name="rocblas_ctpmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ctpmv_strided_batched_assumed_rank #else module procedure & rocblas_ctpmv_strided_batched_rank_0,& rocblas_ctpmv_strided_batched_rank_1 #endif #endif end interface interface rocblas_ztpmv_strided_batched function rocblas_ztpmv_strided_batched_(handle,uplo,transA,diag,n,A,stride_A,x,incx,stride_x, & batch_count) & bind(c, name="rocblas_ztpmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ztpmv_strided_batched_assumed_rank #else module procedure & rocblas_ztpmv_strided_batched_rank_0,& rocblas_ztpmv_strided_batched_rank_1 #endif #endif end interface interface rocblas_stpmv_strided_batched_64 function rocblas_stpmv_strided_batched_64_(handle,uplo,transA,diag,n,A,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_stpmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dtpmv_strided_batched_64 function rocblas_dtpmv_strided_batched_64_(handle,uplo,transA,diag,n,A,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_dtpmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ctpmv_strided_batched_64 function rocblas_ctpmv_strided_batched_64_(handle,uplo,transA,diag,n,A,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ctpmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ztpmv_strided_batched_64 function rocblas_ztpmv_strided_batched_64_(handle,uplo,transA,diag,n,A,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ztpmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The tbmv functions perform one of the matrix-vector operations: !> !> x := A*x or !> x := A**T*x or !> x := A**H*x, !> !> ``x`` is a vector, and ``A`` is a banded ``n`` by ``n`` matrix (see description below). !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A is an upper banded triangular matrix. !> - rocblas_fill_lower: A is a lower banded triangular matrix. !> @param[in] trans - [rocblas_operation] !> indicates whether matrix A is tranposed (conjugated) or not. !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: The main diagonal of A is assumed to consist of only !> 1's and is not referenced. !> - rocblas_diagonal_non_unit: No assumptions are made about the main diagonal of A. !> @param[in] n - [rocblas_int] !> the number of rows and columns of the matrix represented by A. !> @param[in] k - [rocblas_int] !> !> if uplo == rocblas_fill_upper, k specifies the number of super-diagonals !> of the matrix A. !> !> if uplo == rocblas_fill_lower, k specifies the number of sub-diagonals !> of the matrix A. !> k must satisfy k > 0 && k < lda. !> @param[in] A - device pointer storing banded triangular matrix A. !> !> if uplo == rocblas_fill_upper: !> The matrix represented is an upper banded triangular matrix !> with the main diagonal and k super-diagonals, everything !> else can be assumed to be 0. !> The matrix is compacted so that the main diagonal resides on the k'th !> row, the first super diagonal resides on the RHS of the k-1'th row, and so !> forth, !> with the k'th diagonal on the RHS of the 0'th row. !> Ex: (rocblas_fill_upper; n = 5; k = 2) !> 1 6 9 0 0 0 0 9 8 7 !> 0 2 7 8 0 0 6 7 8 9 !> 0 0 3 8 7 ----> 1 2 3 4 5 !> 0 0 0 4 9 0 0 0 0 0 !> 0 0 0 0 5 0 0 0 0 0 !> !> if uplo == rocblas_fill_lower: !> The matrix represnted is a lower banded triangular matrix !> with the main diagonal and k sub-diagonals, everything else can be !> assumed to be 0. !> The matrix is compacted so that the main diagonal resides on the 0'th row, !> working up to the k'th diagonal residing on the LHS of the k'th row. !> Ex: (rocblas_fill_lower; n = 5; k = 2) !> 1 0 0 0 0 1 2 3 4 5 !> 6 2 0 0 0 6 7 8 9 0 !> 9 7 3 0 0 ----> 9 8 7 0 0 !> 0 8 8 4 0 0 0 0 0 0 !> 0 0 7 9 5 0 0 0 0 0 !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. lda must satisfy lda > k. !> @param[in, out] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. interface rocblas_stbmv function rocblas_stbmv_(handle,uplo,trans,diag,n,k,A,lda,x,incx) bind(c, name="rocblas_stbmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_stbmv_assumed_rank #else module procedure & rocblas_stbmv_rank_0,& rocblas_stbmv_rank_1,& rocblas_stbmv_full_rank #endif #endif end interface interface rocblas_dtbmv function rocblas_dtbmv_(handle,uplo,trans,diag,n,k,A,lda,x,incx) bind(c, name="rocblas_dtbmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dtbmv_assumed_rank #else module procedure & rocblas_dtbmv_rank_0,& rocblas_dtbmv_rank_1,& rocblas_dtbmv_full_rank #endif #endif end interface interface rocblas_ctbmv function rocblas_ctbmv_(handle,uplo,trans,diag,n,k,A,lda,x,incx) bind(c, name="rocblas_ctbmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ctbmv_assumed_rank #else module procedure & rocblas_ctbmv_rank_0,& rocblas_ctbmv_rank_1,& rocblas_ctbmv_full_rank #endif #endif end interface interface rocblas_ztbmv function rocblas_ztbmv_(handle,uplo,trans,diag,n,k,A,lda,x,incx) bind(c, name="rocblas_ztbmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ztbmv_assumed_rank #else module procedure & rocblas_ztbmv_rank_0,& rocblas_ztbmv_rank_1,& rocblas_ztbmv_full_rank #endif #endif end interface interface rocblas_stbmv_64 function rocblas_stbmv_64_(handle,uplo,trans,diag,n,k,A,lda,x,incx) & bind(c, name="rocblas_stbmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_dtbmv_64 function rocblas_dtbmv_64_(handle,uplo,trans,diag,n,k,A,lda,x,incx) & bind(c, name="rocblas_dtbmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_ctbmv_64 function rocblas_ctbmv_64_(handle,uplo,trans,diag,n,k,A,lda,x,incx) & bind(c, name="rocblas_ctbmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_ztbmv_64 function rocblas_ztbmv_64_(handle,uplo,trans,diag,n,k,A,lda,x,incx) & bind(c, name="rocblas_ztbmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface !> \brief BLAS Level 2 API !> !> \details !> The tbmv_batched functions perform one of the matrix-vector operations: !> !> x_i := A_i*x_i or !> x_i := A_i**T*x_i or !> x_i := A_i**H*x_i, !> !> where (``A_i``, ``x_i``) is the i-th instance of the batch, !> ``x_i`` is a vector, and ``A_i`` is an ``n`` by ``n`` matrix, for ``i`` = 1, ..., !> ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: each A_i is an upper banded triangular matrix. !> - rocblas_fill_lower: each A_i is a lower banded triangular matrix. !> @param[in] trans - [rocblas_operation] !> indicates whether each matrix A_i is tranposed (conjugated) or not. !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: The main diagonal of each A_i is assumed to consist of !> only !> 1's and is not referenced. !> - rocblas_diagonal_non_unit: No assumptions are made of the main diagonal of each !> A_i. !> @param[in] n - [rocblas_int] !> the number of rows and columns of the matrix represented by each A_i. !> @param[in] k - [rocblas_int] !> !> if uplo == rocblas_fill_upper, k specifies the number of super-diagonals !> of each matrix A_i. !> !> if uplo == rocblas_fill_lower, k specifies the number of sub-diagonals !> of each matrix A_i. !> k must satisfy k > 0 && k < lda. !> @param[in] A - device array of device pointers storing each banded triangular matrix A_i. !> !> if uplo == rocblas_fill_upper: !> The matrix represented is an upper banded triangular matrix !> with the main diagonal and k super-diagonals, everything !> else can be assumed to be 0. !> The matrix is compacted so that the main diagonal resides on the k'th !> row, the first super diagonal resides on the RHS of the k-1'th row, and so !> forth, !> with the k'th diagonal on the RHS of the 0'th row. !> Ex: (rocblas_fill_upper; n = 5; k = 2) !> 1 6 9 0 0 0 0 9 8 7 !> 0 2 7 8 0 0 6 7 8 9 !> 0 0 3 8 7 ----> 1 2 3 4 5 !> 0 0 0 4 9 0 0 0 0 0 !> 0 0 0 0 5 0 0 0 0 0 !> !> if uplo == rocblas_fill_lower: !> The matrix represnted is a lower banded triangular matrix !> with the main diagonal and k sub-diagonals, everything else can be !> assumed to be 0. !> The matrix is compacted so that the main diagonal resides on the 0'th row, !> working up to the k'th diagonal residing on the LHS of the k'th row. !> Ex: (rocblas_fill_lower; n = 5; k = 2) !> 1 0 0 0 0 1 2 3 4 5 !> 6 2 0 0 0 6 7 8 9 0 !> 9 7 3 0 0 ----> 9 8 7 0 0 !> 0 8 8 4 0 0 0 0 0 0 !> 0 0 7 9 5 0 0 0 0 0 !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. lda must satisfy lda > k. !> @param[in, out] x - device array of device pointer storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_stbmv_batched function rocblas_stbmv_batched_(handle,uplo,trans,diag,n,k,A,lda,x,incx,batch_count) & bind(c, name="rocblas_stbmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_dtbmv_batched function rocblas_dtbmv_batched_(handle,uplo,trans,diag,n,k,A,lda,x,incx,batch_count) & bind(c, name="rocblas_dtbmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_ctbmv_batched function rocblas_ctbmv_batched_(handle,uplo,trans,diag,n,k,A,lda,x,incx,batch_count) & bind(c, name="rocblas_ctbmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_ztbmv_batched function rocblas_ztbmv_batched_(handle,uplo,trans,diag,n,k,A,lda,x,incx,batch_count) & bind(c, name="rocblas_ztbmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_stbmv_batched_64 function rocblas_stbmv_batched_64_(handle,uplo,trans,diag,n,k,A,lda,x,incx,batch_count) & bind(c, name="rocblas_stbmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dtbmv_batched_64 function rocblas_dtbmv_batched_64_(handle,uplo,trans,diag,n,k,A,lda,x,incx,batch_count) & bind(c, name="rocblas_dtbmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ctbmv_batched_64 function rocblas_ctbmv_batched_64_(handle,uplo,trans,diag,n,k,A,lda,x,incx,batch_count) & bind(c, name="rocblas_ctbmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ztbmv_batched_64 function rocblas_ztbmv_batched_64_(handle,uplo,trans,diag,n,k,A,lda,x,incx,batch_count) & bind(c, name="rocblas_ztbmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The tbmv_strided_batched functions perform one of the matrix-vector operations: !> !> x_i := A_i*x_i or !> x_i := A_i**T*x_i or !> x_i := A_i**H*x_i, !> !> where (``A_i``, ``x_i``) is the i-th instance of the batch, !> ``x_i`` is a vector, and ``A_i`` is an ``n`` by ``n`` matrix, for ``i`` = 1, ..., !> ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: each A_i is an upper banded triangular matrix. !> - rocblas_fill_lower: each A_i is a lower banded triangular matrix. !> @param[in] trans - [rocblas_operation] !> indicates whether each matrix A_i is tranposed (conjugated) or not. !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: The main diagonal of each A_i is assumed to consist of !> only !> 1's and is not referenced. !> - rocblas_diagonal_non_unit: No assumptions are made of the main diagonal of each !> A_i. !> @param[in] n - [rocblas_int] !> the number of rows and columns of the matrix represented by each A_i. !> @param[in] k - [rocblas_int] !> !> if uplo == rocblas_fill_upper, k specifies the number of super-diagonals !> of each matrix A_i. !> !> if uplo == rocblas_fill_lower, k specifies the number of sub-diagonals !> of each matrix A_i. !> k must satisfy k > 0 && k < lda. !> @param[in] A - device array to the first matrix A_i of the batch. Stores each banded !> triangular matrix A_i. !> !> if uplo == rocblas_fill_upper: !> The matrix represented is an upper banded triangular matrix !> with the main diagonal and k super-diagonals, everything !> else can be assumed to be 0. !> The matrix is compacted so that the main diagonal resides on the k'th !> row, the first super diagonal resides on the RHS of the k-1'th row, and so !> forth, !> with the k'th diagonal on the RHS of the 0'th row. !> Ex: (rocblas_fill_upper; n = 5; k = 2) !> 1 6 9 0 0 0 0 9 8 7 !> 0 2 7 8 0 0 6 7 8 9 !> 0 0 3 8 7 ----> 1 2 3 4 5 !> 0 0 0 4 9 0 0 0 0 0 !> 0 0 0 0 5 0 0 0 0 0 !> !> if uplo == rocblas_fill_lower: !> The matrix represnted is a lower banded triangular matrix !> with the main diagonal and k sub-diagonals, everything else can be !> assumed to be 0. !> The matrix is compacted so that the main diagonal resides on the 0'th row, !> working up to the k'th diagonal residing on the LHS of the k'th row. !> Ex: (rocblas_fill_lower; n = 5; k = 2) !> 1 0 0 0 0 1 2 3 4 5 !> 6 2 0 0 0 6 7 8 9 0 !> 9 7 3 0 0 ----> 9 8 7 0 0 !> 0 8 8 4 0 0 0 0 0 0 !> 0 0 7 9 5 0 0 0 0 0 !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. lda must satisfy lda > k. !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one A_i matrix to the next A_(i + 1). !> @param[in, out] x - device array to the first vector x_i of the batch. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] stride_x - [rocblas_stride] !> stride from the start of one x_i matrix to the next x_(i + 1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_stbmv_strided_batched function rocblas_stbmv_strided_batched_(handle,uplo,trans,diag,n,k,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_stbmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_stbmv_strided_batched_assumed_rank #else module procedure & rocblas_stbmv_strided_batched_rank_0,& rocblas_stbmv_strided_batched_rank_1,& rocblas_stbmv_strided_batched_full_rank #endif #endif end interface interface rocblas_dtbmv_strided_batched function rocblas_dtbmv_strided_batched_(handle,uplo,trans,diag,n,k,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_dtbmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dtbmv_strided_batched_assumed_rank #else module procedure & rocblas_dtbmv_strided_batched_rank_0,& rocblas_dtbmv_strided_batched_rank_1,& rocblas_dtbmv_strided_batched_full_rank #endif #endif end interface interface rocblas_ctbmv_strided_batched function rocblas_ctbmv_strided_batched_(handle,uplo,trans,diag,n,k,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ctbmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ctbmv_strided_batched_assumed_rank #else module procedure & rocblas_ctbmv_strided_batched_rank_0,& rocblas_ctbmv_strided_batched_rank_1,& rocblas_ctbmv_strided_batched_full_rank #endif #endif end interface interface rocblas_ztbmv_strided_batched function rocblas_ztbmv_strided_batched_(handle,uplo,trans,diag,n,k,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ztbmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ztbmv_strided_batched_assumed_rank #else module procedure & rocblas_ztbmv_strided_batched_rank_0,& rocblas_ztbmv_strided_batched_rank_1,& rocblas_ztbmv_strided_batched_full_rank #endif #endif end interface interface rocblas_stbmv_strided_batched_64 function rocblas_stbmv_strided_batched_64_(handle,uplo,trans,diag,n,k,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_stbmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dtbmv_strided_batched_64 function rocblas_dtbmv_strided_batched_64_(handle,uplo,trans,diag,n,k,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_dtbmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ctbmv_strided_batched_64 function rocblas_ctbmv_strided_batched_64_(handle,uplo,trans,diag,n,k,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ctbmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ztbmv_strided_batched_64 function rocblas_ztbmv_strided_batched_64_(handle,uplo,trans,diag,n,k,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ztbmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The tbsv functions solve: !> !> A*x = b or !> A**T*x = b or !> A**H*x = b !> !> where ``x`` and ``b`` are vectors and ``A`` is a banded triangular matrix. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A is an upper triangular matrix. !> - rocblas_fill_lower: A is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_none: Solves A*x = b !> - rocblas_operation_transpose: Solves A**T*x = b !> - rocblas_operation_conjugate_transpose: Solves A**H*x = b !> !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: A is assumed to be unit triangular (the diagonal elements !> of A are not used in computations). !> - rocblas_diagonal_non_unit: A is not assumed to be unit triangular. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows of b. n >= 0. !> @param[in] k - [rocblas_int] !> !> if(uplo == rocblas_fill_upper) !> k specifies the number of super-diagonals of A. !> if(uplo == rocblas_fill_lower) !> k specifies the number of sub-diagonals of A. !> k >= 0. !> !> @param[in] A - device pointer storing the matrix A in banded format. !> !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. !> lda >= (k + 1). !> !> @param[in, out] x - device pointer storing input vector b. Overwritten by the output vector !> x. !> !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. interface rocblas_stbsv function rocblas_stbsv_(handle,uplo,transA,diag,n,k,A,lda,x,incx) bind(c, name="rocblas_stbsv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbsv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_stbsv_assumed_rank #else module procedure & rocblas_stbsv_rank_0,& rocblas_stbsv_rank_1,& rocblas_stbsv_full_rank #endif #endif end interface interface rocblas_dtbsv function rocblas_dtbsv_(handle,uplo,transA,diag,n,k,A,lda,x,incx) bind(c, name="rocblas_dtbsv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbsv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dtbsv_assumed_rank #else module procedure & rocblas_dtbsv_rank_0,& rocblas_dtbsv_rank_1,& rocblas_dtbsv_full_rank #endif #endif end interface interface rocblas_ctbsv function rocblas_ctbsv_(handle,uplo,transA,diag,n,k,A,lda,x,incx) bind(c, name="rocblas_ctbsv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbsv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ctbsv_assumed_rank #else module procedure & rocblas_ctbsv_rank_0,& rocblas_ctbsv_rank_1,& rocblas_ctbsv_full_rank #endif #endif end interface interface rocblas_ztbsv function rocblas_ztbsv_(handle,uplo,transA,diag,n,k,A,lda,x,incx) bind(c, name="rocblas_ztbsv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbsv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ztbsv_assumed_rank #else module procedure & rocblas_ztbsv_rank_0,& rocblas_ztbsv_rank_1,& rocblas_ztbsv_full_rank #endif #endif end interface interface rocblas_stbsv_64 function rocblas_stbsv_64_(handle,uplo,transA,diag,n,k,A,lda,x,incx) & bind(c, name="rocblas_stbsv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbsv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_dtbsv_64 function rocblas_dtbsv_64_(handle,uplo,transA,diag,n,k,A,lda,x,incx) & bind(c, name="rocblas_dtbsv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbsv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_ctbsv_64 function rocblas_ctbsv_64_(handle,uplo,transA,diag,n,k,A,lda,x,incx) & bind(c, name="rocblas_ctbsv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbsv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_ztbsv_64 function rocblas_ztbsv_64_(handle,uplo,transA,diag,n,k,A,lda,x,incx) & bind(c, name="rocblas_ztbsv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbsv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface !> \brief BLAS Level 2 API !> !> \details !> The tbsv_batched functions solve: !> !> A_i*x_i = b_i or !> A_i**T*x_i = b_i or !> A_i**H*x_i = b_i !> !> where ``x_i`` and ``b_i`` are vectors and ``A_i`` is a banded triangular matrix, !> for ``i = [1, batch_count``]. !> !> The input vectors ``b_i`` are overwritten by the output vectors ``x_i``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A_i is an upper triangular matrix. !> - rocblas_fill_lower: A_i is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_none: Solves A_i*x_i = b_i !> - rocblas_operation_transpose: Solves A_i**T*x_i = b_i !> - rocblas_operation_conjugate_transpose: Solves A_i**H*x_i = b_i !> !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: each A_i is assumed to be unit triangular (the diagonal !> elements !> of each A_i are not used in computations). !> - rocblas_diagonal_non_unit: each A_i is not assumed to be unit triangular. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows of each b_i. n >= 0. !> @param[in] k - [rocblas_int] !> !> if(uplo == rocblas_fill_upper) !> k specifies the number of super-diagonals of each A_i. !> if(uplo == rocblas_fill_lower) !> k specifies the number of sub-diagonals of each A_i. !> k >= 0. !> !> @param[in] A - device vector of device pointers storing each matrix A_i in banded format. !> !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. !> lda >= (k + 1). !> !> @param[in, out] x - device vector of device pointers storing each input vector b_i. !> Overwritten by each output !> vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_stbsv_batched function rocblas_stbsv_batched_(handle,uplo,transA,diag,n,k,A,lda,x,incx,batch_count) & bind(c, name="rocblas_stbsv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbsv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_dtbsv_batched function rocblas_dtbsv_batched_(handle,uplo,transA,diag,n,k,A,lda,x,incx,batch_count) & bind(c, name="rocblas_dtbsv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbsv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_ctbsv_batched function rocblas_ctbsv_batched_(handle,uplo,transA,diag,n,k,A,lda,x,incx,batch_count) & bind(c, name="rocblas_ctbsv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbsv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_ztbsv_batched function rocblas_ztbsv_batched_(handle,uplo,transA,diag,n,k,A,lda,x,incx,batch_count) & bind(c, name="rocblas_ztbsv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbsv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_stbsv_batched_64 function rocblas_stbsv_batched_64_(handle,uplo,transA,diag,n,k,A,lda,x,incx,batch_count) & bind(c, name="rocblas_stbsv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbsv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dtbsv_batched_64 function rocblas_dtbsv_batched_64_(handle,uplo,transA,diag,n,k,A,lda,x,incx,batch_count) & bind(c, name="rocblas_dtbsv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbsv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ctbsv_batched_64 function rocblas_ctbsv_batched_64_(handle,uplo,transA,diag,n,k,A,lda,x,incx,batch_count) & bind(c, name="rocblas_ctbsv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbsv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ztbsv_batched_64 function rocblas_ztbsv_batched_64_(handle,uplo,transA,diag,n,k,A,lda,x,incx,batch_count) & bind(c, name="rocblas_ztbsv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbsv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The tbsv_strided_batched functions solve: !> !> A_i*x_i = b_i or !> A_i**T*x_i = b_i or !> A_i**H*x_i = b_i !> !> where ``x_i`` and ``b_i`` are vectors and ``A_i`` is a banded triangular matrix, !> for ``i = [1, batch_count``]. !> !> The input vectors ``b_i`` are overwritten by the output vectors ``x_i``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A_i is an upper triangular matrix. !> - rocblas_fill_lower: A_i is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_none: Solves A_i*x_i = b_i !> - rocblas_operation_transpose: Solves A_i**T*x_i = b_i !> - rocblas_operation_conjugate_transpose: Solves A_i**H*x_i = b_i !> !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: each A_i is assumed to be unit triangular (the diagonal !> elements !> of each A_i are not used in computations). !> - rocblas_diagonal_non_unit: each A_i is not assumed to be unit triangular. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows of each b_i. n >= 0. !> @param[in] k - [rocblas_int] !> !> if(uplo == rocblas_fill_upper) !> k specifies the number of super-diagonals of each A_i. !> if(uplo == rocblas_fill_lower) !> k specifies the number of sub-diagonals of each A_i. !> k >= 0. !> !> @param[in] A - device pointer pointing to the first banded matrix A_1. !> !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. !> lda >= (k + 1). !> @param[in] stride_A - [rocblas_stride] !> specifies the distance between the start of one matrix (A_i) and the next !> (A_i+1). !> !> @param[in, out] x - device pointer pointing to the first input vector b_1. Overwritten by !> output vectors x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] stride_x - [rocblas_stride] !> specifies the distance between the start of one vector (x_i) and the next !> (x_i+1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_stbsv_strided_batched function rocblas_stbsv_strided_batched_(handle,uplo,transA,diag,n,k,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_stbsv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbsv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_stbsv_strided_batched_assumed_rank #else module procedure & rocblas_stbsv_strided_batched_rank_0,& rocblas_stbsv_strided_batched_rank_1,& rocblas_stbsv_strided_batched_full_rank #endif #endif end interface interface rocblas_dtbsv_strided_batched function rocblas_dtbsv_strided_batched_(handle,uplo,transA,diag,n,k,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_dtbsv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbsv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dtbsv_strided_batched_assumed_rank #else module procedure & rocblas_dtbsv_strided_batched_rank_0,& rocblas_dtbsv_strided_batched_rank_1,& rocblas_dtbsv_strided_batched_full_rank #endif #endif end interface interface rocblas_ctbsv_strided_batched function rocblas_ctbsv_strided_batched_(handle,uplo,transA,diag,n,k,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ctbsv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbsv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ctbsv_strided_batched_assumed_rank #else module procedure & rocblas_ctbsv_strided_batched_rank_0,& rocblas_ctbsv_strided_batched_rank_1,& rocblas_ctbsv_strided_batched_full_rank #endif #endif end interface interface rocblas_ztbsv_strided_batched function rocblas_ztbsv_strided_batched_(handle,uplo,transA,diag,n,k,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ztbsv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbsv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ztbsv_strided_batched_assumed_rank #else module procedure & rocblas_ztbsv_strided_batched_rank_0,& rocblas_ztbsv_strided_batched_rank_1,& rocblas_ztbsv_strided_batched_full_rank #endif #endif end interface interface rocblas_stbsv_strided_batched_64 function rocblas_stbsv_strided_batched_64_(handle,uplo,transA,diag,n,k,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_stbsv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbsv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dtbsv_strided_batched_64 function rocblas_dtbsv_strided_batched_64_(handle,uplo,transA,diag,n,k,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_dtbsv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbsv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ctbsv_strided_batched_64 function rocblas_ctbsv_strided_batched_64_(handle,uplo,transA,diag,n,k,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ctbsv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbsv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ztbsv_strided_batched_64 function rocblas_ztbsv_strided_batched_64_(handle,uplo,transA,diag,n,k,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ztbsv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbsv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The trsv functions solve: !> !> A*x = b or !> A**T*x = b or !> A**H*x = b, !> !> where ``x`` and ``b`` are vectors and ``A`` is a triangular matrix. !> The vector ``x`` is overwritten on ``b``. !> !> Although not widespread, some GEMM kernels used by trsv might use atomic operations. !> See Atomic Operations in the API Reference Guide for more information. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A is an upper triangular matrix. !> - rocblas_fill_lower: A is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_none: op(A) = A. !> - rocblas_operation_transpose: op(A) = A^T. !> - rocblas_operation_conjugate_transpose: op(A) = A^H. !> !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: A is assumed to be unit triangular. !> - rocblas_diagonal_non_unit: A is not assumed to be unit triangular. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows of b. n >= 0. !> !> @param[in] A - device pointer storing matrix A, of dimension ( lda, n ). If uplo == !> rocblas_fill_upper, the upper triangular part of the leading n-by-n array contains the !> matrix A. Otherwise, the lower triangular part of the leading n-by-n array contains the !> matrix A. !> !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. lda must be at least max( 1, n ). !> !> @param[in, out] x - device pointer storing vector x. On exit, x is overwritten with the !> transformed vector x. !> !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. interface rocblas_strsv function rocblas_strsv_(handle,uplo,transA,diag,n,A,lda,x,incx) bind(c, name="rocblas_strsv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_strsv_assumed_rank #else module procedure & rocblas_strsv_rank_0,& rocblas_strsv_rank_1,& rocblas_strsv_full_rank #endif #endif end interface interface rocblas_dtrsv function rocblas_dtrsv_(handle,uplo,transA,diag,n,A,lda,x,incx) bind(c, name="rocblas_dtrsv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dtrsv_assumed_rank #else module procedure & rocblas_dtrsv_rank_0,& rocblas_dtrsv_rank_1,& rocblas_dtrsv_full_rank #endif #endif end interface interface rocblas_ctrsv function rocblas_ctrsv_(handle,uplo,transA,diag,n,A,lda,x,incx) bind(c, name="rocblas_ctrsv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ctrsv_assumed_rank #else module procedure & rocblas_ctrsv_rank_0,& rocblas_ctrsv_rank_1,& rocblas_ctrsv_full_rank #endif #endif end interface interface rocblas_ztrsv function rocblas_ztrsv_(handle,uplo,transA,diag,n,A,lda,x,incx) bind(c, name="rocblas_ztrsv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ztrsv_assumed_rank #else module procedure & rocblas_ztrsv_rank_0,& rocblas_ztrsv_rank_1,& rocblas_ztrsv_full_rank #endif #endif end interface interface rocblas_strsv_64 function rocblas_strsv_64_(handle,uplo,transA,diag,n,A,lda,x,incx) & bind(c, name="rocblas_strsv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_dtrsv_64 function rocblas_dtrsv_64_(handle,uplo,transA,diag,n,A,lda,x,incx) & bind(c, name="rocblas_dtrsv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_ctrsv_64 function rocblas_ctrsv_64_(handle,uplo,transA,diag,n,A,lda,x,incx) & bind(c, name="rocblas_ctrsv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_ztrsv_64 function rocblas_ztrsv_64_(handle,uplo,transA,diag,n,A,lda,x,incx) & bind(c, name="rocblas_ztrsv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface !> \brief BLAS Level 2 API !> !> \details !> The trsv_batched functions solve: !> !> A_i*x_i = b_i or !> A_i**T*x_i = b_i or !> A_i**H*x_i = b_i, !> !> where (``A_i``, ``x_i``, ``b_i``) is the i-th instance of the batch. !> ``x_i`` and ``b_i`` are vectors and ``A_i`` is an !> ``n`` by ``n`` triangular matrix. !> !> The vector ``x`` is overwritten on ``b``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A is an upper triangular matrix. !> - rocblas_fill_lower: A is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_none: op(A) = A. !> - rocblas_operation_transpose: op(A) = A^T. !> - rocblas_operation_conjugate_transpose: op(A) = A^H. !> !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: A is assumed to be unit triangular. !> - rocblas_diagonal_non_unit: A is not assumed to be unit triangular. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows of b. n >= 0. !> !> @param[in] A - device pointer to an array of device pointers to the A_i matrices, of !> dimension ( lda, n ). If uplo == rocblas_fill_upper, the upper triangular part of the !> leading n-by-n array contains the matrix A_i. Otherwise, the lower triangular part of the !> leading n-by-n array contains the matrix A_i. !> !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A_i. lda must be at least max( 1, n ). !> !> @param[in, out] x - device pointer to an array of device pointers to the x_i vectors. On !> exit, each x_i is overwritten with the transformed vector x_i. !> !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_strsv_batched function rocblas_strsv_batched_(handle,uplo,transA,diag,n,A,lda,x,incx,batch_count) & bind(c, name="rocblas_strsv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_dtrsv_batched function rocblas_dtrsv_batched_(handle,uplo,transA,diag,n,A,lda,x,incx,batch_count) & bind(c, name="rocblas_dtrsv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_ctrsv_batched function rocblas_ctrsv_batched_(handle,uplo,transA,diag,n,A,lda,x,incx,batch_count) & bind(c, name="rocblas_ctrsv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_ztrsv_batched function rocblas_ztrsv_batched_(handle,uplo,transA,diag,n,A,lda,x,incx,batch_count) & bind(c, name="rocblas_ztrsv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_strsv_batched_64 function rocblas_strsv_batched_64_(handle,uplo,transA,diag,n,A,lda,x,incx,batch_count) & bind(c, name="rocblas_strsv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dtrsv_batched_64 function rocblas_dtrsv_batched_64_(handle,uplo,transA,diag,n,A,lda,x,incx,batch_count) & bind(c, name="rocblas_dtrsv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ctrsv_batched_64 function rocblas_ctrsv_batched_64_(handle,uplo,transA,diag,n,A,lda,x,incx,batch_count) & bind(c, name="rocblas_ctrsv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ztrsv_batched_64 function rocblas_ztrsv_batched_64_(handle,uplo,transA,diag,n,A,lda,x,incx,batch_count) & bind(c, name="rocblas_ztrsv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The trsv_strided_batched functions solve: !> !> A_i*x_i = b_i or !> A_i**T*x_i = b_i or !> A_i**H*x_i = b_i, !> !> where (``A_i``, ``x_i``, ``b_i``) is the i-th instance of the batch, !> ``x_i`` and ``b_i`` are vectors, and ``A_i`` is an ``n`` by ``n`` triangular matrix, for !> ``i`` = 1, ..., ``batch_count``. !> !> The vector ``x`` is overwritten on ``b``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A is an upper triangular matrix. !> - rocblas_fill_lower: A is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_none: op(A) = A. !> - rocblas_operation_transpose: op(A) = A^T. !> - rocblas_operation_conjugate_transpose: op(A) = A^H. !> !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: A is assumed to be unit triangular. !> - rocblas_diagonal_non_unit: A is not assumed to be unit triangular. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows of each b_i. n >= 0. !> !> @param[in] A - device pointer to the matrix A_1 of the batch, of dimension ( lda, n ). If !> uplo == rocblas_fill_upper, the upper triangular part of the leading n-by-n array contains !> the matrix A_i. Otherwise, the lower triangular part of the leading n-by-n array contains !> the matrix A_i. !> !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one A_i matrix to the next A_(i + 1). !> !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A_i. lda must be at least max( 1, n ). !> !> @param[in, out] x - device pointer to the vector x_1 of the batch. On exit, each x_i is !> overwritten with the transformed vector x_i. !> !> @param[in] stride_x - [rocblas_stride] !> stride from the start of one x_i vector to the next x_(i + 1) !> !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_strsv_strided_batched function rocblas_strsv_strided_batched_(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_strsv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_strsv_strided_batched_assumed_rank #else module procedure & rocblas_strsv_strided_batched_rank_0,& rocblas_strsv_strided_batched_rank_1,& rocblas_strsv_strided_batched_full_rank #endif #endif end interface interface rocblas_dtrsv_strided_batched function rocblas_dtrsv_strided_batched_(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_dtrsv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dtrsv_strided_batched_assumed_rank #else module procedure & rocblas_dtrsv_strided_batched_rank_0,& rocblas_dtrsv_strided_batched_rank_1,& rocblas_dtrsv_strided_batched_full_rank #endif #endif end interface interface rocblas_ctrsv_strided_batched function rocblas_ctrsv_strided_batched_(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ctrsv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ctrsv_strided_batched_assumed_rank #else module procedure & rocblas_ctrsv_strided_batched_rank_0,& rocblas_ctrsv_strided_batched_rank_1,& rocblas_ctrsv_strided_batched_full_rank #endif #endif end interface interface rocblas_ztrsv_strided_batched function rocblas_ztrsv_strided_batched_(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ztrsv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ztrsv_strided_batched_assumed_rank #else module procedure & rocblas_ztrsv_strided_batched_rank_0,& rocblas_ztrsv_strided_batched_rank_1,& rocblas_ztrsv_strided_batched_full_rank #endif #endif end interface interface rocblas_strsv_strided_batched_64 function rocblas_strsv_strided_batched_64_(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_strsv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dtrsv_strided_batched_64 function rocblas_dtrsv_strided_batched_64_(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_dtrsv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ctrsv_strided_batched_64 function rocblas_ctrsv_strided_batched_64_(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ctrsv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ztrsv_strided_batched_64 function rocblas_ztrsv_strided_batched_64_(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ztrsv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The tpsv functions solve: !> !> A*x = b or !> A**T*x = b or !> A**H*x = b !> !> where ``x`` and ``b`` are vectors and ``A`` is a triangular matrix stored in the packed !> format. !> !> The input vector ``b`` is overwritten by the output vector ``x``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A is an upper triangular matrix. !> - rocblas_fill_lower: A is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_none: Solves A*x = b. !> - rocblas_operation_transpose: Solves A**T*x = b. !> - rocblas_operation_conjugate_transpose: Solves A**H*x = b. !> !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: A is assumed to be unit triangular (the diagonal elements !> of A are not used in computations). !> - rocblas_diagonal_non_unit: A is not assumed to be unit triangular. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows of b. n >= 0. !> !> @param[in] AP - device pointer storing the packed version of matrix A, !> of dimension >= (n * (n + 1) / 2). !> !> @param[in, out] x - device pointer storing vector b on input, overwritten by x on output. !> !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. interface rocblas_stpsv function rocblas_stpsv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="rocblas_stpsv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpsv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_stpsv_assumed_rank #else module procedure & rocblas_stpsv_rank_0,& rocblas_stpsv_rank_1 #endif #endif end interface interface rocblas_dtpsv function rocblas_dtpsv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="rocblas_dtpsv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpsv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dtpsv_assumed_rank #else module procedure & rocblas_dtpsv_rank_0,& rocblas_dtpsv_rank_1 #endif #endif end interface interface rocblas_ctpsv function rocblas_ctpsv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="rocblas_ctpsv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpsv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ctpsv_assumed_rank #else module procedure & rocblas_ctpsv_rank_0,& rocblas_ctpsv_rank_1 #endif #endif end interface interface rocblas_ztpsv function rocblas_ztpsv_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="rocblas_ztpsv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpsv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ztpsv_assumed_rank #else module procedure & rocblas_ztpsv_rank_0,& rocblas_ztpsv_rank_1 #endif #endif end interface interface rocblas_stpsv_64 function rocblas_stpsv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="rocblas_stpsv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpsv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_dtpsv_64 function rocblas_dtpsv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="rocblas_dtpsv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpsv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_ctpsv_64 function rocblas_ctpsv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="rocblas_ctpsv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpsv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocblas_ztpsv_64 function rocblas_ztpsv_64_(handle,uplo,transA,diag,n,AP,x,incx) bind(c, name="rocblas_ztpsv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpsv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface !> \brief BLAS Level 2 API !> !> \details !> The tpsv_batched functions solve: !> !> A_i*x_i = b_i or !> A_i**T*x_i = b_i or !> A_i**H*x_i = b_i !> !> where ``x_i`` and ``b_i`` are vectors and ``A_i`` is a triangular matrix stored in the !> packed format, !> for ``i in [1, batch_count``]. !> !> The input vectors ``b_i`` are overwritten by the output vectors ``x_i``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: each A_i is an upper triangular matrix. !> - rocblas_fill_lower: each A_i is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_none: Solves A*x = b. !> - rocblas_operation_transpose: Solves A**T*x = b. !> - rocblas_operation_conjugate_transpose: Solves A**H*x = b. !> !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: Each A_i is assumed to be unit triangular (the diagonal !> elements !> of each A_i are not used in computations). !> - rocblas_diagonal_non_unit: each A_i is not assumed to be unit triangular. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows of each b_i. n >= 0. !> !> @param[in] AP - device array of device pointers storing the packed versions of each matrix !> A_i, !> of dimension >= (n * (n + 1) / 2). !> !> @param[in, out] x - device array of device pointers storing each input vector b_i, !> overwritten by x_i on output. !> !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] batch_count - [rocblas_int] !> specifies the number of instances in the batch. interface rocblas_stpsv_batched function rocblas_stpsv_batched_(handle,uplo,transA,diag,n,AP,x,incx,batch_count) & bind(c, name="rocblas_stpsv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpsv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_dtpsv_batched function rocblas_dtpsv_batched_(handle,uplo,transA,diag,n,AP,x,incx,batch_count) & bind(c, name="rocblas_dtpsv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpsv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_ctpsv_batched function rocblas_ctpsv_batched_(handle,uplo,transA,diag,n,AP,x,incx,batch_count) & bind(c, name="rocblas_ctpsv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpsv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_ztpsv_batched function rocblas_ztpsv_batched_(handle,uplo,transA,diag,n,AP,x,incx,batch_count) & bind(c, name="rocblas_ztpsv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpsv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int),value :: batch_count end function end interface interface rocblas_stpsv_batched_64 function rocblas_stpsv_batched_64_(handle,uplo,transA,diag,n,AP,x,incx,batch_count) & bind(c, name="rocblas_stpsv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpsv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dtpsv_batched_64 function rocblas_dtpsv_batched_64_(handle,uplo,transA,diag,n,AP,x,incx,batch_count) & bind(c, name="rocblas_dtpsv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpsv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ctpsv_batched_64 function rocblas_ctpsv_batched_64_(handle,uplo,transA,diag,n,AP,x,incx,batch_count) & bind(c, name="rocblas_ctpsv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpsv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ztpsv_batched_64 function rocblas_ztpsv_batched_64_(handle,uplo,transA,diag,n,AP,x,incx,batch_count) & bind(c, name="rocblas_ztpsv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpsv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The tpsv_strided_batched functions solve: !> !> A_i*x_i = b_i or !> A_i**T*x_i = b_i or !> A_i**H*x_i = b_i !> !> where ``x_i`` and ``b_i`` are vectors and ``A_i`` is a triangular matrix stored in the !> packed format, !> for ``i in [1, batch_count``]. !> !> The input vectors ``b_i`` are overwritten by the output vectors ``x_i``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: each A_i is an upper triangular matrix. !> - rocblas_fill_lower: each A_i is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_none: Solves A*x = b. !> - rocblas_operation_transpose: Solves A**T*x = b. !> - rocblas_operation_conjugate_transpose: Solves A**H*x = b. !> !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: each A_i is assumed to be unit triangular (the diagonal !> elements !> of each A_i are not used in computations). !> - rocblas_diagonal_non_unit: each A_i is not assumed to be unit triangular. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows of each b_i. n >= 0. !> !> @param[in] AP - device pointer pointing to the first packed matrix A_1, !> of dimension >= (n * (n + 1) / 2). !> !> @param[in] stride_A - [rocblas_stride] !> stride from the beginning of one packed matrix (AP_i) to the next (AP_i+1). !> !> @param[in, out] x - device pointer pointing to the first input vector b_1. Overwritten by !> each x_i on output. !> !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] stride_x - [rocblas_stride] !> stride from the beginning of one vector (x_i) to the next (x_i+1). !> @param[in] batch_count - [rocblas_int] !> specifies the number of instances in the batch. interface rocblas_stpsv_strided_batched function rocblas_stpsv_strided_batched_(handle,uplo,transA,diag,n,AP,stride_A,x,incx,stride_x, & batch_count) & bind(c, name="rocblas_stpsv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpsv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_stpsv_strided_batched_assumed_rank #else module procedure & rocblas_stpsv_strided_batched_rank_0,& rocblas_stpsv_strided_batched_rank_1 #endif #endif end interface interface rocblas_dtpsv_strided_batched function rocblas_dtpsv_strided_batched_(handle,uplo,transA,diag,n,AP,stride_A,x,incx,stride_x, & batch_count) & bind(c, name="rocblas_dtpsv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpsv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dtpsv_strided_batched_assumed_rank #else module procedure & rocblas_dtpsv_strided_batched_rank_0,& rocblas_dtpsv_strided_batched_rank_1 #endif #endif end interface interface rocblas_ctpsv_strided_batched function rocblas_ctpsv_strided_batched_(handle,uplo,transA,diag,n,AP,stride_A,x,incx,stride_x, & batch_count) & bind(c, name="rocblas_ctpsv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpsv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ctpsv_strided_batched_assumed_rank #else module procedure & rocblas_ctpsv_strided_batched_rank_0,& rocblas_ctpsv_strided_batched_rank_1 #endif #endif end interface interface rocblas_ztpsv_strided_batched function rocblas_ztpsv_strided_batched_(handle,uplo,transA,diag,n,AP,stride_A,x,incx,stride_x, & batch_count) & bind(c, name="rocblas_ztpsv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpsv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ztpsv_strided_batched_assumed_rank #else module procedure & rocblas_ztpsv_strided_batched_rank_0,& rocblas_ztpsv_strided_batched_rank_1 #endif #endif end interface interface rocblas_stpsv_strided_batched_64 function rocblas_stpsv_strided_batched_64_(handle,uplo,transA,diag,n,AP,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_stpsv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpsv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dtpsv_strided_batched_64 function rocblas_dtpsv_strided_batched_64_(handle,uplo,transA,diag,n,AP,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_dtpsv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpsv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ctpsv_strided_batched_64 function rocblas_ctpsv_strided_batched_64_(handle,uplo,transA,diag,n,AP,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ctpsv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpsv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ztpsv_strided_batched_64 function rocblas_ztpsv_strided_batched_64_(handle,uplo,transA,diag,n,AP,stride_A,x,incx, & stride_x,batch_count) & bind(c, name="rocblas_ztpsv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpsv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: n type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The symv functions perform the matrix-vector operation: !> !> y := alpha*A*x + beta*y !> !> where ``alpha`` and ``beta`` are scalars, and ``x`` and ``y`` are ``n``-element vectors. !> ``A`` should contain an upper or lower triangular ``n`` by ``n`` symmetric matrix. !> !> symv has an implementation which uses atomic operations. See Atomic Operations !> in the API Reference Guide for more information. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - if rocblas_fill_upper, the lower part of A is not referenced. !> - if rocblas_fill_lower, the upper part of A is not referenced. !> @param[in] n - [rocblas_int] !> @param[in] alpha !> specifies the scalar alpha. !> @param[in] A - pointer storing matrix A on the GPU. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. !> @param[in] x - pointer storing vector x on the GPU. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in] beta - specifies the scalar beta. !> @param[out] y - pointer storing vector y on the GPU. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. interface rocblas_ssymv function rocblas_ssymv_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_ssymv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ssymv_assumed_rank #else module procedure & rocblas_ssymv_rank_0,& rocblas_ssymv_rank_1,& rocblas_ssymv_full_rank #endif #endif end interface interface rocblas_dsymv function rocblas_dsymv_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_dsymv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dsymv_assumed_rank #else module procedure & rocblas_dsymv_rank_0,& rocblas_dsymv_rank_1,& rocblas_dsymv_full_rank #endif #endif end interface interface rocblas_csymv function rocblas_csymv_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_csymv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_csymv_assumed_rank #else module procedure & rocblas_csymv_rank_0,& rocblas_csymv_rank_1,& rocblas_csymv_full_rank #endif #endif end interface interface rocblas_zsymv function rocblas_zsymv_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_zsymv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zsymv_assumed_rank #else module procedure & rocblas_zsymv_rank_0,& rocblas_zsymv_rank_1,& rocblas_zsymv_full_rank #endif #endif end interface interface rocblas_ssymv_64 function rocblas_ssymv_64_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_ssymv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_dsymv_64 function rocblas_dsymv_64_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_dsymv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_csymv_64 function rocblas_csymv_64_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_csymv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_zsymv_64 function rocblas_zsymv_64_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_zsymv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 2 API !> !> \details !> The symv_batched functions perform the matrix-vector operation: !> !> y_i := alpha*A_i*x_i + beta*y_i !> !> where (``A_i``, ``x_i``, ``y_i``) is the i-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, for ``i`` = 1, ..., ``batch_count``. !> ``A`` should contain an upper or lower triangular symmetric matrix. !> The opposing triangular part of ``A`` is not referenced. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - if rocblas_fill_upper, the lower part of A is not referenced. !> - if rocblas_fill_lower, the upper part of A is not referenced. !> @param[in] n - [rocblas_int] !> number of rows and columns of each matrix A_i. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] A - device array of device pointers storing each matrix A_i. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each matrix A_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each vector x_i. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[out] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each vector y_i. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_ssymv_batched function rocblas_ssymv_batched_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_ssymv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_dsymv_batched function rocblas_dsymv_batched_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_dsymv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_csymv_batched function rocblas_csymv_batched_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_csymv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_zsymv_batched function rocblas_zsymv_batched_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_zsymv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_ssymv_batched_64 function rocblas_ssymv_batched_64_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_ssymv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dsymv_batched_64 function rocblas_dsymv_batched_64_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_dsymv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_csymv_batched_64 function rocblas_csymv_batched_64_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_csymv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zsymv_batched_64 function rocblas_zsymv_batched_64_(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_zsymv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The symv_strided_batched functions perform the matrix-vector operation: !> !> y_i := alpha*A_i*x_i + beta*y_i !> !> where (``A_i``, ``x_i``, ``y_i``) is the i-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, for ``i`` = 1, ..., ``batch_count``. !> ``A`` should contain an upper or lower triangular symmetric matrix. !> The opposing triangular part of ``A`` is not referenced. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - if rocblas_fill_upper, the lower part of A is not referenced. !> - if rocblas_fill_lower, the upper part of A is not referenced. !> @param[in] n - [rocblas_int] !> number of rows and columns of each matrix A_i. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] A - Device pointer to the first matrix A_1 on the GPU. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each matrix A_i. !> @param[in] strideA - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> @param[in] x - Device pointer to the first vector x_1 on the GPU. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each vector x_i. !> @param[in] stridex - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stride_x. However, ensure that stridex is !> of an appropriate size. !> This typically means stridex >= n * incx. stridex should be non zero. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[out] y - Device pointer to the first vector y_1 on the GPU. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each vector y_i. !> @param[in] stridey - [rocblas_stride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> There are no restrictions placed on stride_y. However, ensure that stridey is !> of an appropriate size. !> This typically means stridey >= n * incy. stridey should be non zero. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_ssymv_strided_batched function rocblas_ssymv_strided_batched_(handle,uplo,n,alpha,A,lda,strideA,x,incx,stridex,beta, & y,incy,stridey,batch_count) & bind(c, name="rocblas_ssymv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ssymv_strided_batched_assumed_rank #else module procedure & rocblas_ssymv_strided_batched_rank_0,& rocblas_ssymv_strided_batched_rank_1,& rocblas_ssymv_strided_batched_full_rank #endif #endif end interface interface rocblas_dsymv_strided_batched function rocblas_dsymv_strided_batched_(handle,uplo,n,alpha,A,lda,strideA,x,incx,stridex,beta, & y,incy,stridey,batch_count) & bind(c, name="rocblas_dsymv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dsymv_strided_batched_assumed_rank #else module procedure & rocblas_dsymv_strided_batched_rank_0,& rocblas_dsymv_strided_batched_rank_1,& rocblas_dsymv_strided_batched_full_rank #endif #endif end interface interface rocblas_csymv_strided_batched function rocblas_csymv_strided_batched_(handle,uplo,n,alpha,A,lda,strideA,x,incx,stridex,beta, & y,incy,stridey,batch_count) & bind(c, name="rocblas_csymv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_csymv_strided_batched_assumed_rank #else module procedure & rocblas_csymv_strided_batched_rank_0,& rocblas_csymv_strided_batched_rank_1,& rocblas_csymv_strided_batched_full_rank #endif #endif end interface interface rocblas_zsymv_strided_batched function rocblas_zsymv_strided_batched_(handle,uplo,n,alpha,A,lda,strideA,x,incx,stridex,beta, & y,incy,stridey,batch_count) & bind(c, name="rocblas_zsymv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zsymv_strided_batched_assumed_rank #else module procedure & rocblas_zsymv_strided_batched_rank_0,& rocblas_zsymv_strided_batched_rank_1,& rocblas_zsymv_strided_batched_full_rank #endif #endif end interface interface rocblas_ssymv_strided_batched_64 function rocblas_ssymv_strided_batched_64_(handle,uplo,n,alpha,A,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_ssymv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dsymv_strided_batched_64 function rocblas_dsymv_strided_batched_64_(handle,uplo,n,alpha,A,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_dsymv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_csymv_strided_batched_64 function rocblas_csymv_strided_batched_64_(handle,uplo,n,alpha,A,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_csymv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex complex(c_float_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zsymv_strided_batched_64 function rocblas_zsymv_strided_batched_64_(handle,uplo,n,alpha,A,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_zsymv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex complex(c_double_complex) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The spmv functions perform the matrix-vector operation: !> !> y := alpha*A*x + beta*y !> !> where ``alpha`` and ``beta`` are scalars, and ``x`` and ``y`` are ``n``-element vectors. !> ``A`` should contain an upper or lower triangular ``n`` by ``n`` packed symmetric matrix. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - if rocblas_fill_upper, the lower part of A is not referenced. !> - if rocblas_fill_lower, the upper part of A is not referenced. !> @param[in] n - [rocblas_int] !> @param[in] alpha !> specifies the scalar alpha. !> @param[in] A - pointer storing matrix A on the GPU. !> @param[in] x - pointer storing vector x on the GPU. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in] beta - specifies the scalar beta. !> @param[out] y - pointer storing vector y on the GPU. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. interface rocblas_sspmv function rocblas_sspmv_(handle,uplo,n,alpha,A,x,incx,beta,y,incy) bind(c, name="rocblas_sspmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sspmv_assumed_rank #else module procedure & rocblas_sspmv_rank_0,& rocblas_sspmv_rank_1 #endif #endif end interface interface rocblas_dspmv function rocblas_dspmv_(handle,uplo,n,alpha,A,x,incx,beta,y,incy) bind(c, name="rocblas_dspmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dspmv_assumed_rank #else module procedure & rocblas_dspmv_rank_0,& rocblas_dspmv_rank_1 #endif #endif end interface interface rocblas_sspmv_64 function rocblas_sspmv_64_(handle,uplo,n,alpha,A,x,incx,beta,y,incy) & bind(c, name="rocblas_sspmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_dspmv_64 function rocblas_dspmv_64_(handle,uplo,n,alpha,A,x,incx,beta,y,incy) & bind(c, name="rocblas_dspmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 2 API !> !> \details !> The spmv_batched functions perform the matrix-vector operation: !> !> y_i := alpha*A_i*x_i + beta*y_i !> !> where (``A_i``, ``x_i``, ``y_i``) is the i-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, for ``i`` = 1, ..., ``batch_count``. !> ``A`` should contain an upper or lower triangular ``n`` by ``n`` packed symmetric matrix. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - if rocblas_fill_upper, the lower part of A is not referenced. !> - if rocblas_fill_lower, the upper part of A is not referenced. !> @param[in] n - [rocblas_int] !> number of rows and columns of each matrix A_i. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] A - device array of device pointers storing each matrix A_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each vector x_i. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[out] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each vector y_i. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_sspmv_batched function rocblas_sspmv_batched_(handle,uplo,n,alpha,A,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_sspmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_dspmv_batched function rocblas_dspmv_batched_(handle,uplo,n,alpha,A,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_dspmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_sspmv_batched_64 function rocblas_sspmv_batched_64_(handle,uplo,n,alpha,A,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_sspmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dspmv_batched_64 function rocblas_dspmv_batched_64_(handle,uplo,n,alpha,A,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_dspmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The spmv_strided_batched functions perform the matrix-vector operation: !> !> y_i := alpha*A_i*x_i + beta*y_i !> !> where (``A_i``, ``x_i``, ``y_i``) is the i-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, for ``i`` = 1, ..., ``batch_count``. !> ``A`` should contain an upper or lower triangular ``n`` by ``n`` packed symmetric matrix. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - if rocblas_fill_upper, the lower part of A is not referenced. !> - if rocblas_fill_lower, the upper part of A is not referenced. !> @param[in] n - [rocblas_int] !> number of rows and columns of each matrix A_i. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] A - Device pointer to the first matrix A_1 on the GPU. !> @param[in] strideA - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> @param[in] x - Device pointer to the first vector x_1 on the GPU. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each vector x_i. !> @param[in] stridex - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stridex. However, ensure that stridex is of !> an appropriate size. !> This typically means stridex >= n * incx. stridex should be non zero. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[out] y - Device pointer to the first vector y_1 on the GPU. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each vector y_i. !> @param[in] stridey - [rocblas_stride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> There are no restrictions placed on stridey. However, ensure that stridey is of !> an appropriate size. !> This typically means stridey >= n * incy. stridey should be non zero. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_sspmv_strided_batched function rocblas_sspmv_strided_batched_(handle,uplo,n,alpha,A,strideA,x,incx,stridex,beta,y, & incy,stridey,batch_count) & bind(c, name="rocblas_sspmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sspmv_strided_batched_assumed_rank #else module procedure & rocblas_sspmv_strided_batched_rank_0,& rocblas_sspmv_strided_batched_rank_1 #endif #endif end interface interface rocblas_dspmv_strided_batched function rocblas_dspmv_strided_batched_(handle,uplo,n,alpha,A,strideA,x,incx,stridex,beta,y, & incy,stridey,batch_count) & bind(c, name="rocblas_dspmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dspmv_strided_batched_assumed_rank #else module procedure & rocblas_dspmv_strided_batched_rank_0,& rocblas_dspmv_strided_batched_rank_1 #endif #endif end interface interface rocblas_sspmv_strided_batched_64 function rocblas_sspmv_strided_batched_64_(handle,uplo,n,alpha,A,strideA,x,incx,stridex,beta, & y,incy,stridey,batch_count) & bind(c, name="rocblas_sspmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dspmv_strided_batched_64 function rocblas_dspmv_strided_batched_64_(handle,uplo,n,alpha,A,strideA,x,incx,stridex,beta, & y,incy,stridey,batch_count) & bind(c, name="rocblas_dspmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The sbmv functions perform the matrix-vector operation: !> !> y := alpha*A*x + beta*y !> !> where ``alpha`` and ``beta`` are scalars, and ``x`` and ``y`` are ``n``-element vectors. !> ``A`` should contain an upper or lower triangular ``n`` by ``n ``symmetric banded matrix. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - if rocblas_fill_upper, the lower part of A is not referenced. !> - if rocblas_fill_lower, the upper part of A is not referenced. !> @param[in] n - [rocblas_int] !> @param[in] k - [rocblas_int] !> specifies the number of sub- and super-diagonals. !> @param[in] alpha !> specifies the scalar alpha. !> @param[in] A - pointer storing matrix A on the GPU. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of matrix A. !> @param[in] x - pointer storing vector x on the GPU. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in] beta - specifies the scalar beta. !> @param[out] y - pointer storing vector y on the GPU. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. interface rocblas_ssbmv function rocblas_ssbmv_(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_ssbmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssbmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ssbmv_assumed_rank #else module procedure & rocblas_ssbmv_rank_0,& rocblas_ssbmv_rank_1,& rocblas_ssbmv_full_rank #endif #endif end interface interface rocblas_dsbmv function rocblas_dsbmv_(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_dsbmv") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsbmv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dsbmv_assumed_rank #else module procedure & rocblas_dsbmv_rank_0,& rocblas_dsbmv_rank_1,& rocblas_dsbmv_full_rank #endif #endif end interface interface rocblas_ssbmv_64 function rocblas_ssbmv_64_(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_ssbmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssbmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface interface rocblas_dsbmv_64 function rocblas_dsbmv_64_(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) & bind(c, name="rocblas_dsbmv_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsbmv_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy end function end interface !> \brief BLAS Level 2 API !> !> \details !> The sbmv_batched functions perform the matrix-vector operation: !> !> y_i := alpha*A_i*x_i + beta*y_i !> !> where (``A_i``, ``x_i``, ``y_i``) is the i-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` symmetric banded matrix, for ``i`` = 1, ..., ``batch_count``. !> ``A`` should contain an upper or lower triangular ``n`` by ``n`` symmetric banded matrix. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - if rocblas_fill_upper, the lower part of A is not referenced. !> - if rocblas_fill_lower, the upper part of A is not referenced. !> @param[in] n - [rocblas_int] !> number of rows and columns of each matrix A_i. !> @param[in] k - [rocblas_int] !> specifies the number of sub- and super-diagonals. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] A - device array of device pointers storing each matrix A_i. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each matrix A_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each vector x_i. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[out] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each vector y_i. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_ssbmv_batched function rocblas_ssbmv_batched_(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_ssbmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssbmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_dsbmv_batched function rocblas_dsbmv_batched_(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_dsbmv_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsbmv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int),value :: batch_count end function end interface interface rocblas_ssbmv_batched_64 function rocblas_ssbmv_batched_64_(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_ssbmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssbmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dsbmv_batched_64 function rocblas_dsbmv_batched_64_(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy,batch_count) & bind(c, name="rocblas_dsbmv_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsbmv_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The sbmv_strided_batched functions perform the matrix-vector operation: !> !> y_i := alpha*A_i*x_i + beta*y_i !> !> where (``A_i``, ``x_i``, ``y_i``) is the i-th instance of the batch, !> ``alpha`` and ``beta`` are scalars, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` symmetric banded matrix, for ``i`` = 1, ..., ``batch_count``. !> ``A`` should contain an upper or lower triangular ``n`` by ``n`` symmetric banded matrix. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - if rocblas_fill_upper, the lower part of A is not referenced. !> - if rocblas_fill_lower, the upper part of A is not referenced. !> @param[in] n - [rocblas_int] !> number of rows and columns of each matrix A_i. !> @param[in] k - [rocblas_int] !> specifies the number of sub- and super-diagonals. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] A - Device pointer to the first matrix A_1 on the GPU. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each matrix A_i. !> @param[in] strideA - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> @param[in] x - Device pointer to the first vector x_1 on the GPU. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each vector x_i. !> @param[in] stridex - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stridex. However, ensure that stridex is of !> an appropriate size. !> This typically means stridex >= n * incx. stridex should be non zero. !> @param[in] beta - device pointer or host pointer to scalar beta. !> @param[out] y - Device pointer to the first vector y_1 on the GPU. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each vector y_i. !> @param[in] stridey - [rocblas_stride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> There are no restrictions placed on stridey. However, ensure that stridey is of !> an appropriate size. !> This typically means stridey >= n * incy. stridey should be non zero. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_ssbmv_strided_batched function rocblas_ssbmv_strided_batched_(handle,uplo,n,k,alpha,A,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_ssbmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssbmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ssbmv_strided_batched_assumed_rank #else module procedure & rocblas_ssbmv_strided_batched_rank_0,& rocblas_ssbmv_strided_batched_rank_1,& rocblas_ssbmv_strided_batched_full_rank #endif #endif end interface interface rocblas_dsbmv_strided_batched function rocblas_dsbmv_strided_batched_(handle,uplo,n,k,alpha,A,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_dsbmv_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsbmv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex real(c_double) :: beta type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dsbmv_strided_batched_assumed_rank #else module procedure & rocblas_dsbmv_strided_batched_rank_0,& rocblas_dsbmv_strided_batched_rank_1,& rocblas_dsbmv_strided_batched_full_rank #endif #endif end interface interface rocblas_ssbmv_strided_batched_64 function rocblas_ssbmv_strided_batched_64_(handle,uplo,n,k,alpha,A,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_ssbmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssbmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_float) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dsbmv_strided_batched_64 function rocblas_dsbmv_strided_batched_64_(handle,uplo,n,k,alpha,A,lda,strideA,x,incx,stridex, & beta,y,incy,stridey,batch_count) & bind(c, name="rocblas_dsbmv_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsbmv_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex real(c_double) :: beta type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The ger, geru, and gerc functions perform the matrix-vector operations: !> !> A := A + alpha*x*y**T , OR !> A := A + alpha*x*y**H for gerc !> !> where ``alpha`` is a scalar, ``x`` and ``y`` are vectors, and ``A`` is an !> ``m`` by ``n`` matrix. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] m - [rocblas_int] !> the number of rows of the matrix A. !> @param[in] n - [rocblas_int] !> the number of columns of the matrix A. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in] y - device pointer storing vector y. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in, out] A - device pointer storing matrix A. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. interface rocblas_sger function rocblas_sger_(handle,m,n,alpha,x,incx,y,incy,A,lda) bind(c, name="rocblas_sger") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sger_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sger_assumed_rank #else module procedure & rocblas_sger_rank_0,& rocblas_sger_rank_1,& rocblas_sger_full_rank #endif #endif end interface interface rocblas_dger function rocblas_dger_(handle,m,n,alpha,x,incx,y,incy,A,lda) bind(c, name="rocblas_dger") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dger_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dger_assumed_rank #else module procedure & rocblas_dger_rank_0,& rocblas_dger_rank_1,& rocblas_dger_full_rank #endif #endif end interface interface rocblas_cgeru function rocblas_cgeru_(handle,m,n,alpha,x,incx,y,incy,A,lda) bind(c, name="rocblas_cgeru") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeru_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cgeru_assumed_rank #else module procedure & rocblas_cgeru_rank_0,& rocblas_cgeru_rank_1,& rocblas_cgeru_full_rank #endif #endif end interface interface rocblas_zgeru function rocblas_zgeru_(handle,m,n,alpha,x,incx,y,incy,A,lda) bind(c, name="rocblas_zgeru") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeru_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zgeru_assumed_rank #else module procedure & rocblas_zgeru_rank_0,& rocblas_zgeru_rank_1,& rocblas_zgeru_full_rank #endif #endif end interface interface rocblas_cgerc function rocblas_cgerc_(handle,m,n,alpha,x,incx,y,incy,A,lda) bind(c, name="rocblas_cgerc") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgerc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cgerc_assumed_rank #else module procedure & rocblas_cgerc_rank_0,& rocblas_cgerc_rank_1,& rocblas_cgerc_full_rank #endif #endif end interface interface rocblas_zgerc function rocblas_zgerc_(handle,m,n,alpha,x,incx,y,incy,A,lda) bind(c, name="rocblas_zgerc") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgerc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zgerc_assumed_rank #else module procedure & rocblas_zgerc_rank_0,& rocblas_zgerc_rank_1,& rocblas_zgerc_full_rank #endif #endif end interface interface rocblas_sger_64 function rocblas_sger_64_(handle,m,n,alpha,x,incx,y,incy,A,lda) bind(c, name="rocblas_sger_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sger_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface interface rocblas_dger_64 function rocblas_dger_64_(handle,m,n,alpha,x,incx,y,incy,A,lda) bind(c, name="rocblas_dger_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dger_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface interface rocblas_cgeru_64 function rocblas_cgeru_64_(handle,m,n,alpha,x,incx,y,incy,A,lda) & bind(c, name="rocblas_cgeru_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeru_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface interface rocblas_zgeru_64 function rocblas_zgeru_64_(handle,m,n,alpha,x,incx,y,incy,A,lda) & bind(c, name="rocblas_zgeru_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeru_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface interface rocblas_cgerc_64 function rocblas_cgerc_64_(handle,m,n,alpha,x,incx,y,incy,A,lda) & bind(c, name="rocblas_cgerc_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgerc_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface interface rocblas_zgerc_64 function rocblas_zgerc_64_(handle,m,n,alpha,x,incx,y,incy,A,lda) & bind(c, name="rocblas_zgerc_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgerc_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface !> \brief BLAS Level 2 API !> !> \details !> The ger_batched, geru_batched, and gerc_batched functions perform a batch of the !> matrix-vector operations: !> !> A := A + alpha*x*y**T , OR !> A := A + alpha*x*y**H for gerc !> !> where (``A_i``, ``x_i``, ``y_i``) is the i-th instance of the batch, !> ``alpha`` is a scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``m`` by ``n`` matrix, for ``i`` = 1, ..., ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] m - [rocblas_int] !> the number of rows of each matrix A_i. !> @param[in] n - [rocblas_int] !> the number of columns of each matrix A_i. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each vector x_i. !> @param[in] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each vector y_i. !> @param[in, out] A - device array of device pointers storing each matrix A_i. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_sger_batched function rocblas_sger_batched_(handle,m,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_sger_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sger_batched_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: batch_count end function end interface interface rocblas_dger_batched function rocblas_dger_batched_(handle,m,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_dger_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dger_batched_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: batch_count end function end interface interface rocblas_cgeru_batched function rocblas_cgeru_batched_(handle,m,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_cgeru_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeru_batched_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: batch_count end function end interface interface rocblas_zgeru_batched function rocblas_zgeru_batched_(handle,m,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_zgeru_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeru_batched_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: batch_count end function end interface interface rocblas_cgerc_batched function rocblas_cgerc_batched_(handle,m,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_cgerc_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgerc_batched_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: batch_count end function end interface interface rocblas_zgerc_batched function rocblas_zgerc_batched_(handle,m,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_zgerc_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgerc_batched_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: batch_count end function end interface interface rocblas_sger_batched_64 function rocblas_sger_batched_64_(handle,m,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_sger_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sger_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dger_batched_64 function rocblas_dger_batched_64_(handle,m,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_dger_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dger_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cgeru_batched_64 function rocblas_cgeru_batched_64_(handle,m,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_cgeru_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeru_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zgeru_batched_64 function rocblas_zgeru_batched_64_(handle,m,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_zgeru_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeru_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cgerc_batched_64 function rocblas_cgerc_batched_64_(handle,m,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_cgerc_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgerc_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zgerc_batched_64 function rocblas_zgerc_batched_64_(handle,m,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_zgerc_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgerc_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The ger_strided_batched, geru_strided_batched, and gerc_strided_batched functions perform !> the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*y_i**T, OR !> A_i := A_i + alpha*x_i*y_i**H for gerc !> !> where (``A_i``, ``x_i``, ``y_i``) is the i-th instance of the batch, !> ``alpha`` is a scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``m`` by ``n`` matrix, for ``i`` = 1, ..., ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] m - [rocblas_int] !> the number of rows of each matrix A_i. !> @param[in] n - [rocblas_int] !> the number of columns of each matrix A_i. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer to the first vector (x_1) in the batch. !> @param[in] incx - [rocblas_int] !> specifies the increments for the elements of each vector x_i. !> @param[in] stridex - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stride_x. However, ensure that stride_x is of !> an appropriate size. For a typical !> case, this means stride_x >= m * incx. !> @param[in, out] y - device pointer to the first vector (y_1) in the batch. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each vector y_i. !> @param[in] stridey - [rocblas_stride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> There are no restrictions placed on stride_y. However, ensure that stride_y is of !> an appropriate size. For a typical !> case, this means stride_y >= n * incy. !> @param[in, out] A - device pointer to the first matrix (A_1) in the batch. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. !> @param[in] strideA - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_sger_strided_batched function rocblas_sger_strided_batched_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,A,lda, & strideA,batch_count) & bind(c, name="rocblas_sger_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sger_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sger_strided_batched_assumed_rank #else module procedure & rocblas_sger_strided_batched_rank_0,& rocblas_sger_strided_batched_rank_1,& rocblas_sger_strided_batched_full_rank #endif #endif end interface interface rocblas_dger_strided_batched function rocblas_dger_strided_batched_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,A,lda, & strideA,batch_count) & bind(c, name="rocblas_dger_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dger_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dger_strided_batched_assumed_rank #else module procedure & rocblas_dger_strided_batched_rank_0,& rocblas_dger_strided_batched_rank_1,& rocblas_dger_strided_batched_full_rank #endif #endif end interface interface rocblas_cgeru_strided_batched function rocblas_cgeru_strided_batched_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,A,lda, & strideA,batch_count) & bind(c, name="rocblas_cgeru_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeru_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cgeru_strided_batched_assumed_rank #else module procedure & rocblas_cgeru_strided_batched_rank_0,& rocblas_cgeru_strided_batched_rank_1,& rocblas_cgeru_strided_batched_full_rank #endif #endif end interface interface rocblas_zgeru_strided_batched function rocblas_zgeru_strided_batched_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,A,lda, & strideA,batch_count) & bind(c, name="rocblas_zgeru_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeru_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zgeru_strided_batched_assumed_rank #else module procedure & rocblas_zgeru_strided_batched_rank_0,& rocblas_zgeru_strided_batched_rank_1,& rocblas_zgeru_strided_batched_full_rank #endif #endif end interface interface rocblas_cgerc_strided_batched function rocblas_cgerc_strided_batched_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,A,lda, & strideA,batch_count) & bind(c, name="rocblas_cgerc_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgerc_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cgerc_strided_batched_assumed_rank #else module procedure & rocblas_cgerc_strided_batched_rank_0,& rocblas_cgerc_strided_batched_rank_1,& rocblas_cgerc_strided_batched_full_rank #endif #endif end interface interface rocblas_zgerc_strided_batched function rocblas_zgerc_strided_batched_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,A,lda, & strideA,batch_count) & bind(c, name="rocblas_zgerc_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgerc_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zgerc_strided_batched_assumed_rank #else module procedure & rocblas_zgerc_strided_batched_rank_0,& rocblas_zgerc_strided_batched_rank_1,& rocblas_zgerc_strided_batched_full_rank #endif #endif end interface interface rocblas_sger_strided_batched_64 function rocblas_sger_strided_batched_64_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,A, & lda,strideA,batch_count) & bind(c, name="rocblas_sger_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sger_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dger_strided_batched_64 function rocblas_dger_strided_batched_64_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,A, & lda,strideA,batch_count) & bind(c, name="rocblas_dger_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dger_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cgeru_strided_batched_64 function rocblas_cgeru_strided_batched_64_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,A, & lda,strideA,batch_count) & bind(c, name="rocblas_cgeru_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeru_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zgeru_strided_batched_64 function rocblas_zgeru_strided_batched_64_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,A, & lda,strideA,batch_count) & bind(c, name="rocblas_zgeru_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeru_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cgerc_strided_batched_64 function rocblas_cgerc_strided_batched_64_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,A, & lda,strideA,batch_count) & bind(c, name="rocblas_cgerc_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgerc_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zgerc_strided_batched_64 function rocblas_zgerc_strided_batched_64_(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,A, & lda,strideA,batch_count) & bind(c, name="rocblas_zgerc_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgerc_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The spr functions perform the matrix-vector operations: !> !> A := A + alpha*x*x**T !> !> where ``alpha`` is a scalar, ``x`` is a vector, and ``A`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - rocblas_fill_upper: The upper triangular part of A is supplied in AP. !> - rocblas_fill_lower: The lower triangular part of A is supplied in AP. !> @param[in] n - [rocblas_int] !> the number of rows and columns of matrix A. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in, out] AP - device pointer storing the packed version of the specified triangular !> portion of !> the symmetric matrix A. Of at least size ((n * (n + 1)) / 2). !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of the symmetric matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), etc. !> Ex: (rocblas_fill_upper; n = 4) !> 1 2 4 7 !> 2 3 5 8 -----> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 4 5 6 9 !> 7 8 9 0 !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of the symmetric matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), etc. !> Ex: (rocblas_fill_lower; n = 4) !> 1 2 3 4 !> 2 5 6 7 -----> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 3 6 8 9 !> 4 7 9 0 interface rocblas_sspr function rocblas_sspr_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="rocblas_sspr") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sspr_assumed_rank #else module procedure & rocblas_sspr_rank_0,& rocblas_sspr_rank_1 #endif #endif end interface interface rocblas_dspr function rocblas_dspr_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="rocblas_dspr") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dspr_assumed_rank #else module procedure & rocblas_dspr_rank_0,& rocblas_dspr_rank_1 #endif #endif end interface interface rocblas_cspr function rocblas_cspr_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="rocblas_cspr") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cspr_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cspr_assumed_rank #else module procedure & rocblas_cspr_rank_0,& rocblas_cspr_rank_1 #endif #endif end interface interface rocblas_zspr function rocblas_zspr_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="rocblas_zspr") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zspr_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zspr_assumed_rank #else module procedure & rocblas_zspr_rank_0,& rocblas_zspr_rank_1 #endif #endif end interface interface rocblas_sspr_64 function rocblas_sspr_64_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="rocblas_sspr_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP end function end interface interface rocblas_dspr_64 function rocblas_dspr_64_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="rocblas_dspr_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP end function end interface interface rocblas_cspr_64 function rocblas_cspr_64_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="rocblas_cspr_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cspr_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP end function end interface interface rocblas_zspr_64 function rocblas_zspr_64_(handle,uplo,n,alpha,x,incx,AP) bind(c, name="rocblas_zspr_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zspr_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP end function end interface !> \brief BLAS Level 2 API !> !> \details !> The spr_batched functions perform the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*x_i**T !> !> where ``alpha`` is a scalar, ``x_i`` is a vector, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., !> ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - rocblas_fill_upper: The upper triangular part of each A_i is supplied in AP. !> - rocblas_fill_lower: The lower triangular part of each A_i is supplied in AP. !> @param[in] n - [rocblas_int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in, out] AP - device array of device pointers storing the packed version of the !> specified triangular portion of !> each symmetric matrix A_i of at least size ((n * (n + 1)) / 2). The array is of !> at least size batch_count. !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of each symmetric matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), etc. !> Ex: (rocblas_fill_upper; n = 4) !> 1 2 4 7 !> 2 3 5 8 -----> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 4 5 6 9 !> 7 8 9 0 !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of each symmetric matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), etc. !> Ex: (rocblas_fill_lower; n = 4) !> 1 2 3 4 !> 2 5 6 7 -----> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 3 6 8 9 !> 4 7 9 0 !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_sspr_batched function rocblas_sspr_batched_(handle,uplo,n,alpha,x,incx,AP,batch_count) & bind(c, name="rocblas_sspr_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: batch_count end function end interface interface rocblas_dspr_batched function rocblas_dspr_batched_(handle,uplo,n,alpha,x,incx,AP,batch_count) & bind(c, name="rocblas_dspr_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: batch_count end function end interface interface rocblas_cspr_batched function rocblas_cspr_batched_(handle,uplo,n,alpha,x,incx,AP,batch_count) & bind(c, name="rocblas_cspr_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cspr_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: batch_count end function end interface interface rocblas_zspr_batched function rocblas_zspr_batched_(handle,uplo,n,alpha,x,incx,AP,batch_count) & bind(c, name="rocblas_zspr_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zspr_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: AP integer(c_int),value :: batch_count end function end interface interface rocblas_sspr_batched_64 function rocblas_sspr_batched_64_(handle,uplo,n,alpha,x,incx,AP,batch_count) & bind(c, name="rocblas_sspr_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dspr_batched_64 function rocblas_dspr_batched_64_(handle,uplo,n,alpha,x,incx,AP,batch_count) & bind(c, name="rocblas_dspr_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cspr_batched_64 function rocblas_cspr_batched_64_(handle,uplo,n,alpha,x,incx,AP,batch_count) & bind(c, name="rocblas_cspr_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cspr_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zspr_batched_64 function rocblas_zspr_batched_64_(handle,uplo,n,alpha,x,incx,AP,batch_count) & bind(c, name="rocblas_zspr_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zspr_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: AP integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The spr_strided_batched functions perform the matrix-vector operations: !> !> A_i := A_i + alpha*x_i*x_i**T !> !> where ``alpha`` is a scalar, ``x_i`` is a vector, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., !> ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - rocblas_fill_upper: The upper triangular part of each A_i is supplied in AP. !> - rocblas_fill_lower: The lower triangular part of each A_i is supplied in AP. !> @param[in] n - [rocblas_int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer pointing to the first vector (x_1). !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] stride_x - [rocblas_stride] !> stride from the start of one vector (x_i) and the next one (x_i+1). !> @param[in, out] AP - device pointer storing the packed version of the specified triangular !> portion of !> each symmetric matrix A_i. Points to the first A_1. !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of each symmetric matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), etc. !> Ex: (rocblas_fill_upper; n = 4) !> 1 2 4 7 !> 2 3 5 8 -----> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 4 5 6 9 !> 7 8 9 0 !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of each symmetric matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(2) = A(2,1), etc. !> Ex: (rocblas_fill_lower; n = 4) !> 1 2 3 4 !> 2 5 6 7 -----> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 3 6 8 9 !> 4 7 9 0 !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one (A_i) to the next (A_i+1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_sspr_strided_batched function rocblas_sspr_strided_batched_(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) & bind(c, name="rocblas_sspr_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sspr_strided_batched_assumed_rank #else module procedure & rocblas_sspr_strided_batched_rank_0,& rocblas_sspr_strided_batched_rank_1 #endif #endif end interface interface rocblas_dspr_strided_batched function rocblas_dspr_strided_batched_(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) & bind(c, name="rocblas_dspr_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dspr_strided_batched_assumed_rank #else module procedure & rocblas_dspr_strided_batched_rank_0,& rocblas_dspr_strided_batched_rank_1 #endif #endif end interface interface rocblas_cspr_strided_batched function rocblas_cspr_strided_batched_(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) & bind(c, name="rocblas_cspr_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cspr_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cspr_strided_batched_assumed_rank #else module procedure & rocblas_cspr_strided_batched_rank_0,& rocblas_cspr_strided_batched_rank_1 #endif #endif end interface interface rocblas_zspr_strided_batched function rocblas_zspr_strided_batched_(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) & bind(c, name="rocblas_zspr_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zspr_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zspr_strided_batched_assumed_rank #else module procedure & rocblas_zspr_strided_batched_rank_0,& rocblas_zspr_strided_batched_rank_1 #endif #endif end interface interface rocblas_sspr_strided_batched_64 function rocblas_sspr_strided_batched_64_(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) & bind(c, name="rocblas_sspr_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dspr_strided_batched_64 function rocblas_dspr_strided_batched_64_(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) & bind(c, name="rocblas_dspr_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cspr_strided_batched_64 function rocblas_cspr_strided_batched_64_(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) & bind(c, name="rocblas_cspr_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cspr_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zspr_strided_batched_64 function rocblas_zspr_strided_batched_64_(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) & bind(c, name="rocblas_zspr_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zspr_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The spr2 functions perform the matrix-vector operation: !> !> A := A + alpha*x*y**T + alpha*y*x**T !> !> where ``alpha`` is a scalar, ``x`` and ``y`` are vectors, and ``A`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - rocblas_fill_upper: The upper triangular part of A is supplied in AP. !> - rocblas_fill_lower: The lower triangular part of A is supplied in AP. !> @param[in] n - [rocblas_int] !> the number of rows and columns of matrix A. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in] y - device pointer storing vector y. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in, out] AP - device pointer storing the packed version of the specified triangular !> portion of !> the symmetric matrix A. Of at least size ((n * (n + 1)) / 2). !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of the symmetric matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), etc. !> Ex: (rocblas_fill_upper; n = 4) !> 1 2 4 7 !> 2 3 5 8 -----> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 4 5 6 9 !> 7 8 9 0 !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of the symmetric matrix A is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(n) = A(2,1), etc. !> Ex: (rocblas_fill_lower; n = 4) !> 1 2 3 4 !> 2 5 6 7 -----> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 3 6 8 9 !> 4 7 9 0 interface rocblas_sspr2 function rocblas_sspr2_(handle,uplo,n,alpha,x,incx,y,incy,AP) bind(c, name="rocblas_sspr2") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sspr2_assumed_rank #else module procedure & rocblas_sspr2_rank_0,& rocblas_sspr2_rank_1 #endif #endif end interface interface rocblas_dspr2 function rocblas_dspr2_(handle,uplo,n,alpha,x,incx,y,incy,AP) bind(c, name="rocblas_dspr2") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dspr2_assumed_rank #else module procedure & rocblas_dspr2_rank_0,& rocblas_dspr2_rank_1 #endif #endif end interface interface rocblas_sspr2_64 function rocblas_sspr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP) & bind(c, name="rocblas_sspr2_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr2_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP end function end interface interface rocblas_dspr2_64 function rocblas_dspr2_64_(handle,uplo,n,alpha,x,incx,y,incy,AP) & bind(c, name="rocblas_dspr2_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr2_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP end function end interface !> \brief BLAS Level 2 API !> !> \details !> The spr2_batched functions perform the matrix-vector operation: !> !> A_i := A_i + alpha*x_i*y_i**T + alpha*y_i*x_i**T !> !> where ``alpha`` is a scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., !> ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - rocblas_fill_upper: The upper triangular part of each A_i is supplied in AP. !> - rocblas_fill_lower: The lower triangular part of each A_i is supplied in AP. !> @param[in] n - [rocblas_int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each y_i. !> @param[in, out] AP - device array of device pointers storing the packed version of the !> specified triangular portion of !> each symmetric matrix A_i of at least size ((n * (n + 1)) / 2). Array is of at !> least size batch_count. !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of each symmetric matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), etc. !> Ex: (rocblas_fill_upper; n = 4) !> 1 2 4 7 !> 2 3 5 8 -----> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 4 5 6 9 !> 7 8 9 0 !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of each symmetric matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(n) = A(2,1), etc. !> Ex: (rocblas_fill_lower; n = 4) !> 1 2 3 4 !> 2 5 6 7 -----> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 3 6 8 9 !> 4 7 9 0 !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_sspr2_batched function rocblas_sspr2_batched_(handle,uplo,n,alpha,x,incx,y,incy,AP,batch_count) & bind(c, name="rocblas_sspr2_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: batch_count end function end interface interface rocblas_dspr2_batched function rocblas_dspr2_batched_(handle,uplo,n,alpha,x,incx,y,incy,AP,batch_count) & bind(c, name="rocblas_dspr2_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: AP integer(c_int),value :: batch_count end function end interface interface rocblas_sspr2_batched_64 function rocblas_sspr2_batched_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,batch_count) & bind(c, name="rocblas_sspr2_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr2_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dspr2_batched_64 function rocblas_dspr2_batched_64_(handle,uplo,n,alpha,x,incx,y,incy,AP,batch_count) & bind(c, name="rocblas_dspr2_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr2_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: AP integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The spr2_strided_batched functions perform the matrix-vector operation: !> !> A_i := A_i + alpha*x_i*y_i**T + alpha*y_i*x_i**T !> !> where ``alpha`` is a scalar, ``x_i`` and ``y_i`` are vectors, and ``A_i`` is an !> ``n`` by ``n`` symmetric matrix, supplied in packed form, for ``i`` = 1, ..., !> ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - rocblas_fill_upper: The upper triangular part of each A_i is supplied in AP. !> - rocblas_fill_lower: The lower triangular part of each A_i is supplied in AP. !> @param[in] n - [rocblas_int] !> the number of rows and columns of each matrix A_i. Must be at least 0. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer pointing to the first vector (x_1). !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] stride_x - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[in] y - device pointer pointing to the first vector (y_1). !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each y_i. !> @param[in] stride_y - [rocblas_stride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> @param[in, out] AP - device pointer storing the packed version of the specified triangular !> portion of !> each symmetric matrix A_i. Points to the first A_1. !> !> if uplo == rocblas_fill_upper: !> The upper triangular portion of each symmetric matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(0,1) !> AP(2) = A(1,1), etc. !> Ex: (rocblas_fill_upper; n = 4) !> 1 2 4 7 !> 2 3 5 8 -----> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 4 5 6 9 !> 7 8 9 0 !> !> if uplo == rocblas_fill_lower: !> The lower triangular portion of each symmetric matrix A_i is supplied. !> The matrix is compacted so that AP contains the triangular portion !> column-by-column !> so that: !> AP(0) = A(0,0) !> AP(1) = A(1,0) !> AP(n) = A(2,1), etc. !> Ex: (rocblas_fill_lower; n = 4) !> 1 2 3 4 !> 2 5 6 7 -----> [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] !> 3 6 8 9 !> 4 7 9 0 !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one (A_i) to the next (A_i+1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_sspr2_strided_batched function rocblas_sspr2_strided_batched_(handle,uplo,n,alpha,x,incx,stride_x,y,incy,stride_y, & AP,stride_A,batch_count) & bind(c, name="rocblas_sspr2_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sspr2_strided_batched_assumed_rank #else module procedure & rocblas_sspr2_strided_batched_rank_0,& rocblas_sspr2_strided_batched_rank_1 #endif #endif end interface interface rocblas_dspr2_strided_batched function rocblas_dspr2_strided_batched_(handle,uplo,n,alpha,x,incx,stride_x,y,incy,stride_y, & AP,stride_A,batch_count) & bind(c, name="rocblas_dspr2_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stride_y type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dspr2_strided_batched_assumed_rank #else module procedure & rocblas_dspr2_strided_batched_rank_0,& rocblas_dspr2_strided_batched_rank_1 #endif #endif end interface interface rocblas_sspr2_strided_batched_64 function rocblas_sspr2_strided_batched_64_(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,AP,stride_A,batch_count) & bind(c, name="rocblas_sspr2_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr2_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dspr2_strided_batched_64 function rocblas_dspr2_strided_batched_64_(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,AP,stride_A,batch_count) & bind(c, name="rocblas_dspr2_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr2_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y type(c_ptr),value :: AP integer(c_int64_t),value :: stride_A integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The syr functions perform the matrix-vector operations: !> !> A := A + alpha*x*x**T !> !> where ``alpha`` is a scalar, ``x`` is a vector, and ``A`` is an !> ``n`` by ``n`` symmetric matrix. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - if rocblas_fill_upper, the lower part of A is not referenced. !> - if rocblas_fill_lower, the upper part of A is not referenced. !> !> @param[in] n - [rocblas_int] !> the number of rows and columns of matrix A. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in, out] A - device pointer storing matrix A. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. interface rocblas_ssyr function rocblas_ssyr_(handle,uplo,n,alpha,x,incx,A,lda) bind(c, name="rocblas_ssyr") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ssyr_assumed_rank #else module procedure & rocblas_ssyr_rank_0,& rocblas_ssyr_rank_1,& rocblas_ssyr_full_rank #endif #endif end interface interface rocblas_dsyr function rocblas_dsyr_(handle,uplo,n,alpha,x,incx,A,lda) bind(c, name="rocblas_dsyr") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dsyr_assumed_rank #else module procedure & rocblas_dsyr_rank_0,& rocblas_dsyr_rank_1,& rocblas_dsyr_full_rank #endif #endif end interface interface rocblas_csyr function rocblas_csyr_(handle,uplo,n,alpha,x,incx,A,lda) bind(c, name="rocblas_csyr") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_csyr_assumed_rank #else module procedure & rocblas_csyr_rank_0,& rocblas_csyr_rank_1,& rocblas_csyr_full_rank #endif #endif end interface interface rocblas_zsyr function rocblas_zsyr_(handle,uplo,n,alpha,x,incx,A,lda) bind(c, name="rocblas_zsyr") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zsyr_assumed_rank #else module procedure & rocblas_zsyr_rank_0,& rocblas_zsyr_rank_1,& rocblas_zsyr_full_rank #endif #endif end interface interface rocblas_ssyr_64 function rocblas_ssyr_64_(handle,uplo,n,alpha,x,incx,A,lda) bind(c, name="rocblas_ssyr_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface interface rocblas_dsyr_64 function rocblas_dsyr_64_(handle,uplo,n,alpha,x,incx,A,lda) bind(c, name="rocblas_dsyr_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface interface rocblas_csyr_64 function rocblas_csyr_64_(handle,uplo,n,alpha,x,incx,A,lda) bind(c, name="rocblas_csyr_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface interface rocblas_zsyr_64 function rocblas_zsyr_64_(handle,uplo,n,alpha,x,incx,A,lda) bind(c, name="rocblas_zsyr_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface !> \brief BLAS Level 2 API !> !> \details !> The syr_batched functions perform a batch of matrix-vector operations: !> !> A[i] := A[i] + alpha*x[i]*x[i]**T !> !> where ``alpha`` is a scalar, ``x`` is an array of vectors, and ``A`` is an array of !> ``n`` by ``n`` symmetric matrices, for ``i`` = 1 , ... , ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - if rocblas_fill_upper, the lower part of A is not referenced. !> - if rocblas_fill_lower, the upper part of A is not referenced. !> @param[in] n - [rocblas_int] !> the number of rows and columns of matrix A. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in, out] A - device array of device pointers storing each matrix A_i. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_ssyr_batched function rocblas_ssyr_batched_(handle,uplo,n,alpha,x,incx,A,lda,batch_count) & bind(c, name="rocblas_ssyr_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: batch_count end function end interface interface rocblas_dsyr_batched function rocblas_dsyr_batched_(handle,uplo,n,alpha,x,incx,A,lda,batch_count) & bind(c, name="rocblas_dsyr_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: batch_count end function end interface interface rocblas_csyr_batched function rocblas_csyr_batched_(handle,uplo,n,alpha,x,incx,A,lda,batch_count) & bind(c, name="rocblas_csyr_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: batch_count end function end interface interface rocblas_zsyr_batched function rocblas_zsyr_batched_(handle,uplo,n,alpha,x,incx,A,lda,batch_count) & bind(c, name="rocblas_zsyr_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: batch_count end function end interface interface rocblas_ssyr_batched_64 function rocblas_ssyr_batched_64_(handle,uplo,n,alpha,x,incx,A,lda,batch_count) & bind(c, name="rocblas_ssyr_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dsyr_batched_64 function rocblas_dsyr_batched_64_(handle,uplo,n,alpha,x,incx,A,lda,batch_count) & bind(c, name="rocblas_dsyr_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: batch_count end function end interface interface rocblas_csyr_batched_64 function rocblas_csyr_batched_64_(handle,uplo,n,alpha,x,incx,A,lda,batch_count) & bind(c, name="rocblas_csyr_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zsyr_batched_64 function rocblas_zsyr_batched_64_(handle,uplo,n,alpha,x,incx,A,lda,batch_count) & bind(c, name="rocblas_zsyr_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The syr_strided_batched functions perform the matrix-vector operations: !> !> A[i] := A[i] + alpha*x[i]*x[i]**T !> !> where ``alpha`` is a scalar, ``x`` is an array of vectors, and ``A`` is an array of !> ``n`` by ``n`` symmetric matrices, for ``i`` = 1 , ... , ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - if rocblas_fill_upper, the lower part of A is not referenced. !> - if rocblas_fill_lower, the upper part of A is not referenced. !> @param[in] n - [rocblas_int] !> the number of rows and columns of each matrix A. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer to the first vector x_1. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [rocblas_stride] !> specifies the pointer increment between vectors (x_i) and (x_i+1). !> @param[in, out] A - device pointer to the first matrix A_1. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. !> @param[in] strideA - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_ssyr_strided_batched function rocblas_ssyr_strided_batched_(handle,uplo,n,alpha,x,incx,stridex,A,lda,strideA, & batch_count) & bind(c, name="rocblas_ssyr_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ssyr_strided_batched_assumed_rank #else module procedure & rocblas_ssyr_strided_batched_rank_0,& rocblas_ssyr_strided_batched_rank_1,& rocblas_ssyr_strided_batched_full_rank #endif #endif end interface interface rocblas_dsyr_strided_batched function rocblas_dsyr_strided_batched_(handle,uplo,n,alpha,x,incx,stridex,A,lda,strideA, & batch_count) & bind(c, name="rocblas_dsyr_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dsyr_strided_batched_assumed_rank #else module procedure & rocblas_dsyr_strided_batched_rank_0,& rocblas_dsyr_strided_batched_rank_1,& rocblas_dsyr_strided_batched_full_rank #endif #endif end interface interface rocblas_csyr_strided_batched function rocblas_csyr_strided_batched_(handle,uplo,n,alpha,x,incx,stridex,A,lda,strideA, & batch_count) & bind(c, name="rocblas_csyr_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_csyr_strided_batched_assumed_rank #else module procedure & rocblas_csyr_strided_batched_rank_0,& rocblas_csyr_strided_batched_rank_1,& rocblas_csyr_strided_batched_full_rank #endif #endif end interface interface rocblas_zsyr_strided_batched function rocblas_zsyr_strided_batched_(handle,uplo,n,alpha,x,incx,stridex,A,lda,strideA, & batch_count) & bind(c, name="rocblas_zsyr_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zsyr_strided_batched_assumed_rank #else module procedure & rocblas_zsyr_strided_batched_rank_0,& rocblas_zsyr_strided_batched_rank_1,& rocblas_zsyr_strided_batched_full_rank #endif #endif end interface interface rocblas_ssyr_strided_batched_64 function rocblas_ssyr_strided_batched_64_(handle,uplo,n,alpha,x,incx,stridex,A,lda,strideA, & batch_count) & bind(c, name="rocblas_ssyr_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dsyr_strided_batched_64 function rocblas_dsyr_strided_batched_64_(handle,uplo,n,alpha,x,incx,stridex,A,lda,strideA, & batch_count) & bind(c, name="rocblas_dsyr_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batch_count end function end interface interface rocblas_csyr_strided_batched_64 function rocblas_csyr_strided_batched_64_(handle,uplo,n,alpha,x,incx,stridex,A,lda,strideA, & batch_count) & bind(c, name="rocblas_csyr_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zsyr_strided_batched_64 function rocblas_zsyr_strided_batched_64_(handle,uplo,n,alpha,x,incx,stridex,A,lda,strideA, & batch_count) & bind(c, name="rocblas_zsyr_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The syr2 functions perform the matrix-vector operations: !> !> A := A + alpha*x*y**T + alpha*y*x**T !> !> where ``alpha`` is a scalar, ``x`` and ``y`` are vectors, and ``A`` is an !> ``n`` by ``n`` symmetric matrix. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - if rocblas_fill_upper, the lower part of A is not referenced. !> - if rocblas_fill_lower, the upper part of A is not referenced. !> !> @param[in] n - [rocblas_int] !> the number of rows and columns of matrix A. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in] y - device pointer storing vector y. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in, out] A - device pointer storing matrix A. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. interface rocblas_ssyr2 function rocblas_ssyr2_(handle,uplo,n,alpha,x,incx,y,incy,A,lda) bind(c, name="rocblas_ssyr2") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ssyr2_assumed_rank #else module procedure & rocblas_ssyr2_rank_0,& rocblas_ssyr2_rank_1,& rocblas_ssyr2_full_rank #endif #endif end interface interface rocblas_dsyr2 function rocblas_dsyr2_(handle,uplo,n,alpha,x,incx,y,incy,A,lda) bind(c, name="rocblas_dsyr2") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dsyr2_assumed_rank #else module procedure & rocblas_dsyr2_rank_0,& rocblas_dsyr2_rank_1,& rocblas_dsyr2_full_rank #endif #endif end interface interface rocblas_csyr2 function rocblas_csyr2_(handle,uplo,n,alpha,x,incx,y,incy,A,lda) bind(c, name="rocblas_csyr2") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_csyr2_assumed_rank #else module procedure & rocblas_csyr2_rank_0,& rocblas_csyr2_rank_1,& rocblas_csyr2_full_rank #endif #endif end interface interface rocblas_zsyr2 function rocblas_zsyr2_(handle,uplo,n,alpha,x,incx,y,incy,A,lda) bind(c, name="rocblas_zsyr2") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zsyr2_assumed_rank #else module procedure & rocblas_zsyr2_rank_0,& rocblas_zsyr2_rank_1,& rocblas_zsyr2_full_rank #endif #endif end interface interface rocblas_ssyr2_64 function rocblas_ssyr2_64_(handle,uplo,n,alpha,x,incx,y,incy,A,lda) & bind(c, name="rocblas_ssyr2_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface interface rocblas_dsyr2_64 function rocblas_dsyr2_64_(handle,uplo,n,alpha,x,incx,y,incy,A,lda) & bind(c, name="rocblas_dsyr2_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface interface rocblas_csyr2_64 function rocblas_csyr2_64_(handle,uplo,n,alpha,x,incx,y,incy,A,lda) & bind(c, name="rocblas_csyr2_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface interface rocblas_zsyr2_64 function rocblas_zsyr2_64_(handle,uplo,n,alpha,x,incx,y,incy,A,lda) & bind(c, name="rocblas_zsyr2_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface !> \brief BLAS Level 2 API !> !> \details !> The syr2_batched functions perform a batch of matrix-vector operations: !> !> A[i] := A[i] + alpha*x[i]*y[i]**T + alpha*y[i]*x[i]**T !> !> where ``alpha`` is a scalar, x[i] and y[i] are vectors, and A[i] is a !> ``n`` by ``n`` symmetric matrix, for ``i`` = 1 , ... , ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - if rocblas_fill_upper, the lower part of A is not referenced. !> - if rocblas_fill_lower, the upper part of A is not referenced. !> @param[in] n - [rocblas_int] !> the number of rows and columns of matrix A. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] y - device array of device pointers storing each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each y_i. !> @param[in, out] A - device array of device pointers storing each matrix A_i. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_ssyr2_batched function rocblas_ssyr2_batched_(handle,uplo,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_ssyr2_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: batch_count end function end interface interface rocblas_dsyr2_batched function rocblas_dsyr2_batched_(handle,uplo,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_dsyr2_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: batch_count end function end interface interface rocblas_csyr2_batched function rocblas_csyr2_batched_(handle,uplo,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_csyr2_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: batch_count end function end interface interface rocblas_zsyr2_batched function rocblas_zsyr2_batched_(handle,uplo,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_zsyr2_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: batch_count end function end interface interface rocblas_ssyr2_batched_64 function rocblas_ssyr2_batched_64_(handle,uplo,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_ssyr2_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dsyr2_batched_64 function rocblas_dsyr2_batched_64_(handle,uplo,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_dsyr2_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: batch_count end function end interface interface rocblas_csyr2_batched_64 function rocblas_csyr2_batched_64_(handle,uplo,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_csyr2_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zsyr2_batched_64 function rocblas_zsyr2_batched_64_(handle,uplo,n,alpha,x,incx,y,incy,A,lda,batch_count) & bind(c, name="rocblas_zsyr2_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(c_int64_t),value :: incy type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 2 API !> !> \details !> The syr2_strided_batched functions perform the matrix-vector operations: !> !> A[i] := A[i] + alpha*x[i]*y[i]**T + alpha*y[i]*x[i]**T !> !> where ``alpha`` is a scalar, x[i] and y[i] are vectors, and A[i] is a !> ``n`` by ``n`` symmetric matrices, for ``i`` = 1 , ... , ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies either upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> - if rocblas_fill_upper, the lower part of A is not referenced. !> - if rocblas_fill_lower, the upper part of A is not referenced. !> @param[in] n - [rocblas_int] !> the number of rows and columns of each matrix A. !> @param[in] alpha !> device pointer or host pointer to scalar alpha. !> @param[in] x - device pointer to the first vector x_1. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [rocblas_stride] !> specifies the pointer increment between vectors (x_i) and (x_i+1). !> @param[in] y - device pointer to the first vector y_1. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each y_i. !> @param[in] stridey - [rocblas_stride] !> specifies the pointer increment between vectors (y_i) and (y_i+1). !> @param[in, out] A - device pointer to the first matrix A_1. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. !> @param[in] strideA - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_ssyr2_strided_batched function rocblas_ssyr2_strided_batched_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,A, & lda,strideA,batch_count) & bind(c, name="rocblas_ssyr2_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ssyr2_strided_batched_assumed_rank #else module procedure & rocblas_ssyr2_strided_batched_rank_0,& rocblas_ssyr2_strided_batched_rank_1,& rocblas_ssyr2_strided_batched_full_rank #endif #endif end interface interface rocblas_dsyr2_strided_batched function rocblas_dsyr2_strided_batched_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,A, & lda,strideA,batch_count) & bind(c, name="rocblas_dsyr2_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dsyr2_strided_batched_assumed_rank #else module procedure & rocblas_dsyr2_strided_batched_rank_0,& rocblas_dsyr2_strided_batched_rank_1,& rocblas_dsyr2_strided_batched_full_rank #endif #endif end interface interface rocblas_csyr2_strided_batched function rocblas_csyr2_strided_batched_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,A, & lda,strideA,batch_count) & bind(c, name="rocblas_csyr2_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_csyr2_strided_batched_assumed_rank #else module procedure & rocblas_csyr2_strided_batched_rank_0,& rocblas_csyr2_strided_batched_rank_1,& rocblas_csyr2_strided_batched_full_rank #endif #endif end interface interface rocblas_zsyr2_strided_batched function rocblas_zsyr2_strided_batched_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey,A, & lda,strideA,batch_count) & bind(c, name="rocblas_zsyr2_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zsyr2_strided_batched_assumed_rank #else module procedure & rocblas_zsyr2_strided_batched_rank_0,& rocblas_zsyr2_strided_batched_rank_1,& rocblas_zsyr2_strided_batched_full_rank #endif #endif end interface interface rocblas_ssyr2_strided_batched_64 function rocblas_ssyr2_strided_batched_64_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & A,lda,strideA,batch_count) & bind(c, name="rocblas_ssyr2_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dsyr2_strided_batched_64 function rocblas_dsyr2_strided_batched_64_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & A,lda,strideA,batch_count) & bind(c, name="rocblas_dsyr2_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batch_count end function end interface interface rocblas_csyr2_strided_batched_64 function rocblas_csyr2_strided_batched_64_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & A,lda,strideA,batch_count) & bind(c, name="rocblas_csyr2_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zsyr2_strided_batched_64 function rocblas_zsyr2_strided_batched_64_(handle,uplo,n,alpha,x,incx,stridex,y,incy,stridey, & A,lda,strideA,batch_count) & bind(c, name="rocblas_zsyr2_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The hemm functions perform one of the matrix-matrix operations: !> !> C := alpha*A*B + beta*C if side == rocblas_side_left, !> C := alpha*B*A + beta*C if side == rocblas_side_right, !> !> where ``alpha`` and ``beta`` are scalars, ``B`` and ``C`` are ``m`` by ``n`` matrices, and !> ``A`` is a Hermitian matrix stored as either upper or lower. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] side - [rocblas_side] !> - rocblas_side_left: C := alpha*A*B + beta*C !> - rocblas_side_right: C := alpha*B*A + beta*C !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A is an upper triangular matrix. !> - rocblas_fill_lower: A is a lower triangular matrix. !> !> @param[in] m - [rocblas_int] !> m specifies the number of rows of B and C. m >= 0. !> !> @param[in] n - [rocblas_int] !> n specifies the number of columns of B and C. n >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A and B are not referenced. !> !> @param[in] A - pointer storing matrix A on the GPU. !> - A is m by m if side == rocblas_side_left. !> - A is n by n if side == rocblas_side_right. !> - Only the upper/lower triangular part is accessed. !> - The imaginary component of the diagonal elements is not used. !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A. !> - If side = rocblas_side_left, lda >= max( 1, m ). !> - Otherwise, lda >= max( 1, n ). !> !> @param[in] B - pointer storing matrix B on the GPU. !> Matrix dimension is m by n. !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B. ldb >= max( 1, m ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C need not be set before entry. !> !> @param[in] C - pointer storing matrix C on the GPU. !> Matrix dimension is m by n. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, m ). interface rocblas_chemm function rocblas_chemm_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_chemm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemm_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_chemm_assumed_rank #else module procedure & rocblas_chemm_rank_0,& rocblas_chemm_rank_1,& rocblas_chemm_full_rank #endif #endif end interface interface rocblas_zhemm function rocblas_zhemm_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_zhemm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemm_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zhemm_assumed_rank #else module procedure & rocblas_zhemm_rank_0,& rocblas_zhemm_rank_1,& rocblas_zhemm_full_rank #endif #endif end interface interface rocblas_chemm_64 function rocblas_chemm_64_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_chemm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemm_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_zhemm_64 function rocblas_zhemm_64_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_zhemm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemm_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> The hemm_batched functions perform a batch of the matrix-matrix operations: !> !> C_i := alpha*A_i*B_i + beta*C_i if side == rocblas_side_left, !> C_i := alpha*B_i*A_i + beta*C_i if side == rocblas_side_right, !> !> where ``alpha`` and ``beta`` are scalars, ``B_i`` and ``C_i`` are ``m`` by ``n`` matrices, !> and !> ``A_i`` is a Hermitian matrix stored as either upper or lower. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] side - [rocblas_side] !> - rocblas_side_left: C_i := alpha*A_i*B_i + beta*C_i !> - rocblas_side_right: C_i := alpha*B_i*A_i + beta*C_i !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A_i is an upper triangular matrix. !> - rocblas_fill_lower: A_i is a lower triangular matrix. !> !> @param[in] m - [rocblas_int] !> m specifies the number of rows of B_i and C_i. m >= 0. !> !> @param[in] n - [rocblas_int] !> n specifies the number of columns of B_i and C_i. n >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A_i and B_i are not referenced. !> !> @param[in] A - device array of device pointers storing each matrix A_i on the GPU. !> - A_i is m by m if side == rocblas_side_left. !> - A_i is n by n if side == rocblas_side_right. !> - Only the upper/lower triangular part is accessed. !> - The imaginary component of the diagonal elements is not used. !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A_i. !> - If side = rocblas_side_left, lda >= max( 1, m ). !> - Otherwise, lda >= max( 1, n ). !> !> @param[in] B - device array of device pointers storing each matrix B_i on the GPU. !> Matrix dimension is m by n. !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B_i. ldb >= max( 1, m ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C_i need not be set before entry. !> !> @param[in] C - device array of device pointers storing each matrix C_i on the GPU. !> Matrix dimension is m by n. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C_i. ldc >= max( 1, m ). !> !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_chemm_batched function rocblas_chemm_batched_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc,batch_count) & bind(c, name="rocblas_chemm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_zhemm_batched function rocblas_zhemm_batched_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc,batch_count) & bind(c, name="rocblas_zhemm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_chemm_batched_64 function rocblas_chemm_batched_64_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_chemm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zhemm_batched_64 function rocblas_zhemm_batched_64_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_zhemm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The hemm_strided_batched functions perform a batch of the matrix-matrix operations: !> !> C_i := alpha*A_i*B_i + beta*C_i if side == rocblas_side_left, !> C_i := alpha*B_i*A_i + beta*C_i if side == rocblas_side_right, !> !> where ``alpha`` and ``beta`` are scalars, ``B_i`` and ``C_i`` are ``m`` by ``n`` matrices, !> and !> ``A_i`` is a Hermitian matrix stored as either upper or lower. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] side - [rocblas_side] !> - rocblas_side_left: C_i := alpha*A_i*B_i + beta*C_i !> - rocblas_side_right: C_i := alpha*B_i*A_i + beta*C_i !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A_i is an upper triangular matrix. !> - rocblas_fill_lower: A_i is a lower triangular matrix. !> !> @param[in] m - [rocblas_int] !> m specifies the number of rows of B_i and C_i. m >= 0. !> !> @param[in] n - [rocblas_int] !> n specifies the number of columns of B_i and C_i. n >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A_i and B_i are not referenced. !> !> @param[in] A - device pointer to first matrix A_1. !> - A_i is m by m if side == rocblas_side_left. !> - A_i is n by n if side == rocblas_side_right. !> - Only the upper/lower triangular part is accessed. !> - The imaginary component of the diagonal elements is not used. !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A_i. !> - If side = rocblas_side_left, lda >= max( 1, m ). !> - Otherwise, lda >= max( 1, n ). !> !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[in] B - device pointer to first matrix B_1 of dimension (ldb, n) on the GPU. !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B_i. !> - If side = rocblas_operation_none, ldb >= max( 1, m ). !> - Otherwise, ldb >= max( 1, n ). !> !> @param[in] stride_B - [rocblas_stride] !> stride from the start of one matrix (B_i) to the next one (B_i+1). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C need not be set before entry. !> !> @param[in] C - device pointer to first matrix C_1 of dimension (ldc, n) on the GPU. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, m ). !> !> @param[in, out] stride_C - [rocblas_stride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_chemm_strided_batched function rocblas_chemm_strided_batched_(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_chemm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_chemm_strided_batched_assumed_rank #else module procedure & rocblas_chemm_strided_batched_rank_0,& rocblas_chemm_strided_batched_rank_1,& rocblas_chemm_strided_batched_full_rank #endif #endif end interface interface rocblas_zhemm_strided_batched function rocblas_zhemm_strided_batched_(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_zhemm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zhemm_strided_batched_assumed_rank #else module procedure & rocblas_zhemm_strided_batched_rank_0,& rocblas_zhemm_strided_batched_rank_1,& rocblas_zhemm_strided_batched_full_rank #endif #endif end interface interface rocblas_chemm_strided_batched_64 function rocblas_chemm_strided_batched_64_(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_chemm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zhemm_strided_batched_64 function rocblas_zhemm_strided_batched_64_(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_zhemm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The herk functions perform one of the matrix-matrix operations for a Hermitian rank-k !> update: !> !> C := alpha*op( A )*op( A )^H + beta*C, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` is an ``n`` by ``k`` matrix, and !> ``C`` is a ``n`` x ``n`` Hermitian matrix stored as either upper or lower. !> !> op( A ) = A, and A is n by k if transA == rocblas_operation_none !> op( A ) = A^H and A is k by n if transA == rocblas_operation_conjugate_transpose !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C is an upper triangular matrix. !> - rocblas_fill_lower: C is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_conjugate_transpose: op(A) = A^H !> - rocblas_operation_none: op(A) = A !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and A need not be set before !> entry. !> !> @param[in] A - pointer storing matrix A on the GPU. !> Matrix dimension is ( lda, k ) when transA = rocblas_operation_none. Otherwise, !> (lda, n). !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A. !> - If transA = rocblas_operation_none, lda >= max( 1, n ). !> - Otherwise, lda >= max( 1, k ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C need not be set before entry. !> !> @param[in] C - pointer storing matrix C on the GPU. !> The imaginary component of the diagonal elements are not used but are set to zero !> unless quick return. !> Only the upper/lower triangular part is accessed. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). interface rocblas_cherk function rocblas_cherk_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) & bind(c, name="rocblas_cherk") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherk_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cherk_assumed_rank #else module procedure & rocblas_cherk_rank_0,& rocblas_cherk_rank_1,& rocblas_cherk_full_rank #endif #endif end interface interface rocblas_zherk function rocblas_zherk_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) & bind(c, name="rocblas_zherk") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherk_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zherk_assumed_rank #else module procedure & rocblas_zherk_rank_0,& rocblas_zherk_rank_1,& rocblas_zherk_full_rank #endif #endif end interface interface rocblas_cherk_64 function rocblas_cherk_64_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) & bind(c, name="rocblas_cherk_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherk_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_zherk_64 function rocblas_zherk_64_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) & bind(c, name="rocblas_zherk_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherk_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> The herk_batched functions perform a batch of the matrix-matrix operations for a Hermitian !> rank-k update: !> !> C_i := alpha*op( A_i )*op( A_i )^H + beta*C_i, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` is an ``n`` by ``k`` matrix, and !> ``C_i`` is a ``n`` x ``n`` Hermitian matrix stored as either upper or lower. !> !> op( A_i ) = A_i, and A_i is n by k if transA == rocblas_operation_none !> op( A_i ) = A_i^H and A_i is k by n if transA == rocblas_operation_conjugate_transpose !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C_i is an upper triangular matrix. !> - rocblas_fill_lower: C_i is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_conjugate_transpose: op(A) = A^H !> - rocblas_operation_none: op(A) = A !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and A need not be set before !> entry. !> !> @param[in] A - device array of device pointers storing each matrix_i A of dimension (lda, !> k) !> when transA is rocblas_operation_none. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A_i. !> - If transA = rocblas_operation_none, lda >= max( 1, n ). !> - Otherwise, lda >= max( 1, k ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C need not be set before entry. !> !> @param[in] C - device array of device pointers storing each matrix C_i on the GPU. !> The imaginary component of the diagonal elements are not used but are set to zero !> unless quick return. !> Only the upper/lower triangular part of each C_i is accessed. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_cherk_batched function rocblas_cherk_batched_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc,batch_count) & bind(c, name="rocblas_cherk_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherk_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_zherk_batched function rocblas_zherk_batched_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc,batch_count) & bind(c, name="rocblas_zherk_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherk_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_cherk_batched_64 function rocblas_cherk_batched_64_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc,batch_count) & bind(c, name="rocblas_cherk_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherk_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zherk_batched_64 function rocblas_zherk_batched_64_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc,batch_count) & bind(c, name="rocblas_zherk_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherk_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The herk_strided_batched functions perform a batch of the matrix-matrix operations for a !> Hermitian rank-k update: !> !> C_i := alpha*op( A_i )*op( A_i )^H + beta*C_i, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` is an ``n`` by ``k`` matrix, and !> ``C_i`` is an ``n`` x ``n`` Hermitian matrix stored as either upper or lower. !> !> op( A_i ) = A_i, and A_i is n by k if transA == rocblas_operation_none !> op( A_i ) = A_i^H and A_i is k by n if transA == rocblas_operation_conjugate_transpose !> !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C_i is an upper triangular matrix. !> - rocblas_fill_lower: C_i is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_conjugate_transpose: op(A) = A^H !> - rocblas_operation_none: op(A) = A !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and A need not be set before !> entry. !> !> @param[in] A - Device pointer to the first matrix A_1 on the GPU of dimension (lda, k) !> when transA is rocblas_operation_none. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A_i. !> - If transA = rocblas_operation_none, lda >= max( 1, n ). !> - Otherwise, lda >= max( 1, k ). !> !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C need not be set before entry. !> !> @param[in] C - Device pointer to the first matrix C_1 on the GPU. !> The imaginary component of the diagonal elements are not used but are set to zero !> unless quick return. !> Only the upper/lower triangular part of each C_i is accessed. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> !> @param[in, out] stride_C - [rocblas_stride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_cherk_strided_batched function rocblas_cherk_strided_batched_(handle,uplo,transA,n,k,alpha,A,lda,stride_A,beta,C, & ldc,stride_C,batch_count) & bind(c, name="rocblas_cherk_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherk_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cherk_strided_batched_assumed_rank #else module procedure & rocblas_cherk_strided_batched_rank_0,& rocblas_cherk_strided_batched_rank_1,& rocblas_cherk_strided_batched_full_rank #endif #endif end interface interface rocblas_zherk_strided_batched function rocblas_zherk_strided_batched_(handle,uplo,transA,n,k,alpha,A,lda,stride_A,beta,C, & ldc,stride_C,batch_count) & bind(c, name="rocblas_zherk_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherk_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zherk_strided_batched_assumed_rank #else module procedure & rocblas_zherk_strided_batched_rank_0,& rocblas_zherk_strided_batched_rank_1,& rocblas_zherk_strided_batched_full_rank #endif #endif end interface interface rocblas_cherk_strided_batched_64 function rocblas_cherk_strided_batched_64_(handle,uplo,transA,n,k,alpha,A,lda,stride_A,beta,C, & ldc,stride_C,batch_count) & bind(c, name="rocblas_cherk_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherk_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zherk_strided_batched_64 function rocblas_zherk_strided_batched_64_(handle,uplo,transA,n,k,alpha,A,lda,stride_A,beta,C, & ldc,stride_C,batch_count) & bind(c, name="rocblas_zherk_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherk_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The her2k functions perform one of the matrix-matrix operations for a Hermitian rank-2k !> update: !> !> C := alpha*op( A )*op( B )^H + conj(alpha)*op( B )*op( A )^H + beta*C, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` and ``op(B)`` are ``n`` by ``k`` !> matrices, and !> ``C`` is an ``n`` x ``n`` Hermitian matrix stored as either upper or lower. !> !> op( A ) = A, op( B ) = B, and A and B are n by k if trans == rocblas_operation_none !> op( A ) = A^H, op( B ) = B^H, and A and B are k by n if trans == !> rocblas_operation_conjugate_transpose !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C is an upper triangular matrix. !> - rocblas_fill_lower: C is a lower triangular matrix. !> !> @param[in] trans - [rocblas_operation] !> - rocblas_operation_conjugate_transpose: op( A ) = A^H, op( B ) = B^H !> - rocblas_operation_none: op( A ) = A, op( B ) = B !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and A need not be set before !> entry. !> !> @param[in] A - pointer storing matrix A on the GPU. !> Matrix dimension is ( lda, k ) if trans = rocblas_operation_none. Otherwise, (lda, !> n). !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A. !> - If trans = rocblas_operation_none, lda >= max( 1, n ). !> - Otherwise, lda >= max( 1, k ). !> !> @param[in] B - pointer storing matrix B on the GPU. !> Matrix dimension is ( ldb, k ) if trans = rocblas_operation_none. Otherwise, (ldb, !> n). !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B. !> - If trans = rocblas_operation_none, ldb >= max( 1, n ). !> - Otherwise, ldb >= max( 1, k ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C need not be set before entry. !> !> @param[in] C - pointer storing matrix C on the GPU. !> The imaginary component of the diagonal elements are not used but are set to zero !> unless quick return. !> Only the upper/lower triangular part is accessed. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). interface rocblas_cher2k function rocblas_cher2k_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_cher2k") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2k_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cher2k_assumed_rank #else module procedure & rocblas_cher2k_rank_0,& rocblas_cher2k_rank_1,& rocblas_cher2k_full_rank #endif #endif end interface interface rocblas_zher2k function rocblas_zher2k_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_zher2k") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2k_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zher2k_assumed_rank #else module procedure & rocblas_zher2k_rank_0,& rocblas_zher2k_rank_1,& rocblas_zher2k_full_rank #endif #endif end interface interface rocblas_cher2k_64 function rocblas_cher2k_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_cher2k_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2k_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_zher2k_64 function rocblas_zher2k_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_zher2k_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2k_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> The her2k_batched functions perform a batch of the matrix-matrix operations for a Hermitian !> rank-2k update: !> !> C_i := alpha*op( A_i )*op( B_i )^H + conj(alpha)*op( B_i )*op( A_i )^H + beta*C_i, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` !> matrices, and !> ``C_i`` is an ``n`` x ``n`` Hermitian matrix stored as either upper or lower. !> !> op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == !> rocblas_operation_none !> op( A_i ) = A_i^H, op( B_i ) = B_i^H, and A_i and B_i are k by n if trans == !> rocblas_operation_conjugate_transpose !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C_i is an upper triangular matrix. !> - rocblas_fill_lower: C_i is a lower triangular matrix. !> !> @param[in] trans - [rocblas_operation] !> - rocblas_operation_conjugate_transpose: op(A) = A^H !> - rocblas_operation_none: op(A) = A !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and A need not be set before !> entry. !> !> @param[in] A - device array of device pointers storing each matrix_i A of dimension (lda, !> k) !> when trans is rocblas_operation_none. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A_i. !> - If trans = rocblas_operation_none, lda >= max( 1, n ). !> - Otherwise, lda >= max( 1, k ). !> @param[in] B - device array of device pointers storing each matrix_i B of dimension (ldb, !> k) !> when trans is rocblas_operation_none. Otherwise, of dimension (ldb, n). !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B_i. !> - If trans = rocblas_operation_none, ldb >= max( 1, n ). !> - Otherwise, ldb >= max( 1, k ). !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C need not be set before entry. !> !> @param[in] C - device array of device pointers storing each matrix C_i on the GPU. !> The imaginary component of the diagonal elements are not used but are set to zero !> unless quick return. !> Only the upper/lower triangular part of each C_i is accessed. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_cher2k_batched function rocblas_cher2k_batched_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_cher2k_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2k_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_zher2k_batched function rocblas_zher2k_batched_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_zher2k_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2k_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_cher2k_batched_64 function rocblas_cher2k_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_cher2k_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2k_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zher2k_batched_64 function rocblas_zher2k_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_zher2k_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2k_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The her2k_strided_batched functions perform a batch of the matrix-matrix operations for a !> Hermitian rank-2k update: !> !> C_i := alpha*op( A_i )*op( B_i )^H + conj(alpha)*op( B_i )*op( A_i )^H + beta*C_i, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` !> matrices, and !> ``C_i`` is an ``n`` x ``n`` Hermitian matrix stored as either upper or lower. !> !> op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == !> rocblas_operation_none !> op( A_i ) = A_i^H, op( B_i ) = B_i^H, and A_i and B_i are k by n if trans == !> rocblas_operation_conjugate_transpose !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C_i is an upper triangular matrix. !> - rocblas_fill_lower: C_i is a lower triangular matrix. !> !> @param[in] trans - [rocblas_operation] !> - rocblas_operation_conjugate_transpose: op( A_i ) = A_i^H, op( B_i ) = B_i^H !> - rocblas_operation_none: op( A_i ) = A_i, op( B_i ) = B_i !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and A need not be set before !> entry. !> !> @param[in] A - Device pointer to the first matrix A_1 on the GPU of dimension (lda, k) !> when trans is rocblas_operation_none. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A_i. !> - If trans = rocblas_operation_none, lda >= max( 1, n ). !> - Otherwise, lda >= max( 1, k ). !> !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[in] B - Device pointer to the first matrix B_1 on the GPU of dimension (ldb, k) !> when trans is rocblas_operation_none. Otherwise, of dimension (ldb, n). !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B_i. !> - If trans = rocblas_operation_none, ldb >= max( 1, n ). !> - Otherwise, ldb >= max( 1, k ). !> !> @param[in] stride_B - [rocblas_stride] !> stride from the start of one matrix (B_i) to the next one (B_i+1). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C need not be set before entry. !> !> @param[in] C - Device pointer to the first matrix C_1 on the GPU. !> The imaginary component of the diagonal elements are not used but are set to zero !> unless quick return. !> Only the upper/lower triangular part of each C_i is accessed. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> !> @param[in, out] stride_C - [rocblas_stride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_cher2k_strided_batched function rocblas_cher2k_strided_batched_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_cher2k_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2k_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cher2k_strided_batched_assumed_rank #else module procedure & rocblas_cher2k_strided_batched_rank_0,& rocblas_cher2k_strided_batched_rank_1,& rocblas_cher2k_strided_batched_full_rank #endif #endif end interface interface rocblas_zher2k_strided_batched function rocblas_zher2k_strided_batched_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_zher2k_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2k_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zher2k_strided_batched_assumed_rank #else module procedure & rocblas_zher2k_strided_batched_rank_0,& rocblas_zher2k_strided_batched_rank_1,& rocblas_zher2k_strided_batched_full_rank #endif #endif end interface interface rocblas_cher2k_strided_batched_64 function rocblas_cher2k_strided_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_cher2k_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2k_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zher2k_strided_batched_64 function rocblas_zher2k_strided_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_zher2k_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2k_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The herkx functions perform one of the matrix-matrix operations for a Hermitian rank-k !> update: !> !> C := alpha*op( A )*op( B )^H + beta*C, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` and ``op(B)`` are ``n`` by ``k`` !> matrices, and !> ``C`` is an ``n`` x ``n`` Hermitian matrix stored as either upper or lower. !> !> This routine should only be used when the caller can guarantee that the result of !> ``op( A )*op( B )^T`` will be Hermitian. !> !> op( A ) = A, op( B ) = B, and A and B are n by k if trans == rocblas_operation_none !> op( A ) = A^H, op( B ) = B^H, and A and B are k by n if trans == !> rocblas_operation_conjugate_transpose !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C is an upper triangular matrix. !> - rocblas_fill_lower: C is a lower triangular matrix. !> !> @param[in] trans - [rocblas_operation] !> - rocblas_operation_conjugate_transpose: op( A ) = A^H, op( B ) = B^H !> - rocblas_operation_none: op( A ) = A, op( B ) = B !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and A need not be set before !> entry. !> !> @param[in] A - pointer storing matrix A on the GPU. !> Matrix dimension is ( lda, k ) when trans = rocblas_operation_none. Otherwise, !> (lda, n). !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A. !> - If trans = rocblas_operation_none, lda >= max( 1, n ). !> - Otherwise, lda >= max( 1, k ). !> @param[in] B - pointer storing matrix B on the GPU. !> Matrix dimension is ( ldb, k ) when trans = rocblas_operation_none. Otherwise, !> (ldb, n). !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B. !> - If trans = rocblas_operation_none, ldb >= max( 1, n ). !> - Otherwise, ldb >= max( 1, k ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C need not be set before entry. !> !> @param[in] C - pointer storing matrix C on the GPU. !> The imaginary component of the diagonal elements are not used but are set to zero !> unless quick return. !> Only the upper/lower triangular part is accessed. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). interface rocblas_cherkx function rocblas_cherkx_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_cherkx") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherkx_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cherkx_assumed_rank #else module procedure & rocblas_cherkx_rank_0,& rocblas_cherkx_rank_1,& rocblas_cherkx_full_rank #endif #endif end interface interface rocblas_zherkx function rocblas_zherkx_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_zherkx") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherkx_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zherkx_assumed_rank #else module procedure & rocblas_zherkx_rank_0,& rocblas_zherkx_rank_1,& rocblas_zherkx_full_rank #endif #endif end interface interface rocblas_cherkx_64 function rocblas_cherkx_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_cherkx_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherkx_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_zherkx_64 function rocblas_zherkx_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_zherkx_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherkx_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> The herkx_batched functions perform a batch of the matrix-matrix operations for a Hermitian !> rank-k update: !> !> C_i := alpha*op( A_i )*op( B_i )^H + beta*C_i, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` !> matrices, and !> ``C_i`` is an ``n`` x ``n`` Hermitian matrix stored as either upper or lower. !> !> This routine should only be used when the caller can guarantee that the result of !> ``op( A )*op( B )^T`` will be Hermitian. !> !> op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == !> rocblas_operation_none !> op( A_i ) = A_i^H, op( B_i ) = B_i^H, and A_i and B_i are k by n if trans == !> rocblas_operation_conjugate_transpose !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C_i is an upper triangular matrix. !> - rocblas_fill_lower: C_i is a lower triangular matrix. !> !> @param[in] trans - [rocblas_operation] !> - rocblas_operation_conjugate_transpose: op(A) = A^H !> - rocblas_operation_none: op(A) = A !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and A need not be set before !> entry. !> !> @param[in] A - device array of device pointers storing each matrix_i A of dimension (lda, !> k) !> when trans is rocblas_operation_none. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A_i. !> - If trans = rocblas_operation_none, lda >= max( 1, n ). !> - Otherwise, lda >= max( 1, k ). !> !> @param[in] B - device array of device pointers storing each matrix_i B of dimension (ldb, !> k) !> when trans is rocblas_operation_none. Otherwise, of dimension (ldb, n). !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B_i. !> - If trans = rocblas_operation_none, ldb >= max( 1, n ). !> - Otherwise, ldb >= max( 1, k ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C need not be set before entry. !> !> @param[in] C - device array of device pointers storing each matrix C_i on the GPU. !> The imaginary component of the diagonal elements are not used but are set to zero !> unless quick return. !> Only the upper/lower triangular part of each C_i is accessed. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_cherkx_batched function rocblas_cherkx_batched_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_cherkx_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherkx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_zherkx_batched function rocblas_zherkx_batched_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_zherkx_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherkx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_cherkx_batched_64 function rocblas_cherkx_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_cherkx_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherkx_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zherkx_batched_64 function rocblas_zherkx_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_zherkx_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherkx_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The herkx_strided_batched functions perform a batch of the matrix-matrix operations for a !> Hermitian rank-k update: !> !> C_i := alpha*op( A_i )*op( B_i )^H + beta*C_i, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` !> matrices, and !> ``C_i`` is an ``n`` x ``n`` Hermitian matrix stored as either upper or lower. !> !> This routine should only be used when the caller can guarantee that the result of !> ``op( A )*op( B )^T`` will be Hermitian. !> !> op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == !> rocblas_operation_none !> op( A_i ) = A_i^H, op( B_i ) = B_i^H, and A_i and B_i are k by n if trans == !> rocblas_operation_conjugate_transpose !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C_i is an upper triangular matrix. !> - rocblas_fill_lower: C_i is a lower triangular matrix. !> !> @param[in] trans - [rocblas_operation] !> - rocblas_operation_conjugate_transpose: op( A_i ) = A_i^H, op( B_i ) = B_i^H !> - rocblas_operation_none: op( A_i ) = A_i, op( B_i ) = B_i !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A is not referenced and A need not be set before !> entry. !> !> @param[in] A - Device pointer to the first matrix A_1 on the GPU of dimension (lda, k) !> when trans is rocblas_operation_none. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A_i. !> - If trans = rocblas_operation_none, lda >= max( 1, n ). !> - Otherwise, lda >= max( 1, k ). !> !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[in] B - Device pointer to the first matrix B_1 on the GPU of dimension (ldb, k) !> when trans is rocblas_operation_none. Otherwise, of dimension (ldb, n). !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B_i. !> - If trans = rocblas_operation_none, ldb >= max( 1, n ). !> - Otherwise, ldb >= max( 1, k ). !> !> @param[in] stride_B - [rocblas_stride] !> stride from the start of one matrix (B_i) to the next one (B_i+1). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C need not be set before entry. !> !> @param[in] C - Device pointer to the first matrix C_1 on the GPU. !> The imaginary component of the diagonal elements are not used but are set to zero !> unless quick return. !> Only the upper/lower triangular part of each C_i is accessed. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> !> @param[in, out] stride_C - [rocblas_stride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_cherkx_strided_batched function rocblas_cherkx_strided_batched_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_cherkx_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherkx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cherkx_strided_batched_assumed_rank #else module procedure & rocblas_cherkx_strided_batched_rank_0,& rocblas_cherkx_strided_batched_rank_1,& rocblas_cherkx_strided_batched_full_rank #endif #endif end interface interface rocblas_zherkx_strided_batched function rocblas_zherkx_strided_batched_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_zherkx_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherkx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zherkx_strided_batched_assumed_rank #else module procedure & rocblas_zherkx_strided_batched_rank_0,& rocblas_zherkx_strided_batched_rank_1,& rocblas_zherkx_strided_batched_full_rank #endif #endif end interface interface rocblas_cherkx_strided_batched_64 function rocblas_cherkx_strided_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_cherkx_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherkx_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zherkx_strided_batched_64 function rocblas_zherkx_strided_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_zherkx_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherkx_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The symm functions perform one of the matrix-matrix operations: !> !> C := alpha*A*B + beta*C if side == rocblas_side_left, !> C := alpha*B*A + beta*C if side == rocblas_side_right, !> !> where ``alpha`` and ``beta`` are scalars, ``B`` and ``C`` are ``m`` by ``n`` matrices, and !> ``A`` is a symmetric matrix stored as either upper or lower. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] side - [rocblas_side] !> - rocblas_side_left: C := alpha*A*B + beta*C !> - rocblas_side_right: C := alpha*B*A + beta*C !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A is an upper triangular matrix !> - rocblas_fill_lower: A is a lower triangular matrix !> !> @param[in] m - [rocblas_int] !> m specifies the number of rows of B and C. m >= 0. !> !> @param[in] n - [rocblas_int] !> n specifies the number of columns of B and C. n >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, A and B are not referenced. !> !> @param[in] A - pointer storing matrix A on the GPU. !> - A is m by m if side == rocblas_side_left. !> - A is n by n if side == rocblas_side_right. !> - Only the upper/lower triangular part is accessed. !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A. !> - If side = rocblas_side_left, lda >= max( 1, m ). !> - Otherwise, lda >= max( 1, n ). !> !> @param[in] B - pointer storing matrix B on the GPU. !> Matrix dimension is m by n. !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B. ldb >= max( 1, m ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C need not be set before entry. !> !> @param[in] C - pointer storing matrix C on the GPU. !> Matrix dimension is m by n. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, m ). interface rocblas_ssymm function rocblas_ssymm_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_ssymm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymm_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ssymm_assumed_rank #else module procedure & rocblas_ssymm_rank_0,& rocblas_ssymm_rank_1,& rocblas_ssymm_full_rank #endif #endif end interface interface rocblas_dsymm function rocblas_dsymm_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_dsymm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymm_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dsymm_assumed_rank #else module procedure & rocblas_dsymm_rank_0,& rocblas_dsymm_rank_1,& rocblas_dsymm_full_rank #endif #endif end interface interface rocblas_csymm function rocblas_csymm_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_csymm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymm_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_csymm_assumed_rank #else module procedure & rocblas_csymm_rank_0,& rocblas_csymm_rank_1,& rocblas_csymm_full_rank #endif #endif end interface interface rocblas_zsymm function rocblas_zsymm_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_zsymm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymm_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zsymm_assumed_rank #else module procedure & rocblas_zsymm_rank_0,& rocblas_zsymm_rank_1,& rocblas_zsymm_full_rank #endif #endif end interface interface rocblas_ssymm_64 function rocblas_ssymm_64_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_ssymm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymm_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_dsymm_64 function rocblas_dsymm_64_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_dsymm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymm_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_csymm_64 function rocblas_csymm_64_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_csymm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymm_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_zsymm_64 function rocblas_zsymm_64_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_zsymm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymm_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> The symm_batched functions perform a batch of the matrix-matrix operations: !> !> C_i := alpha*A_i*B_i + beta*C_i if side == rocblas_side_left, !> C_i := alpha*B_i*A_i + beta*C_i if side == rocblas_side_right, !> !> where ``alpha`` and ``beta`` are scalars, ``B_i`` and ``C_i`` are ``m`` by ``n`` matrices, !> and !> ``A_i`` is a symmetric matrix stored as either upper or lower. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] side - [rocblas_side] !> - rocblas_side_left: C_i := alpha*A_i*B_i + beta*C_i !> - rocblas_side_right: C_i := alpha*B_i*A_i + beta*C_i !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A_i is an upper triangular matrix !> - rocblas_fill_lower: A_i is a lower triangular matrix !> !> @param[in] m - [rocblas_int] !> m specifies the number of rows of B_i and C_i. m >= 0. !> !> @param[in] n - [rocblas_int] !> n specifies the number of columns of B_i and C_i. n >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, A_i and B_i are not referenced. !> !> @param[in] A - device array of device pointers storing each matrix A_i on the GPU. !> - A_i is m by m if side == rocblas_side_left. !> - A_i is n by n if side == rocblas_side_right. !> - Only the upper/lower triangular part is accessed. !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A_i. !> - If side = rocblas_side_left, lda >= max( 1, m ). !> - Otherwise, lda >= max( 1, n ). !> !> @param[in] B - device array of device pointers storing each matrix B_i on the GPU. !> Matrix dimension is m by n. !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B_i. ldb >= max( 1, m ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C_i need not be set before entry. !> !> @param[in] C - device array of device pointers storing each matrix C_i on the GPU. !> Matrix dimension is m by n. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C_i. ldc >= max( 1, m ). !> !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_ssymm_batched function rocblas_ssymm_batched_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc,batch_count) & bind(c, name="rocblas_ssymm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_dsymm_batched function rocblas_dsymm_batched_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc,batch_count) & bind(c, name="rocblas_dsymm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_csymm_batched function rocblas_csymm_batched_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc,batch_count) & bind(c, name="rocblas_csymm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_zsymm_batched function rocblas_zsymm_batched_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc,batch_count) & bind(c, name="rocblas_zsymm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_ssymm_batched_64 function rocblas_ssymm_batched_64_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_ssymm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dsymm_batched_64 function rocblas_dsymm_batched_64_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_dsymm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_csymm_batched_64 function rocblas_csymm_batched_64_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_csymm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zsymm_batched_64 function rocblas_zsymm_batched_64_(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_zsymm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The symm_strided_batched functions perform a batch of the matrix-matrix operations: !> !> C_i := alpha*A_i*B_i + beta*C_i if side == rocblas_side_left, !> C_i := alpha*B_i*A_i + beta*C_i if side == rocblas_side_right, !> !> where ``alpha`` and ``beta`` are scalars, ``B_i`` and ``C_i`` are ``m`` by ``n`` matrices, !> and !> ``A_i`` is a symmetric matrix stored as either upper or lower. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] side - [rocblas_side] !> - rocblas_side_left: C_i := alpha*A_i*B_i + beta*C_i !> - rocblas_side_right: C_i := alpha*B_i*A_i + beta*C_i !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A_i is an upper triangular matrix. !> - rocblas_fill_lower: A_i is a lower triangular matrix. !> !> @param[in] m - [rocblas_int] !> m specifies the number of rows of B_i and C_i. m >= 0. !> !> @param[in] n - [rocblas_int] !> n specifies the number of columns of B_i and C_i. n >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, A_i and B_i are not referenced. !> !> @param[in] A - device pointer to first matrix A_1. !> - A_i is m by m if side == rocblas_side_left. !> - A_i is n by n if side == rocblas_side_right. !> - Only the upper/lower triangular part is accessed. !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A_i. !> - If side = rocblas_side_left, lda >= max( 1, m ). !> - Otherwise, lda >= max( 1, n ). !> !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[in] B - device pointer to first matrix B_1 of dimension (ldb, n) on the GPU. !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B_i. ldb >= max( 1, m ). !> !> @param[in] stride_B - [rocblas_stride] !> stride from the start of one matrix (B_i) to the next one (B_i+1). !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C need not be set before entry. !> !> @param[in] C - device pointer to first matrix C_1 of dimension (ldc, n) on the GPU. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, m ). !> !> @param[in, out] stride_C - [rocblas_stride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_ssymm_strided_batched function rocblas_ssymm_strided_batched_(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_ssymm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ssymm_strided_batched_assumed_rank #else module procedure & rocblas_ssymm_strided_batched_rank_0,& rocblas_ssymm_strided_batched_rank_1,& rocblas_ssymm_strided_batched_full_rank #endif #endif end interface interface rocblas_dsymm_strided_batched function rocblas_dsymm_strided_batched_(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_dsymm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dsymm_strided_batched_assumed_rank #else module procedure & rocblas_dsymm_strided_batched_rank_0,& rocblas_dsymm_strided_batched_rank_1,& rocblas_dsymm_strided_batched_full_rank #endif #endif end interface interface rocblas_csymm_strided_batched function rocblas_csymm_strided_batched_(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_csymm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_csymm_strided_batched_assumed_rank #else module procedure & rocblas_csymm_strided_batched_rank_0,& rocblas_csymm_strided_batched_rank_1,& rocblas_csymm_strided_batched_full_rank #endif #endif end interface interface rocblas_zsymm_strided_batched function rocblas_zsymm_strided_batched_(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_zsymm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zsymm_strided_batched_assumed_rank #else module procedure & rocblas_zsymm_strided_batched_rank_0,& rocblas_zsymm_strided_batched_rank_1,& rocblas_zsymm_strided_batched_full_rank #endif #endif end interface interface rocblas_ssymm_strided_batched_64 function rocblas_ssymm_strided_batched_64_(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_ssymm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dsymm_strided_batched_64 function rocblas_dsymm_strided_batched_64_(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_dsymm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_csymm_strided_batched_64 function rocblas_csymm_strided_batched_64_(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_csymm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zsymm_strided_batched_64 function rocblas_zsymm_strided_batched_64_(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_zsymm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The syrk functions perform one of the matrix-matrix operations for a symmetric rank-k !> update: !> !> C := alpha*op( A )*op( A )^T + beta*C, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` is an ``n`` by ``k`` matrix, and !> ``C`` is a symmetric ``n`` x ``n`` matrix stored as either upper or lower. !> !> op( A ) = A, and A is n by k if transA == rocblas_operation_none !> op( A ) = A^T and A is k by n if transA == rocblas_operation_transpose !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C is an upper triangular matrix. !> - rocblas_fill_lower: C is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_transpose: op(A) = A^T !> - rocblas_operation_none: op(A) = A !> - rocblas_operation_conjugate_transpose: op(A) = A^T !> - rocblas_operation_conjugate_transpose is not supported for complex types. See !> cherk !> and zherk. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, A is not referenced and A need not be set before !> entry. !> !> @param[in] A - pointer storing matrix A on the GPU. !> Matrix dimension is ( lda, k ) if transA = rocblas_operation_none. Otherwise, (lda, !> n). !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A. !> - If transA = rocblas_operation_none, lda >= max( 1, n ). !> - Otherwise, lda >= max( 1, k ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C need not be set before entry. !> !> @param[in] C - pointer storing matrix C on the GPU. !> Only the upper/lower triangular part is accessed. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). interface rocblas_ssyrk function rocblas_ssyrk_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) & bind(c, name="rocblas_ssyrk") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrk_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ssyrk_assumed_rank #else module procedure & rocblas_ssyrk_rank_0,& rocblas_ssyrk_rank_1,& rocblas_ssyrk_full_rank #endif #endif end interface interface rocblas_dsyrk function rocblas_dsyrk_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) & bind(c, name="rocblas_dsyrk") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrk_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dsyrk_assumed_rank #else module procedure & rocblas_dsyrk_rank_0,& rocblas_dsyrk_rank_1,& rocblas_dsyrk_full_rank #endif #endif end interface interface rocblas_csyrk function rocblas_csyrk_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) & bind(c, name="rocblas_csyrk") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrk_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_csyrk_assumed_rank #else module procedure & rocblas_csyrk_rank_0,& rocblas_csyrk_rank_1,& rocblas_csyrk_full_rank #endif #endif end interface interface rocblas_zsyrk function rocblas_zsyrk_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) & bind(c, name="rocblas_zsyrk") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrk_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zsyrk_assumed_rank #else module procedure & rocblas_zsyrk_rank_0,& rocblas_zsyrk_rank_1,& rocblas_zsyrk_full_rank #endif #endif end interface interface rocblas_ssyrk_64 function rocblas_ssyrk_64_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) & bind(c, name="rocblas_ssyrk_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrk_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_dsyrk_64 function rocblas_dsyrk_64_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) & bind(c, name="rocblas_dsyrk_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrk_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_csyrk_64 function rocblas_csyrk_64_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) & bind(c, name="rocblas_csyrk_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrk_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_zsyrk_64 function rocblas_zsyrk_64_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) & bind(c, name="rocblas_zsyrk_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrk_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> The syrk_batched functions perform a batch of the matrix-matrix operations for a symmetric !> rank-k update: !> !> C_i := alpha*op( A_i )*op( A_i )^T + beta*C_i, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` is an ``n`` by ``k`` matrix, and !> ``C_i`` is a symmetric ``n`` x ``n`` matrix stored as either upper or lower. !> !> op( A_i ) = A_i, and A_i is n by k if transA == rocblas_operation_none !> op( A_i ) = A_i^T and A_i is k by n if transA == rocblas_operation_transpose !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C_i is an upper triangular matrix. !> - rocblas_fill_lower: C_i is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_transpose: op(A) = A^T !> - rocblas_operation_none: op(A) = A !> - rocblas_operation_conjugate_transpose: op(A) = A^T !> - rocblas_operation_conjugate_transpose is not supported for complex types. See !> cherk !> and zherk. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, A is not referenced and A need not be set before !> entry. !> !> @param[in] A - device array of device pointers storing each matrix_i A of dimension (lda, !> k) !> when transA is rocblas_operation_none. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A_i. !> - If transA = rocblas_operation_none, lda >= max( 1, n ), !> - Otherwise, lda >= max( 1, k ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C need not be set before entry. !> !> @param[in] C - device array of device pointers storing each matrix C_i on the GPU. !> Only the upper/lower triangular part of each C_i is accessed. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_ssyrk_batched function rocblas_ssyrk_batched_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc,batch_count) & bind(c, name="rocblas_ssyrk_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrk_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_dsyrk_batched function rocblas_dsyrk_batched_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc,batch_count) & bind(c, name="rocblas_dsyrk_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrk_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_csyrk_batched function rocblas_csyrk_batched_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc,batch_count) & bind(c, name="rocblas_csyrk_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrk_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_zsyrk_batched function rocblas_zsyrk_batched_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc,batch_count) & bind(c, name="rocblas_zsyrk_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrk_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_ssyrk_batched_64 function rocblas_ssyrk_batched_64_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc,batch_count) & bind(c, name="rocblas_ssyrk_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrk_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dsyrk_batched_64 function rocblas_dsyrk_batched_64_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc,batch_count) & bind(c, name="rocblas_dsyrk_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrk_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_csyrk_batched_64 function rocblas_csyrk_batched_64_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc,batch_count) & bind(c, name="rocblas_csyrk_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrk_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zsyrk_batched_64 function rocblas_zsyrk_batched_64_(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc,batch_count) & bind(c, name="rocblas_zsyrk_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrk_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The syrk_strided_batched functions perform a batch of the matrix-matrix operations for a !> symmetric rank-k update: !> !> C_i := alpha*op( A_i )*op( A_i )^T + beta*C_i, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` is an ``n`` by ``k`` matrix, and !> ``C_i`` is a symmetric ``n`` x ``n`` matrix stored as either upper or lower. !> !> op( A_i ) = A_i, and A_i is n by k if transA == rocblas_operation_none !> op( A_i ) = A_i^T and A_i is k by n if transA == rocblas_operation_transpose !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C_i is an upper triangular matrix. !> - rocblas_fill_lower: C_i is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_transpose: op(A) = A^T !> - rocblas_operation_none: op(A) = A !> - rocblas_operation_conjugate_transpose: op(A) = A^T !> - rocblas_operation_conjugate_transpose is not supported for complex types. See !> cherk !> and zherk. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, A is not referenced and A need not be set before !> entry. !> !> @param[in] A - Device pointer to the first matrix A_1 on the GPU of dimension (lda, k) !> when transA is rocblas_operation_none. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A_i. !> - If transA = rocblas_operation_none, lda >= max( 1, n ). !> - Otherwise, lda >= max( 1, k ). !> !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C need not be set before entry. !> !> @param[in] C - Device pointer to the first matrix C_1 on the GPU. !> Only the upper/lower triangular part of each C_i is accessed. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> !> @param[in, out] stride_C - [rocblas_stride] !> stride from the start of one matrix (C_i) to the next one (C_i+1) !> !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_ssyrk_strided_batched function rocblas_ssyrk_strided_batched_(handle,uplo,transA,n,k,alpha,A,lda,stride_A,beta,C, & ldc,stride_C,batch_count) & bind(c, name="rocblas_ssyrk_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrk_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ssyrk_strided_batched_assumed_rank #else module procedure & rocblas_ssyrk_strided_batched_rank_0,& rocblas_ssyrk_strided_batched_rank_1,& rocblas_ssyrk_strided_batched_full_rank #endif #endif end interface interface rocblas_dsyrk_strided_batched function rocblas_dsyrk_strided_batched_(handle,uplo,transA,n,k,alpha,A,lda,stride_A,beta,C, & ldc,stride_C,batch_count) & bind(c, name="rocblas_dsyrk_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrk_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dsyrk_strided_batched_assumed_rank #else module procedure & rocblas_dsyrk_strided_batched_rank_0,& rocblas_dsyrk_strided_batched_rank_1,& rocblas_dsyrk_strided_batched_full_rank #endif #endif end interface interface rocblas_csyrk_strided_batched function rocblas_csyrk_strided_batched_(handle,uplo,transA,n,k,alpha,A,lda,stride_A,beta,C, & ldc,stride_C,batch_count) & bind(c, name="rocblas_csyrk_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrk_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_csyrk_strided_batched_assumed_rank #else module procedure & rocblas_csyrk_strided_batched_rank_0,& rocblas_csyrk_strided_batched_rank_1,& rocblas_csyrk_strided_batched_full_rank #endif #endif end interface interface rocblas_zsyrk_strided_batched function rocblas_zsyrk_strided_batched_(handle,uplo,transA,n,k,alpha,A,lda,stride_A,beta,C, & ldc,stride_C,batch_count) & bind(c, name="rocblas_zsyrk_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrk_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zsyrk_strided_batched_assumed_rank #else module procedure & rocblas_zsyrk_strided_batched_rank_0,& rocblas_zsyrk_strided_batched_rank_1,& rocblas_zsyrk_strided_batched_full_rank #endif #endif end interface interface rocblas_ssyrk_strided_batched_64 function rocblas_ssyrk_strided_batched_64_(handle,uplo,transA,n,k,alpha,A,lda,stride_A,beta,C, & ldc,stride_C,batch_count) & bind(c, name="rocblas_ssyrk_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrk_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dsyrk_strided_batched_64 function rocblas_dsyrk_strided_batched_64_(handle,uplo,transA,n,k,alpha,A,lda,stride_A,beta,C, & ldc,stride_C,batch_count) & bind(c, name="rocblas_dsyrk_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrk_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_csyrk_strided_batched_64 function rocblas_csyrk_strided_batched_64_(handle,uplo,transA,n,k,alpha,A,lda,stride_A,beta,C, & ldc,stride_C,batch_count) & bind(c, name="rocblas_csyrk_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrk_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zsyrk_strided_batched_64 function rocblas_zsyrk_strided_batched_64_(handle,uplo,transA,n,k,alpha,A,lda,stride_A,beta,C, & ldc,stride_C,batch_count) & bind(c, name="rocblas_zsyrk_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrk_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The syr2k functions perform one of the matrix-matrix operations for a symmetric rank-2k !> update: !> !> C := alpha*(op( A )*op( B )^T + op( B )*op( A )^T) + beta*C, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` and ``op(B)`` are ``n`` by ``k`` !> matrices, and !> ``C`` is a symmetric ``n`` x ``n`` matrix stored as either upper or lower. !> !> op( A ) = A, op( B ) = B, and A and B are n by k if trans == rocblas_operation_none !> op( A ) = A^T, op( B ) = B^T, and A and B are k by n if trans == !> rocblas_operation_transpose !> or for ssyr2k and dsyr2k when trans == rocblas_operation_conjugate_transpose !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C is an upper triangular matrix. !> - rocblas_fill_lower: C is a lower triangular matrix. !> !> @param[in] trans - [rocblas_operation] !> - rocblas_operation_transpose: op( A ) = A^T, op( B ) = B^T !> - rocblas_operation_none: op( A ) = A, op( B ) = B !> - rocblas_operation_conjugate_transpose: op( A ) = A^T, op( B ) = B^T !> - rocblas_operation_conjugate_transpose is not supported for complex types in !> csyr2k and zsyr2k. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A) and op(B). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, A is not referenced and A need not be set before !> entry. !> !> @param[in] A - pointer storing matrix A on the GPU. !> Matrix dimension is ( lda, k ) when trans = rocblas_operation_none. Otherwise, !> (lda, n). !> Only the upper/lower triangular part is accessed. !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A. !> - If trans = rocblas_operation_none, lda >= max( 1, n ). !> - Otherwise, lda >= max( 1, k ). !> !> @param[in] B - pointer storing matrix B on the GPU. !> Matrix dimension is ( ldb, k ) when trans = rocblas_operation_none. Otherwise, !> (ldb, n). !> Only the upper/lower triangular part is accessed. !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B. !> - If trans = rocblas_operation_none, ldb >= max( 1, n ). !> - Otherwise, ldb >= max( 1, k ). !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, C need not be set before entry. !> !> @param[in] C - pointer storing matrix C on the GPU. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). interface rocblas_ssyr2k function rocblas_ssyr2k_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_ssyr2k") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2k_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ssyr2k_assumed_rank #else module procedure & rocblas_ssyr2k_rank_0,& rocblas_ssyr2k_rank_1,& rocblas_ssyr2k_full_rank #endif #endif end interface interface rocblas_dsyr2k function rocblas_dsyr2k_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_dsyr2k") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2k_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dsyr2k_assumed_rank #else module procedure & rocblas_dsyr2k_rank_0,& rocblas_dsyr2k_rank_1,& rocblas_dsyr2k_full_rank #endif #endif end interface interface rocblas_csyr2k function rocblas_csyr2k_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_csyr2k") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2k_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_csyr2k_assumed_rank #else module procedure & rocblas_csyr2k_rank_0,& rocblas_csyr2k_rank_1,& rocblas_csyr2k_full_rank #endif #endif end interface interface rocblas_zsyr2k function rocblas_zsyr2k_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_zsyr2k") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2k_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zsyr2k_assumed_rank #else module procedure & rocblas_zsyr2k_rank_0,& rocblas_zsyr2k_rank_1,& rocblas_zsyr2k_full_rank #endif #endif end interface interface rocblas_ssyr2k_64 function rocblas_ssyr2k_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_ssyr2k_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2k_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_dsyr2k_64 function rocblas_dsyr2k_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_dsyr2k_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2k_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_csyr2k_64 function rocblas_csyr2k_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_csyr2k_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2k_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_zsyr2k_64 function rocblas_zsyr2k_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_zsyr2k_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2k_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> The syr2k_batched functions perform a batch of the matrix-matrix operations for a symmetric !> rank-2k update: !> !> C_i := alpha*(op( A_i )*op( B_i )^T + op( B_i )*op( A_i )^T) + beta*C_i, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` !> matrices, and !> ``C_i`` is a symmetric ``n`` x ``n`` matrix stored as either upper or lower. !> !> op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == !> rocblas_operation_none !> op( A_i ) = A_i^T, op( B_i ) = B_i^T, and A_i and B_i are k by n if trans == !> rocblas_operation_transpose !> or for ssyr2k_batched and dsyr2k_batched when trans == !> rocblas_operation_conjugate_transpose !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C_i is an upper triangular matrix. !> - rocblas_fill_lower: C_i is a lower triangular matrix. !> !> @param[in] trans - [rocblas_operation] !> - rocblas_operation_transpose: op( A_i ) = A_i^T, op( B_i ) = B_i^T !> - rocblas_operation_none: op( A_i ) = A_i, op( B_i ) = B_i !> - rocblas_operation_conjugate_transpose: op( A_i ) = A_i^T, op( B_i ) = B_i^T !> - rocblas_operation_conjugate_transpose is not supported for complex types in !> csyr2k_batched and zsyr2k_batched. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, A is not referenced and A need not be set before !> entry. !> !> @param[in] A - device array of device pointers storing each matrix_i A of dimension (lda, !> k) !> when trans is rocblas_operation_none. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A_i. !> - If trans = rocblas_operation_none, lda >= max( 1, n ). !> - Otherwise, lda >= max( 1, k ). !> @param[in] B - device array of device pointers storing each matrix_i B of dimension (ldb, !> k) !> when trans is rocblas_operation_none. Otherwise, of dimension (ldb, n). !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B. !> - If trans = rocblas_operation_none, ldb >= max( 1, n ), !> - Otherwise, ldb >= max( 1, k ). !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, C need not be set before entry. !> !> @param[in] C - device array of device pointers storing each matrix C_i on the GPU. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_ssyr2k_batched function rocblas_ssyr2k_batched_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_ssyr2k_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2k_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_dsyr2k_batched function rocblas_dsyr2k_batched_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_dsyr2k_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2k_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_csyr2k_batched function rocblas_csyr2k_batched_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_csyr2k_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2k_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_zsyr2k_batched function rocblas_zsyr2k_batched_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_zsyr2k_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2k_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_ssyr2k_batched_64 function rocblas_ssyr2k_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_ssyr2k_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2k_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dsyr2k_batched_64 function rocblas_dsyr2k_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_dsyr2k_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2k_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_csyr2k_batched_64 function rocblas_csyr2k_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_csyr2k_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2k_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zsyr2k_batched_64 function rocblas_zsyr2k_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_zsyr2k_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2k_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The syr2k_strided_batched functions perform a batch of the matrix-matrix operations for a !> symmetric rank-2k update: !> !> C_i := alpha*(op( A_i )*op( B_i )^T + op( B_i )*op( A_i )^T) + beta*C_i, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` !> matrices, and !> ``C_i`` is a symmetric ``n`` x ``n`` matrix stored as either upper or lower. !> !> op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == !> rocblas_operation_none !> op( A_i ) = A_i^T, op( B_i ) = B_i^T, and A_i and B_i are k by n if trans == !> rocblas_operation_transpose !> or for ssyr2k_strided_batched and dsyr2k_strided_batched when trans == !> rocblas_operation_conjugate_transpose !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C_i is an upper triangular matrix. !> - rocblas_fill_lower: C_i is a lower triangular matrix. !> !> @param[in] trans - [rocblas_operation] !> - rocblas_operation_transpose: op( A_i ) = A_i^T, op( B_i ) = B_i^T !> - rocblas_operation_none: op( A_i ) = A_i, op( B_i ) = B_i !> - rocblas_operation_conjugate_transpose: op( A_i ) = A_i^T, op( B_i ) = B_i^T !> - rocblas_operation_conjugate_transpose is not supported for complex types in !> csyr2k_strided_batched and zsyr2k_strided_batched. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, A is not referenced and A need not be set before !> entry. !> !> @param[in] A - Device pointer to the first matrix A_1 on the GPU of dimension (lda, k) !> when trans is rocblas_operation_none. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A_i. !> - If trans = rocblas_operation_none, lda >= max( 1, n ). !> - Otherwise lda >= max( 1, k ). !> !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[in] B - Device pointer to the first matrix B_1 on the GPU of dimension (ldb, k) !> when trans is rocblas_operation_none. Otherwise, of dimension (ldb, n). !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B_i. !> - If trans = rocblas_operation_none, ldb >= max( 1, n ). !> - Otherwise, ldb >= max( 1, k ). !> !> @param[in] stride_B - [rocblas_stride] !> stride from the start of one matrix (B_i) to the next one (B_i+1). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, C need not be set before entry. !> !> @param[in] C - Device pointer to the first matrix C_1 on the GPU. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> !> @param[in, out] stride_C - [rocblas_stride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_ssyr2k_strided_batched function rocblas_ssyr2k_strided_batched_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_ssyr2k_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2k_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ssyr2k_strided_batched_assumed_rank #else module procedure & rocblas_ssyr2k_strided_batched_rank_0,& rocblas_ssyr2k_strided_batched_rank_1,& rocblas_ssyr2k_strided_batched_full_rank #endif #endif end interface interface rocblas_dsyr2k_strided_batched function rocblas_dsyr2k_strided_batched_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_dsyr2k_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2k_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dsyr2k_strided_batched_assumed_rank #else module procedure & rocblas_dsyr2k_strided_batched_rank_0,& rocblas_dsyr2k_strided_batched_rank_1,& rocblas_dsyr2k_strided_batched_full_rank #endif #endif end interface interface rocblas_csyr2k_strided_batched function rocblas_csyr2k_strided_batched_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_csyr2k_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2k_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_csyr2k_strided_batched_assumed_rank #else module procedure & rocblas_csyr2k_strided_batched_rank_0,& rocblas_csyr2k_strided_batched_rank_1,& rocblas_csyr2k_strided_batched_full_rank #endif #endif end interface interface rocblas_zsyr2k_strided_batched function rocblas_zsyr2k_strided_batched_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_zsyr2k_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2k_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zsyr2k_strided_batched_assumed_rank #else module procedure & rocblas_zsyr2k_strided_batched_rank_0,& rocblas_zsyr2k_strided_batched_rank_1,& rocblas_zsyr2k_strided_batched_full_rank #endif #endif end interface interface rocblas_ssyr2k_strided_batched_64 function rocblas_ssyr2k_strided_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_ssyr2k_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2k_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dsyr2k_strided_batched_64 function rocblas_dsyr2k_strided_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_dsyr2k_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2k_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_csyr2k_strided_batched_64 function rocblas_csyr2k_strided_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_csyr2k_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2k_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zsyr2k_strided_batched_64 function rocblas_zsyr2k_strided_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_zsyr2k_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2k_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The syrkx functions perform one of the matrix-matrix operations for a symmetric rank-k !> update: !> !> C := alpha*op( A )*op( B )^T + beta*C, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` and ``op(B)`` are ``n`` by ``k`` !> matrices, and !> ``C`` is a symmetric ``n`` x ``n`` matrix stored as either upper or lower. !> !> This routine should only be used when the caller can guarantee that the result of !> ``op( A )*op( B )^T`` will be symmetric. !> !> op( A ) = A, op( B ) = B, and A and B are n by k if trans == rocblas_operation_none !> op( A ) = A^T, op( B ) = B^T, and A and B are k by n if trans == !> rocblas_operation_transpose !> or for ssyrkx and dsyrkx when trans == rocblas_operation_conjugate_transpose !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C is an upper triangular matrix. !> - rocblas_fill_lower: C is a lower triangular matrix. !> !> @param[in] trans - [rocblas_operation] !> - rocblas_operation_transpose: op( A ) = A^T, op( B ) = B^T !> - rocblas_operation_none: op( A ) = A, op( B ) = B !> - rocblas_operation_conjugate_transpose: op( A ) = A^T, op( B ) = B^T !> - rocblas_operation_conjugate_transpose is not supported for complex types in !> csyrkx and zsyrkx. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A) and op(B). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, A is not referenced and A need not be set before !> entry. !> !> @param[in] A - pointer storing matrix A on the GPU. !> Matrix dimension is ( lda, k ) if trans = rocblas_operation_none. Otherwise, (lda, !> n). !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A. !> - If trans = rocblas_operation_none, lda >= max( 1, n ). !> - Otherwise, lda >= max( 1, k ). !> !> @param[in] B - pointer storing matrix B on the GPU. !> Matrix dimension is ( ldb, k ) if trans = rocblas_operation_none. Otherwise (ldb, !> n). !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B. !> - If trans = rocblas_operation_none, ldb >= max( 1, n ). !> - Otherwise, ldb >= max( 1, k ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, C need not be set before entry. !> !> @param[in] C - pointer storing matrix C on the GPU. !> Only the upper/lower triangular part is accessed. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). interface rocblas_ssyrkx function rocblas_ssyrkx_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_ssyrkx") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrkx_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ssyrkx_assumed_rank #else module procedure & rocblas_ssyrkx_rank_0,& rocblas_ssyrkx_rank_1,& rocblas_ssyrkx_full_rank #endif #endif end interface interface rocblas_dsyrkx function rocblas_dsyrkx_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_dsyrkx") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrkx_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dsyrkx_assumed_rank #else module procedure & rocblas_dsyrkx_rank_0,& rocblas_dsyrkx_rank_1,& rocblas_dsyrkx_full_rank #endif #endif end interface interface rocblas_csyrkx function rocblas_csyrkx_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_csyrkx") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrkx_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_csyrkx_assumed_rank #else module procedure & rocblas_csyrkx_rank_0,& rocblas_csyrkx_rank_1,& rocblas_csyrkx_full_rank #endif #endif end interface interface rocblas_zsyrkx function rocblas_zsyrkx_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_zsyrkx") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrkx_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zsyrkx_assumed_rank #else module procedure & rocblas_zsyrkx_rank_0,& rocblas_zsyrkx_rank_1,& rocblas_zsyrkx_full_rank #endif #endif end interface interface rocblas_ssyrkx_64 function rocblas_ssyrkx_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_ssyrkx_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrkx_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_dsyrkx_64 function rocblas_dsyrkx_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_dsyrkx_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrkx_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_csyrkx_64 function rocblas_csyrkx_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_csyrkx_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrkx_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_zsyrkx_64 function rocblas_zsyrkx_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_zsyrkx_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrkx_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> The syrkx_batched functions perform a batch of the matrix-matrix operations for a symmetric !> rank-k update: !> !> C_i := alpha*op( A_i )*op( B_i )^T + beta*C_i, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` !> matrices, and !> ``C_i`` is a symmetric ``n`` x ``n`` matrix stored as either upper or lower. !> !> This routine should only be used when the caller can guarantee that the result of !> ``op( A_i )*op( B_i )^T`` will be symmetric. !> !> op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == !> rocblas_operation_none !> op( A_i ) = A_i^T, op( B_i ) = B_i^T, and A_i and B_i are k by n if trans == !> rocblas_operation_transpose !> or for ssyrkx_batched and dsyrkx_batched when trans == !> rocblas_operation_conjugate_transpose !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C_i is an upper triangular matrix. !> - rocblas_fill_lower: C_i is a lower triangular matrix. !> !> @param[in] trans - [rocblas_operation] !> - rocblas_operation_transpose: op( A_i ) = A_i^T, op( B_i ) = B_i^T !> - rocblas_operation_none: op( A_i ) = A_i, op( B_i ) = B_i !> - rocblas_operation_conjugate_transpose: op( A_i ) = A_i^T, op( B_i ) = B_i^T !> - rocblas_operation_conjugate_transpose is not supported for complex types in !> csyrkx_batched and zsyrkx_batched. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, A is not referenced and A need not be set before !> entry. !> !> @param[in] A - device array of device pointers storing each matrix_i A of dimension (lda, !> k) !> when trans is rocblas_operation_none. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A_i. !> - if trans = rocblas_operation_none, lda >= max( 1, n ). !> - Otherwise, lda >= max( 1, k ). !> !> @param[in] B - device array of device pointers storing each matrix_i B of dimension (ldb, !> k) !> when trans is rocblas_operation_none. Otherwise, of dimension (ldb, n). !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B. !> - If trans = rocblas_operation_none, ldb >= max( 1, n ). !> - Otherwise, ldb >= max( 1, k ). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, then C need not be set before entry. !> !> @param[in] C - device array of device pointers storing each matrix C_i on the GPU. !> Only the upper/lower triangular part of each C_i is accessed. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_ssyrkx_batched function rocblas_ssyrkx_batched_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_ssyrkx_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrkx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_dsyrkx_batched function rocblas_dsyrkx_batched_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_dsyrkx_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrkx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_csyrkx_batched function rocblas_csyrkx_batched_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_csyrkx_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrkx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_zsyrkx_batched function rocblas_zsyrkx_batched_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_zsyrkx_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrkx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_ssyrkx_batched_64 function rocblas_ssyrkx_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_ssyrkx_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrkx_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dsyrkx_batched_64 function rocblas_dsyrkx_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_dsyrkx_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrkx_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_csyrkx_batched_64 function rocblas_csyrkx_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_csyrkx_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrkx_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zsyrkx_batched_64 function rocblas_zsyrkx_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_zsyrkx_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrkx_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The syrkx_strided_batched functions perform a batch of the matrix-matrix operations for a !> symmetric rank-k update: !> !> C_i := alpha*op( A_i )*op( B_i )^T + beta*C_i, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)`` and ``op(B_i)`` are ``n`` by ``k`` !> matrices, and !> ``C_i`` is a symmetric ``n`` x ``n`` matrix stored as either upper or lower. !> !> This routine should only be used when the caller can guarantee that the result of !> ``op( A_i )*op( B_i )^T`` will be symmetric. !> !> op( A_i ) = A_i, op( B_i ) = B_i, and A_i and B_i are n by k if trans == !> rocblas_operation_none !> op( A_i ) = A_i^T, op( B_i ) = B_i^T, and A_i and B_i are k by n if trans == !> rocblas_operation_transpose !> or for ssyrkx_strided_batched and dsyrkx_strided_batched when trans == !> rocblas_operation_conjugate_transpose !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C_i is an upper triangular matrix. !> - rocblas_fill_lower: C_i is a lower triangular matrix. !> !> @param[in] trans - [rocblas_operation] !> - rocblas_operation_transpose: op( A_i ) = A_i^T, op( B_i ) = B_i^T !> - rocblas_operation_none: op( A_i ) = A_i, op( B_i ) = B_i !> - rocblas_operation_conjugate_transpose: op( A_i ) = A_i^T, op( B_i ) = B_i^T !> - rocblas_operation_conjugate_transpose is not supported for complex types in !> csyrkx_strided_batched and zsyrkx_strided_batched. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C_i. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, A is not referenced and A need not be set before !> entry. !> !> @param[in] A - Device pointer to the first matrix A_1 on the GPU of dimension (lda, k) !> when trans is rocblas_operation_none. Otherwise, of dimension (lda, n). !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A_i. !> - If trans = rocblas_operation_none, lda >= max( 1, n ). !> - Otherwise, lda >= max( 1, k ). !> !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[in] B - Device pointer to the first matrix B_1 on the GPU of dimension (ldb, k) !> when trans is rocblas_operation_none. Otherwise, of dimension (ldb, n). !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B_i. !> - If trans = rocblas_operation_none, ldb >= max( 1, n ). !> - Otherwise, ldb >= max( 1, k ). !> !> @param[in] stride_B - [rocblas_stride] !> stride from the start of one matrix (B_i) to the next one (B_i+1). !> !> @param[in] beta !> beta specifies the scalar beta. When beta is !> zero, C need not be set before entry. !> !> @param[in] C - Device pointer to the first matrix C_1 on the GPU. !> Only the upper/lower triangular part of each C_i is accessed. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> !> @param[in, out] stride_C - [rocblas_stride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_ssyrkx_strided_batched function rocblas_ssyrkx_strided_batched_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_ssyrkx_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrkx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ssyrkx_strided_batched_assumed_rank #else module procedure & rocblas_ssyrkx_strided_batched_rank_0,& rocblas_ssyrkx_strided_batched_rank_1,& rocblas_ssyrkx_strided_batched_full_rank #endif #endif end interface interface rocblas_dsyrkx_strided_batched function rocblas_dsyrkx_strided_batched_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_dsyrkx_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrkx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dsyrkx_strided_batched_assumed_rank #else module procedure & rocblas_dsyrkx_strided_batched_rank_0,& rocblas_dsyrkx_strided_batched_rank_1,& rocblas_dsyrkx_strided_batched_full_rank #endif #endif end interface interface rocblas_csyrkx_strided_batched function rocblas_csyrkx_strided_batched_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_csyrkx_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrkx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_csyrkx_strided_batched_assumed_rank #else module procedure & rocblas_csyrkx_strided_batched_rank_0,& rocblas_csyrkx_strided_batched_rank_1,& rocblas_csyrkx_strided_batched_full_rank #endif #endif end interface interface rocblas_zsyrkx_strided_batched function rocblas_zsyrkx_strided_batched_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_zsyrkx_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrkx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zsyrkx_strided_batched_assumed_rank #else module procedure & rocblas_zsyrkx_strided_batched_rank_0,& rocblas_zsyrkx_strided_batched_rank_1,& rocblas_zsyrkx_strided_batched_full_rank #endif #endif end interface interface rocblas_ssyrkx_strided_batched_64 function rocblas_ssyrkx_strided_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_ssyrkx_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrkx_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dsyrkx_strided_batched_64 function rocblas_dsyrkx_strided_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_dsyrkx_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrkx_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_csyrkx_strided_batched_64 function rocblas_csyrkx_strided_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_csyrkx_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrkx_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zsyrkx_strided_batched_64 function rocblas_zsyrkx_strided_batched_64_(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_zsyrkx_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrkx_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The trmm functions perform one of the matrix-matrix operations: !> !> C := alpha*op( A )*B, or !> C := alpha*B*op( A ), !> !> The Legacy BLAS in-place trmm functionality: !> !> B := alpha*op( A )*B, or !> B := alpha*B*op( A ), !> !> is available by setting pointer ``C`` equal to pointer ``B``, and ``ldc`` equal to ``ldb``. !> !> ``alpha`` is a scalar, ``B`` is an ``m`` by ``n`` matrix, ``C`` is an ``m`` by ``n`` !> matrix, ``A`` is a unit, or !> non-unit, upper or lower triangular matrix, and ``op( A )`` is one of: !> !> op( A ) = A or !> op( A ) = A^T or !> op( A ) = A^H. !> !> When ``uplo == rocblas_fill_upper``, the leading ``k`` by ``k`` !> upper triangular part of the array ``A`` must contain the upper !> triangular matrix and the strictly lower triangular part of !> ``A`` is not referenced. Here, ``k`` is ``m`` when ``side == rocblas_side_left`` !> and is ``n`` when ``side == rocblas_side_right``. !> !> When ``uplo == rocblas_fill_lower``, the leading ``k`` by ``k`` !> lower triangular part of the array ``A ``must contain the lower !> triangular matrix and the strictly upper triangular part of !> ``A`` is not referenced. Here, ``k`` is ``m`` when ``side == rocblas_side_left`` !> and is ``n`` when ``side == rocblas_side_right``. !> !> Note that when ``diag == rocblas_diagonal_unit``, the diagonal elements of !> ``A`` are not referenced either but are assumed to be unity. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] side - [rocblas_side] !> Specifies whether op(A) multiplies B from the left or right as follows: !> - rocblas_side_left: C := alpha*op( A )*B !> - rocblas_side_right: C := alpha*B*op( A ) !> !> @param[in] uplo - [rocblas_fill] !> Specifies whether the matrix A is an upper or lower triangular matrix as follows: !> - rocblas_fill_upper: A is an upper triangular matrix. !> - rocblas_fill_lower: A is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> Specifies the form of op(A) to be used in the matrix multiplication as follows: !> - rocblas_operation_none: op(A) = A !> - rocblas_operation_transpose: op(A) = A^T !> - rocblas_operation_conjugate_transpose: op(A) = A^H !> !> @param[in] diag - [rocblas_diagonal] !> Specifies whether or not A is unit triangular as follows: !> - rocblas_diagonal_unit: A is assumed to be unit triangular. !> - rocblas_diagonal_non_unit: A is not assumed to be unit triangular. !> !> @param[in] m - [rocblas_int] !> m specifies the number of rows of B. m >= 0. !> !> @param[in] n - [rocblas_int] !> n specifies the number of columns of B. n >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, A is not referenced and B need not be set before !> entry. !> !> @param[in] A - Device pointer to matrix A on the GPU. !> A has dimension ( lda, k ), where k is m !> when side == rocblas_side_left and !> is n when side == rocblas_side_right. !> - When uplo == rocblas_fill_upper the leading k by k !> upper triangular part of the array A must contain the upper !> triangular matrix, and the strictly lower triangular part of !> A is not referenced. !> - When uplo == rocblas_fill_lower the leading k by k !> lower triangular part of the array A must contain the lower !> triangular matrix, and the strictly upper triangular part of !> A is not referenced. !> - Note that when diag == rocblas_diagonal_unit the diagonal elements of !> A are not referenced either but are assumed to be unity. !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A. !> - If side == rocblas_side_left, lda >= max( 1, m ). !> - If side == rocblas_side_right, lda >= max( 1, n ). !> !> @param[in] B - Device pointer to the matrix B on the GPU. !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B. ldb >= max( 1, m ). !> !> @param[out] C - Device pointer to the matrix C on the GPU. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, m). !> If B and C are pointers to the same matrix, ldc must equal ldb or !> rocblas_status_invalid_value will be returned. interface rocblas_strmm function rocblas_strmm_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="rocblas_strmm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmm_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_strmm_assumed_rank #else module procedure & rocblas_strmm_rank_0,& rocblas_strmm_rank_1,& rocblas_strmm_full_rank #endif #endif end interface interface rocblas_dtrmm function rocblas_dtrmm_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="rocblas_dtrmm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmm_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dtrmm_assumed_rank #else module procedure & rocblas_dtrmm_rank_0,& rocblas_dtrmm_rank_1,& rocblas_dtrmm_full_rank #endif #endif end interface interface rocblas_ctrmm function rocblas_ctrmm_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="rocblas_ctrmm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmm_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ctrmm_assumed_rank #else module procedure & rocblas_ctrmm_rank_0,& rocblas_ctrmm_rank_1,& rocblas_ctrmm_full_rank #endif #endif end interface interface rocblas_ztrmm function rocblas_ztrmm_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="rocblas_ztrmm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmm_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ztrmm_assumed_rank #else module procedure & rocblas_ztrmm_rank_0,& rocblas_ztrmm_rank_1,& rocblas_ztrmm_full_rank #endif #endif end interface interface rocblas_strmm_64 function rocblas_strmm_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="rocblas_strmm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmm_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_dtrmm_64 function rocblas_dtrmm_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="rocblas_dtrmm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmm_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_ctrmm_64 function rocblas_ctrmm_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="rocblas_ctrmm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmm_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_ztrmm_64 function rocblas_ztrmm_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) & bind(c, name="rocblas_ztrmm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmm_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> The trmm_batched functions perform one of the matrix-matrix operations: !> !> C_i := alpha*op( A_i )*B_i, or !> C_i := alpha*B_i*op( A_i ) for i = 0, 1, ... batch_count -1, !> !> The Legacy BLAS in-place trmm_batched functionality: !> !> B_i := alpha*op( A_i )*B_i, or !> B_i := alpha*B_i*op( A_i ) for i = 0, 1, ... batch_count -1, !> !> is available by setting pointer ``C`` equal to pointer ``B`` and ``ldc`` equal to ``ldb``. !> !> ``alpha`` is a scalar, ``B_i`` is an ``m`` by ``n`` matrix, ``C_i`` is an ``m`` by ``n`` !> matrix, ``A_i`` is a unit, or !> non-unit, upper or lower triangular matrix, and ``op( A_i )`` is one of: !> !> op( A_i ) = A_i or !> op( A_i ) = A_i^T or !> op( A_i ) = A_i^H. !> !> When ``uplo == rocblas_fill_upper``, the leading ``k`` by ``k`` !> upper triangular part of the array ``A`` must contain the upper !> triangular matrix, and the strictly lower triangular part of !> ``A`` is not referenced. Here, ``k`` is ``m`` when ``side == rocblas_side_left`` !> and is ``n`` when ``side == rocblas_side_right``. !> !> When ``uplo == rocblas_fill_lower``, the leading ``k`` by ``k`` !> lower triangular part of the array ``A`` must contain the lower !> triangular matrix, and the strictly upper triangular part of !> ``A`` is not referenced. Here, ``k`` is ``m`` when ``side == rocblas_side_left`` !> and is ``n`` when ``side == rocblas_side_right``. !> !> Note that when ``diag == rocblas_diagonal_unit``, the diagonal elements of !> ``A`` are not referenced either but are assumed to be unity. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] side - [rocblas_side] !> Specifies whether op(A_i) multiplies B_i from the left or right as follows: !> - rocblas_side_left: C_i := alpha*op( A_i )*B_i !> - rocblas_side_right: C_i := alpha*B_i*op( A_i ) !> !> @param[in] uplo - [rocblas_fill] !> Specifies whether the matrix A is an upper or lower triangular matrix as follows: !> - rocblas_fill_upper: A is an upper triangular matrix. !> - rocblas_fill_lower: A is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> Specifies the form of op(A_i) to be used in the matrix multiplication as follows: !> - rocblas_operation_none: op(A_i) = A_i !> - rocblas_operation_transpose: op(A_i) = A_i^T !> - rocblas_operation_conjugate_transpose: op(A_i) = A_i^H !> !> @param[in] diag - [rocblas_diagonal] !> Specifies whether or not A_i is unit triangular as follows: !> - rocblas_diagonal_unit: A_i is assumed to be unit triangular. !> - rocblas_diagonal_non_unit: A_i is not assumed to be unit triangular. !> !> @param[in] m - [rocblas_int] !> m specifies the number of rows of B_i. m >= 0. !> !> @param[in] n - [rocblas_int] !> n specifies the number of columns of B_i. n >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A_i is not referenced and B_i need not be set before !> entry. !> !> @param[in] A - Device array of device pointers storing each matrix A_i on the GPU. !> Each A_i is of dimension ( lda, k ), where k is m !> when side == rocblas_side_left and !> is n when side == rocblas_side_right. !> - When uplo == rocblas_fill_upper the leading k by k !> upper triangular part of the array A must contain the upper !> triangular matrix, and the strictly lower triangular part of !> A is not referenced. !> - When uplo == rocblas_fill_lower the leading k by k !> lower triangular part of the array A must contain the lower !> triangular matrix, and the strictly upper triangular part of !> A is not referenced. !> - Note that when diag == rocblas_diagonal_unit the diagonal elements of !> A_i are not referenced either but are assumed to be unity. !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A. !> - If side == rocblas_side_left, lda >= max( 1, m ). !> - If side == rocblas_side_right, lda >= max( 1, n ). !> !> @param[in] B - device array of device pointers storing each matrix B_i on the GPU. !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B_i. ldb >= max( 1, m ). !> !> @param[out] C - device array of device pointers storing each matrix C_i on the GPU. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, m). !> If B and C are pointers to the same array of pointers, then ldc must !> equal ldb or rocblas_status_invalid_value will be returned. !> !> @param[in] batch_count - [rocblas_int] !> number of instances i in the batch. interface rocblas_strmm_batched function rocblas_strmm_batched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc, & batch_count) & bind(c, name="rocblas_strmm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_dtrmm_batched function rocblas_dtrmm_batched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc, & batch_count) & bind(c, name="rocblas_dtrmm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_ctrmm_batched function rocblas_ctrmm_batched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc, & batch_count) & bind(c, name="rocblas_ctrmm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_ztrmm_batched function rocblas_ztrmm_batched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc, & batch_count) & bind(c, name="rocblas_ztrmm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_strmm_batched_64 function rocblas_strmm_batched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc, & batch_count) & bind(c, name="rocblas_strmm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dtrmm_batched_64 function rocblas_dtrmm_batched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc, & batch_count) & bind(c, name="rocblas_dtrmm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ctrmm_batched_64 function rocblas_ctrmm_batched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc, & batch_count) & bind(c, name="rocblas_ctrmm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ztrmm_batched_64 function rocblas_ztrmm_batched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc, & batch_count) & bind(c, name="rocblas_ztrmm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The trmm_strided_batched functions performs one of the matrix-matrix operations: !> !> C_i := alpha*op( A_i )*B_i, or !> C_i := alpha*B_i*op( A_i ) for i = 0, 1, ... batch_count -1, !> !> The Legacy BLAS in-place trmm_strided_batched functionality: !> !> B_i := alpha*op( A_i )*B_i, or !> B_i := alpha*B_i*op( A_i ) for i = 0, 1, ... batch_count -1, !> !> is available by setting pointer ``C`` equal to pointer ``B``, ``ldc`` equal to ``ldb``, and !> ``stride_C`` equal to ``stride_B``. !> !> ``alpha`` is a scalar, ``B_i`` is an ``m`` by ``n`` matrix, ``C_i`` is an ``m`` by ``n`` !> matrix, ``A_i`` is a unit, or !> non-unit, upper or lower triangular matrix and ``op( A_i )`` is one of: !> !> op( A_i ) = A_i or !> op( A_i ) = A_i^T or !> op( A_i ) = A_i^H. !> !> When ``uplo == rocblas_fill_upper``, the leading ``k`` by ``k`` !> upper triangular part of the array ``A`` must contain the upper !> triangular matrix, and the strictly lower triangular part of !> ``A`` is not referenced. Here, ``k`` is ``m`` when ``side == rocblas_side_left`` !> and is ``n`` when ``side == rocblas_side_right``. !> !> When ``uplo == rocblas_fill_lower``, the leading ``k`` by ``k`` !> lower triangular part of the array ``A`` must contain the lower !> triangular matrix, and the strictly upper triangular part of !> ``A`` is not referenced. Here, ``k`` is ``m`` when ``side == rocblas_side_left`` !> and is ``n`` when ``side == rocblas_side_right``. !> !> Note that when ``diag == rocblas_diagonal_unit``, the diagonal elements of !> ``A`` are not referenced either but are assumed to be unity. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] side - [rocblas_side] !> Specifies whether op(A_i) multiplies B_i from the left or right as follows: !> - rocblas_side_left: C_i := alpha*op( A_i )*B_i !> - rocblas_side_right: C_i := alpha*B_i*op( A_i ) !> !> @param[in] uplo - [rocblas_fill] !> Specifies whether the matrix A is an upper or lower triangular matrix as follows: !> - rocblas_fill_upper: A is an upper triangular matrix. !> - rocblas_fill_lower: A is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> Specifies the form of op(A_i) to be used in the matrix multiplication as follows: !> - rocblas_operation_none: op(A_i) = A_i !> - rocblas_operation_transpose: op(A_i) = A_i^T !> - rocblas_operation_conjugate_transpose: op(A_i) = A_i^H !> !> @param[in] diag - [rocblas_diagonal] !> Specifies whether or not A_i is unit triangular as follows: !> - rocblas_diagonal_unit: A_i is assumed to be unit triangular. !> - rocblas_diagonal_non_unit: A_i is not assumed to be unit triangular. !> !> @param[in] m - [rocblas_int] !> m specifies the number of rows of B_i. m >= 0. !> !> @param[in] n - [rocblas_int] !> n specifies the number of columns of B_i. n >= 0. !> !> @param[in] alpha !> alpha specifies the scalar alpha. When alpha is !> zero, then A_i is not referenced and B_i need not be set before !> entry. !> !> @param[in] A - Device pointer to the first matrix A_0 on the GPU. !> Each A_i is of dimension ( lda, k ), where k is m !> when side == rocblas_side_left and !> is n when side == rocblas_side_right. !> - When uplo == rocblas_fill_upper, the leading k by k !> upper triangular part of the array A must contain the upper !> triangular matrix, and the strictly lower triangular part of !> A is not referenced. !> - When uplo == rocblas_fill_lower ,the leading k by k !> lower triangular part of the array A must contain the lower !> triangular matrix, and the strictly upper triangular part of !> A is not referenced. !> - Note that when diag == rocblas_diagonal_unit, the diagonal elements of !> A_i are not referenced either but are assumed to be unity. !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A. !> - If side == rocblas_side_left, lda >= max( 1, m ). !> - If side == rocblas_side_right, lda >= max( 1, n ). !> !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[in] B - Device pointer to the first matrix B_0 on the GPU. !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B_i. ldb >= max( 1, m ). !> !> @param[in] stride_B - [rocblas_stride] !> stride from the start of one matrix (B_i) to the next one (B_i+1). !> !> @param[out] C - Device pointer to the first matrix C_0 on the GPU. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C_i. ldc >= max( 1, m). !> If B and C pointers are to the same matrix, then ldc must equal ldb or !> rocblas_status_invalid_size will be returned. !> !> @param[in] stride_C - [rocblas_stride] !> stride from the start of one matrix (C_i) and the next one (C_i+1). !> If B == C and ldb == ldc, then stride_C should equal stride_B or !> behavior is undefined. !> !> @param[in] batch_count - [rocblas_int] !> number of instances i in the batch. interface rocblas_strmm_strided_batched function rocblas_strmm_strided_batched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,stride_A, & B,ldb,stride_B,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_strmm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function end interface interface rocblas_dtrmm_strided_batched function rocblas_dtrmm_strided_batched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,stride_A, & B,ldb,stride_B,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_dtrmm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function end interface interface rocblas_ctrmm_strided_batched function rocblas_ctrmm_strided_batched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,stride_A, & B,ldb,stride_B,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_ctrmm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function end interface interface rocblas_ztrmm_strided_batched function rocblas_ztrmm_strided_batched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,stride_A, & B,ldb,stride_B,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_ztrmm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function end interface interface rocblas_strmm_strided_batched_64 function rocblas_strmm_strided_batched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_A,B,ldb,stride_B,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_strmm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dtrmm_strided_batched_64 function rocblas_dtrmm_strided_batched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_A,B,ldb,stride_B,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_dtrmm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ctrmm_strided_batched_64 function rocblas_ctrmm_strided_batched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_A,B,ldb,stride_B,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_ctrmm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ztrmm_strided_batched_64 function rocblas_ztrmm_strided_batched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_A,B,ldb,stride_B,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_ztrmm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The trtri functions compute the inverse of a matrix ``A``, namely, invA, !> and write the result into ``invA``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies whether upper (rocblas_fill_upper) or lower (rocblas_fill_lower): !> - If rocblas_fill_upper, the lower part of A is not referenced. !> - If rocblas_fill_lower, the upper part of A is not referenced. !> @param[in] diag - [rocblas_diagonal] !> - 'rocblas_diagonal_non_unit': A is non-unit triangular. !> - 'rocblas_diagonal_unit': A is unit triangular. !> @param[in] n - [rocblas_int] !> size of matrix A and invA. !> @param[in] A - device pointer storing matrix A. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. !> @param[out] invA - device pointer storing matrix invA. !> Partial inplace operation is supported. See below: !> - If UPLO = 'U', the leading N-by-N upper triangular part of the invA will store !> the inverse of the upper triangular matrix, and the strictly lower !> triangular part of invA can be cleared. !> - If UPLO = 'L', the leading N-by-N lower triangular part of the invA will store !> the inverse of the lower triangular matrix, and the strictly upper !> triangular part of invA can be cleared. !> @param[in] ldinvA - [rocblas_int] !> specifies the leading dimension of invA. interface rocblas_strtri function rocblas_strtri_(handle,uplo,diag,n,A,lda,invA,ldinvA) bind(c, name="rocblas_strtri") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strtri_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: invA integer(c_int),value :: ldinvA end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_strtri_assumed_rank #else module procedure & rocblas_strtri_rank_0,& rocblas_strtri_rank_1,& rocblas_strtri_full_rank #endif #endif end interface interface rocblas_dtrtri function rocblas_dtrtri_(handle,uplo,diag,n,A,lda,invA,ldinvA) bind(c, name="rocblas_dtrtri") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrtri_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: invA integer(c_int),value :: ldinvA end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dtrtri_assumed_rank #else module procedure & rocblas_dtrtri_rank_0,& rocblas_dtrtri_rank_1,& rocblas_dtrtri_full_rank #endif #endif end interface interface rocblas_ctrtri function rocblas_ctrtri_(handle,uplo,diag,n,A,lda,invA,ldinvA) bind(c, name="rocblas_ctrtri") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrtri_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: invA integer(c_int),value :: ldinvA end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ctrtri_assumed_rank #else module procedure & rocblas_ctrtri_rank_0,& rocblas_ctrtri_rank_1,& rocblas_ctrtri_full_rank #endif #endif end interface interface rocblas_ztrtri function rocblas_ztrtri_(handle,uplo,diag,n,A,lda,invA,ldinvA) bind(c, name="rocblas_ztrtri") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrtri_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: invA integer(c_int),value :: ldinvA end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ztrtri_assumed_rank #else module procedure & rocblas_ztrtri_rank_0,& rocblas_ztrtri_rank_1,& rocblas_ztrtri_full_rank #endif #endif end interface !> \brief BLAS Level 3 API !> !> \details !> The trtri_batched functions compute the inverse of ``A_i`` and write into ``invA_i``, where !> ``A_i`` and ``invA_i`` are the ``i``-th matrices in the batch, !> for ``i`` = 1, ..., ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies whether upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> @param[in] diag - [rocblas_diagonal] !> - 'rocblas_diagonal_non_unit': A is non-unit triangular. !> - 'rocblas_diagonal_unit': A is unit triangular. !> @param[in] n - [rocblas_int] !> @param[in] A - device array of device pointers storing each matrix A_i. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. !> @param[out] invA - device array of device pointers storing the inverse of each matrix A_i. !> Partial inplace operation is supported. See below: !> - If UPLO = 'U', the leading N-by-N upper triangular part of the invA will store !> the inverse of the upper triangular matrix, and the strictly lower !> triangular part of invA can be cleared. !> - If UPLO = 'L', the leading N-by-N lower triangular part of the invA will store !> the inverse of the lower triangular matrix, and the strictly upper !> triangular part of invA can be cleared. !> @param[in] ldinvA - [rocblas_int] !> specifies the leading dimension of each invA_i. !> @param[in] batch_count - [rocblas_int] !> numbers of matrices in the batch. interface rocblas_strtri_batched function rocblas_strtri_batched_(handle,uplo,diag,n,A,lda,invA,ldinvA,batch_count) & bind(c, name="rocblas_strtri_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strtri_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: invA integer(c_int),value :: ldinvA integer(c_int),value :: batch_count end function end interface interface rocblas_dtrtri_batched function rocblas_dtrtri_batched_(handle,uplo,diag,n,A,lda,invA,ldinvA,batch_count) & bind(c, name="rocblas_dtrtri_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrtri_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: invA integer(c_int),value :: ldinvA integer(c_int),value :: batch_count end function end interface interface rocblas_ctrtri_batched function rocblas_ctrtri_batched_(handle,uplo,diag,n,A,lda,invA,ldinvA,batch_count) & bind(c, name="rocblas_ctrtri_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrtri_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: invA integer(c_int),value :: ldinvA integer(c_int),value :: batch_count end function end interface interface rocblas_ztrtri_batched function rocblas_ztrtri_batched_(handle,uplo,diag,n,A,lda,invA,ldinvA,batch_count) & bind(c, name="rocblas_ztrtri_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrtri_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: invA integer(c_int),value :: ldinvA integer(c_int),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The trtri_strided_batched functions compute the inverse of ``A_i`` and write into !> ``invA_i``, where !> ``A_i`` and ``invA_i`` are the ``i``-th matrices in the batch, !> for ``i`` = 1, ..., ``batch_count``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> specifies whether upper (rocblas_fill_upper) or lower (rocblas_fill_lower). !> @param[in] diag - [rocblas_diagonal] !> - 'rocblas_diagonal_non_unit': A is non-unit triangular. !> - 'rocblas_diagonal_unit': A is unit triangular. !> @param[in] n - [rocblas_int] !> @param[in] A - device pointer pointing to address of first matrix A_1. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A. !> @param[in] stride_a - [rocblas_stride] !> "batch stride a": stride from the start of one A_i matrix to the next A_(i + 1). !> @param[out] invA - device pointer storing the inverses of each matrix A_i. !> Partial inplace operation is supported. See below: !> - If UPLO = 'U', the leading N-by-N upper triangular part of the invA will store !> the inverse of the upper triangular matrix, and the strictly lower !> triangular part of invA can be cleared. !> - If UPLO = 'L', the leading N-by-N lower triangular part of the invA will store !> the inverse of the lower triangular matrix, and the strictly upper !> triangular part of invA can be cleared. !> @param[in] ldinvA - [rocblas_int] !> specifies the leading dimension of each invA_i. !> @param[in] stride_invA - [rocblas_stride] !> "batch stride invA": stride from the start of one invA_i matrix to the next !> invA_(i + 1). !> @param[in] batch_count - [rocblas_int] !> numbers of matrices in the batch. interface rocblas_strtri_strided_batched function rocblas_strtri_strided_batched_(handle,uplo,diag,n,A,lda,stride_a,invA,ldinvA, & stride_invA,batch_count) & bind(c, name="rocblas_strtri_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strtri_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: invA integer(c_int),value :: ldinvA integer(c_int64_t),value :: stride_invA integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_strtri_strided_batched_assumed_rank #else module procedure & rocblas_strtri_strided_batched_rank_0,& rocblas_strtri_strided_batched_rank_1,& rocblas_strtri_strided_batched_full_rank #endif #endif end interface interface rocblas_dtrtri_strided_batched function rocblas_dtrtri_strided_batched_(handle,uplo,diag,n,A,lda,stride_a,invA,ldinvA, & stride_invA,batch_count) & bind(c, name="rocblas_dtrtri_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrtri_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: invA integer(c_int),value :: ldinvA integer(c_int64_t),value :: stride_invA integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dtrtri_strided_batched_assumed_rank #else module procedure & rocblas_dtrtri_strided_batched_rank_0,& rocblas_dtrtri_strided_batched_rank_1,& rocblas_dtrtri_strided_batched_full_rank #endif #endif end interface interface rocblas_ctrtri_strided_batched function rocblas_ctrtri_strided_batched_(handle,uplo,diag,n,A,lda,stride_a,invA,ldinvA, & stride_invA,batch_count) & bind(c, name="rocblas_ctrtri_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrtri_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: invA integer(c_int),value :: ldinvA integer(c_int64_t),value :: stride_invA integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ctrtri_strided_batched_assumed_rank #else module procedure & rocblas_ctrtri_strided_batched_rank_0,& rocblas_ctrtri_strided_batched_rank_1,& rocblas_ctrtri_strided_batched_full_rank #endif #endif end interface interface rocblas_ztrtri_strided_batched function rocblas_ztrtri_strided_batched_(handle,uplo,diag,n,A,lda,stride_a,invA,ldinvA, & stride_invA,batch_count) & bind(c, name="rocblas_ztrtri_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrtri_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: invA integer(c_int),value :: ldinvA integer(c_int64_t),value :: stride_invA integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ztrtri_strided_batched_assumed_rank #else module procedure & rocblas_ztrtri_strided_batched_rank_0,& rocblas_ztrtri_strided_batched_rank_1,& rocblas_ztrtri_strided_batched_full_rank #endif #endif end interface !> \brief BLAS Level 3 API !> !> \details !> The trsm functions solve: !> !> op(A)*X = alpha*B or X*op(A) = alpha*B, !> !> where ``alpha`` is a scalar, ``X`` and ``B`` are ``m`` by ``n`` matrices, !> ``A`` is a triangular matrix, and ``op(A)`` is one of: !> !> op( A ) = A or op( A ) = A^T or op( A ) = A^H. !> !> The matrix ``X`` is overwritten on ``B``. !> !> Note about memory allocation: !> When trsm is launched with a ``k`` evenly divisible by the internal block size of 128, !> and is no larger than 10 of these blocks, the API takes advantage of utilizing preallocated !> memory found in the handle to increase overall performance (where ``k`` is ``m`` !> when ``rocblas_side_left`` and ``n`` when ``rocblas_side_right``). !> !> Although not widespread, some gemm kernels used by trsm might use atomic operations. !> See Atomic Operations in the API Reference Guide for more information. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] side - [rocblas_side] !> - rocblas_side_left: op(A)*X = alpha*B !> - rocblas_side_right: X*op(A) = alpha*B !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A is an upper triangular matrix. !> - rocblas_fill_lower: A is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - transB: op(A) = A. !> - rocblas_operation_transpose: op(A) = A^T !> - rocblas_operation_conjugate_transpose: op(A) = A^H !> !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: A is assumed to be unit triangular. !> - rocblas_diagonal_non_unit: A is not assumed to be unit triangular. !> !> @param[in] m - [rocblas_int] !> m specifies the number of rows of B. m >= 0. !> !> @param[in] n - [rocblas_int] !> n specifies the number of columns of B. n >= 0. !> !> @param[in] alpha !> device pointer or host pointer specifying the scalar alpha. When alpha is !> &zero, then A is not referenced and B need not be set before !> entry. !> !> @param[in] A - device pointer storing matrix A. !> of dimension ( lda, k ), where k is m !> when rocblas_side_left and !> n when rocblas_side_right. !> Only the upper/lower triangular part is accessed. !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A. !> - If side = rocblas_side_left, lda >= max( 1, m ). !> - If side = rocblas_side_right, lda >= max( 1, n ). !> !> @param[in,out] B - device pointer storing matrix B. !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B. ldb >= max( 1, m ). interface rocblas_strsm function rocblas_strsm_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) & bind(c, name="rocblas_strsm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsm_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_strsm_assumed_rank #else module procedure & rocblas_strsm_rank_0,& rocblas_strsm_rank_1,& rocblas_strsm_full_rank #endif #endif end interface interface rocblas_dtrsm function rocblas_dtrsm_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) & bind(c, name="rocblas_dtrsm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsm_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dtrsm_assumed_rank #else module procedure & rocblas_dtrsm_rank_0,& rocblas_dtrsm_rank_1,& rocblas_dtrsm_full_rank #endif #endif end interface interface rocblas_ctrsm function rocblas_ctrsm_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) & bind(c, name="rocblas_ctrsm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsm_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ctrsm_assumed_rank #else module procedure & rocblas_ctrsm_rank_0,& rocblas_ctrsm_rank_1,& rocblas_ctrsm_full_rank #endif #endif end interface interface rocblas_ztrsm function rocblas_ztrsm_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) & bind(c, name="rocblas_ztrsm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsm_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ztrsm_assumed_rank #else module procedure & rocblas_ztrsm_rank_0,& rocblas_ztrsm_rank_1,& rocblas_ztrsm_full_rank #endif #endif end interface interface rocblas_strsm_64 function rocblas_strsm_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) & bind(c, name="rocblas_strsm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsm_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface interface rocblas_dtrsm_64 function rocblas_dtrsm_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) & bind(c, name="rocblas_dtrsm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsm_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface interface rocblas_ctrsm_64 function rocblas_ctrsm_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) & bind(c, name="rocblas_ctrsm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsm_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface interface rocblas_ztrsm_64 function rocblas_ztrsm_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) & bind(c, name="rocblas_ztrsm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsm_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface !> \brief BLAS Level 3 API !> !> \details !> The trsm_batched functions perform the following batched operation: !> !> op(A_i)*X_i = alpha*B_i or !> X_i*op(A_i) = alpha*B_i, for i = 1, ..., batch_count, !> !> where ``alpha`` is a scalar, ``X`` and ``B`` are batched ``m`` by ``n`` matrices, !> ``A`` is a triangular batched matrix, and ``op(A)`` is one of: !> !> op( A ) = A or !> op( A ) = A^T or !> op( A ) = A^H. !> !> Each matrix ``X_i`` is overwritten on ``B_i`` for ``i`` = 1, ..., ``batch_count``. !> !> Note about memory allocation: !> When trsm is launched with a ``k`` evenly divisible by the internal block size of 128, !> and is no larger than 10 of these blocks, the API takes advantage of utilizing preallocated !> memory found in the handle to increase overall performance (where ``k`` is ``m`` !> when ``rocblas_side_left`` and ``n`` when ``rocblas_side_right``). !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] side - [rocblas_side] !> - rocblas_side_left: op(A)*X = alpha*B !> - rocblas_side_right: X*op(A) = alpha*B !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: each A_i is an upper triangular matrix. !> - rocblas_fill_lower: each A_i is a lower triangular matrix. !> @param[in] transA - [rocblas_operation] !> - transB: op(A) = A !> - rocblas_operation_transpose: op(A) = A^T !> - rocblas_operation_conjugate_transpose: op(A) = A^H !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: each A_i is assumed to be unit triangular. !> - rocblas_diagonal_non_unit: each A_i is not assumed to be unit triangular. !> @param[in] m - [rocblas_int] !> m specifies the number of rows of each B_i. m >= 0. !> @param[in] n - [rocblas_int] !> n specifies the number of columns of each B_i. n >= 0. !> @param[in] alpha !> device pointer or host pointer specifying the scalar alpha. When alpha is !> &zero, then A is not referenced and B need not be set before !> entry. !> @param[in] A - device array of device pointers storing each matrix A_i on the GPU. !> Matrices are of dimension ( lda, k ), where k is m !> when rocblas_side_left and n when rocblas_side_right. !> Only the upper/lower triangular part is accessed. !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of each A_i. !> - If side = rocblas_side_left, lda >= max( 1, m ). !> - If side = rocblas_side_right, lda >= max( 1, n ). !> @param[in,out] B - device array of device pointers storing each matrix B_i on the GPU. !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of each B_i. ldb >= max( 1, m ). !> @param[in] batch_count - [rocblas_int] !> number of trsm operatons in the batch. interface rocblas_strsm_batched function rocblas_strsm_batched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb, & batch_count) & bind(c, name="rocblas_strsm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function end interface interface rocblas_dtrsm_batched function rocblas_dtrsm_batched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb, & batch_count) & bind(c, name="rocblas_dtrsm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function end interface interface rocblas_ctrsm_batched function rocblas_ctrsm_batched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb, & batch_count) & bind(c, name="rocblas_ctrsm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function end interface interface rocblas_ztrsm_batched function rocblas_ztrsm_batched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb, & batch_count) & bind(c, name="rocblas_ztrsm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function end interface interface rocblas_strsm_batched_64 function rocblas_strsm_batched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb, & batch_count) & bind(c, name="rocblas_strsm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dtrsm_batched_64 function rocblas_dtrsm_batched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb, & batch_count) & bind(c, name="rocblas_dtrsm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ctrsm_batched_64 function rocblas_ctrsm_batched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb, & batch_count) & bind(c, name="rocblas_ctrsm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ztrsm_batched_64 function rocblas_ztrsm_batched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb, & batch_count) & bind(c, name="rocblas_ztrsm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The trsm_strided_batched functions perform the following strided batched operation: !> !> op(A_i)*X_i = alpha*B_i or !> X_i*op(A_i) = alpha*B_i, for i = 1, ..., batch_count, !> !> where ``alpha`` is a scalar, ``X`` and ``B`` are strided batched ``m`` by ``n`` matrices, !> ``A`` is a triangular strided batched matrix, and ``op(A)`` is one of: !> !> op( A ) = A or !> op( A ) = A^T or !> op( A ) = A^H. !> !> Each matrix ``X_i`` is overwritten on ``B_i`` for ``i`` = 1, ..., ``batch_count``. !> !> Note about memory allocation: !> When trsm is launched with a ``k`` evenly divisible by the internal block size of 128, !> and is no larger than 10 of these blocks, the API takes advantage of utilizing preallocated !> memory found in the handle to increase overall performance (where ``k`` is ``m`` when !> ``HIPBLAS_SIDE_LEFT`` and ``n`` when ``HIPBLAS_SIDE_RIGHT``). !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] side - [rocblas_side] !> - rocblas_side_left: op(A)*X = alpha*B. !> - rocblas_side_right: X*op(A) = alpha*B. !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: each A_i is an upper triangular matrix. !> - rocblas_fill_lower: each A_i is a lower triangular matrix. !> @param[in] transA - [rocblas_operation] !> - transB: op(A) = A. !> - rocblas_operation_transpose: op(A) = A^T. !> - rocblas_operation_conjugate_transpose: op(A) = A^H. !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: each A_i is assumed to be unit triangular. !> - rocblas_diagonal_non_unit: each A_i is not assumed to be unit triangular. !> @param[in] m - [rocblas_int] !> m specifies the number of rows of each B_i. m >= 0. !> @param[in] n - [rocblas_int] !> n specifies the number of columns of each B_i. n >= 0. !> @param[in] alpha !> device pointer or host pointer specifying the scalar alpha. When alpha is !> &zero, then A is not referenced and B need not be set before !> entry. !> @param[in] A - device pointer pointing to the first matrix A_1. !> of dimension ( lda, k ), where k is m !> when rocblas_side_left and !> n when rocblas_side_right. !> Only the upper/lower triangular part is accessed. !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of each A_i. !> - If side = rocblas_side_left, lda >= max( 1, m ). !> - If side = rocblas_side_right, lda >= max( 1, n ). !> @param[in] stride_a - [rocblas_stride] !> stride from the start of one A_i matrix to the next A_(i + 1). !> @param[in,out] B - device pointer pointing to the first matrix B_1. !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of each B_i. ldb >= max( 1, m ). !> @param[in] stride_b - [rocblas_stride] !> stride from the start of one B_i matrix to the next B_(i + 1). !> @param[in] batch_count - [rocblas_int] !> number of trsm operatons in the batch. interface rocblas_strsm_strided_batched function rocblas_strsm_strided_batched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,stride_a, & B,ldb,stride_b,batch_count) & bind(c, name="rocblas_strsm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_b integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_strsm_strided_batched_assumed_rank #else module procedure & rocblas_strsm_strided_batched_rank_0,& rocblas_strsm_strided_batched_rank_1,& rocblas_strsm_strided_batched_full_rank #endif #endif end interface interface rocblas_dtrsm_strided_batched function rocblas_dtrsm_strided_batched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,stride_a, & B,ldb,stride_b,batch_count) & bind(c, name="rocblas_dtrsm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_b integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dtrsm_strided_batched_assumed_rank #else module procedure & rocblas_dtrsm_strided_batched_rank_0,& rocblas_dtrsm_strided_batched_rank_1,& rocblas_dtrsm_strided_batched_full_rank #endif #endif end interface interface rocblas_ctrsm_strided_batched function rocblas_ctrsm_strided_batched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,stride_a, & B,ldb,stride_b,batch_count) & bind(c, name="rocblas_ctrsm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_b integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ctrsm_strided_batched_assumed_rank #else module procedure & rocblas_ctrsm_strided_batched_rank_0,& rocblas_ctrsm_strided_batched_rank_1,& rocblas_ctrsm_strided_batched_full_rank #endif #endif end interface interface rocblas_ztrsm_strided_batched function rocblas_ztrsm_strided_batched_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,stride_a, & B,ldb,stride_b,batch_count) & bind(c, name="rocblas_ztrsm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_b integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ztrsm_strided_batched_assumed_rank #else module procedure & rocblas_ztrsm_strided_batched_rank_0,& rocblas_ztrsm_strided_batched_rank_1,& rocblas_ztrsm_strided_batched_full_rank #endif #endif end interface interface rocblas_strsm_strided_batched_64 function rocblas_strsm_strided_batched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_a,B,ldb,stride_b,batch_count) & bind(c, name="rocblas_strsm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_b integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dtrsm_strided_batched_64 function rocblas_dtrsm_strided_batched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_a,B,ldb,stride_b,batch_count) & bind(c, name="rocblas_dtrsm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_b integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ctrsm_strided_batched_64 function rocblas_ctrsm_strided_batched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_a,B,ldb,stride_b,batch_count) & bind(c, name="rocblas_ctrsm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_b integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ztrsm_strided_batched_64 function rocblas_ztrsm_strided_batched_64_(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_a,B,ldb,stride_b,batch_count) & bind(c, name="rocblas_ztrsm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_b integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The gemm functions perform one of the matrix-matrix operations: !> !> C = alpha*op( A )*op( B ) + beta*C, !> !> where ``op( X )`` is one of !> !> op( X ) = X or !> op( X ) = X**T or !> op( X ) = X**H, !> !> ``alpha`` and ``beta`` are scalars, and ``A``, ``B`` and ``C`` are matrices, with !> ``op( A )`` an ``m`` by ``k`` matrix, ``op( B )`` a ``k`` by ``n`` matrix, and ``C`` an !> ``m`` by ``n`` matrix. !> !> Although not widespread, some gemm kernels might use atomic operations. See Atomic !> Operations !> in the API Reference Guide for more information. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] transA - [rocblas_operation] !> specifies the form of op( A ). !> @param[in] transB - [rocblas_operation] !> specifies the form of op( B ). !> @param[in] m - [rocblas_int] !> number or rows of matrices op( A ) and C. !> @param[in] n - [rocblas_int] !> number of columns of matrices op( B ) and C. !> @param[in] k - [rocblas_int] !> number of columns of matrix op( A ) and number of rows of matrix op( B ). !> @param[in] alpha - device pointer or host pointer specifying the scalar alpha. !> @param[in] A - device pointer storing matrix A. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. !> @param[in] B - device pointer storing matrix B. !> @param[in] ldb - [rocblas_int] !> specifies the leading dimension of B. !> @param[in] beta - device pointer or host pointer specifying the scalar beta. !> @param[in, out] C - device pointer storing matrix C on the GPU. !> @param[in] ldc - [rocblas_int] !> specifies the leading dimension of C. interface rocblas_sgemm function rocblas_sgemm_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_sgemm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemm_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sgemm_assumed_rank #else module procedure & rocblas_sgemm_rank_0,& rocblas_sgemm_rank_1,& rocblas_sgemm_full_rank #endif #endif end interface interface rocblas_dgemm function rocblas_dgemm_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_dgemm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemm_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dgemm_assumed_rank #else module procedure & rocblas_dgemm_rank_0,& rocblas_dgemm_rank_1,& rocblas_dgemm_full_rank #endif #endif end interface interface rocblas_hgemm function rocblas_hgemm_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_hgemm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hgemm_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_short) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_short) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function end interface interface rocblas_cgemm function rocblas_cgemm_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_cgemm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemm_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cgemm_assumed_rank #else module procedure & rocblas_cgemm_rank_0,& rocblas_cgemm_rank_1,& rocblas_cgemm_full_rank #endif #endif end interface interface rocblas_zgemm function rocblas_zgemm_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_zgemm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemm_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zgemm_assumed_rank #else module procedure & rocblas_zgemm_rank_0,& rocblas_zgemm_rank_1,& rocblas_zgemm_full_rank #endif #endif end interface interface rocblas_sgemm_64 function rocblas_sgemm_64_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_sgemm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemm_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_dgemm_64 function rocblas_dgemm_64_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_dgemm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemm_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_hgemm_64 function rocblas_hgemm_64_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_hgemm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hgemm_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k integer(c_short) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_short) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_cgemm_64 function rocblas_cgemm_64_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_cgemm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemm_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_zgemm_64 function rocblas_zgemm_64_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_zgemm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemm_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> The gemm_batched functions perform one of the batched matrix-matrix operations: !> !> C_i = alpha*op( A_i )*op( B_i ) + beta*C_i, for i = 1, ..., batch_count, !> !> where ``op( X )`` is one of !> !> op( X ) = X or !> op( X ) = X**T or !> op( X ) = X**H, !> !> ``alpha`` and ``beta`` are scalars, and ``A``, ``B``, and ``C`` are strided batched !> matrices, with !> ``op( A )`` an ``m`` by ``k`` by ``batch_count`` matrix, !> ``op( B )`` a ``k`` by ``n`` by ``batch_count`` matrix, and !> ``C`` an ``m`` by ``n`` by ``batch_count`` matrix. !> !> @param[in] handle - [rocblas_handle !> handle to the rocBLAS library context queue. !> @param[in] transA - [rocblas_operation] !> specifies the form of op( A ). !> @param[in] transB - [rocblas_operation] !> specifies the form of op( B ). !> @param[in] m - [rocblas_int] !> matrix dimention m. !> @param[in] n - [rocblas_int] !> matrix dimention n. !> @param[in] k - [rocblas_int] !> matrix dimention k. !> @param[in] alpha - device pointer or host pointer specifying the scalar alpha. !> @param[in] A - device array of device pointers storing each matrix A_i. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. !> @param[in] B - device array of device pointers storing each matrix B_i. !> @param[in] ldb - [rocblas_int] !> specifies the leading dimension of each B_i. !> @param[in] beta - device pointer or host pointer specifying the scalar beta. !> @param[in, out] C - device array of device pointers storing each matrix C_i. !> @param[in] ldc - [rocblas_int] !> specifies the leading dimension of each C_i. !> @param[in] batch_count !> [rocblas_int] !> number of gemm operations in the batch. interface rocblas_sgemm_batched function rocblas_sgemm_batched_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_sgemm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_dgemm_batched function rocblas_dgemm_batched_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_dgemm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_hgemm_batched function rocblas_hgemm_batched_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_hgemm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hgemm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_short) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_short) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_cgemm_batched function rocblas_cgemm_batched_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_cgemm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_zgemm_batched function rocblas_zgemm_batched_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_zgemm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_sgemm_batched_64 function rocblas_sgemm_batched_64_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_sgemm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dgemm_batched_64 function rocblas_dgemm_batched_64_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_dgemm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_hgemm_batched_64 function rocblas_hgemm_batched_64_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_hgemm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hgemm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k integer(c_short) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_short) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cgemm_batched_64 function rocblas_cgemm_batched_64_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_cgemm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zgemm_batched_64 function rocblas_zgemm_batched_64_(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_zgemm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The gemm_strided_batched functions perform one of the strided batched matrix-matrix !> operations: !> !> C_i = alpha*op( A_i )*op( B_i ) + beta*C_i, for i = 1, ..., batch_count, !> !> where ``op( X )`` is one of !> !> op( X ) = X or !> op( X ) = X**T or !> op( X ) = X**H, !> !> ``alpha`` and ``beta`` are scalars, and ``A``, ``B``, and ``C`` are strided batched !> matrices, with !> ``op( A )`` an ``m`` by ``k`` by ``batch_count`` strided_batched matrix, !> ``op( B )`` a ``k`` by ``n`` by ``batch_count`` strided_batched matrix, and !> ``C`` an ``m`` by ``n`` by ``batch_count`` strided_batched matrix. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] transA - [rocblas_operation] !> specifies the form of op( A ). !> @param[in] transB - [rocblas_operation] !> specifies the form of op( B ). !> @param[in] m - [rocblas_int] !> matrix dimention m. !> @param[in] n - [rocblas_int] !> matrix dimention n. !> @param[in] k - [rocblas_int] !> matrix dimention k. !> @param[in] alpha - device pointer or host pointer specifying the scalar alpha. !> @param[in] A - device pointer pointing to the first matrix A_1. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. !> @param[in] stride_a - [rocblas_stride] !> stride from the start of one A_i matrix to the next A_(i + 1). !> @param[in] B - device pointer pointing to the first matrix B_1. !> @param[in] ldb - [rocblas_int] !> specifies the leading dimension of each B_i. !> @param[in] stride_b - [rocblas_stride] !> stride from the start of one B_i matrix to the next B_(i + 1). !> @param[in] beta - device pointer or host pointer specifying the scalar beta. !> @param[in, out] C - device pointer pointing to the first matrix C_1. !> @param[in] ldc - [rocblas_int] !> specifies the leading dimension of each C_i. !> @param[in] stride_c - [rocblas_stride] !> stride from the start of one C_i matrix to the next C_(i + 1). !> @param[in] batch_count !> [rocblas_int] !> number of gemm operatons in the batch. interface rocblas_sgemm_strided_batched function rocblas_sgemm_strided_batched_(handle,transA,transB,m,n,k,alpha,A,lda,stride_a,B,ldb, & stride_b,beta,C,ldc,stride_c,batch_count) & bind(c, name="rocblas_sgemm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_b real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_c integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sgemm_strided_batched_assumed_rank #else module procedure & rocblas_sgemm_strided_batched_rank_0,& rocblas_sgemm_strided_batched_rank_1,& rocblas_sgemm_strided_batched_full_rank #endif #endif end interface interface rocblas_dgemm_strided_batched function rocblas_dgemm_strided_batched_(handle,transA,transB,m,n,k,alpha,A,lda,stride_a,B,ldb, & stride_b,beta,C,ldc,stride_c,batch_count) & bind(c, name="rocblas_dgemm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_b real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_c integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dgemm_strided_batched_assumed_rank #else module procedure & rocblas_dgemm_strided_batched_rank_0,& rocblas_dgemm_strided_batched_rank_1,& rocblas_dgemm_strided_batched_full_rank #endif #endif end interface interface rocblas_hgemm_strided_batched function rocblas_hgemm_strided_batched_(handle,transA,transB,m,n,k,alpha,A,lda,stride_a,B,ldb, & stride_b,beta,C,ldc,stride_c,batch_count) & bind(c, name="rocblas_hgemm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hgemm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_short) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_b integer(c_short) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_c integer(c_int),value :: batch_count end function end interface interface rocblas_cgemm_strided_batched function rocblas_cgemm_strided_batched_(handle,transA,transB,m,n,k,alpha,A,lda,stride_a,B,ldb, & stride_b,beta,C,ldc,stride_c,batch_count) & bind(c, name="rocblas_cgemm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_b complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_c integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cgemm_strided_batched_assumed_rank #else module procedure & rocblas_cgemm_strided_batched_rank_0,& rocblas_cgemm_strided_batched_rank_1,& rocblas_cgemm_strided_batched_full_rank #endif #endif end interface interface rocblas_zgemm_strided_batched function rocblas_zgemm_strided_batched_(handle,transA,transB,m,n,k,alpha,A,lda,stride_a,B,ldb, & stride_b,beta,C,ldc,stride_c,batch_count) & bind(c, name="rocblas_zgemm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_b complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_c integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zgemm_strided_batched_assumed_rank #else module procedure & rocblas_zgemm_strided_batched_rank_0,& rocblas_zgemm_strided_batched_rank_1,& rocblas_zgemm_strided_batched_full_rank #endif #endif end interface interface rocblas_sgemm_strided_batched_64 function rocblas_sgemm_strided_batched_64_(handle,transA,transB,m,n,k,alpha,A,lda,stride_a,B, & ldb,stride_b,beta,C,ldc,stride_c,batch_count) & bind(c, name="rocblas_sgemm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_b real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_c integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dgemm_strided_batched_64 function rocblas_dgemm_strided_batched_64_(handle,transA,transB,m,n,k,alpha,A,lda,stride_a,B, & ldb,stride_b,beta,C,ldc,stride_c,batch_count) & bind(c, name="rocblas_dgemm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_b real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_c integer(c_int64_t),value :: batch_count end function end interface interface rocblas_hgemm_strided_batched_64 function rocblas_hgemm_strided_batched_64_(handle,transA,transB,m,n,k,alpha,A,lda,stride_a,B, & ldb,stride_b,beta,C,ldc,stride_c,batch_count) & bind(c, name="rocblas_hgemm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_hgemm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k integer(c_short) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_b integer(c_short) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_c integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cgemm_strided_batched_64 function rocblas_cgemm_strided_batched_64_(handle,transA,transB,m,n,k,alpha,A,lda,stride_a,B, & ldb,stride_b,beta,C,ldc,stride_c,batch_count) & bind(c, name="rocblas_cgemm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_b complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_c integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zgemm_strided_batched_64 function rocblas_zgemm_strided_batched_64_(handle,transA,transB,m,n,k,alpha,A,lda,stride_a,B, & ldb,stride_b,beta,C,ldc,stride_c,batch_count) & bind(c, name="rocblas_zgemm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_b complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_c integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The dgmm functions perform one of the matrix-matrix operations: !> !> C = A * diag(x) if side == rocblas_side_right !> C = diag(x) * A if side == rocblas_side_left !> !> where ``C`` and ``A`` are ``m`` by ``n`` dimensional matrices, ``diag( x )`` is a diagonal !> matrix, !> and ``x`` is vector of dimension ``n`` if ``side == rocblas_side_right`` and dimension !> ``m`` !> if ``side == rocblas_side_left``. !> !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] side - [rocblas_side] !> specifies the side of diag(x). !> @param[in] m - [rocblas_int] !> matrix dimension m. !> @param[in] n - [rocblas_int] !> matrix dimension n. !> @param[in] A - device pointer storing matrix A. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. !> @param[in] x - device pointer storing vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment between values of x !> @param[in, out] C - device pointer storing matrix C. !> @param[in] ldc - [rocblas_int] !> specifies the leading dimension of C. interface rocblas_sdgmm function rocblas_sdgmm_(handle,side,m,n,A,lda,x,incx,C,ldc) bind(c, name="rocblas_sdgmm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdgmm_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sdgmm_assumed_rank #else module procedure & rocblas_sdgmm_rank_0,& rocblas_sdgmm_rank_1,& rocblas_sdgmm_full_rank #endif #endif end interface interface rocblas_ddgmm function rocblas_ddgmm_(handle,side,m,n,A,lda,x,incx,C,ldc) bind(c, name="rocblas_ddgmm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddgmm_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ddgmm_assumed_rank #else module procedure & rocblas_ddgmm_rank_0,& rocblas_ddgmm_rank_1,& rocblas_ddgmm_full_rank #endif #endif end interface interface rocblas_cdgmm function rocblas_cdgmm_(handle,side,m,n,A,lda,x,incx,C,ldc) bind(c, name="rocblas_cdgmm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdgmm_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cdgmm_assumed_rank #else module procedure & rocblas_cdgmm_rank_0,& rocblas_cdgmm_rank_1,& rocblas_cdgmm_full_rank #endif #endif end interface interface rocblas_zdgmm function rocblas_zdgmm_(handle,side,m,n,A,lda,x,incx,C,ldc) bind(c, name="rocblas_zdgmm") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdgmm_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zdgmm_assumed_rank #else module procedure & rocblas_zdgmm_rank_0,& rocblas_zdgmm_rank_1,& rocblas_zdgmm_full_rank #endif #endif end interface interface rocblas_sdgmm_64 function rocblas_sdgmm_64_(handle,side,m,n,A,lda,x,incx,C,ldc) bind(c, name="rocblas_sdgmm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdgmm_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_ddgmm_64 function rocblas_ddgmm_64_(handle,side,m,n,A,lda,x,incx,C,ldc) bind(c, name="rocblas_ddgmm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddgmm_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_cdgmm_64 function rocblas_cdgmm_64_(handle,side,m,n,A,lda,x,incx,C,ldc) bind(c, name="rocblas_cdgmm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdgmm_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_zdgmm_64 function rocblas_zdgmm_64_(handle,side,m,n,A,lda,x,incx,C,ldc) bind(c, name="rocblas_zdgmm_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdgmm_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> The dgmm_batched functions perform one of the batched matrix-matrix operations: !> !> C_i = A_i * diag(x_i) for i = 0, 1, ... batch_count-1 if side == rocblas_side_right !> C_i = diag(x_i) * A_i for i = 0, 1, ... batch_count-1 if side == rocblas_side_left, !> !> where ``C_i`` and ``A_i`` are ``m`` by ``n`` dimensional matrices, ``diag(x_i)`` is a !> diagonal matrix, !> and ``x_i`` is a vector of dimension ``n`` if ``side == rocblas_side_right`` and dimension !> ``m`` !> if ``side == rocblas_side_left``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] side - [rocblas_side] !> specifies the side of diag(x). !> @param[in] m - [rocblas_int] !> matrix dimension m. !> @param[in] n - [rocblas_int] !> matrix dimension n. !> @param[in] A - device array of device pointers storing each matrix A_i on the GPU. !> Each A_i is of dimension ( lda, n ). !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A_i. !> @param[in] x - device array of device pointers storing each vector x_i on the GPU. !> Each x_i is of dimension n if side == rocblas_side_right and dimension !> m if side == rocblas_side_left. !> @param[in] incx - [rocblas_int] !> specifies the increment between values of x_i. !> @param[in, out] C - device array of device pointers storing each matrix C_i on the GPU. !> Each C_i is of dimension ( ldc, n ). !> @param[in] ldc - [rocblas_int] !> specifies the leading dimension of C_i. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. interface rocblas_sdgmm_batched function rocblas_sdgmm_batched_(handle,side,m,n,A,lda,x,incx,C,ldc,batch_count) & bind(c, name="rocblas_sdgmm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdgmm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_ddgmm_batched function rocblas_ddgmm_batched_(handle,side,m,n,A,lda,x,incx,C,ldc,batch_count) & bind(c, name="rocblas_ddgmm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddgmm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_cdgmm_batched function rocblas_cdgmm_batched_(handle,side,m,n,A,lda,x,incx,C,ldc,batch_count) & bind(c, name="rocblas_cdgmm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdgmm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_zdgmm_batched function rocblas_zdgmm_batched_(handle,side,m,n,A,lda,x,incx,C,ldc,batch_count) & bind(c, name="rocblas_zdgmm_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdgmm_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_sdgmm_batched_64 function rocblas_sdgmm_batched_64_(handle,side,m,n,A,lda,x,incx,C,ldc,batch_count) & bind(c, name="rocblas_sdgmm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdgmm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ddgmm_batched_64 function rocblas_ddgmm_batched_64_(handle,side,m,n,A,lda,x,incx,C,ldc,batch_count) & bind(c, name="rocblas_ddgmm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddgmm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cdgmm_batched_64 function rocblas_cdgmm_batched_64_(handle,side,m,n,A,lda,x,incx,C,ldc,batch_count) & bind(c, name="rocblas_cdgmm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdgmm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zdgmm_batched_64 function rocblas_zdgmm_batched_64_(handle,side,m,n,A,lda,x,incx,C,ldc,batch_count) & bind(c, name="rocblas_zdgmm_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdgmm_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: x integer(c_int64_t),value :: incx type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The dgmm_strided_batched functions perform one of the batched matrix-matrix operations: !> !> C_i = A_i * diag(x_i) if side == rocblas_side_right for i = 0, 1, ... batch_count-1 !> C_i = diag(x_i) * A_i if side == rocblas_side_left for i = 0, 1, ... batch_count-1, !> !> where ``C_i`` and ``A_i`` are ``m`` by ``n`` dimensional matrices, ``diag(x_i)`` is a !> diagonal matrix, !> and ``x_i`` is a vector of dimension ``n`` if ``side == rocblas_side_right`` and dimension !> ``m`` !> if ``side == rocblas_side_left``. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] side - [rocblas_side] !> specifies the side of diag(x). !> @param[in] m - [rocblas_int] !> matrix dimension m. !> @param[in] n - [rocblas_int] !> matrix dimension n. !> @param[in] A - device pointer to the first matrix A_0 on the GPU. !> Each A_i is of dimension ( lda, n ). !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> @param[in] x - pointer to the first vector x_0 on the GPU. !> Each x_i is of dimension n if side == rocblas_side_right and dimension !> m if side == rocblas_side_left. !> @param[in] incx - [rocblas_int] !> specifies the increment between values of x. !> @param[in] stride_x - [rocblas_stride] !> stride from the start of one vector(x_i) to the next one (x_i+1). !> @param[in, out] C - device pointer to the first matrix C_0 on the GPU. !> Each C_i is of dimension ( ldc, n ). !> @param[in] ldc - [rocblas_int] !> specifies the leading dimension of C. !> @param[in] stride_C - [rocblas_stride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> @param[in] batch_count - [rocblas_int] !> number of instances i in the batch. interface rocblas_sdgmm_strided_batched function rocblas_sdgmm_strided_batched_(handle,side,m,n,A,lda,stride_A,x,incx,stride_x,C,ldc, & stride_C,batch_count) & bind(c, name="rocblas_sdgmm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdgmm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sdgmm_strided_batched_assumed_rank #else module procedure & rocblas_sdgmm_strided_batched_rank_0,& rocblas_sdgmm_strided_batched_rank_1,& rocblas_sdgmm_strided_batched_full_rank #endif #endif end interface interface rocblas_ddgmm_strided_batched function rocblas_ddgmm_strided_batched_(handle,side,m,n,A,lda,stride_A,x,incx,stride_x,C,ldc, & stride_C,batch_count) & bind(c, name="rocblas_ddgmm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddgmm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_ddgmm_strided_batched_assumed_rank #else module procedure & rocblas_ddgmm_strided_batched_rank_0,& rocblas_ddgmm_strided_batched_rank_1,& rocblas_ddgmm_strided_batched_full_rank #endif #endif end interface interface rocblas_cdgmm_strided_batched function rocblas_cdgmm_strided_batched_(handle,side,m,n,A,lda,stride_A,x,incx,stride_x,C,ldc, & stride_C,batch_count) & bind(c, name="rocblas_cdgmm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdgmm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cdgmm_strided_batched_assumed_rank #else module procedure & rocblas_cdgmm_strided_batched_rank_0,& rocblas_cdgmm_strided_batched_rank_1,& rocblas_cdgmm_strided_batched_full_rank #endif #endif end interface interface rocblas_zdgmm_strided_batched function rocblas_zdgmm_strided_batched_(handle,side,m,n,A,lda,stride_A,x,incx,stride_x,C,ldc, & stride_C,batch_count) & bind(c, name="rocblas_zdgmm_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdgmm_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zdgmm_strided_batched_assumed_rank #else module procedure & rocblas_zdgmm_strided_batched_rank_0,& rocblas_zdgmm_strided_batched_rank_1,& rocblas_zdgmm_strided_batched_full_rank #endif #endif end interface interface rocblas_sdgmm_strided_batched_64 function rocblas_sdgmm_strided_batched_64_(handle,side,m,n,A,lda,stride_A,x,incx,stride_x,C, & ldc,stride_C,batch_count) & bind(c, name="rocblas_sdgmm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdgmm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_ddgmm_strided_batched_64 function rocblas_ddgmm_strided_batched_64_(handle,side,m,n,A,lda,stride_A,x,incx,stride_x,C, & ldc,stride_C,batch_count) & bind(c, name="rocblas_ddgmm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddgmm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cdgmm_strided_batched_64 function rocblas_cdgmm_strided_batched_64_(handle,side,m,n,A,lda,stride_A,x,incx,stride_x,C, & ldc,stride_C,batch_count) & bind(c, name="rocblas_cdgmm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdgmm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zdgmm_strided_batched_64 function rocblas_zdgmm_strided_batched_64_(handle,side,m,n,A,lda,stride_A,x,incx,stride_x,C, & ldc,stride_C,batch_count) & bind(c, name="rocblas_zdgmm_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdgmm_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: x integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The geam functions perform one of the matrix-matrix operations: !> !> C = alpha*op( A ) + beta*op( B ), !> !> where ``op( X )`` is one of: !> !> op( X ) = X or !> op( X ) = X**T or !> op( X ) = X**H, !> !> ``alpha`` and ``beta`` are scalars, and ``A``, ``B`` and ``C`` are matrices, with !> ``op( A )`` an ``m`` by ``n`` matrix, ``op( B )`` an ``m`` by ``n`` matrix, and ``C`` an !> ``m`` by ``n`` matrix. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] transA - [rocblas_operation] !> specifies the form of op( A ). !> @param[in] transB - [rocblas_operation] !> specifies the form of op( B ). !> @param[in] m - [rocblas_int] !> matrix dimension m. !> @param[in] n - [rocblas_int] !> matrix dimension n. !> @param[in] alpha - device pointer or host pointer specifying the scalar alpha. !> @param[in] A - device pointer storing matrix A. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. !> @param[in] beta - device pointer or host pointer specifying the scalar beta. !> @param[in] B - device pointer storing matrix B. !> @param[in] ldb - [rocblas_int] !> specifies the leading dimension of B. !> @param[in, out] C - device pointer storing matrix C. !> @param[in] ldc - [rocblas_int] !> specifies the leading dimension of C. interface rocblas_sgeam function rocblas_sgeam_(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) & bind(c, name="rocblas_sgeam") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgeam_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda real(c_float) :: beta type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sgeam_assumed_rank #else module procedure & rocblas_sgeam_rank_0,& rocblas_sgeam_rank_1,& rocblas_sgeam_full_rank #endif #endif end interface interface rocblas_dgeam function rocblas_dgeam_(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) & bind(c, name="rocblas_dgeam") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgeam_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda real(c_double) :: beta type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dgeam_assumed_rank #else module procedure & rocblas_dgeam_rank_0,& rocblas_dgeam_rank_1,& rocblas_dgeam_full_rank #endif #endif end interface interface rocblas_cgeam function rocblas_cgeam_(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) & bind(c, name="rocblas_cgeam") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeam_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda complex(c_float_complex) :: beta type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cgeam_assumed_rank #else module procedure & rocblas_cgeam_rank_0,& rocblas_cgeam_rank_1,& rocblas_cgeam_full_rank #endif #endif end interface interface rocblas_zgeam function rocblas_zgeam_(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) & bind(c, name="rocblas_zgeam") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeam_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda complex(c_double_complex) :: beta type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zgeam_assumed_rank #else module procedure & rocblas_zgeam_rank_0,& rocblas_zgeam_rank_1,& rocblas_zgeam_full_rank #endif #endif end interface interface rocblas_sgeam_64 function rocblas_sgeam_64_(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) & bind(c, name="rocblas_sgeam_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgeam_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda real(c_float) :: beta type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_dgeam_64 function rocblas_dgeam_64_(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) & bind(c, name="rocblas_dgeam_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgeam_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda real(c_double) :: beta type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_cgeam_64 function rocblas_cgeam_64_(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) & bind(c, name="rocblas_cgeam_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeam_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda complex(c_float_complex) :: beta type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_zgeam_64 function rocblas_zgeam_64_(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) & bind(c, name="rocblas_zgeam_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeam_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda complex(c_double_complex) :: beta type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> The geam_batched functions perform one of the batched matrix-matrix operations: !> !> C_i = alpha*op( A_i ) + beta*op( B_i ) for i = 0, 1, ... batch_count - 1, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)``, ``op(B_i)``, and ``C_i`` are ``m`` !> by ``n`` matrices, !> and ``op( X )`` is one of: !> !> op( X ) = X or !> op( X ) = X**T !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] transA - [rocblas_operation] !> specifies the form of op( A ). !> @param[in] transB - [rocblas_operation] !> specifies the form of op( B ). !> @param[in] m - [rocblas_int] !> matrix dimension m. !> @param[in] n - [rocblas_int] !> matrix dimension n. !> @param[in] alpha - device pointer or host pointer specifying the scalar alpha. !> @param[in] A - device array of device pointers storing each matrix A_i on the GPU. !> Each A_i is of dimension ( lda, k ), where k is m !> when transA == rocblas_operation_none and !> is n when transA == rocblas_operation_transpose. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. !> @param[in] beta - device pointer or host pointer specifying the scalar beta. !> @param[in] B - device array of device pointers storing each matrix B_i on the GPU. !> Each B_i is of dimension ( ldb, k ), where k is m !> when transB == rocblas_operation_none and !> is n when transB == rocblas_operation_transpose. !> @param[in] ldb - [rocblas_int] !> specifies the leading dimension of B. !> @param[in, out] C - device array of device pointers storing each matrix C_i on the GPU. !> Each C_i is of dimension ( ldc, n ). !> @param[in] ldc - [rocblas_int] !> specifies the leading dimension of C. !> !> @param[in] batch_count - [rocblas_int] !> number of instances i in the batch. interface rocblas_sgeam_batched function rocblas_sgeam_batched_(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc, & batch_count) & bind(c, name="rocblas_sgeam_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgeam_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda real(c_float) :: beta type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_dgeam_batched function rocblas_dgeam_batched_(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc, & batch_count) & bind(c, name="rocblas_dgeam_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgeam_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda real(c_double) :: beta type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_cgeam_batched function rocblas_cgeam_batched_(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc, & batch_count) & bind(c, name="rocblas_cgeam_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeam_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda complex(c_float_complex) :: beta type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_zgeam_batched function rocblas_zgeam_batched_(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc, & batch_count) & bind(c, name="rocblas_zgeam_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeam_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda complex(c_double_complex) :: beta type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_sgeam_batched_64 function rocblas_sgeam_batched_64_(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc, & batch_count) & bind(c, name="rocblas_sgeam_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgeam_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda real(c_float) :: beta type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dgeam_batched_64 function rocblas_dgeam_batched_64_(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc, & batch_count) & bind(c, name="rocblas_dgeam_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgeam_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda real(c_double) :: beta type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cgeam_batched_64 function rocblas_cgeam_batched_64_(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc, & batch_count) & bind(c, name="rocblas_cgeam_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeam_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda complex(c_float_complex) :: beta type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zgeam_batched_64 function rocblas_zgeam_batched_64_(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc, & batch_count) & bind(c, name="rocblas_zgeam_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeam_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda complex(c_double_complex) :: beta type(c_ptr),value :: B integer(c_int64_t),value :: ldb type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The geam_strided_batched functions perform one of the batched matrix-matrix operations: !> !> C_i = alpha*op( A_i ) + beta*op( B_i ) for i = 0, 1, ... batch_count - 1, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A_i)``, ``op(B_i)``, and ``C_i`` are ``m`` !> by ``n`` matrices, !> and ``op( X )`` is one of: !> !> op( X ) = X or !> op( X ) = X**T !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] transA - [rocblas_operation] !> specifies the form of op( A ). !> !> @param[in] transB - [rocblas_operation] !> specifies the form of op( B ). !> !> @param[in] m - [rocblas_int] !> matrix dimension m. !> !> @param[in] n - [rocblas_int] !> matrix dimension n. !> !> @param[in] alpha - device pointer or host pointer specifying the scalar alpha. !> !> @param[in] A - device pointer to the first matrix A_0 on the GPU. !> Each A_i is of dimension ( lda, k ), where k is m !> when transA == rocblas_operation_none and !> is n when transA == rocblas_operation_transpose. !> !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. !> !> @param[in] stride_A - [rocblas_stride] !> stride from the start of one matrix (A_i) to the next one (A_i+1). !> !> @param[in] beta - device pointer or host pointer specifying the scalar beta. !> !> @param[in] B - pointer to the first matrix B_0 on the GPU. !> Each B_i is of dimension ( ldb, k ), where k is m !> when transB == rocblas_operation_none and !> is n when transB == rocblas_operation_transpose. !> !> @param[in] ldb - [rocblas_int] !> specifies the leading dimension of B. !> !> @param[in] stride_B - [rocblas_stride] !> stride from the start of one matrix (B_i) to the next one (B_i+1). !> !> @param[in, out] C - pointer to the first matrix C_0 on the GPU. !> Each C_i is of dimension ( ldc, n ). !> !> @param[in] ldc - [rocblas_int] !> specifies the leading dimension of C. !> !> @param[in] stride_C - [rocblas_stride] !> stride from the start of one matrix (C_i) to the next one (C_i+1). !> !> @param[in] batch_count - [rocblas_int] !> number of instances i in the batch. interface rocblas_sgeam_strided_batched function rocblas_sgeam_strided_batched_(handle,transA,transB,m,n,alpha,A,lda,stride_A,beta,B, & ldb,stride_B,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_sgeam_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgeam_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A real(c_float) :: beta type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_sgeam_strided_batched_assumed_rank #else module procedure & rocblas_sgeam_strided_batched_rank_0,& rocblas_sgeam_strided_batched_rank_1,& rocblas_sgeam_strided_batched_full_rank #endif #endif end interface interface rocblas_dgeam_strided_batched function rocblas_dgeam_strided_batched_(handle,transA,transB,m,n,alpha,A,lda,stride_A,beta,B, & ldb,stride_B,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_dgeam_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgeam_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A real(c_double) :: beta type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_dgeam_strided_batched_assumed_rank #else module procedure & rocblas_dgeam_strided_batched_rank_0,& rocblas_dgeam_strided_batched_rank_1,& rocblas_dgeam_strided_batched_full_rank #endif #endif end interface interface rocblas_cgeam_strided_batched function rocblas_cgeam_strided_batched_(handle,transA,transB,m,n,alpha,A,lda,stride_A,beta,B, & ldb,stride_B,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_cgeam_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeam_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A complex(c_float_complex) :: beta type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_cgeam_strided_batched_assumed_rank #else module procedure & rocblas_cgeam_strided_batched_rank_0,& rocblas_cgeam_strided_batched_rank_1,& rocblas_cgeam_strided_batched_full_rank #endif #endif end interface interface rocblas_zgeam_strided_batched function rocblas_zgeam_strided_batched_(handle,transA,transB,m,n,alpha,A,lda,stride_A,beta,B, & ldb,stride_B,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_zgeam_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeam_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A complex(c_double_complex) :: beta type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_zgeam_strided_batched_assumed_rank #else module procedure & rocblas_zgeam_strided_batched_rank_0,& rocblas_zgeam_strided_batched_rank_1,& rocblas_zgeam_strided_batched_full_rank #endif #endif end interface interface rocblas_sgeam_strided_batched_64 function rocblas_sgeam_strided_batched_64_(handle,transA,transB,m,n,alpha,A,lda,stride_A,beta, & B,ldb,stride_B,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_sgeam_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgeam_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A real(c_float) :: beta type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dgeam_strided_batched_64 function rocblas_dgeam_strided_batched_64_(handle,transA,transB,m,n,alpha,A,lda,stride_A,beta, & B,ldb,stride_B,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_dgeam_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgeam_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A real(c_double) :: beta type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cgeam_strided_batched_64 function rocblas_cgeam_strided_batched_64_(handle,transA,transB,m,n,alpha,A,lda,stride_A,beta, & B,ldb,stride_B,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_cgeam_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeam_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A complex(c_float_complex) :: beta type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zgeam_strided_batched_64 function rocblas_zgeam_strided_batched_64_(handle,transA,transB,m,n,alpha,A,lda,stride_A,beta, & B,ldb,stride_B,C,ldc,stride_C,batch_count) & bind(c, name="rocblas_zgeam_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeam_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_A complex(c_double_complex) :: beta type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_B type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_C integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS EX API !> !> \details !> The gemm_ex functions perform one of the matrix-matrix operations: !> !> D = alpha*op( A )*op( B ) + beta*C, !> !> where ``op( X )`` is one of !> !> op( X ) = X or !> op( X ) = X**T or !> op( X ) = X**H, !> !> ``alpha`` and ``beta`` are scalars, and ``A``, ``B``, ``C``, and ``D`` are matrices, with !> ``op( A )`` an ``m`` by ``k`` matrix, ``op( B )`` a ``k`` by ``n`` matrix, and ``C`` and !> ``D`` both ``m`` by ``n`` matrices. !> ``C`` and ``D`` can point to the same matrix if their parameters are identical. !> !> Supported types are as follows: !> - rocblas_datatype_f64_r = a_type = b_type = c_type = d_type = compute_type !> - rocblas_datatype_f32_r = a_type = b_type = c_type = d_type = compute_type !> - rocblas_datatype_f16_r = a_type = b_type = c_type = d_type = compute_type !> - rocblas_datatype_f16_r = a_type = b_type = c_type = d_type; rocblas_datatype_f32_r = !> compute_type !> - rocblas_datatype_f16_r = a_type = b_type; rocblas_datatype_f32_r = c_type = d_type = !> compute_type !> - rocblas_datatype_bf16_r = a_type = b_type = c_type = d_type; rocblas_datatype_f32_r = !> compute_type !> - rocblas_datatype_bf16_r = a_type = b_type; rocblas_datatype_f32_r = c_type = d_type = !> compute_type !> - rocblas_datatype_i8_r = a_type = b_type; rocblas_datatype_i32_r = c_type = d_type = !> compute_type !> - rocblas_datatype_f32_c = a_type = b_type = c_type = d_type = compute_type !> - rocblas_datatype_f64_c = a_type = b_type = c_type = d_type = compute_type !> !> Although not widespread, some gemm kernels used by gemm_ex might use atomic operations. !> See Atomic Operations in the API Reference Guide for more information. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] transA - [rocblas_operation] !> specifies the form of op( A ). !> @param[in] transB - [rocblas_operation] !> specifies the form of op( B ). !> @param[in] m - [rocblas_int] !> matrix dimension m. !> @param[in] n - [rocblas_int] !> matrix dimension n. !> @param[in] k - [rocblas_int] !> matrix dimension k. !> @param[in] alpha - [const void *] !> device pointer or host pointer specifying the scalar alpha. Same datatype as !> compute_type. !> @param[in] a - [void *] !> device pointer storing matrix A. !> @param[in] a_type - [rocblas_datatype] !> specifies the datatype of matrix A. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. !> @param[in] b - [void *] !> device pointer storing matrix B. !> @param[in] b_type - [rocblas_datatype] !> specifies the datatype of matrix B. !> @param[in] ldb - [rocblas_int] !> specifies the leading dimension of B. !> @param[in] beta - [const void *] !> device pointer or host pointer specifying the scalar beta. Same datatype as !> compute_type. !> @param[in] c - [void *] !> device pointer storing matrix C. !> @param[in] c_type - [rocblas_datatype] !> specifies the datatype of matrix C. !> @param[in] ldc - [rocblas_int] !> specifies the leading dimension of C. !> @param[out] d - [void *] !> device pointer storing matrix D. !> If d and c pointers are to the same matrix, then d_type must equal c_type and ldd !> must equal ldc !> or the respective invalid status will be returned. !> @param[in] d_type - [rocblas_datatype] !> specifies the datatype of matrix D. !> @param[in] ldd - [rocblas_int] !> specifies the leading dimension of D. !> @param[in] compute_type !> [rocblas_datatype] !> specifies the datatype of computation. !> @param[in] algo - [rocblas_gemm_algo] !> enumerant specifying the algorithm type. !> @param[in] solution_index !> [int32_t] !> if algo is rocblas_gemm_algo_solution_index, this controls which solution is !> used. !> When algo is not rocblas_gemm_algo_solution_index, or if solution_index = 0, the !> default solution is used. !> Passing rocblas_gemm_algo_solution_index and solution_index < 0 to use the !> default solution is deprecated. !> @param[in] flags - [uint32_t] !> optional gemm flags. interface rocblas_gemm_ex function rocblas_gemm_ex_(handle,transA,transB,m,n,k,alpha,a,a_type,lda,b,b_type,ldb,beta,c, & c_type,ldc,d,d_type,ldd,compute_type,algo,solution_index,flags) & bind(c, name="rocblas_gemm_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_gemm_ex_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: a integer(kind(rocblas_datatype_f16_r)),value :: a_type integer(c_int),value :: lda type(c_ptr),value :: b integer(kind(rocblas_datatype_f16_r)),value :: b_type integer(c_int),value :: ldb type(c_ptr),value :: beta type(c_ptr),value :: c integer(kind(rocblas_datatype_f16_r)),value :: c_type integer(c_int),value :: ldc type(c_ptr),value :: d integer(kind(rocblas_datatype_f16_r)),value :: d_type integer(c_int),value :: ldd integer(kind(rocblas_datatype_f16_r)),value :: compute_type integer(kind(rocblas_gemm_algo_standard)),value :: algo integer(c_int32_t),value :: solution_index integer(c_int32_t),value :: flags end function end interface interface rocblas_gemm_ex_64 function rocblas_gemm_ex_64_(handle,transA,transB,m,n,k,alpha,a,a_type,lda,b,b_type,ldb,beta, & c,c_type,ldc,d,d_type,ldd,compute_type,algo,solution_index,flags) & bind(c, name="rocblas_gemm_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_gemm_ex_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: a integer(kind(rocblas_datatype_f16_r)),value :: a_type integer(c_int64_t),value :: lda type(c_ptr),value :: b integer(kind(rocblas_datatype_f16_r)),value :: b_type integer(c_int64_t),value :: ldb type(c_ptr),value :: beta type(c_ptr),value :: c integer(kind(rocblas_datatype_f16_r)),value :: c_type integer(c_int64_t),value :: ldc type(c_ptr),value :: d integer(kind(rocblas_datatype_f16_r)),value :: d_type integer(c_int64_t),value :: ldd integer(kind(rocblas_datatype_f16_r)),value :: compute_type integer(kind(rocblas_gemm_algo_standard)),value :: algo integer(c_int32_t),value :: solution_index integer(c_int32_t),value :: flags end function end interface !> \brief BLAS EX API !> !> \details !> The gemm_batched_ex functions perform one of the batched matrix-matrix operations: !> !> D_i = alpha*op(A_i)*op(B_i) + beta*C_i, for i = 1, ..., batch_count. !> !> where ``op( X )`` is one of !> !> op( X ) = X or !> op( X ) = X**T or !> op( X ) = X**H, !> !> ``alpha`` and ``beta`` are scalars, and ``A``, ``B``, ``C``, and ``D`` are batched pointers !> to matrices, with !> ``op( A )`` an ``m`` by ``k`` by ``batch_count`` batched matrix, !> ``op( B )`` a ``k`` by ``n`` by ``batch_count`` batched matrix, and !> ``C`` and ``D`` are ``m`` by ``n`` by batch_count batched matrices. !> The batched matrices are an array of pointers to matrices. !> The number of pointers to matrices is ``batch_count``. !> ``C`` and ``D`` can point to the same matrices if their parameters are identical. !> !> Supported types are as follows: !> - rocblas_datatype_f64_r = a_type = b_type = c_type = d_type = compute_type !> - rocblas_datatype_f32_r = a_type = b_type = c_type = d_type = compute_type !> - rocblas_datatype_f16_r = a_type = b_type = c_type = d_type = compute_type !> - rocblas_datatype_f16_r = a_type = b_type = c_type = d_type; rocblas_datatype_f32_r = !> compute_type !> - rocblas_datatype_bf16_r = a_type = b_type = c_type = d_type; rocblas_datatype_f32_r = !> compute_type !> - rocblas_datatype_i8_r = a_type = b_type; rocblas_datatype_i32_r = c_type = d_type = !> compute_type !> - rocblas_datatype_f32_c = a_type = b_type = c_type = d_type = compute_type !> - rocblas_datatype_f64_c = a_type = b_type = c_type = d_type = compute_type !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] transA - [rocblas_operation] !> specifies the form of op( A ). !> @param[in] transB - [rocblas_operation] !> specifies the form of op( B ). !> @param[in] m - [rocblas_int] !> matrix dimension m. !> @param[in] n - [rocblas_int] !> matrix dimension n. !> @param[in] k - [rocblas_int] !> matrix dimension k. !> @param[in] alpha - [const void *] !> device pointer or host pointer specifying the scalar alpha. Same datatype as !> compute_type. !> @param[in] a - [void *] !> device pointer storing array of pointers to each matrix A_i. !> @param[in] a_type - [rocblas_datatype] !> specifies the datatype of each matrix A_i. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. !> @param[in] b - [void *] !> device pointer storing array of pointers to each matrix B_i. !> @param[in] b_type - [rocblas_datatype] !> specifies the datatype of each matrix B_i. !> @param[in] ldb - [rocblas_int] !> specifies the leading dimension of each B_i. !> @param[in] beta - [const void *] !> device pointer or host pointer specifying the scalar beta. Same datatype as !> compute_type. !> @param[in] c - [void *] !> device array of device pointers to each matrix C_i. !> @param[in] c_type - [rocblas_datatype] !> specifies the datatype of each matrix C_i. !> @param[in] ldc - [rocblas_int] !> specifies the leading dimension of each C_i. !> @param[out] d - [void *] !> device array of device pointers to each matrix D_i. !> If d and c are the same array of matrix pointers, then d_type must equal c_type !> and ldd must equal ldc !> or the respective invalid status will be returned. !> @param[in] d_type - [rocblas_datatype] !> specifies the datatype of each matrix D_i. !> @param[in] ldd - [rocblas_int] !> specifies the leading dimension of each D_i. !> @param[in] batch_count !> [rocblas_int] !> number of gemm operations in the batch. !> @param[in] compute_type !> [rocblas_datatype] !> specifies the datatype of computation. !> @param[in] algo - [rocblas_gemm_algo] !> enumerant specifying the algorithm type. !> @param[in] solution_index !> [int32_t] !> if algo is rocblas_gemm_algo_solution_index, this controls which solution is !> used. !> When algo is not rocblas_gemm_algo_solution_index, or if solution_index = 0, the !> default solution is used. !> Passing rocblas_gemm_algo_solution_index and solution_index < 0 to use the !> default solution is deprecated. !> @param[in] flags - [uint32_t] !> optional gemm flags. interface rocblas_gemm_batched_ex function rocblas_gemm_batched_ex_(handle,transA,transB,m,n,k,alpha,a,a_type,lda,b,b_type,ldb, & beta,c,c_type,ldc,d,d_type,ldd,batch_count,compute_type,algo,solution_index,flags) & bind(c, name="rocblas_gemm_batched_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_gemm_batched_ex_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: a integer(kind(rocblas_datatype_f16_r)),value :: a_type integer(c_int),value :: lda type(c_ptr),value :: b integer(kind(rocblas_datatype_f16_r)),value :: b_type integer(c_int),value :: ldb type(c_ptr),value :: beta type(c_ptr),value :: c integer(kind(rocblas_datatype_f16_r)),value :: c_type integer(c_int),value :: ldc type(c_ptr),value :: d integer(kind(rocblas_datatype_f16_r)),value :: d_type integer(c_int),value :: ldd integer(c_int),value :: batch_count integer(kind(rocblas_datatype_f16_r)),value :: compute_type integer(kind(rocblas_gemm_algo_standard)),value :: algo integer(c_int32_t),value :: solution_index integer(c_int32_t),value :: flags end function end interface interface rocblas_gemm_batched_ex_64 function rocblas_gemm_batched_ex_64_(handle,transA,transB,m,n,k,alpha,a,a_type,lda,b,b_type, & ldb,beta,c,c_type,ldc,d,d_type,ldd,batch_count,compute_type,algo,solution_index,flags) & bind(c, name="rocblas_gemm_batched_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_gemm_batched_ex_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: a integer(kind(rocblas_datatype_f16_r)),value :: a_type integer(c_int64_t),value :: lda type(c_ptr),value :: b integer(kind(rocblas_datatype_f16_r)),value :: b_type integer(c_int64_t),value :: ldb type(c_ptr),value :: beta type(c_ptr),value :: c integer(kind(rocblas_datatype_f16_r)),value :: c_type integer(c_int64_t),value :: ldc type(c_ptr),value :: d integer(kind(rocblas_datatype_f16_r)),value :: d_type integer(c_int64_t),value :: ldd integer(c_int64_t),value :: batch_count integer(kind(rocblas_datatype_f16_r)),value :: compute_type integer(kind(rocblas_gemm_algo_standard)),value :: algo integer(c_int32_t),value :: solution_index integer(c_int32_t),value :: flags end function end interface !> \brief BLAS EX API !> !> \details !> The gemm_strided_batched_ex functions perform one of the strided_batched matrix-matrix !> operations: !> !> D_i = alpha*op(A_i)*op(B_i) + beta*C_i, for i = 1, ..., batch_count !> !> where op( X ) is one of !> !> op( X ) = X or !> op( X ) = X**T or !> op( X ) = X**H, !> !> ``alpha`` and ``beta`` are scalars, and ``A``, ``B``, ``C``, and ``D`` are strided_batched !> matrices, with !> ``op( A )`` an ``m`` by ``k`` by ``batch_count`` strided_batched matrix, !> ``op( B )`` a ``k`` by ``n`` by ``batch_count`` strided_batched matrix, and !> ``C`` and ``D`` both ``m`` by ``n`` by ``batch_count`` strided_batched matrices. !> ``C`` and ``D`` can point to the same matrices if their parameters are identical. !> !> The strided_batched matrices are multiple matrices separated by a constant stride. !> The number of matrices is ``batch_count``. !> !> Supported types are as follows: !> - rocblas_datatype_f64_r = a_type = b_type = c_type = d_type = compute_type !> - rocblas_datatype_f32_r = a_type = b_type = c_type = d_type = compute_type !> - rocblas_datatype_f16_r = a_type = b_type = c_type = d_type = compute_type !> - rocblas_datatype_f16_r = a_type = b_type = c_type = d_type; rocblas_datatype_f32_r = !> compute_type !> - rocblas_datatype_bf16_r = a_type = b_type = c_type = d_type; rocblas_datatype_f32_r = !> compute_type !> - rocblas_datatype_i8_r = a_type = b_type; rocblas_datatype_i32_r = c_type = d_type = !> compute_type !> - rocblas_datatype_f32_c = a_type = b_type = c_type = d_type = compute_type !> - rocblas_datatype_f64_c = a_type = b_type = c_type = d_type = compute_type !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] transA - [rocblas_operation] !> specifies the form of op( A ). !> @param[in] transB - [rocblas_operation] !> specifies the form of op( B ). !> @param[in] m - [rocblas_int] !> matrix dimension m. !> @param[in] n - [rocblas_int] !> matrix dimension n. !> @param[in] k - [rocblas_int] !> matrix dimension k. !> @param[in] alpha - [const void *] !> device pointer or host pointer specifying the scalar alpha. Same datatype as !> compute_type. !> @param[in] a - [void *] !> device pointer pointing to first matrix A_1. !> @param[in] a_type - [rocblas_datatype] !> specifies the datatype of each matrix A_i. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. !> @param[in] stride_a - [rocblas_stride] !> specifies stride from start of one A_i matrix to the next A_(i + 1). !> @param[in] b - [void *] !> device pointer pointing to first matrix B_1. !> @param[in] b_type - [rocblas_datatype] !> specifies the datatype of each matrix B_i. !> @param[in] ldb - [rocblas_int] !> specifies the leading dimension of each B_i. !> @param[in] stride_b - [rocblas_stride] !> specifies stride from start of one B_i matrix to the next B_(i + 1). !> @param[in] beta - [const void *] !> device pointer or host pointer specifying the scalar beta. Same datatype as !> compute_type. !> @param[in] c - [void *] !> device pointer pointing to first matrix C_1. !> @param[in] c_type - [rocblas_datatype] !> specifies the datatype of each matrix C_i. !> @param[in] ldc - [rocblas_int] !> specifies the leading dimension of each C_i. !> @param[in] stride_c - [rocblas_stride] !> specifies stride from start of one C_i matrix to the next C_(i + 1). !> @param[out] d - [void *] !> device pointer storing each matrix D_i. !> If d and c pointers are to the same matrix, then d_type must equal c_type, ldd !> must equal ldc, !> and stride_d must equal stride_c or the respective invalid status will be !> returned. !> @param[in] d_type - [rocblas_datatype] !> specifies the datatype of each matrix D_i. !> @param[in] ldd - [rocblas_int] !> specifies the leading dimension of each D_i. !> @param[in] stride_d - [rocblas_stride] !> specifies stride from start of one D_i matrix to the next D_(i + 1). !> @param[in] batch_count !> [rocblas_int] !> number of gemm operations in the batch. !> @param[in] compute_type !> [rocblas_datatype] !> specifies the datatype of computation. !> @param[in] algo - [rocblas_gemm_algo] !> enumerant specifying the algorithm type. !> @param[in] solution_index !> [int32_t] !> if algo is rocblas_gemm_algo_solution_index, this controls which solution is !> used. !> When algo is not rocblas_gemm_algo_solution_index, or if solution_index = 0, the !> default solution is used. !> Passing rocblas_gemm_algo_solution_index and solution_index < 0 to use the !> default solution is deprecated. !> @param[in] flags - [uint32_t] !> optional gemm flags. interface rocblas_gemm_strided_batched_ex function rocblas_gemm_strided_batched_ex_(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,d,d_type,ldd,stride_d, & batch_count,compute_type,algo,solution_index,flags) & bind(c, name="rocblas_gemm_strided_batched_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_gemm_strided_batched_ex_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: a integer(kind(rocblas_datatype_f16_r)),value :: a_type integer(c_int),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: b integer(kind(rocblas_datatype_f16_r)),value :: b_type integer(c_int),value :: ldb integer(c_int64_t),value :: stride_b type(c_ptr),value :: beta type(c_ptr),value :: c integer(kind(rocblas_datatype_f16_r)),value :: c_type integer(c_int),value :: ldc integer(c_int64_t),value :: stride_c type(c_ptr),value :: d integer(kind(rocblas_datatype_f16_r)),value :: d_type integer(c_int),value :: ldd integer(c_int64_t),value :: stride_d integer(c_int),value :: batch_count integer(kind(rocblas_datatype_f16_r)),value :: compute_type integer(kind(rocblas_gemm_algo_standard)),value :: algo integer(c_int32_t),value :: solution_index integer(c_int32_t),value :: flags end function end interface interface rocblas_gemm_strided_batched_ex_64 function rocblas_gemm_strided_batched_ex_64_(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,d,d_type,ldd,stride_d, & batch_count,compute_type,algo,solution_index,flags) & bind(c, name="rocblas_gemm_strided_batched_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_gemm_strided_batched_ex_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: m integer(c_int64_t),value :: n integer(c_int64_t),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: a integer(kind(rocblas_datatype_f16_r)),value :: a_type integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: b integer(kind(rocblas_datatype_f16_r)),value :: b_type integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_b type(c_ptr),value :: beta type(c_ptr),value :: c integer(kind(rocblas_datatype_f16_r)),value :: c_type integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_c type(c_ptr),value :: d integer(kind(rocblas_datatype_f16_r)),value :: d_type integer(c_int64_t),value :: ldd integer(c_int64_t),value :: stride_d integer(c_int64_t),value :: batch_count integer(kind(rocblas_datatype_f16_r)),value :: compute_type integer(kind(rocblas_gemm_algo_standard)),value :: algo integer(c_int32_t),value :: solution_index integer(c_int32_t),value :: flags end function end interface !> \brief BLAS Level 3 API !> !> \details !> The gemmt functions perform matrix-matrix operations and update the upper or lower !> triangular part of the result matrix: !> !> C = alpha*op( A )*op( B ) + beta*C, !> !> where ``op( X )`` is one of !> !> op( X ) = X or !> op( X ) = X**T or !> op( X ) = X**H, !> !> ``alpha`` and ``beta`` are scalars, ``A`` and ``B`` are general matrices, and ``C`` is !> either an upper or lower triangular matrix, with !> ``op( A )`` an ``n`` by ``k`` matrix, ``op( B )`` a ``k`` by ``n`` matrix, and ``C`` an !> ``n`` by ``n`` matrix. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C is an upper triangular matrix. !> - rocblas_fill_lower: C is a lower triangular matrix. !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_none: op(A) = A. !> - rocblas_operation_transpose: op(A) = A^T !> - rocblas_operation_conjugate_transpose: op(A) = A^H !> @param[in] transB - [rocblas_operation] !> - rocblas_operation_none: op(B) = B. !> - rocblas_operation_transpose: op(B) = B^T !> - rocblas_operation_conjugate_transpose: op(B) = B^H !> @param[in] n - [rocblas_int] !> number or rows of matrices op( A ), columns of op( B ), and (rows, columns) of C. !> @param[in] k - [rocblas_int] !> number of rows of matrices op( B ) and columns of op( A ). !> @param[in] alpha - device pointer or host pointer specifying the scalar alpha. !> @param[in] A - device pointer storing matrix A. If transa = rocblas_operation_none, then !> the leading n-by-k part of the array contains the matrix A. Otherwise, the leading k-by-n !> part of the array contains the matrix A. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. If transA == rocblas_operation_none, must !> have lda >= max(1, n). Otherwise, must have lda >= max(1, k). !> @param[in] B - device pointer storing matrix B. If transB = rocblas_operation_none, then !> the leading k-by-n part of the array contains the matrix B. Otherwise, the leading n-by-k !> part of the array contains the matrix B. !> @param[in] ldb - [rocblas_int] !> specifies the leading dimension of B. If transB == rocblas_operation_none, must !> have ldb >= max(1, k). Otherwise, must have ldb >= max(1, n). !> @param[in] beta - device pointer or host pointer specifying the scalar beta. !> @param[in, out] C - device pointer storing matrix C on the GPU. If uplo == !> rocblas_fill_upper, the upper triangular part of the leading n-by-n array contains the !> matrix C. Otherwise, the lower triangular part of the leading n-by-n array contains the !> matrix C. !> @param[in] ldc - [rocblas_int] !> specifies the leading dimension of C. Must have ldc >= max(1, n). interface rocblas_sgemmt function rocblas_sgemmt_(handle,uplo,transA,transB,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_sgemmt") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemmt_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function end interface interface rocblas_dgemmt function rocblas_dgemmt_(handle,uplo,transA,transB,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_dgemmt") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemmt_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function end interface interface rocblas_cgemmt function rocblas_cgemmt_(handle,uplo,transA,transB,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_cgemmt") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemmt_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function end interface interface rocblas_zgemmt function rocblas_zgemmt_(handle,uplo,transA,transB,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_zgemmt") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemmt_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function end interface interface rocblas_sgemmt_64 function rocblas_sgemmt_64_(handle,uplo,transA,transB,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_sgemmt_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemmt_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_dgemmt_64 function rocblas_dgemmt_64_(handle,uplo,transA,transB,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_dgemmt_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemmt_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_cgemmt_64 function rocblas_cgemmt_64_(handle,uplo,transA,transB,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_cgemmt_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemmt_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface interface rocblas_zgemmt_64 function rocblas_zgemmt_64_(handle,uplo,transA,transB,n,k,alpha,A,lda,B,ldb,beta,C,ldc) & bind(c, name="rocblas_zgemmt_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemmt_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc end function end interface !> \brief BLAS Level 3 API !> !> \details !> The gemmt_batched functions perform matrix-matrix operations and update the upper or lower !> triangular part of the result matrix: !> !> C_i = alpha*op( A_i )*op( B_i ) + beta*C_i, for i = 1, ..., batch_count, !> !> where ``op( X )`` is one of !> !> op( X ) = X or !> op( X ) = X**T or !> op( X ) = X**H, !> !> ``alpha`` and ``beta`` are scalars, ``A`` and ``B`` are general matrices, and ``C`` is !> either an upper or lower triangular matrix, with !> ``op( A )`` consisting of ``n`` by ``k`` by ``batch_count`` matrices, !> ``op( B )`` consisting of ``k`` by ``n`` by ``batch_count`` matrices, and !> ``C`` consisting of ``n`` by ``n`` by ``batch_count`` matrices. !> !> @param[in] handle - [rocblas_handle !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C is an upper triangular matrix. !> - rocblas_fill_lower: C is a lower triangular matrix. !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_none: op(A_i) = A_i. !> - rocblas_operation_transpose: op(A_i) = A_i^T !> - rocblas_operation_conjugate_transpose: op(A_i) = A_i^H !> @param[in] transB - [rocblas_operation] !> - rocblas_operation_none: op(B_i) = B_i. !> - rocblas_operation_transpose: op(B_i) = B_i^T !> - rocblas_operation_conjugate_transpose: op(B_i) = B_i^H !> @param[in] n - [rocblas_int] !> number or rows of matrices op( A_i ), columns of op( B_i ), and (rows, columns) !> of C_i. !> @param[in] k - [rocblas_int] !> number of rows of matrices op( B_i ) and columns of op( A_i ). !> @param[in] alpha - device pointer or host pointer specifying the scalar alpha. !> @param[in] A - device array of device pointers storing each matrix A_i. If transa = !> rocblas_operation_none, then the leading n-by-k part of the array contains each matrix A_i. !> Otherwise, the leading k-by-n part of the array contains each matrix A_i. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. If transA == rocblas_operation_none, !> must have lda >= max(1, n). Otherwise, must have lda >= max(1, k). !> @param[in] B - device array of device pointers storing each matrix B_i. If transB = !> rocblas_operation_none, then the leading k-by-n part of the array contains each matrix B_i. !> Otherwise, the leading n-by-k part of the array contains each matrix B_i. !> @param[in] ldb - [rocblas_int] !> specifies the leading dimension of each B_i. If transB == rocblas_operation_none, !> must have ldb >= max(1, k). Otherwise, must have ldb >= max(1, n). !> @param[in] beta - device pointer or host pointer specifying the scalar beta. !> @param[in, out] C - device array of device pointers storing each matrix C_i. If uplo == !> rocblas_fill_upper, the upper triangular part of the leading n-by-n array contains each !> matrix C_i. Otherwise, the lower triangular part of the leading n-by-n array contains each !> matrix C_i. !> @param[in] ldc - [rocblas_int] !> specifies the leading dimension of each C_i. Must have ldc >= max(1, n). !> @param[in] batch_count !> [rocblas_int] !> number of gemm operations in the batch. interface rocblas_sgemmt_batched function rocblas_sgemmt_batched_(handle,uplo,transA,transB,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_sgemmt_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemmt_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_dgemmt_batched function rocblas_dgemmt_batched_(handle,uplo,transA,transB,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_dgemmt_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemmt_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_cgemmt_batched function rocblas_cgemmt_batched_(handle,uplo,transA,transB,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_cgemmt_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemmt_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_zgemmt_batched function rocblas_zgemmt_batched_(handle,uplo,transA,transB,n,k,alpha,A,lda,B,ldb,beta,C,ldc, & batch_count) & bind(c, name="rocblas_zgemmt_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemmt_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int),value :: batch_count end function end interface interface rocblas_sgemmt_batched_64 function rocblas_sgemmt_batched_64_(handle,uplo,transA,transB,n,k,alpha,A,lda,B,ldb,beta,C, & ldc,batch_count) & bind(c, name="rocblas_sgemmt_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemmt_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dgemmt_batched_64 function rocblas_dgemmt_batched_64_(handle,uplo,transA,transB,n,k,alpha,A,lda,B,ldb,beta,C, & ldc,batch_count) & bind(c, name="rocblas_dgemmt_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemmt_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cgemmt_batched_64 function rocblas_cgemmt_batched_64_(handle,uplo,transA,transB,n,k,alpha,A,lda,B,ldb,beta,C, & ldc,batch_count) & bind(c, name="rocblas_cgemmt_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemmt_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zgemmt_batched_64 function rocblas_zgemmt_batched_64_(handle,uplo,transA,transB,n,k,alpha,A,lda,B,ldb,beta,C, & ldc,batch_count) & bind(c, name="rocblas_zgemmt_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemmt_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS Level 3 API !> !> \details !> The gemmt_strided_batched functions perform matrix-matrix operations and update the upper !> or lower triangular part of the result matrix: !> !> C_i = alpha*op( A_i )*op( B_i ) + beta*C_i, for i = 1, ..., batch_count, !> !> where ``op( X )`` is one of !> !> op( X ) = X or !> op( X ) = X**T or !> op( X ) = X**H, !> !> ``alpha`` and ``beta`` are scalars, ``A`` and ``B`` are general matrices, and ``C`` is !> either an upper or lower triangular matrix, with !> ``op( A )`` an ``n`` by ``k`` by ``batch_count`` strided_batched matrix, !> ``op( B )`` a ``k`` by ``n`` by ``batch_count`` strided_batched matrix, and !> ``C`` an ``n`` by ``n`` by ``batch_count`` strided_batched matrix. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C is an upper triangular matrix. !> - rocblas_fill_lower: C is a lower triangular matrix. !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_none: op(A_i) = A_i. !> - rocblas_operation_transpose: op(A_i) = A_i^T !> - rocblas_operation_conjugate_transpose: op(A_i) = A_i^H !> @param[in] transB - [rocblas_operation] !> - rocblas_operation_none: op(B_i) = B_i. !> - rocblas_operation_transpose: op(B_i) = B_i^T !> - rocblas_operation_conjugate_transpose: op(B_i) = B_i^H !> @param[in] n - [rocblas_int] !> number or rows of matrices op( A_i ), columns of op( B_i ), and (rows, columns) !> of C_i. !> @param[in] k - [rocblas_int] !> number of rows of matrices op( B_i ) and columns of op( A_i ). !> @param[in] alpha - device pointer or host pointer specifying the scalar alpha. !> @param[in] A - device array of device pointers storing each matrix A_i. If transa = !> rocblas_operation_none, then the leading n-by-k part of the array contains each matrix A_i. !> Otherwise, the leading k-by-n part of the array contains each matrix A_i. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of each A_i. If transA == rocblas_operation_none, !> must have lda >= max(1, n). Otherwise, must have lda >= max(1, k). !> @param[in] stride_a - [rocblas_stride] !> stride from the start of one A_i matrix to the next A_(i + 1). !> @param[in] B - device array of device pointers storing each matrix B_i. If transB = !> rocblas_operation_none, then the leading k-by-n part of the array contains each matrix B_i. !> Otherwise, the leading n-by-k part of the array contains each matrix B_i. !> @param[in] ldb - [rocblas_int] !> specifies the leading dimension of each B_i. If transB == rocblas_operation_none, !> must have ldb >= max(1, k). Otherwise, must have ldb >= max(1, n). !> @param[in] stride_b - [rocblas_stride] !> stride from the start of one B_i matrix to the next B_(i + 1). !> @param[in] beta - device pointer or host pointer specifying the scalar beta. !> @param[in, out] C - device array of device pointers storing each matrix C_i. If uplo == !> rocblas_fill_upper, the upper triangular part of the leading n-by-n array contains each !> matrix C_i. Otherwise, the lower triangular part of the leading n-by-n array contains each !> matrix C_i. !> @param[in] ldc - [rocblas_int] !> specifies the leading dimension of each C_i. Must have ldc >= max(1, n). !> @param[in] stride_c - [rocblas_stride] !> stride from the start of one C_i matrix to the next C_(i + 1). !> @param[in] batch_count !> [rocblas_int] !> number of gemm operatons in the batch. interface rocblas_sgemmt_strided_batched function rocblas_sgemmt_strided_batched_(handle,uplo,transA,transB,n,k,alpha,A,lda,stride_a,B, & ldb,stride_b,beta,C,ldc,stride_c,batch_count) & bind(c, name="rocblas_sgemmt_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemmt_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_b real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_c integer(c_int),value :: batch_count end function end interface interface rocblas_dgemmt_strided_batched function rocblas_dgemmt_strided_batched_(handle,uplo,transA,transB,n,k,alpha,A,lda,stride_a,B, & ldb,stride_b,beta,C,ldc,stride_c,batch_count) & bind(c, name="rocblas_dgemmt_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemmt_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_b real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_c integer(c_int),value :: batch_count end function end interface interface rocblas_cgemmt_strided_batched function rocblas_cgemmt_strided_batched_(handle,uplo,transA,transB,n,k,alpha,A,lda,stride_a,B, & ldb,stride_b,beta,C,ldc,stride_c,batch_count) & bind(c, name="rocblas_cgemmt_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemmt_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_b complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_c integer(c_int),value :: batch_count end function end interface interface rocblas_zgemmt_strided_batched function rocblas_zgemmt_strided_batched_(handle,uplo,transA,transB,n,k,alpha,A,lda,stride_a,B, & ldb,stride_b,beta,C,ldc,stride_c,batch_count) & bind(c, name="rocblas_zgemmt_strided_batched") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemmt_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_b complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: stride_c integer(c_int),value :: batch_count end function end interface interface rocblas_sgemmt_strided_batched_64 function rocblas_sgemmt_strided_batched_64_(handle,uplo,transA,transB,n,k,alpha,A,lda, & stride_a,B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) & bind(c, name="rocblas_sgemmt_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemmt_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_b real(c_float) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_c integer(c_int64_t),value :: batch_count end function end interface interface rocblas_dgemmt_strided_batched_64 function rocblas_dgemmt_strided_batched_64_(handle,uplo,transA,transB,n,k,alpha,A,lda, & stride_a,B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) & bind(c, name="rocblas_dgemmt_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemmt_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: n integer(c_int64_t),value :: k real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_b real(c_double) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_c integer(c_int64_t),value :: batch_count end function end interface interface rocblas_cgemmt_strided_batched_64 function rocblas_cgemmt_strided_batched_64_(handle,uplo,transA,transB,n,k,alpha,A,lda, & stride_a,B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) & bind(c, name="rocblas_cgemmt_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemmt_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_b complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_c integer(c_int64_t),value :: batch_count end function end interface interface rocblas_zgemmt_strided_batched_64 function rocblas_zgemmt_strided_batched_64_(handle,uplo,transA,transB,n,k,alpha,A,lda, & stride_a,B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) & bind(c, name="rocblas_zgemmt_strided_batched_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemmt_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int64_t),value :: n integer(c_int64_t),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: stride_a type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: stride_b complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int64_t),value :: ldc integer(c_int64_t),value :: stride_c integer(c_int64_t),value :: batch_count end function end interface !> \brief BLAS EX API !> !> \details !> The geam_ex function performs one of the matrix-matrix operations: !> !> Dij = min(alpha * (Aik + Bkj), beta * Cij) !> Dij = min(alpha * Aik, alpha * Bkj) + beta * Cij !> !> ``alpha`` and ``beta`` are scalars, and ``A``, ``B``, ``C``, and ``D`` are matrices, with !> ``op( A )`` an ``m`` by ``k`` matrix, ``op( B )`` a ``k`` by ``n`` matrix, and ``C`` and !> ``D`` both ``m`` by ``n`` matrices. !> ``C`` and ``D`` can point to the same matrix if their type and leading dimensions are !> identical. !> !> Aik refers to the element at the ``i`` -th row and ``k`` -th column of ``op( A )``, Bkj !> refers to !> the element at the ``k`` -th row and ``j`` -th column of ``op( B )``, and Cij/Dij refers to !> the element !> at the ``i``-th row and ``j``-th column of ``C``/``D``. !> !> Supported types are as follows: !> - rocblas_datatype_f64_r = a_type = b_type = c_type = d_type = compute_type !> - rocblas_datatype_f32_r = a_type = b_type = c_type = d_type = compute_type !> - rocblas_datatype_f16_r = a_type = b_type = c_type = d_type = compute_type !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] transA - [rocblas_operation] !> specifies the form of op( A ). !> @param[in] transB - [rocblas_operation] !> specifies the form of op( B ). !> @param[in] m - [rocblas_int] !> matrix dimension m. !> @param[in] n - [rocblas_int] !> matrix dimension n. !> @param[in] k - [rocblas_int] !> matrix dimension k. !> @param[in] alpha - [const void *] !> device pointer or host pointer specifying the scalar alpha. Same datatype as !> compute_type. !> @param[in] A - [void *] !> device pointer storing matrix A. !> @param[in] a_type - [rocblas_datatype] !> specifies the datatype of matrix A. !> @param[in] lda - [rocblas_int] !> specifies the leading dimension of A. !> - If transA == N, must have lda >= max(1, m). !> - Otherwise, must have lda >= max(1, k). !> @param[in] B - [void *] !> device pointer storing matrix B. !> @param[in] b_type - [rocblas_datatype] !> specifies the datatype of matrix B. !> @param[in] ldb - [rocblas_int] !> specifies the leading dimension of B. !> - If transB == N, must have ldb >= max(1, k). !> - Otherwise, must have ldb >= max(1, n). !> @param[in] beta - [const void *] !> device pointer or host pointer specifying the scalar beta. Same datatype as !> compute_type. !> @param[in] C - [void *] !> device pointer storing matrix C. !> @param[in] c_type - [rocblas_datatype] !> specifies the datatype of matrix C. !> @param[in] ldc - [rocblas_int] !> specifies the leading dimension of C. Must have ldc >= max(1, m). !> @param[out] D - [void *] !> device pointer storing matrix D. !> If D and C pointers are to the same matrix, then d_type must equal c_type and ldd !> must equal ldc !> or the respective invalid status will be returned. !> @param[in] d_type - [rocblas_datatype] !> specifies the datatype of matrix D. !> @param[in] ldd - [rocblas_int] !> specifies the leading dimension of D. Must have ldd >= max(1, m). !> @param[in] compute_type !> [rocblas_datatype] !> specifies the datatype of computation. !> @param[in] geam_ex_op - [rocblas_geam_ex_operation] !> enumerant specifying the operation type and support for !> rocblas_geam_ex_operation_min_plus and rocblas_geam_ex_operation_plus_min. interface rocblas_geam_ex function rocblas_geam_ex_(handle,transA,transB,m,n,k,alpha,A,a_type,lda,B,b_type,ldb,beta,C, & c_type,ldc,D,d_type,ldd,compute_type,geam_ex_op) & bind(c, name="rocblas_geam_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_geam_ex_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_operation_none)),value :: transB integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: A integer(kind(rocblas_datatype_f16_r)),value :: a_type integer(c_int),value :: lda type(c_ptr),value :: B integer(kind(rocblas_datatype_f16_r)),value :: b_type integer(c_int),value :: ldb type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(rocblas_datatype_f16_r)),value :: c_type integer(c_int),value :: ldc type(c_ptr),value :: D integer(kind(rocblas_datatype_f16_r)),value :: d_type integer(c_int),value :: ldd integer(kind(rocblas_datatype_f16_r)),value :: compute_type integer(kind(rocblas_geam_ex_operation_min_plus)),value :: geam_ex_op end function end interface !> \brief BLAS EX API !> !> \details !> trsm_ex solves: !> !> op(A)*X = alpha*B or X*op(A) = alpha*B, !> !> where alpha is a scalar, X and B are m by n matrices, !> A is triangular matrix and op(A) is one of !> !> op( A ) = A or op( A ) = A^T or op( A ) = A^H. !> !> The matrix X is overwritten on B. !> !> This function gives the user the ability to reuse the invA matrix between runs. !> If invA == NULL, rocblas_trsm_ex will automatically calculate invA on every run. !> !> Setting up invA: !> The accepted invA matrix consists of the packed 128x128 inverses of the diagonal blocks of !> matrix A, followed by any smaller diagonal block that remains. !> To set up invA it is recommended that rocblas_trtri_batched be used with matrix A as the !> input. !> !> Device memory of size 128 x k should be allocated for invA ahead of time, where k is m when !> rocblas_side_left and is n when rocblas_side_right. The actual number of elements in invA !> should be passed as invA_size. !> !> To begin, rocblas_trtri_batched must be called on the full 128x128-sized diagonal blocks of !> matrix A. Below are the restricted parameters: !> - n = 128 !> - ldinvA = 128 !> - stride_invA = 128x128 !> - batch_count = k / 128, !> !> Then any remaining block may be added: !> - n = k % 128 !> - invA = invA + stride_invA * previous_batch_count !> - ldinvA = 128 !> - batch_count = 1 !> !> Although not widespread, some gemm kernels used by trsm_ex may use atomic operations. !> See Atomic Operations in the API Reference Guide for more information. !> !> @param[in] handle - [rocblas_handle] !> handle to the rocblas library context queue. !> !> @param[in] side - [rocblas_side] !> - rocblas_side_left: op(A)*X = alpha*B !> - rocblas_side_right: X*op(A) = alpha*B !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: A is an upper triangular matrix. !> - rocblas_fill_lower: A is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - transB: op(A) = A. !> - rocblas_operation_transpose: op(A) = A^T !> - rocblas_operation_conjugate_transpose: op(A) = A^H !> !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: A is assumed to be unit triangular. !> - rocblas_diagonal_non_unit: A is not assumed to be unit triangular. !> !> @param[in] m - [rocblas_int] !> m specifies the number of rows of B. m >= 0. !> !> @param[in] n - [rocblas_int] !> n specifies the number of columns of B. n >= 0. !> !> @param[in] alpha - [void *] !> device pointer or host pointer specifying the scalar alpha. When alpha is !> &zero then A is not referenced, and B need not be set before !> entry. !> !> @param[in] A - [void *] !> device pointer storing matrix A. !> of dimension ( lda, k ), where k is m !> when rocblas_side_left and !> is n when rocblas_side_right !> only the upper/lower triangular part is accessed. !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A. !> !> if side = rocblas_side_left, lda >= max( 1, m ), !> if side = rocblas_side_right, lda >= max( 1, n ). !> !> @param[in, out] B - [void *] !> device pointer storing matrix B. !> B is of dimension ( ldb, n ). !> Before entry, the leading m by n part of the array B must !> contain the right-hand side matrix B, and on exit is !> overwritten by the solution matrix X. !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of B. ldb >= max( 1, m ). !> !> @param[in] invA - [void *] !> device pointer storing the inverse diagonal blocks of A. !> invA is of dimension ( ld_invA, k ), where k is m !> when rocblas_side_left and !> is n when rocblas_side_right. !> ld_invA must be equal to 128. !> !> @param[in] invA_size - [rocblas_int] !> invA_size specifies the number of elements of device memory in invA. !> !> @param[in] compute_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_trsm_ex function rocblas_trsm_ex_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,invA,invA_size, & compute_type) & bind(c, name="rocblas_trsm_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_trsm_ex_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: invA integer(c_int),value :: invA_size integer(kind(rocblas_datatype_f16_r)),value :: compute_type end function end interface !> \brief BLAS EX API !> !> \details !> trsm_batched_ex solves: !> !> op(A_i)*X_i = alpha*B_i or X_i*op(A_i) = alpha*B_i, !> !> for i = 1, ..., batch_count; and where alpha is a scalar, X and B are arrays of m by n !> matrices, !> A is an array of triangular matrix and each op(A_i) is one of !> !> op( A_i ) = A_i or op( A_i ) = A_i^T or op( A_i ) = A_i^H. !> !> Each matrix X_i is overwritten on B_i. !> !> This function gives the user the ability to reuse the invA matrix between runs. !> If invA == NULL, rocblas_trsm_batched_ex will automatically calculate each invA_i on every !> run. !> !> Setting up invA: !> Each accepted invA_i matrix consists of the packed 128x128 inverses of the diagonal blocks !> of !> matrix A_i, followed by any smaller diagonal block that remains. !> To set up each invA_i it is recommended that rocblas_trtri_batched be used with matrix A_i !> as the input. !> invA is an array of pointers of batch_count length holding each invA_i. !> !> Device memory of size 128 x k should be allocated for each invA_i ahead of time, where k is !> m when !> rocblas_side_left and is n when rocblas_side_right. The actual number of elements in each !> invA_i !> should be passed as invA_size. !> !> To begin, rocblas_trtri_batched must be called on the full 128x128-sized diagonal blocks of !> each !> matrix A_i. Below are the restricted parameters: !> - n = 128 !> - ldinvA = 128 !> - stride_invA = 128x128 !> - batch_count = k / 128, !> !> Then any remaining block may be added: !> - n = k % 128 !> - invA = invA + stride_invA * previous_batch_count !> - ldinvA = 128 !> - batch_count = 1 !> !> @param[in] handle - [rocblas_handle] !> handle to the rocblas library context queue. !> !> @param[in] side - [rocblas_side] !> - rocblas_side_left: op(A)*X = alpha*B !> - rocblas_side_right: X*op(A) = alpha*B !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: each A_i is an upper triangular matrix. !> - rocblas_fill_lower: each A_i is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - transB: op(A) = A. !> - rocblas_operation_transpose: op(A) = A^T !> - rocblas_operation_conjugate_transpose: op(A) = A^H !> !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: each A_i is assumed to be unit triangular. !> - rocblas_diagonal_non_unit: each A_i is not assumed to be unit triangular. !> !> @param[in] m - [rocblas_int] !> m specifies the number of rows of each B_i. m >= 0. !> !> @param[in] n - [rocblas_int] !> n specifies the number of columns of each B_i. n >= 0. !> !> @param[in] alpha - [void *] !> device pointer or host pointer alpha specifying the scalar alpha. When alpha is !> &zero then A is not referenced, and B need not be set before !> entry. !> !> @param[in] A - [void *] !> device array of device pointers storing each matrix A_i. !> each A_i is of dimension ( lda, k ), where k is m !> when rocblas_side_left and !> is n when rocblas_side_right !> only the upper/lower triangular part is accessed. !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of each A_i. !> !> if side = rocblas_side_left, lda >= max( 1, m ), !> if side = rocblas_side_right, lda >= max( 1, n ). !> !> @param[in, out] B - [void *] !> device array of device pointers storing each matrix B_i. !> each B_i is of dimension ( ldb, n ). !> Before entry, the leading m by n part of the array B_i must !> contain the right-hand side matrix B_i, and on exit is !> overwritten by the solution matrix X_i !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of each B_i. ldb >= max( 1, m ). !> !> @param[in] batch_count - [rocblas_int] !> specifies how many batches. !> !> @param[in] invA - [void *] !> device array of device pointers storing the inverse diagonal blocks of each A_i. !> each invA_i is of dimension ( ld_invA, k ), where k is m !> when rocblas_side_left and !> is n when rocblas_side_right. !> ld_invA must be equal to 128. !> !> @param[in] invA_size - [rocblas_int] !> invA_size specifies the number of elements of device memory in each invA_i. !> !> @param[in] compute_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_trsm_batched_ex function rocblas_trsm_batched_ex_(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb, & batch_count,invA,invA_size,compute_type) & bind(c, name="rocblas_trsm_batched_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_trsm_batched_ex_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count type(c_ptr),value :: invA integer(c_int),value :: invA_size integer(kind(rocblas_datatype_f16_r)),value :: compute_type end function end interface !> \brief BLAS EX API !> !> \details !> The trsm_strided_batched_ex functions solve: !> !> op(A_i)*X_i = alpha*B_i or X_i*op(A_i) = alpha*B_i, !> !> for ``i`` = 1, ..., ``batch_count``, where ``alpha`` is a scalar, ``X`` and ``B`` are !> strided batched ``m`` by ``n`` matrices, !> ``A`` is a strided batched triangular matrix, and ``op(A_i)`` is one of: !> !> op( A_i ) = A_i or op( A_i ) = A_i^T or op( A_i ) = A_i^H. !> !> Each matrix ``X_i`` is overwritten on ``B_i``. !> !> This function gives the user the ability to reuse each ``invA_i`` matrix between runs. !> If ``invA == NULL``, ``rocblas_trsm_batched_ex`` will automatically calculate each !> ``invA_i`` on every run. !> !> Setting up invA: !> Each accepted ``invA_i`` matrix consists of the packed 128x128 inverses of the diagonal !> blocks of !> matrix ``A_i``, followed by any smaller diagonal block that remains. !> To set up ``invA_i``, it is recommended that ``rocblas_trtri_batched`` be used with matrix !> ``A_i`` as the input. !> ``invA`` is a contiguous piece of memory holding each ``invA_i``. !> !> Device memory of size 128 x ``k`` should be allocated for each ``invA_i`` ahead of time, !> where ``k`` is ``m`` when !> ``rocblas_side_left`` and is ``n`` when ``rocblas_side_right``. The actual number of !> elements in each ``invA_i`` !> should be passed as ``invA_size``. !> !> To begin, ``rocblas_trtri_batched`` must be called on the full 128x128-sized diagonal !> blocks of each !> matrix ``A_i``. Below are the restricted parameters: !> - n = 128 !> - ldinvA = 128 !> - stride_invA = 128x128 !> - batch_count = k / 128 !> !> Then any remaining block can be added: !> - n = k % 128 !> - invA = invA + stride_invA * previous_batch_count !> - ldinvA = 128 !> - batch_count = 1 !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] side - [rocblas_side] !> - rocblas_side_left: op(A)*X = alpha*B !> - rocblas_side_right: X*op(A) = alpha*B !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: each A_i is an upper triangular matrix. !> - rocblas_fill_lower: each A_i is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - transB: op(A) = A. !> - rocblas_operation_transpose: op(A) = A^T !> - rocblas_operation_conjugate_transpose: op(A) = A^H !> !> @param[in] diag - [rocblas_diagonal] !> - rocblas_diagonal_unit: each A_i is assumed to be unit triangular. !> - rocblas_diagonal_non_unit: each A_i is not assumed to be unit triangular. !> !> @param[in] m - [rocblas_int] !> m specifies the number of rows of each B_i. m >= 0. !> !> @param[in] n - [rocblas_int] !> n specifies the number of columns of each B_i. n >= 0. !> !> @param[in] alpha - [void *] !> device pointer or host pointer specifying the scalar alpha. When alpha is !> &zero, then A is not referenced, and B need not be set before !> entry. !> !> @param[in] A - [void *] !> device pointer storing matrix A. !> Of dimension ( lda, k ), where k is m !> when rocblas_side_left and !> is n when rocblas_side_right. !> Only the upper/lower triangular part is accessed. !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A. !> - If side = rocblas_side_left, lda >= max( 1, m ). !> - If side = rocblas_side_right, lda >= max( 1, n ). !> !> @param[in] stride_A - [rocblas_stride] !> The stride between each A matrix. !> !> @param[in, out] B - [void *] !> device pointer pointing to first matrix B_i. !> Each B_i is of dimension ( ldb, n ). !> Before entry, the leading m by n part of each array B_i must !> contain the right-hand side of matrix B_i, and on exit is !> overwritten by the solution matrix X_i. !> !> @param[in] ldb - [rocblas_int] !> ldb specifies the first dimension of each B_i. ldb >= max( 1, m ). !> !> @param[in] stride_B - [rocblas_stride] !> The stride between each B_i matrix. !> !> @param[in] batch_count - [rocblas_int] !> specifies how many batches. !> !> @param[in] invA - [void *] !> device pointer storing the inverse diagonal blocks of each A_i. !> invA points to the first invA_1. !> Each invA_i is of dimension ( ld_invA, k ), where k is m !> when rocblas_side_left and !> is n when rocblas_side_right. !> ld_invA must be equal to 128. !> !> @param[in] invA_size - [rocblas_int] !> invA_size specifies the number of elements of device memory in each invA_i. !> !> @param[in] stride_invA - [rocblas_stride] !> The stride between each invA matrix. !> !> @param[in] compute_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_trsm_strided_batched_ex function rocblas_trsm_strided_batched_ex_(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) & bind(c, name="rocblas_trsm_strided_batched_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_trsm_strided_batched_ex_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: stride_A type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: stride_B integer(c_int),value :: batch_count type(c_ptr),value :: invA integer(c_int),value :: invA_size integer(c_int64_t),value :: stride_invA integer(kind(rocblas_datatype_f16_r)),value :: compute_type end function end interface !> \brief BLAS EX API !> !> \details !> The syrk_ex functions perform one of the matrix-matrix operations for a symmetric rank-k !> update: !> !> C := alpha*op( A )*op( A )^T + beta*C, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` is an ``n`` by ``k`` matrix, and !> ``C`` is a symmetric ``n`` x ``n`` matrix stored as either upper or lower. !> !> op( A ) = A, and A is n by k if transA == rocblas_operation_none !> op( A ) = A^T and A is k by n if transA == rocblas_operation_transpose !> !> Currently supported datatypes are as follows: !> !> ------------------------------------ !> | a_type | c_type | execution_type | !> |--------|--------|----------------| !> | bf16_r | bf16_r | f32_r | !> | bf16_r | f32_r | f32_r | !> | f16_r | f16_r | f32_r | !> | f16_r | f32_r | f32_r | !> | f32_r | f32_r | f64_r | !> | f32_r | f64_r | f64_r | !> ------------------------------------ !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C is an upper triangular matrix. !> - rocblas_fill_lower: C is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_transpose: op(A) = A^T !> - rocblas_operation_none: op(A) = A !> - rocblas_operation_conjugate_transpose: op(A) = A^T !> - rocblas_operation_conjugate_transpose is not supported for complex types. See !> cherk !> and zherk. !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha - [const void *] !> device pointer or host pointer specifying the scalar alpha. When alpha is !> zero, then A is not referenced and A need not be set before !> entry. Same datatype as compute_type. !> !> @param[in] A - pointer storing matrix A on the GPU. !> Matrix dimension is ( lda, k ) when transA = rocblas_operation_none. Otherwise, !> (lda, n). !> @param[in] a_type - [rocblas_datatype] !> specifies the datatype of matrix A. !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A. !> - If transA = rocblas_operation_none, lda >= max( 1, n ). !> - Otherwise, lda >= max( 1, k ). !> !> @param[in] beta - [const void *] !> device pointer or host pointer specifying the scalar beta. When beta is !> zero, then C need not be set before !> entry. Same datatype as compute_type. !> !> @param[in] C - pointer storing matrix C on the GPU. !> Only the upper/lower triangular part is accessed. !> @param[in] c_type - [rocblas_datatype] !> specifies the datatype of matrix C. !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> @param[in] execution_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_syrk_ex function rocblas_syrk_ex_(handle,uplo,transA,n,k,alpha,A,a_type,lda,beta,C,c_type,ldc, & execution_type) & bind(c, name="rocblas_syrk_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_syrk_ex_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: A integer(kind(rocblas_datatype_f16_r)),value :: a_type integer(c_int),value :: lda type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(rocblas_datatype_f16_r)),value :: c_type integer(c_int),value :: ldc integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface !> \brief BLAS EX API !> !> \details !> The herk_ex functions perform one of the matrix-matrix operations for a Hermitian rank-k !> update: !> !> C := alpha*op( A )*op( A )^H + beta*C, !> !> where ``alpha`` and ``beta`` are scalars, ``op(A)`` is an ``n`` by ``k`` matrix, and !> ``C`` is a ``n`` x ``n`` Hermitian matrix stored as either upper or lower. !> !> op( A ) = A, and A is n by k if transA == rocblas_operation_none !> op( A ) = A^H and A is k by n if transA == rocblas_operation_conjugate_transpose !> !> Currently supported datatypes are as follows: !> !> ------------------------------------ !> | a_type | c_type | execution_type | !> |--------|--------|----------------| !> | f32_c | f32_c | f64_c | !> | f32_c | f64_c | f64_c | !> ------------------------------------ !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> !> @param[in] uplo - [rocblas_fill] !> - rocblas_fill_upper: C is an upper triangular matrix. !> - rocblas_fill_lower: C is a lower triangular matrix. !> !> @param[in] transA - [rocblas_operation] !> - rocblas_operation_conjugate_transpose: op(A) = A^H !> - rocblas_operation_none: op(A) = A !> !> @param[in] n - [rocblas_int] !> n specifies the number of rows and columns of C. n >= 0. !> !> @param[in] k - [rocblas_int] !> k specifies the number of columns of op(A). k >= 0. !> !> @param[in] alpha - [const void *] !> device pointer or host pointer specifying the scalar alpha. When alpha is !> zero, then A is not referenced and A need not be set before !> entry. Same datatype as the real component of the compute_type. !> !> @param[in] A - pointer storing matrix A on the GPU. !> Matrix dimension is ( lda, k ) when transA = rocblas_operation_none. Otherwise, !> (lda, n). !> !> @param[in] a_type - [rocblas_datatype] !> specifies the datatype of matrix A. !> !> @param[in] lda - [rocblas_int] !> lda specifies the first dimension of A. !> - If transA = rocblas_operation_none, lda >= max( 1, n ). !> - Otherwise, lda >= max( 1, k ). !> !> @param[in] beta - [const void *] !> device pointer or host pointer specifying the scalar beta. When beta is !> zero, then C need not be set before !> entry. Same datatype as the real component of the compute_type. !> !> @param[in] C - pointer storing matrix C on the GPU. !> Only the upper/lower triangular part is accessed. !> !> @param[in] c_type - [rocblas_datatype] !> specifies the datatype of matrix C. !> !> @param[in] ldc - [rocblas_int] !> ldc specifies the first dimension of C. ldc >= max( 1, n ). !> !> @param[in] execution_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_herk_ex function rocblas_herk_ex_(handle,uplo,transA,n,k,alpha,A,a_type,lda,beta,C,c_type,ldc, & execution_type) & bind(c, name="rocblas_herk_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_herk_ex_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: transA integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: alpha type(c_ptr),value :: A integer(kind(rocblas_datatype_f16_r)),value :: a_type integer(c_int),value :: lda type(c_ptr),value :: beta type(c_ptr),value :: C integer(kind(rocblas_datatype_f16_r)),value :: c_type integer(c_int),value :: ldc integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface !> \brief BLAS EX API !> !> \details !> axpy_ex computes constant alpha multiplied by vector x, plus vector y. !> !> y := alpha * x + y !> !> Currently supported datatypes are as follows: !> !> ------------------------------------------------- !> | alpha_type | x_type | y_type | execution_type | !> |------------|--------|--------|----------------| !> | bf16_r | bf16_r | bf16_r| f32_r | !> | f32_r | bf16_r | bf16_r| f32_r | !> | f16_r | f16_r | f16_r | f16_r | !> | f16_r | f16_r | f16_r | f32_r | !> | f32_r | f16_r | f16_r | f32_r | !> | f32_r | f32_r | f32_r | f32_r | !> | f64_r | f64_r | f64_r | f64_r | !> | f32_c | f32_c | f32_c | f32_c | !> | f64_c | f64_c | f64_c | f64_c | !> ------------------------------------------------- !> !> @param[in] handle - [rocblas_handle] !> handle to the rocblas library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in x and y. !> @param[in] alpha - device pointer or host pointer to specify the scalar alpha. !> @param[in] alpha_type - [rocblas_datatype] !> specifies the datatype of alpha. !> @param[in] x - device pointer storing vector x. !> @param[in] x_type - [rocblas_datatype] !> specifies the datatype of vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in, out] y - device pointer storing vector y. !> @param[in] y_type - [rocblas_datatype] !> specifies the datatype of vector y. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in] execution_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_axpy_ex function rocblas_axpy_ex_(handle,n,alpha,alpha_type,x,x_type,incx,y,y_type,incy, & execution_type) & bind(c, name="rocblas_axpy_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_axpy_ex_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: alpha integer(kind(rocblas_datatype_f16_r)),value :: alpha_type type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int),value :: incx type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int),value :: incy integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_axpy_ex_64 function rocblas_axpy_ex_64_(handle,n,alpha,alpha_type,x,x_type,incx,y,y_type,incy, & execution_type) & bind(c, name="rocblas_axpy_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_axpy_ex_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: alpha integer(kind(rocblas_datatype_f16_r)),value :: alpha_type type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int64_t),value :: incy integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface !> \brief BLAS EX API !> !> \details !> axpy_batched_ex computes constant alpha multiplied by vector x, plus vector y over !> a set of batched vectors. !> !> y := alpha * x + y !> !> Currently supported datatypes are as follows: !> !> ------------------------------------------------- !> | alpha_type | x_type | y_type | execution_type | !> |------------|--------|--------|----------------| !> | bf16_r | bf16_r | bf16_r| f32_r | !> | f32_r | bf16_r | bf16_r| f32_r | !> | f16_r | f16_r | f16_r | f16_r | !> | f16_r | f16_r | f16_r | f32_r | !> | f32_r | f16_r | f16_r | f32_r | !> | f32_r | f32_r | f32_r | f32_r | !> | f64_r | f64_r | f64_r | f64_r | !> | f32_c | f32_c | f32_c | f32_c | !> | f64_c | f64_c | f64_c | f64_c | !> ------------------------------------------------- !> !> @param[in] handle - [rocblas_handle] !> handle to the rocblas library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in each x_i and y_i. !> @param[in] alpha - device pointer or host pointer to specify the scalar alpha. !> @param[in] alpha_type - [rocblas_datatype] !> specifies the datatype of alpha. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] x_type - [rocblas_datatype] !> specifies the datatype of each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in, out] y - device array of device pointers storing each vector y_i. !> @param[in] y_type - [rocblas_datatype] !> specifies the datatype of each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each y_i. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. !> @param[in] execution_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_axpy_batched_ex function rocblas_axpy_batched_ex_(handle,n,alpha,alpha_type,x,x_type,incx,y,y_type,incy, & batch_count,execution_type) & bind(c, name="rocblas_axpy_batched_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_axpy_batched_ex_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: alpha integer(kind(rocblas_datatype_f16_r)),value :: alpha_type type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int),value :: incx type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int),value :: incy integer(c_int),value :: batch_count integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_axpy_batched_ex_64 function rocblas_axpy_batched_ex_64_(handle,n,alpha,alpha_type,x,x_type,incx,y,y_type,incy, & batch_count,execution_type) & bind(c, name="rocblas_axpy_batched_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_axpy_batched_ex_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: alpha integer(kind(rocblas_datatype_f16_r)),value :: alpha_type type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface !> \brief BLAS EX API !> !> \details !> The axpy_strided_batched_ex function computes constant ``alpha`` multiplied by vector ``x`` !> plus vector ``y`` over !> a set of strided batched vectors. !> !> y := alpha * x + y !> !> Currently supported datatypes are as follows: !> !> ------------------------------------------------- !> | alpha_type | x_type | y_type | execution_type | !> |------------|--------|--------|----------------| !> | bf16_r | bf16_r | bf16_r| f32_r | !> | f32_r | bf16_r | bf16_r| f32_r | !> | f16_r | f16_r | f16_r | f16_r | !> | f16_r | f16_r | f16_r | f32_r | !> | f32_r | f16_r | f16_r | f32_r | !> | f32_r | f32_r | f32_r | f32_r | !> | f64_r | f64_r | f64_r | f64_r | !> | f32_c | f32_c | f32_c | f32_c | !> | f64_c | f64_c | f64_c | f64_c | !> ------------------------------------------------- !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in each x_i and y_i. !> @param[in] alpha - device pointer or host pointer to specify the scalar alpha. !> @param[in] alpha_type - [rocblas_datatype] !> specifies the datatype of alpha. !> @param[in] x - device pointer to the first vector x_1. !> @param[in] x_type - [rocblas_datatype] !> specifies the datatype of each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stridex. However, ensure that stridex is of !> an appropriate size. For a typical !> case, this means stridex >= n * incx. !> @param[in, out] y - device pointer to the first vector y_1. !> @param[in] y_type - [rocblas_datatype] !> specifies the datatype of each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each y_i. !> @param[in] stridey - [rocblas_stride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> There are no restrictions placed on stridey. However, ensure that stridey is of !> an appropriate size. For a typical !> case, this means stridey >= n * incy. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. !> @param[in] execution_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_axpy_strided_batched_ex function rocblas_axpy_strided_batched_ex_(handle,n,alpha,alpha_type,x,x_type,incx,stridex,y, & y_type,incy,stridey,batch_count,execution_type) & bind(c, name="rocblas_axpy_strided_batched_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_axpy_strided_batched_ex_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: alpha integer(kind(rocblas_datatype_f16_r)),value :: alpha_type type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int),value :: incy integer(c_int64_t),value :: stridey integer(c_int),value :: batch_count integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_axpy_strided_batched_ex_64 function rocblas_axpy_strided_batched_ex_64_(handle,n,alpha,alpha_type,x,x_type,incx,stridex, & y,y_type,incy,stridey,batch_count,execution_type) & bind(c, name="rocblas_axpy_strided_batched_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_axpy_strided_batched_ex_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: alpha integer(kind(rocblas_datatype_f16_r)),value :: alpha_type type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int64_t),value :: incy integer(c_int64_t),value :: stridey integer(c_int64_t),value :: batch_count integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface !> \brief BLAS EX API !> !> \details !> dot_ex performs the dot product of vectors x and y. !> !> result = x * y; !> !> dotc_ex performs the dot product of the conjugate of complex vector x and complex vector y !> !> result = conjugate (x) * y; !> !> Currently supported datatypes are as follows: !> !> -------------------------------------------------- !> | x_type | y_type | result_type | execution_type | !> |--------|--------|-------------|----------------| !> | f16_r | f16_r | f16_r | f16_r | !> | f16_r | f16_r | f16_r | f32_r | !> | bf16_r | bf16_r | bf16_r | f32_r | !> | f32_r | f32_r | f32_r | f32_r | !> | f32_r | f32_r | f64_r | f64_r | !> | f64_r | f64_r | f64_r | f64_r | !> | f32_c | f32_c | f32_c | f32_c | !> | f64_c | f64_c | f64_c | f64_c | !> -------------------------------------------------- !> !> @param[in] handle - [rocblas_handle] !> handle to the rocblas library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in x and y. !> @param[in] x - device pointer storing vector x. !> @param[in] x_type - [rocblas_datatype] !> specifies the datatype of vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in] y - device pointer storing vector y. !> @param[in] y_type - [rocblas_datatype] !> specifies the datatype of vector y. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in, out] myResult !> device pointer or host pointer to store the dot product. !> Return value is 0.0 if n <= 0. !> @param[in] result_type - [rocblas_datatype] !> specifies the datatype of the result. !> @param[in] execution_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_dot_ex function rocblas_dot_ex_(handle,n,x,x_type,incx,y,y_type,incy,myResult,result_type, & execution_type) & bind(c, name="rocblas_dot_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dot_ex_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int),value :: incx type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int),value :: incy type(c_ptr),value :: myResult integer(kind(rocblas_datatype_f16_r)),value :: result_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_dotc_ex function rocblas_dotc_ex_(handle,n,x,x_type,incx,y,y_type,incy,myResult,result_type, & execution_type) & bind(c, name="rocblas_dotc_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dotc_ex_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int),value :: incx type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int),value :: incy type(c_ptr),value :: myResult integer(kind(rocblas_datatype_f16_r)),value :: result_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_dot_ex_64 function rocblas_dot_ex_64_(handle,n,x,x_type,incx,y,y_type,incy,myResult,result_type, & execution_type) & bind(c, name="rocblas_dot_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dot_ex_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int64_t),value :: incy type(c_ptr),value :: myResult integer(kind(rocblas_datatype_f16_r)),value :: result_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_dotc_ex_64 function rocblas_dotc_ex_64_(handle,n,x,x_type,incx,y,y_type,incy,myResult,result_type, & execution_type) & bind(c, name="rocblas_dotc_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dotc_ex_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int64_t),value :: incy type(c_ptr),value :: myResult integer(kind(rocblas_datatype_f16_r)),value :: result_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface !> \brief BLAS EX API !> !> \details !> dot_batched_ex performs a batch of dot products of vectors x and y. !> !> result_i = x_i * y_i; !> !> dotc_batched_ex performs a batch of dot products of the conjugate of complex vector x and !> complex vector y !> !> result_i = conjugate (x_i) * y_i; !> !> where (x_i, y_i) is the i-th instance of the batch. !> x_i and y_i are vectors, for i = 1, ..., batch_count !> !> Currently supported datatypes are as follows: !> !> -------------------------------------------------- !> | x_type | y_type | result_type | execution_type | !> |--------|--------|-------------|----------------| !> | f16_r | f16_r | f16_r | f16_r | !> | f16_r | f16_r | f16_r | f32_r | !> | bf16_r | bf16_r | bf16_r | f32_r | !> | f32_r | f32_r | f32_r | f32_r | !> | f32_r | f32_r | f64_r | f64_r | !> | f64_r | f64_r | f64_r | f64_r | !> | f32_c | f32_c | f32_c | f32_c | !> | f64_c | f64_c | f64_c | f64_c | !> -------------------------------------------------- !> !> @param[in] handle - [rocblas_handle] !> handle to the rocblas library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in each x_i and y_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] x_type - [rocblas_datatype] !> specifies the datatype of each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] y - device array of device pointers storing each vector y_i. !> @param[in] y_type - [rocblas_datatype] !> specifies the datatype of each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each y_i. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. !> @param[in, out] myResult !> device array or host array of batch_count size to store the dot products of each !> batch. !> Return value is 0.0 for each element if n <= 0. !> @param[in] result_type - [rocblas_datatype] !> specifies the datatype of the result. !> @param[in] execution_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_dot_batched_ex function rocblas_dot_batched_ex_(handle,n,x,x_type,incx,y,y_type,incy,batch_count,myResult, & result_type,execution_type) & bind(c, name="rocblas_dot_batched_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dot_batched_ex_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int),value :: incx type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int),value :: incy integer(c_int),value :: batch_count type(c_ptr),value :: myResult integer(kind(rocblas_datatype_f16_r)),value :: result_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_dotc_batched_ex function rocblas_dotc_batched_ex_(handle,n,x,x_type,incx,y,y_type,incy,batch_count,myResult, & result_type,execution_type) & bind(c, name="rocblas_dotc_batched_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dotc_batched_ex_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int),value :: incx type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int),value :: incy integer(c_int),value :: batch_count type(c_ptr),value :: myResult integer(kind(rocblas_datatype_f16_r)),value :: result_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_dot_batched_ex_64 function rocblas_dot_batched_ex_64_(handle,n,x,x_type,incx,y,y_type,incy,batch_count,myResult, & result_type,execution_type) & bind(c, name="rocblas_dot_batched_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dot_batched_ex_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult integer(kind(rocblas_datatype_f16_r)),value :: result_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_dotc_batched_ex_64 function rocblas_dotc_batched_ex_64_(handle,n,x,x_type,incx,y,y_type,incy,batch_count, & myResult,result_type,execution_type) & bind(c, name="rocblas_dotc_batched_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dotc_batched_ex_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int64_t),value :: incy integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult integer(kind(rocblas_datatype_f16_r)),value :: result_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface !> \brief BLAS EX API !> !> \details !> The dot_strided_batched_ex functions perform a batch of dot products of vectors x and y: !> !> result_i = x_i * y_i; !> !> where (``x_i``, ``y_i``) is the ``i``-th instance of the batch. !> ``x_i`` and ``y_i`` are vectors, for ``i`` = 1, ...,`` batch_count``. !> !> Currently supported datatypes are as follows: !> !> -------------------------------------------------- !> | x_type | y_type | result_type | execution_type | !> |--------|--------|-------------|----------------| !> | f16_r | f16_r | f16_r | f16_r | !> | f16_r | f16_r | f16_r | f32_r | !> | bf16_r | bf16_r | bf16_r | f32_r | !> | f32_r | f32_r | f32_r | f32_r | !> | f32_r | f32_r | f64_r | f64_r | !> | f64_r | f64_r | f64_r | f64_r | !> | f32_c | f32_c | f32_c | f32_c | !> | f64_c | f64_c | f64_c | f64_c | !> -------------------------------------------------- !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in each x_i and y_i. !> @param[in] x - device pointer to the first vector (x_1) in the batch. !> @param[in] x_type - [rocblas_datatype] !> specifies the datatype of each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] stride_x - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[in] y - device pointer to the first vector (y_1) in the batch. !> @param[in] y_type - [rocblas_datatype] !> specifies the datatype of each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each y_i. !> @param[in] stride_y - [rocblas_stride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. !> @param[in, out] myResult !> device array or host array of batch_count size to store the dot products of each !> batch. !> Returns 0.0 for each element if n <= 0. !> @param[in] result_type - [rocblas_datatype] !> specifies the datatype of the result. !> @param[in] execution_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_dot_strided_batched_ex function rocblas_dot_strided_batched_ex_(handle,n,x,x_type,incx,stride_x,y,y_type,incy, & stride_y,batch_count,myResult,result_type,execution_type) & bind(c, name="rocblas_dot_strided_batched_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dot_strided_batched_ex_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int),value :: incy integer(c_int64_t),value :: stride_y integer(c_int),value :: batch_count type(c_ptr),value :: myResult integer(kind(rocblas_datatype_f16_r)),value :: result_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_dot_strided_batched_ex_64 function rocblas_dot_strided_batched_ex_64_(handle,n,x,x_type,incx,stride_x,y,y_type,incy, & stride_y,batch_count,myResult,result_type,execution_type) & bind(c, name="rocblas_dot_strided_batched_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dot_strided_batched_ex_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult integer(kind(rocblas_datatype_f16_r)),value :: result_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface !> \brief BLAS EX API !> !> \details !> The dotc_strided_batched_ex functions perform a batch of dot products of the conjugate of !> complex vector x and complex vector y: !> !> result_i = conjugate (x_i) * y_i; !> !> where (``x_i``, ``y_i``) is the ``i``-th instance of the batch. !> ``x_i`` and ``y_i`` are vectors, for ``i`` = 1, ..., ``batch_count``. !> !> Currently supported datatypes are as follows: !> !> -------------------------------------------------- !> | x_type | y_type | result_type | execution_type | !> |--------|--------|-------------|----------------| !> | f16_r | f16_r | f16_r | f16_r | !> | f16_r | f16_r | f16_r | f32_r | !> | bf16_r | bf16_r | bf16_r | f32_r | !> | f32_r | f32_r | f32_r | f32_r | !> | f32_r | f32_r | f64_r | f64_r | !> | f64_r | f64_r | f64_r | f64_r | !> | f32_c | f32_c | f32_c | f32_c | !> | f64_c | f64_c | f64_c | f64_c | !> -------------------------------------------------- !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in each x_i and y_i. !> @param[in] x - device pointer to the first vector (x_1) in the batch. !> @param[in] x_type - [rocblas_datatype] !> specifies the datatype of each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] stride_x - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> @param[in] y - device pointer to the first vector (y_1) in the batch. !> @param[in] y_type - [rocblas_datatype] !> specifies the datatype of each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment for the elements of each y_i. !> @param[in] stride_y - [rocblas_stride] !> stride from the start of one vector (y_i) to the next one (y_i+1). !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. !> @param[in, out] myResult !> device array or host array of batch_count size to store the dot products of each !> batch. !> Returns 0.0 for each element if n <= 0. !> @param[in] result_type - [rocblas_datatype] !> specifies the datatype of the result. !> @param[in] execution_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_dotc_strided_batched_ex function rocblas_dotc_strided_batched_ex_(handle,n,x,x_type,incx,stride_x,y,y_type,incy, & stride_y,batch_count,myResult,result_type,execution_type) & bind(c, name="rocblas_dotc_strided_batched_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dotc_strided_batched_ex_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int),value :: incy integer(c_int64_t),value :: stride_y integer(c_int),value :: batch_count type(c_ptr),value :: myResult integer(kind(rocblas_datatype_f16_r)),value :: result_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_dotc_strided_batched_ex_64 function rocblas_dotc_strided_batched_ex_64_(handle,n,x,x_type,incx,stride_x,y,y_type,incy, & stride_y,batch_count,myResult,result_type,execution_type) & bind(c, name="rocblas_dotc_strided_batched_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dotc_strided_batched_ex_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y integer(c_int64_t),value :: batch_count type(c_ptr),value :: myResult integer(kind(rocblas_datatype_f16_r)),value :: result_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface !> \brief BLAS_EX API !> !> \details !> nrm2_ex computes the euclidean norm of a real or complex vector. !> !> result := sqrt( x'*x ) for real vectors !> result := sqrt( x**H*x ) for complex vectors !> !> Currently supported datatypes are as follows: !> !> ------------------------------------- !> | x_type | result | execution_type | !> |---------|--------|----------------| !> | bf16_r | bf16_r| f32_r | !> | f16_r | f16_r | f32_r | !> | f32_r | f32_r | f32_r | !> | f64_r | f64_r | f64_r | !> | f32_c | f32_r | f32_r | !> | f64_c | f64_r | f64_r | !> ------------------------------------- !> !> @param[in] handle - [rocblas_handle] !> handle to the rocblas library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in x. !> @param[in] x - device pointer storing vector x. !> @param[in] x_type - [rocblas_datatype] !> specifies the datatype of the vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of y. !> @param[in, out] results !> device pointer or host pointer to store the nrm2 product. !> Return value is 0.0 if n, incx<=0. !> @param[in] result_type - [rocblas_datatype] !> specifies the datatype of the result. !> @param[in] execution_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_nrm2_ex function rocblas_nrm2_ex_(handle,n,x,x_type,incx,results,result_type,execution_type) & bind(c, name="rocblas_nrm2_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_nrm2_ex_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int),value :: incx type(c_ptr),value :: results integer(kind(rocblas_datatype_f16_r)),value :: result_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_nrm2_ex_64 function rocblas_nrm2_ex_64_(handle,n,x,x_type,incx,results,result_type,execution_type) & bind(c, name="rocblas_nrm2_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_nrm2_ex_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int64_t),value :: incx type(c_ptr),value :: results integer(kind(rocblas_datatype_f16_r)),value :: result_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface !> \brief BLAS_EX API !> !> \details !> nrm2_batched_ex computes the euclidean norm over a batch of real or complex vectors. !> !> result := sqrt( x_i'*x_i ) for real vectors x, for i = 1, ..., batch_count !> result := sqrt( x_i**H*x_i ) for complex vectors x, for i = 1, ..., batch_count !> !> Currently supported datatypes are as follows: !> !> ------------------------------------- !> | x_type | result | execution_type | !> |---------|--------|----------------| !> | bf16_r | bf16_r| f32_r | !> | f16_r | f16_r | f32_r | !> | f32_r | f32_r | f32_r | !> | f64_r | f64_r | f64_r | !> | f32_c | f32_r | f32_r | !> | f64_c | f64_r | f64_r | !> ------------------------------------- !> !> @param[in] handle - [rocblas_handle] !> handle to the rocblas library context queue. !> @param[in] n - [rocblas_int] !> number of elements in each x_i. !> @param[in] x - device array of device pointers storing each vector x_i. !> @param[in] x_type - [rocblas_datatype] !> specifies the datatype of each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. !> @param[out] results !> device pointer or host pointer to array of batch_count size for nrm2 results. !> Return value is 0.0 for each element if n <= 0, incx<=0. !> @param[in] result_type - [rocblas_datatype] !> specifies the datatype of the result. !> @param[in] execution_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_nrm2_batched_ex function rocblas_nrm2_batched_ex_(handle,n,x,x_type,incx,batch_count,results,result_type, & execution_type) & bind(c, name="rocblas_nrm2_batched_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_nrm2_batched_ex_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int),value :: incx integer(c_int),value :: batch_count type(c_ptr),value :: results integer(kind(rocblas_datatype_f16_r)),value :: result_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_nrm2_batched_ex_64 function rocblas_nrm2_batched_ex_64_(handle,n,x,x_type,incx,batch_count,results,result_type, & execution_type) & bind(c, name="rocblas_nrm2_batched_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_nrm2_batched_ex_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count type(c_ptr),value :: results integer(kind(rocblas_datatype_f16_r)),value :: result_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface !> \brief BLAS_EX API !> !> \details !> The nrm2_strided_batched_ex functions compute the Euclidean norm over a batch of real or !> complex vectors. !> !> result := sqrt( x_i'*x_i ) for real vectors x, for i = 1, ..., batch_count !> result := sqrt( x_i**H*x_i ) for complex vectors, for i = 1, ..., batch_count !> !> Currently supported datatypes are as follows: !> !> ------------------------------------- !> | x_type | result | execution_type | !> |---------|--------|----------------| !> | bf16_r | bf16_r| f32_r | !> | f16_r | f16_r | f32_r | !> | f32_r | f32_r | f32_r | !> | f64_r | f64_r | f64_r | !> | f32_c | f32_r | f32_r | !> | f64_c | f64_r | f64_r | !> ------------------------------------- !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> number of elements in each x_i. !> @param[in] x - device pointer to the first vector x_1. !> @param[in] x_type - [rocblas_datatype] !> specifies the datatype of each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. incx must be > 0. !> @param[in] stride_x - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stride_x. However, ensure that stride_x is of !> an appropriate size. For a typical !> case, this means stride_x >= n * incx. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. !> @param[out] results !> device pointer or host pointer to array for storing contiguous batch_count !> results. !> Returns 0.0 for each element if n <= 0, incx<=0. !> @param[in] result_type - [rocblas_datatype] !> specifies the datatype of the result. !> @param[in] execution_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_nrm2_strided_batched_ex function rocblas_nrm2_strided_batched_ex_(handle,n,x,x_type,incx,stride_x,batch_count,results, & result_type,execution_type) & bind(c, name="rocblas_nrm2_strided_batched_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_nrm2_strided_batched_ex_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int),value :: incx integer(c_int64_t),value :: stride_x integer(c_int),value :: batch_count type(c_ptr),value :: results integer(kind(rocblas_datatype_f16_r)),value :: result_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_nrm2_strided_batched_ex_64 function rocblas_nrm2_strided_batched_ex_64_(handle,n,x,x_type,incx,stride_x,batch_count, & results,result_type,execution_type) & bind(c, name="rocblas_nrm2_strided_batched_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_nrm2_strided_batched_ex_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x integer(c_int64_t),value :: batch_count type(c_ptr),value :: results integer(kind(rocblas_datatype_f16_r)),value :: result_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface !> \brief BLAS EX API !> !> \details !> rot_ex applies the Givens rotation matrix defined by c=cos(alpha) and s=sin(alpha) to !> vectors x and y. !> Scalars c and s may be stored in either host or device memory. Location is specified by !> calling rocblas_set_pointer_mode. !> !> In the case where cs_type is real: !> !> x := c * x + s * y !> y := c * y - s * x !> !> In the case where cs_type is complex, the imaginary part of c is ignored: !> !> x := real(c) * x + s * y !> y := real(c) * y - conj(s) * x !> !> Currently supported datatypes are as follows: !> !> ------------------------------------------------ !> | x_type | y_type | cs_type | execution_type | !> |---------|---------|---------|----------------| !> | bf16_r | bf16_r | bf16_r | f32_r | !> | f16_r | f16_r | f16_r | f32_r | !> | f32_r | f32_r | f32_r | f32_r | !> | f64_r | f64_r | f64_r | f64_r | !> | f32_c | f32_c | f32_c | f32_c | !> | f32_c | f32_c | f32_r | f32_c | !> | f64_c | f64_c | f64_c | f64_c | !> | f64_c | f64_c | f64_r | f64_c | !> ------------------------------------------------ !> !> @param[in] handle - [rocblas_handle] !> handle to the rocblas library context queue. !> @param[in] n - [rocblas_int] !> number of elements in the x and y vectors. !> @param[in, out] x - device pointer storing vector x. !> @param[in] x_type - [rocblas_datatype] !> specifies the datatype of vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment between elements of x. !> @param[in, out] y - device pointer storing vector y. !> @param[in] y_type - [rocblas_datatype] !> specifies the datatype of vector y. !> @param[in] incy - [rocblas_int] !> specifies the increment between elements of y. !> @param[in] c - device pointer or host pointer storing scalar cosine component of the !> rotation matrix. !> @param[in] s - device pointer or host pointer storing scalar sine component of the rotation !> matrix. !> @param[in] cs_type - [rocblas_datatype] !> specifies the datatype of c and s. !> @param[in] execution_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_rot_ex function rocblas_rot_ex_(handle,n,x,x_type,incx,y,y_type,incy,c,s,cs_type,execution_type) & bind(c, name="rocblas_rot_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_rot_ex_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int),value :: incx type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(kind(rocblas_datatype_f16_r)),value :: cs_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_rot_ex_64 function rocblas_rot_ex_64_(handle,n,x,x_type,incx,y,y_type,incy,c,s,cs_type,execution_type) & bind(c, name="rocblas_rot_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_rot_ex_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int64_t),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(kind(rocblas_datatype_f16_r)),value :: cs_type integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface !> \brief BLAS EX API !> !> \details !> rot_batched_ex applies the Givens rotation matrix defined by c=cos(alpha) and s=sin(alpha) !> to batched vectors x_i and y_i, for i = 1, ..., batch_count. !> Scalars c and s may be stored in either host or device memory. Location is specified by !> calling rocblas_set_pointer_mode. !> !> In the case where cs_type is real: !> !> x := c * x + s * y !> y := c * y - s * x !> !> In the case where cs_type is complex, the imaginary part of c is ignored: !> !> x := real(c) * x + s * y !> y := real(c) * y - conj(s) * x !> !> Currently supported datatypes are as follows: !> !> ------------------------------------------------ !> | x_type | y_type | cs_type | execution_type | !> |---------|---------|---------|----------------| !> | bf16_r | bf16_r | bf16_r | f32_r | !> | f16_r | f16_r | f16_r | f32_r | !> | f32_r | f32_r | f32_r | f32_r | !> | f64_r | f64_r | f64_r | f64_r | !> | f32_c | f32_c | f32_c | f32_c | !> | f32_c | f32_c | f32_r | f32_c | !> | f64_c | f64_c | f64_c | f64_c | !> | f64_c | f64_c | f64_r | f64_c | !> ------------------------------------------------ !> !> @param[in] handle - [rocblas_handle] !> handle to the rocblas library context queue. !> @param[in] n - [rocblas_int] !> number of elements in each x_i and y_i vectors. !> @param[in, out] x - device array of deivce pointers storing each vector x_i. !> @param[in] x_type - [rocblas_datatype] !> specifies the datatype of each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment between elements of each x_i. !> @param[in, out] y - device array of device pointers storing each vector y_i. !> @param[in] y_type - [rocblas_datatype] !> specifies the datatype of each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment between elements of each y_i. !> @param[in] c - device pointer or host pointer to scalar cosine component of the rotation !> matrix. !> @param[in] s - device pointer or host pointer to scalar sine component of the rotation !> matrix. !> @param[in] cs_type - [rocblas_datatype] !> specifies the datatype of c and s. !> @param[in] batch_count - [rocblas_int] !> the number of x and y arrays, the number of batches. !> @param[in] execution_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_rot_batched_ex function rocblas_rot_batched_ex_(handle,n,x,x_type,incx,y,y_type,incy,c,s,cs_type,batch_count, & execution_type) & bind(c, name="rocblas_rot_batched_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_rot_batched_ex_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int),value :: incx type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(kind(rocblas_datatype_f16_r)),value :: cs_type integer(c_int),value :: batch_count integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_rot_batched_ex_64 function rocblas_rot_batched_ex_64_(handle,n,x,x_type,incx,y,y_type,incy,c,s,cs_type, & batch_count,execution_type) & bind(c, name="rocblas_rot_batched_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_rot_batched_ex_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int64_t),value :: incx type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int64_t),value :: incy type(c_ptr),value :: c type(c_ptr),value :: s integer(kind(rocblas_datatype_f16_r)),value :: cs_type integer(c_int64_t),value :: batch_count integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface !> \brief BLAS Level 1 API !> !> \details !> The rot_strided_batched_ex functions apply the Givens rotation matrix defined by !> ``c=cos(alpha)`` and ``s=sin(alpha)`` !> to strided batched vectors ``x_i`` and ``y_i``, for ``i`` = 1, ..., ``batch_count``. !> Scalars ``c`` and ``s`` can be stored in either host or device memory. The location is !> specified by calling ``rocblas_set_pointer_mode``. !> !> In the case where ``cs_type`` is real: !> !> x := c * x + s * y !> y := c * y - s * x !> !> In the case where ``cs_type`` is complex, the imaginary part of ``c`` is ignored: !> !> x := real(c) * x + s * y !> y := real(c) * y - conj(s) * x !> !> Currently supported datatypes are as follows: !> !> ------------------------------------------------ !> | x_type | y_type | cs_type | execution_type | !> |---------|---------|---------|----------------| !> | bf16_r | bf16_r | bf16_r | f32_r | !> | f16_r | f16_r | f16_r | f32_r | !> | f32_r | f32_r | f32_r | f32_r | !> | f64_r | f64_r | f64_r | f64_r | !> | f32_c | f32_c | f32_c | f32_c | !> | f32_c | f32_c | f32_r | f32_c | !> | f64_c | f64_c | f64_c | f64_c | !> | f64_c | f64_c | f64_r | f64_c | !> ------------------------------------------------ !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> number of elements in each of the x_i and y_i vectors. !> @param[in, out] x - device pointer to the first vector x_1. !> @param[in] x_type - [rocblas_datatype] !> specifies the datatype of each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment between elements of each x_i. !> @param[in] stride_x - [rocblas_stride] !> specifies the increment from the beginning of x_i to the beginning of x_(i+1). !> @param[in, out] y - device pointer to the first vector y_1. !> @param[in] y_type - [rocblas_datatype] !> specifies the datatype of each vector y_i. !> @param[in] incy - [rocblas_int] !> specifies the increment between elements of each y_i. !> @param[in] stride_y - [rocblas_stride] !> specifies the increment from the beginning of y_i to the beginning of y_(i+1). !> @param[in] c - device pointer or host pointer to scalar cosine component of the rotation !> matrix. !> @param[in] s - device pointer or host pointer to scalar sine component of the rotation !> matrix. !> @param[in] cs_type - [rocblas_datatype] !> specifies the datatype of c and s. !> @param[in] batch_count - [rocblas_int] !> the number of x and y arrays, the number of batches. !> @param[in] execution_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_rot_strided_batched_ex function rocblas_rot_strided_batched_ex_(handle,n,x,x_type,incx,stride_x,y,y_type,incy, & stride_y,c,s,cs_type,batch_count,execution_type) & bind(c, name="rocblas_rot_strided_batched_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_rot_strided_batched_ex_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int),value :: incy integer(c_int64_t),value :: stride_y type(c_ptr),value :: c type(c_ptr),value :: s integer(kind(rocblas_datatype_f16_r)),value :: cs_type integer(c_int),value :: batch_count integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_rot_strided_batched_ex_64 function rocblas_rot_strided_batched_ex_64_(handle,n,x,x_type,incx,stride_x,y,y_type,incy, & stride_y,c,s,cs_type,batch_count,execution_type) & bind(c, name="rocblas_rot_strided_batched_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_rot_strided_batched_ex_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int64_t),value :: incx integer(c_int64_t),value :: stride_x type(c_ptr),value :: y integer(kind(rocblas_datatype_f16_r)),value :: y_type integer(c_int64_t),value :: incy integer(c_int64_t),value :: stride_y type(c_ptr),value :: c type(c_ptr),value :: s integer(kind(rocblas_datatype_f16_r)),value :: cs_type integer(c_int64_t),value :: batch_count integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface !> \brief BLAS EX API !> !> \details !> scal_ex scales each element of vector x with scalar alpha. !> !> x := alpha * x !> !> Currently supported datatypes are as follows: !> !> ---------------------------------------- !> | alpha_type | x_type | execution_type | !> |------------|--------|----------------| !> | f32_r | bf16_r | f32_r | !> | bf16_r | bf16_r | f32_r | !> | f16_r | f16_r | f16_r | !> | f16_r | f16_r | f32_r | !> | f32_r | f16_r | f32_r | !> | f32_r | f32_r | f32_r | !> | f64_r | f64_r | f64_r | !> | f32_c | f32_c | f32_c | !> | f64_c | f64_c | f64_c | !> | f32_r | f32_c | f32_c | !> | f64_r | f64_c | f64_c | !> ---------------------------------------- !> !> @param[in] handle - [rocblas_handle] !> handle to the rocblas library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in x. !> @param[in] alpha - device pointer or host pointer for the scalar alpha. !> @param[in] alpha_type - [rocblas_datatype] !> specifies the datatype of alpha. !> @param[in, out] x - device pointer storing vector x. !> @param[in] x_type - [rocblas_datatype] !> specifies the datatype of vector x. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of x. !> @param[in] execution_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_scal_ex function rocblas_scal_ex_(handle,n,alpha,alpha_type,x,x_type,incx,execution_type) & bind(c, name="rocblas_scal_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scal_ex_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: alpha integer(kind(rocblas_datatype_f16_r)),value :: alpha_type type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int),value :: incx integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_scal_ex_64 function rocblas_scal_ex_64_(handle,n,alpha,alpha_type,x,x_type,incx,execution_type) & bind(c, name="rocblas_scal_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scal_ex_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: alpha integer(kind(rocblas_datatype_f16_r)),value :: alpha_type type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int64_t),value :: incx integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface !> \brief BLAS EX API !> !> \details !> scal_batched_ex scales each element of each vector x_i with scalar alpha. !> !> x_i := alpha * x_i !> !> Currently supported datatypes are as follows: !> !> ---------------------------------------- !> | alpha_type | x_type | execution_type | !> |------------|--------|----------------| !> | f32_r | bf16_r | f32_r | !> | bf16_r | bf16_r | f32_r | !> | f16_r | f16_r | f16_r | !> | f16_r | f16_r | f32_r | !> | f32_r | f16_r | f32_r | !> | f32_r | f32_r | f32_r | !> | f64_r | f64_r | f64_r | !> | f32_c | f32_c | f32_c | !> | f64_c | f64_c | f64_c | !> | f32_r | f32_c | f32_c | !> | f64_r | f64_c | f64_c | !> ---------------------------------------- !> !> @param[in] handle - [rocblas_handle] !> handle to the rocblas library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in x. !> @param[in] alpha - device pointer or host pointer for the scalar alpha. !> @param[in] alpha_type - [rocblas_datatype] !> specifies the datatype of alpha. !> @param[in, out] x - device array of device pointers storing each vector x_i. !> @param[in] x_type - [rocblas_datatype] !> specifies the datatype of each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. !> @param[in] execution_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_scal_batched_ex function rocblas_scal_batched_ex_(handle,n,alpha,alpha_type,x,x_type,incx,batch_count, & execution_type) & bind(c, name="rocblas_scal_batched_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scal_batched_ex_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: alpha integer(kind(rocblas_datatype_f16_r)),value :: alpha_type type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int),value :: incx integer(c_int),value :: batch_count integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_scal_batched_ex_64 function rocblas_scal_batched_ex_64_(handle,n,alpha,alpha_type,x,x_type,incx,batch_count, & execution_type) & bind(c, name="rocblas_scal_batched_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scal_batched_ex_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: alpha integer(kind(rocblas_datatype_f16_r)),value :: alpha_type type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int64_t),value :: incx integer(c_int64_t),value :: batch_count integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface !> \brief BLAS EX API !> !> \details !> The scal_strided_batched_ex functions scale each element of vector ``x`` with scalar !> ``alpha`` over a set !> of strided batched vectors. !> !> x := alpha * x !> !> Currently supported datatypes are as follows: !> !> ---------------------------------------- !> | alpha_type | x_type | execution_type | !> |------------|--------|----------------| !> | f32_r | bf16_r | f32_r | !> | bf16_r | bf16_r | f32_r | !> | f16_r | f16_r | f16_r | !> | f16_r | f16_r | f32_r | !> | f32_r | f16_r | f32_r | !> | f32_r | f32_r | f32_r | !> | f64_r | f64_r | f64_r | !> | f32_c | f32_c | f32_c | !> | f64_c | f64_c | f64_c | !> | f32_r | f32_c | f32_c | !> | f64_r | f64_c | f64_c | !> ---------------------------------------- !> !> @param[in] handle - [rocblas_handle] !> handle to the rocBLAS library context queue. !> @param[in] n - [rocblas_int] !> the number of elements in x. !> @param[in] alpha - device pointer or host pointer for the scalar alpha. !> @param[in] alpha_type - [rocblas_datatype] !> specifies the datatype of alpha. !> @param[in, out] x - device pointer to the first vector x_1. !> @param[in] x_type - [rocblas_datatype] !> specifies the datatype of each vector x_i. !> @param[in] incx - [rocblas_int] !> specifies the increment for the elements of each x_i. !> @param[in] stridex - [rocblas_stride] !> stride from the start of one vector (x_i) to the next one (x_i+1). !> There are no restrictions placed on stridex. However, ensure that stridex is of !> an appropriate size. For a typical !> case, this means stridex >= n * incx. !> @param[in] batch_count - [rocblas_int] !> number of instances in the batch. !> @param[in] execution_type - [rocblas_datatype] !> specifies the datatype of computation. interface rocblas_scal_strided_batched_ex function rocblas_scal_strided_batched_ex_(handle,n,alpha,alpha_type,x,x_type,incx,stridex, & batch_count,execution_type) & bind(c, name="rocblas_scal_strided_batched_ex") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scal_strided_batched_ex_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: alpha integer(kind(rocblas_datatype_f16_r)),value :: alpha_type type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int),value :: incx integer(c_int64_t),value :: stridex integer(c_int),value :: batch_count integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface interface rocblas_scal_strided_batched_ex_64 function rocblas_scal_strided_batched_ex_64_(handle,n,alpha,alpha_type,x,x_type,incx,stridex, & batch_count,execution_type) & bind(c, name="rocblas_scal_strided_batched_ex_64") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scal_strided_batched_ex_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: alpha integer(kind(rocblas_datatype_f16_r)),value :: alpha_type type(c_ptr),value :: x integer(kind(rocblas_datatype_f16_r)),value :: x_type integer(c_int64_t),value :: incx integer(c_int64_t),value :: stridex integer(c_int64_t),value :: batch_count integer(kind(rocblas_datatype_f16_r)),value :: execution_type end function end interface !> \details !> Returns a string representing the ``rocblas_status`` value. !> !> @param[in] status - [rocblas_status] !> rocBLAS status to convert to string interface rocblas_status_to_string function rocblas_status_to_string_(status) bind(c, name="rocblas_status_to_string") use iso_c_binding use hipfort_rocblas_enums implicit none type(c_ptr) :: rocblas_status_to_string_ integer(kind(rocblas_status_success)),value :: status end function end interface !> \brief Initialize rocBLAS on the current HIP device to avoid costly startup time for the first !> call on that device. !> \details !> !> Calling `rocblas_initialize()` allows upfront initialization, including device-specific !> kernel setup. !> Otherwise, this function is automatically called on the first function call that requires !> these initializations (mainly GEMM). interface rocblas_initialize subroutine rocblas_initialize_() bind(c, name="rocblas_initialize") use iso_c_binding use hipfort_rocblas_enums implicit none end subroutine end interface !> \brief Loads ``char* buf`` with the rocBLAS library version. ``size_t len`` !> is the maximum length of the ``char* buf``. !> \details !> !> @param[in, out] buf - pointer to buffer for version string !> !> @param[in] len - length of buf interface rocblas_get_version_string function rocblas_get_version_string_(buf,len) bind(c, name="rocblas_get_version_string") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_get_version_string_ type(c_ptr),value :: buf integer(c_size_t),value :: len end function end interface !> \brief Queries the minimum buffer size for a successful call to !> `rocblas_get_version_string` !> \details !> !> @param[out] len - pointer to size_t for storing the length interface rocblas_get_version_string_size function rocblas_get_version_string_size_(len) bind(c, name="rocblas_get_version_string_size") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_get_version_string_size_ integer(c_size_t) :: len end function end interface !> \brief Loads char* buf with the rocblas library commit hash. size_t len !> is the maximum length of char* buf. !> \details !> !> @param[in, out] buf - pointer to buffer for version string !> !> @param[in] len - length of buf interface rocblas_get_commit_hash_string function rocblas_get_commit_hash_string_(buf,len) bind(c, name="rocblas_get_commit_hash_string") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_get_commit_hash_string_ type(c_ptr),value :: buf integer(c_size_t),value :: len end function end interface !> \brief Queries the minimum buffer size for a successful call to !> `rocblas_get_commit_hash_string` !> \details !> !> @param[out] len - pointer to size_t for storing the length interface rocblas_get_commit_hash_string_size function rocblas_get_commit_hash_string_size_(len) & bind(c, name="rocblas_get_commit_hash_string_size") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_get_commit_hash_string_size_ integer(c_size_t) :: len end function end interface !> \brief !> \details !> Indicates that subsequent rocBLAS kernel calls should start collecting the optimal device !> memory size in bytes for their given kernel arguments !> and keeping track of the maximum. !> Each kernel call can reuse temporary device memory on the same stream so the maximum is !> collected. !> Returns ``rocblas_status_size_query_mismatch`` if another size query is already in !> progress. Returns ``rocblas_status_success`` otherwise. !> @param[in] handle - rocblas handle interface rocblas_start_device_memory_size_query function rocblas_start_device_memory_size_query_(handle) & bind(c, name="rocblas_start_device_memory_size_query") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_start_device_memory_size_query_ type(c_ptr),value :: handle end function end interface !> \brief !> \details !> Stops collecting the optimal device memory size information. !> Returns ``rocblas_status_size_query_mismatch`` if a collection is not underway, !> ``rocblas_status_invalid_handle`` if ``handle`` is nullptr, !> and ``rocblas_status_invalid_pointer`` if ``size`` is nullptr. Returns !> ``rocblas_status_success`` otherwise. !> @param[in] handle - rocblas handle !> @param[out] mySize - maximum of the optimal sizes collected interface rocblas_stop_device_memory_size_query function rocblas_stop_device_memory_size_query_(handle,mySize) & bind(c, name="rocblas_stop_device_memory_size_query") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stop_device_memory_size_query_ type(c_ptr),value :: handle integer(c_size_t) :: mySize end function end interface interface rocblas_is_device_memory_size_query function rocblas_is_device_memory_size_query_(handle) & bind(c, name="rocblas_is_device_memory_size_query") use iso_c_binding use hipfort_rocblas_enums implicit none logical(c_bool) :: rocblas_is_device_memory_size_query_ type(c_ptr),value :: handle end function end interface interface rocblas_set_optimal_device_memory_size_impl function rocblas_set_optimal_device_memory_size_impl_(handle,count) & bind(c, name="rocblas_set_optimal_device_memory_size_impl") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_set_optimal_device_memory_size_impl_ type(c_ptr),value :: handle integer(c_size_t),value :: count end function end interface interface rocblas_device_malloc_alloc function rocblas_device_malloc_alloc_(handle,res,count) & bind(c, name="rocblas_device_malloc_alloc") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_device_malloc_alloc_ type(c_ptr),value :: handle type(c_ptr) :: res integer(c_size_t),value :: count end function end interface interface rocblas_device_malloc_success function rocblas_device_malloc_success_(ptr) bind(c, name="rocblas_device_malloc_success") use iso_c_binding use hipfort_rocblas_enums implicit none logical(c_bool) :: rocblas_device_malloc_success_ type(c_ptr),value :: ptr end function end interface interface rocblas_device_malloc_ptr function rocblas_device_malloc_ptr_(ptr,res) bind(c, name="rocblas_device_malloc_ptr") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_device_malloc_ptr_ type(c_ptr),value :: ptr type(c_ptr) :: res end function end interface interface rocblas_device_malloc_get function rocblas_device_malloc_get_(ptr,index,res) bind(c, name="rocblas_device_malloc_get") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_device_malloc_get_ type(c_ptr),value :: ptr integer(c_size_t),value :: index type(c_ptr) :: res end function end interface interface rocblas_device_malloc_free function rocblas_device_malloc_free_(ptr) bind(c, name="rocblas_device_malloc_free") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_device_malloc_free_ type(c_ptr),value :: ptr end function end interface interface rocblas_device_malloc_set_default_memory_size subroutine rocblas_device_malloc_set_default_memory_size_(mySize) & bind(c, name="rocblas_device_malloc_set_default_memory_size") use iso_c_binding use hipfort_rocblas_enums implicit none integer(c_size_t),value :: mySize end subroutine end interface !> \brief !> \details !> Gets the current device memory size for the handle. !> Returns ``rocblas_status_invalid_handle`` if ``handle`` is nullptr, !> ``rocblas_status_invalid_pointer`` if ``size`` is nullptr, and ``rocblas_status_success`` !> otherwise. !> @param[in] handle - rocblas handle !> @param[out] mySize - current device memory size for the handle interface rocblas_get_device_memory_size function rocblas_get_device_memory_size_(handle,mySize) & bind(c, name="rocblas_get_device_memory_size") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_get_device_memory_size_ type(c_ptr),value :: handle integer(c_size_t) :: mySize end function end interface !> \brief !> \details !> Changes the size of allocated device memory at runtime. !> !> Any previously allocated device memory managed by the handle is freed. !> !> If size > 0 sets the device memory size to the specified size (in bytes). !> If size == 0, frees the memory allocated so far, and lets rocBLAS manage device memory in !> the future, expanding it when necessary. !> Returns rocblas_status_invalid_handle if handle is nullptr; rocblas_status_invalid_pointer !> if size is nullptr; rocblas_status_success otherwise !> @param[in] handle - rocblas handle !> @param[in] mySize - size of allocated device memory interface rocblas_set_device_memory_size function rocblas_set_device_memory_size_(handle,mySize) & bind(c, name="rocblas_set_device_memory_size") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_set_device_memory_size_ type(c_ptr),value :: handle integer(c_size_t),value :: mySize end function end interface !> \brief !> \details !> Sets the device workspace for the handle to use. !> !> Any previously allocated device memory managed by the handle is freed. !> !> Returns ``rocblas_status_invalid_handle`` if ``handle`` is nullptr and !> ``rocblas_status_success`` otherwise. !> @param[in] handle - rocblas handle !> @param[in] addr - address of workspace memory !> @param[in] mySize - size of workspace memory interface rocblas_set_workspace function rocblas_set_workspace_(handle,addr,mySize) bind(c, name="rocblas_set_workspace") use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_set_workspace_ type(c_ptr),value :: handle type(c_ptr),value :: addr integer(c_size_t),value :: mySize end function end interface !> \brief !> \details !> Returns ``true`` when the device memory in ``handle`` is managed by rocBLAS. !> @param[in] handle - rocblas handle interface rocblas_is_managing_device_memory function rocblas_is_managing_device_memory_(handle) & bind(c, name="rocblas_is_managing_device_memory") use iso_c_binding use hipfort_rocblas_enums implicit none logical(c_bool) :: rocblas_is_managing_device_memory_ type(c_ptr),value :: handle end function end interface !> \brief !> \details !> Returns true when device memory in ``handle`` is managed by the user. !> @param[in] handle - rocblas handle interface rocblas_is_user_managing_device_memory function rocblas_is_user_managing_device_memory_(handle) & bind(c, name="rocblas_is_user_managing_device_memory") use iso_c_binding use hipfort_rocblas_enums implicit none logical(c_bool) :: rocblas_is_user_managing_device_memory_ type(c_ptr),value :: handle end function end interface interface rocblas_abort subroutine rocblas_abort_() bind(c, name="rocblas_abort") use iso_c_binding use hipfort_rocblas_enums implicit none end subroutine end interface interface rocblas_set_vector function rocblas_set_vector_(n,elem_size,x,incx,y,incy) bind(c, name="rocblas_set_vector") result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_int),value :: elem_size type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_set_vector_l_assumed_rank,rocblas_set_vector_i4_assumed_rank,& rocblas_set_vector_i8_assumed_rank,rocblas_set_vector_r4_assumed_rank,& rocblas_set_vector_r8_assumed_rank,rocblas_set_vector_c4_assumed_rank,& rocblas_set_vector_c8_assumed_rank #else module procedure rocblas_set_vector_l_rank_0,rocblas_set_vector_l_full_rank,& rocblas_set_vector_i4_rank_0,rocblas_set_vector_i4_full_rank,& rocblas_set_vector_i8_rank_0,rocblas_set_vector_i8_full_rank,& rocblas_set_vector_r4_rank_0,rocblas_set_vector_r4_full_rank,& rocblas_set_vector_r8_rank_0,rocblas_set_vector_r8_full_rank,& rocblas_set_vector_c4_rank_0,rocblas_set_vector_c4_full_rank,& rocblas_set_vector_c8_rank_0,rocblas_set_vector_c8_full_rank #endif #endif end interface interface rocblas_get_vector function rocblas_get_vector_(n,elem_size,x,incx,y,incy) bind(c, name="rocblas_get_vector") result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_int),value :: elem_size type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_get_vector_l_assumed_rank,rocblas_get_vector_i4_assumed_rank,& rocblas_get_vector_i8_assumed_rank,rocblas_get_vector_r4_assumed_rank,& rocblas_get_vector_r8_assumed_rank,rocblas_get_vector_c4_assumed_rank,& rocblas_get_vector_c8_assumed_rank #else module procedure rocblas_get_vector_l_rank_0,rocblas_get_vector_l_full_rank,& rocblas_get_vector_i4_rank_0,rocblas_get_vector_i4_full_rank,& rocblas_get_vector_i8_rank_0,rocblas_get_vector_i8_full_rank,& rocblas_get_vector_r4_rank_0,rocblas_get_vector_r4_full_rank,& rocblas_get_vector_r8_rank_0,rocblas_get_vector_r8_full_rank,& rocblas_get_vector_c4_rank_0,rocblas_get_vector_c4_full_rank,& rocblas_get_vector_c8_rank_0,rocblas_get_vector_c8_full_rank #endif #endif end interface interface rocblas_set_matrix function rocblas_set_matrix_(rows,cols,elem_size,A,lda,B,ldb) bind(c, name="rocblas_set_matrix") result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),value :: elem_size type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_set_matrix_l_assumed_rank,rocblas_set_matrix_i4_assumed_rank,& rocblas_set_matrix_i8_assumed_rank,rocblas_set_matrix_r4_assumed_rank,& rocblas_set_matrix_r8_assumed_rank,rocblas_set_matrix_c4_assumed_rank,& rocblas_set_matrix_c8_assumed_rank #else module procedure rocblas_set_matrix_l_full_rank,rocblas_set_matrix_l_rank_0,rocblas_set_matrix_l_rank_1,& rocblas_set_matrix_i4_full_rank,rocblas_set_matrix_i4_rank_0,rocblas_set_matrix_i4_rank_1,& rocblas_set_matrix_i8_full_rank,rocblas_set_matrix_i8_rank_0,rocblas_set_matrix_i8_rank_1,& rocblas_set_matrix_r4_full_rank,rocblas_set_matrix_r4_rank_0,rocblas_set_matrix_r4_rank_1,& rocblas_set_matrix_r8_full_rank,rocblas_set_matrix_r8_rank_0,rocblas_set_matrix_r8_rank_1,& rocblas_set_matrix_c4_full_rank,rocblas_set_matrix_c4_rank_0,rocblas_set_matrix_c4_rank_1,& rocblas_set_matrix_c8_full_rank,rocblas_set_matrix_c8_rank_0,rocblas_set_matrix_c8_rank_1 #endif #endif end interface interface rocblas_get_matrix function rocblas_get_matrix_(rows,cols,elem_size,A,lda,B,ldb) bind(c, name="rocblas_get_matrix") result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),value :: elem_size type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_get_matrix_l_assumed_rank,rocblas_get_matrix_i4_assumed_rank,& rocblas_get_matrix_i8_assumed_rank,rocblas_get_matrix_r4_assumed_rank,& rocblas_get_matrix_r8_assumed_rank,rocblas_get_matrix_c4_assumed_rank,& rocblas_get_matrix_c8_assumed_rank #else module procedure rocblas_get_matrix_l_full_rank,rocblas_get_matrix_l_rank_0,rocblas_get_matrix_l_rank_1,& rocblas_get_matrix_i4_full_rank,rocblas_get_matrix_i4_rank_0,rocblas_get_matrix_i4_rank_1,& rocblas_get_matrix_i8_full_rank,rocblas_get_matrix_i8_rank_0,rocblas_get_matrix_i8_rank_1,& rocblas_get_matrix_r4_full_rank,rocblas_get_matrix_r4_rank_0,rocblas_get_matrix_r4_rank_1,& rocblas_get_matrix_r8_full_rank,rocblas_get_matrix_r8_rank_0,rocblas_get_matrix_r8_rank_1,& rocblas_get_matrix_c4_full_rank,rocblas_get_matrix_c4_rank_0,rocblas_get_matrix_c4_rank_1,& rocblas_get_matrix_c8_full_rank,rocblas_get_matrix_c8_rank_0,rocblas_get_matrix_c8_rank_1 #endif #endif end interface interface rocblas_set_vector_async function rocblas_set_vector_async_(n,elem_size,x,incx,y,incy,stream) bind(c, name="rocblas_set_vector_async") result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_int),value :: elem_size type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: stream end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_set_vector_async_l_assumed_rank,rocblas_set_vector_async_i4_assumed_rank,& rocblas_set_vector_async_i8_assumed_rank,rocblas_set_vector_async_r4_assumed_rank,& rocblas_set_vector_async_r8_assumed_rank,rocblas_set_vector_async_c4_assumed_rank,& rocblas_set_vector_async_c8_assumed_rank #else module procedure rocblas_set_vector_async_l_rank_0,rocblas_set_vector_async_l_full_rank,& rocblas_set_vector_async_i4_rank_0,rocblas_set_vector_async_i4_full_rank,& rocblas_set_vector_async_i8_rank_0,rocblas_set_vector_async_i8_full_rank,& rocblas_set_vector_async_r4_rank_0,rocblas_set_vector_async_r4_full_rank,& rocblas_set_vector_async_r8_rank_0,rocblas_set_vector_async_r8_full_rank,& rocblas_set_vector_async_c4_rank_0,rocblas_set_vector_async_c4_full_rank,& rocblas_set_vector_async_c8_rank_0,rocblas_set_vector_async_c8_full_rank #endif #endif end interface interface rocblas_get_vector_async function rocblas_get_vector_async_(n,elem_size,x,incx,y,incy,stream) bind(c, name="rocblas_get_vector_async") result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_int),value :: elem_size type(c_ptr),value :: x integer(c_int),value :: incx type(c_ptr),value :: y integer(c_int),value :: incy type(c_ptr),value :: stream end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_get_vector_async_l_assumed_rank,rocblas_get_vector_async_i4_assumed_rank,& rocblas_get_vector_async_i8_assumed_rank,rocblas_get_vector_async_r4_assumed_rank,& rocblas_get_vector_async_r8_assumed_rank,rocblas_get_vector_async_c4_assumed_rank,& rocblas_get_vector_async_c8_assumed_rank #else module procedure rocblas_get_vector_async_l_rank_0,rocblas_get_vector_async_l_full_rank,& rocblas_get_vector_async_i4_rank_0,rocblas_get_vector_async_i4_full_rank,& rocblas_get_vector_async_i8_rank_0,rocblas_get_vector_async_i8_full_rank,& rocblas_get_vector_async_r4_rank_0,rocblas_get_vector_async_r4_full_rank,& rocblas_get_vector_async_r8_rank_0,rocblas_get_vector_async_r8_full_rank,& rocblas_get_vector_async_c4_rank_0,rocblas_get_vector_async_c4_full_rank,& rocblas_get_vector_async_c8_rank_0,rocblas_get_vector_async_c8_full_rank #endif #endif end interface interface rocblas_set_matrix_async function rocblas_set_matrix_async_(rows,cols,elem_size,A,lda,B,ldb,stream) bind(c, name="rocblas_set_matrix_async") result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),value :: elem_size type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: stream end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_set_matrix_async_l_assumed_rank,rocblas_set_matrix_async_i4_assumed_rank,& rocblas_set_matrix_async_i8_assumed_rank,rocblas_set_matrix_async_r4_assumed_rank,& rocblas_set_matrix_async_r8_assumed_rank,rocblas_set_matrix_async_c4_assumed_rank,& rocblas_set_matrix_async_c8_assumed_rank #else module procedure rocblas_set_matrix_async_l_full_rank,rocblas_set_matrix_async_l_rank_0,rocblas_set_matrix_async_l_rank_1,& rocblas_set_matrix_async_i4_full_rank,rocblas_set_matrix_async_i4_rank_0,rocblas_set_matrix_async_i4_rank_1,& rocblas_set_matrix_async_i8_full_rank,rocblas_set_matrix_async_i8_rank_0,rocblas_set_matrix_async_i8_rank_1,& rocblas_set_matrix_async_r4_full_rank,rocblas_set_matrix_async_r4_rank_0,rocblas_set_matrix_async_r4_rank_1,& rocblas_set_matrix_async_r8_full_rank,rocblas_set_matrix_async_r8_rank_0,rocblas_set_matrix_async_r8_rank_1,& rocblas_set_matrix_async_c4_full_rank,rocblas_set_matrix_async_c4_rank_0,rocblas_set_matrix_async_c4_rank_1,& rocblas_set_matrix_async_c8_full_rank,rocblas_set_matrix_async_c8_rank_0,rocblas_set_matrix_async_c8_rank_1 #endif #endif end interface interface rocblas_get_matrix_async function rocblas_get_matrix_async_(rows,cols,elem_size,A,lda,B,ldb,stream) bind(c, name="rocblas_get_matrix_async") result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),value :: elem_size type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: stream end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocblas_get_matrix_async_l_assumed_rank,rocblas_get_matrix_async_i4_assumed_rank,& rocblas_get_matrix_async_i8_assumed_rank,rocblas_get_matrix_async_r4_assumed_rank,& rocblas_get_matrix_async_r8_assumed_rank,rocblas_get_matrix_async_c4_assumed_rank,& rocblas_get_matrix_async_c8_assumed_rank #else module procedure rocblas_get_matrix_async_l_full_rank,rocblas_get_matrix_async_l_rank_0,rocblas_get_matrix_async_l_rank_1,& rocblas_get_matrix_async_i4_full_rank,rocblas_get_matrix_async_i4_rank_0,rocblas_get_matrix_async_i4_rank_1,& rocblas_get_matrix_async_i8_full_rank,rocblas_get_matrix_async_i8_rank_0,rocblas_get_matrix_async_i8_rank_1,& rocblas_get_matrix_async_r4_full_rank,rocblas_get_matrix_async_r4_rank_0,rocblas_get_matrix_async_r4_rank_1,& rocblas_get_matrix_async_r8_full_rank,rocblas_get_matrix_async_r8_rank_0,rocblas_get_matrix_async_r8_rank_1,& rocblas_get_matrix_async_c4_full_rank,rocblas_get_matrix_async_c4_rank_0,rocblas_get_matrix_async_c4_rank_1,& rocblas_get_matrix_async_c8_full_rank,rocblas_get_matrix_async_c8_rank_0,rocblas_get_matrix_async_c8_rank_1 #endif #endif end interface #ifdef USE_FPOINTER_INTERFACES contains #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sscal_assumed_rank(handle,n,alpha,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sscal_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_sscal_assumed_rank = rocblas_sscal_(handle,n,alpha,c_loc(x),incx) end function #else function rocblas_sscal_rank_0(handle,n,alpha,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sscal_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx ! rocblas_sscal_rank_0 = rocblas_sscal_(handle,n,alpha,c_loc(x),incx) end function function rocblas_sscal_rank_1(handle,n,alpha,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sscal_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_sscal_rank_1 = rocblas_sscal_(handle,n,alpha,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dscal_assumed_rank(handle,n,alpha,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dscal_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_dscal_assumed_rank = rocblas_dscal_(handle,n,alpha,c_loc(x),incx) end function #else function rocblas_dscal_rank_0(handle,n,alpha,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dscal_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx ! rocblas_dscal_rank_0 = rocblas_dscal_(handle,n,alpha,c_loc(x),incx) end function function rocblas_dscal_rank_1(handle,n,alpha,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dscal_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_dscal_rank_1 = rocblas_dscal_(handle,n,alpha,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cscal_assumed_rank(handle,n,alpha,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cscal_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_cscal_assumed_rank = rocblas_cscal_(handle,n,alpha,c_loc(x),incx) end function #else function rocblas_cscal_rank_0(handle,n,alpha,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cscal_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx ! rocblas_cscal_rank_0 = rocblas_cscal_(handle,n,alpha,c_loc(x),incx) end function function rocblas_cscal_rank_1(handle,n,alpha,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cscal_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_cscal_rank_1 = rocblas_cscal_(handle,n,alpha,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zscal_assumed_rank(handle,n,alpha,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zscal_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_zscal_assumed_rank = rocblas_zscal_(handle,n,alpha,c_loc(x),incx) end function #else function rocblas_zscal_rank_0(handle,n,alpha,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zscal_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx ! rocblas_zscal_rank_0 = rocblas_zscal_(handle,n,alpha,c_loc(x),incx) end function function rocblas_zscal_rank_1(handle,n,alpha,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zscal_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_zscal_rank_1 = rocblas_zscal_(handle,n,alpha,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_csscal_assumed_rank(handle,n,alpha,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csscal_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_csscal_assumed_rank = rocblas_csscal_(handle,n,alpha,c_loc(x),incx) end function #else function rocblas_csscal_rank_0(handle,n,alpha,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csscal_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx ! rocblas_csscal_rank_0 = rocblas_csscal_(handle,n,alpha,c_loc(x),incx) end function function rocblas_csscal_rank_1(handle,n,alpha,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csscal_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_csscal_rank_1 = rocblas_csscal_(handle,n,alpha,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zdscal_assumed_rank(handle,n,alpha,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdscal_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_zdscal_assumed_rank = rocblas_zdscal_(handle,n,alpha,c_loc(x),incx) end function #else function rocblas_zdscal_rank_0(handle,n,alpha,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdscal_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx ! rocblas_zdscal_rank_0 = rocblas_zdscal_(handle,n,alpha,c_loc(x),incx) end function function rocblas_zdscal_rank_1(handle,n,alpha,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdscal_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_zdscal_rank_1 = rocblas_zdscal_(handle,n,alpha,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sscal_strided_batched_assumed_rank(handle,n,alpha,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sscal_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_sscal_strided_batched_assumed_rank = rocblas_sscal_strided_batched_(handle,n,alpha, & c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_sscal_strided_batched_rank_0(handle,n,alpha,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sscal_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_sscal_strided_batched_rank_0 = rocblas_sscal_strided_batched_(handle,n,alpha, & c_loc(x),incx,stride_x,batch_count) end function function rocblas_sscal_strided_batched_rank_1(handle,n,alpha,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sscal_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_sscal_strided_batched_rank_1 = rocblas_sscal_strided_batched_(handle,n,alpha, & c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dscal_strided_batched_assumed_rank(handle,n,alpha,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dscal_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dscal_strided_batched_assumed_rank = rocblas_dscal_strided_batched_(handle,n,alpha, & c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_dscal_strided_batched_rank_0(handle,n,alpha,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dscal_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dscal_strided_batched_rank_0 = rocblas_dscal_strided_batched_(handle,n,alpha, & c_loc(x),incx,stride_x,batch_count) end function function rocblas_dscal_strided_batched_rank_1(handle,n,alpha,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dscal_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dscal_strided_batched_rank_1 = rocblas_dscal_strided_batched_(handle,n,alpha, & c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cscal_strided_batched_assumed_rank(handle,n,alpha,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cscal_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_cscal_strided_batched_assumed_rank = rocblas_cscal_strided_batched_(handle,n,alpha, & c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_cscal_strided_batched_rank_0(handle,n,alpha,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cscal_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_cscal_strided_batched_rank_0 = rocblas_cscal_strided_batched_(handle,n,alpha, & c_loc(x),incx,stride_x,batch_count) end function function rocblas_cscal_strided_batched_rank_1(handle,n,alpha,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cscal_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_cscal_strided_batched_rank_1 = rocblas_cscal_strided_batched_(handle,n,alpha, & c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zscal_strided_batched_assumed_rank(handle,n,alpha,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zscal_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_zscal_strided_batched_assumed_rank = rocblas_zscal_strided_batched_(handle,n,alpha, & c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_zscal_strided_batched_rank_0(handle,n,alpha,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zscal_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_zscal_strided_batched_rank_0 = rocblas_zscal_strided_batched_(handle,n,alpha, & c_loc(x),incx,stride_x,batch_count) end function function rocblas_zscal_strided_batched_rank_1(handle,n,alpha,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zscal_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_zscal_strided_batched_rank_1 = rocblas_zscal_strided_batched_(handle,n,alpha, & c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_csscal_strided_batched_assumed_rank(handle,n,alpha,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csscal_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_csscal_strided_batched_assumed_rank = rocblas_csscal_strided_batched_(handle,n, & alpha,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_csscal_strided_batched_rank_0(handle,n,alpha,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csscal_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_csscal_strided_batched_rank_0 = rocblas_csscal_strided_batched_(handle,n,alpha, & c_loc(x),incx,stride_x,batch_count) end function function rocblas_csscal_strided_batched_rank_1(handle,n,alpha,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csscal_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_csscal_strided_batched_rank_1 = rocblas_csscal_strided_batched_(handle,n,alpha, & c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zdscal_strided_batched_assumed_rank(handle,n,alpha,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdscal_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_zdscal_strided_batched_assumed_rank = rocblas_zdscal_strided_batched_(handle,n, & alpha,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_zdscal_strided_batched_rank_0(handle,n,alpha,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdscal_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_zdscal_strided_batched_rank_0 = rocblas_zdscal_strided_batched_(handle,n,alpha, & c_loc(x),incx,stride_x,batch_count) end function function rocblas_zdscal_strided_batched_rank_1(handle,n,alpha,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdscal_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_zdscal_strided_batched_rank_1 = rocblas_zdscal_strided_batched_(handle,n,alpha, & c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_scopy_assumed_rank(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scopy_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_scopy_assumed_rank = rocblas_scopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #else function rocblas_scopy_rank_0(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scopy_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: y integer(c_int) :: incy ! rocblas_scopy_rank_0 = rocblas_scopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function function rocblas_scopy_rank_1(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scopy_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_scopy_rank_1 = rocblas_scopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dcopy_assumed_rank(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dcopy_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_dcopy_assumed_rank = rocblas_dcopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #else function rocblas_dcopy_rank_0(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dcopy_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: y integer(c_int) :: incy ! rocblas_dcopy_rank_0 = rocblas_dcopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function function rocblas_dcopy_rank_1(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dcopy_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_dcopy_rank_1 = rocblas_dcopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ccopy_assumed_rank(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ccopy_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_ccopy_assumed_rank = rocblas_ccopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #else function rocblas_ccopy_rank_0(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ccopy_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy ! rocblas_ccopy_rank_0 = rocblas_ccopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function function rocblas_ccopy_rank_1(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ccopy_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_ccopy_rank_1 = rocblas_ccopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zcopy_assumed_rank(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zcopy_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_zcopy_assumed_rank = rocblas_zcopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #else function rocblas_zcopy_rank_0(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zcopy_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy ! rocblas_zcopy_rank_0 = rocblas_zcopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function function rocblas_zcopy_rank_1(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zcopy_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_zcopy_rank_1 = rocblas_zcopy_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_scopy_strided_batched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scopy_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_scopy_strided_batched_assumed_rank = rocblas_scopy_strided_batched_(handle,n, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_scopy_strided_batched_rank_0(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scopy_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_scopy_strided_batched_rank_0 = rocblas_scopy_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count) end function function rocblas_scopy_strided_batched_rank_1(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scopy_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_scopy_strided_batched_rank_1 = rocblas_scopy_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dcopy_strided_batched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dcopy_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dcopy_strided_batched_assumed_rank = rocblas_dcopy_strided_batched_(handle,n, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_dcopy_strided_batched_rank_0(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dcopy_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dcopy_strided_batched_rank_0 = rocblas_dcopy_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count) end function function rocblas_dcopy_strided_batched_rank_1(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dcopy_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dcopy_strided_batched_rank_1 = rocblas_dcopy_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ccopy_strided_batched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ccopy_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_ccopy_strided_batched_assumed_rank = rocblas_ccopy_strided_batched_(handle,n, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_ccopy_strided_batched_rank_0(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ccopy_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_ccopy_strided_batched_rank_0 = rocblas_ccopy_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count) end function function rocblas_ccopy_strided_batched_rank_1(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ccopy_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_ccopy_strided_batched_rank_1 = rocblas_ccopy_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zcopy_strided_batched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zcopy_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_zcopy_strided_batched_assumed_rank = rocblas_zcopy_strided_batched_(handle,n, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_zcopy_strided_batched_rank_0(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zcopy_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_zcopy_strided_batched_rank_0 = rocblas_zcopy_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count) end function function rocblas_zcopy_strided_batched_rank_1(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zcopy_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_zcopy_strided_batched_rank_1 = rocblas_zcopy_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sdot_assumed_rank(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdot_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! rocblas_sdot_assumed_rank = rocblas_sdot_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #else function rocblas_sdot_rank_0(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdot_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: y integer(c_int) :: incy type(c_ptr) :: myResult ! rocblas_sdot_rank_0 = rocblas_sdot_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function function rocblas_sdot_rank_1(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdot_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! rocblas_sdot_rank_1 = rocblas_sdot_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ddot_assumed_rank(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddot_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! rocblas_ddot_assumed_rank = rocblas_ddot_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #else function rocblas_ddot_rank_0(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddot_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: y integer(c_int) :: incy type(c_ptr) :: myResult ! rocblas_ddot_rank_0 = rocblas_ddot_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function function rocblas_ddot_rank_1(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddot_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! rocblas_ddot_rank_1 = rocblas_ddot_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cdotu_assumed_rank(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotu_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! rocblas_cdotu_assumed_rank = rocblas_cdotu_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #else function rocblas_cdotu_rank_0(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotu_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy type(c_ptr) :: myResult ! rocblas_cdotu_rank_0 = rocblas_cdotu_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function function rocblas_cdotu_rank_1(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotu_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! rocblas_cdotu_rank_1 = rocblas_cdotu_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zdotu_assumed_rank(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotu_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! rocblas_zdotu_assumed_rank = rocblas_zdotu_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #else function rocblas_zdotu_rank_0(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotu_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy type(c_ptr) :: myResult ! rocblas_zdotu_rank_0 = rocblas_zdotu_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function function rocblas_zdotu_rank_1(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotu_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! rocblas_zdotu_rank_1 = rocblas_zdotu_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cdotc_assumed_rank(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotc_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! rocblas_cdotc_assumed_rank = rocblas_cdotc_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #else function rocblas_cdotc_rank_0(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotc_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy type(c_ptr) :: myResult ! rocblas_cdotc_rank_0 = rocblas_cdotc_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function function rocblas_cdotc_rank_1(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotc_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! rocblas_cdotc_rank_1 = rocblas_cdotc_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zdotc_assumed_rank(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotc_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! rocblas_zdotc_assumed_rank = rocblas_zdotc_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #else function rocblas_zdotc_rank_0(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotc_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy type(c_ptr) :: myResult ! rocblas_zdotc_rank_0 = rocblas_zdotc_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function function rocblas_zdotc_rank_1(handle,n,x,incx,y,incy,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotc_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: myResult ! rocblas_zdotc_rank_1 = rocblas_zdotc_(handle,n,c_loc(x),incx,c_loc(y),incy,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sdot_strided_batched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdot_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_sdot_strided_batched_assumed_rank = rocblas_sdot_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count,myResult) end function #else function rocblas_sdot_strided_batched_rank_0(handle,n,x,incx,stridex,y,incy,stridey, & batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdot_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_sdot_strided_batched_rank_0 = rocblas_sdot_strided_batched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batch_count,myResult) end function function rocblas_sdot_strided_batched_rank_1(handle,n,x,incx,stridex,y,incy,stridey, & batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdot_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_sdot_strided_batched_rank_1 = rocblas_sdot_strided_batched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batch_count,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ddot_strided_batched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddot_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_ddot_strided_batched_assumed_rank = rocblas_ddot_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count,myResult) end function #else function rocblas_ddot_strided_batched_rank_0(handle,n,x,incx,stridex,y,incy,stridey, & batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddot_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_ddot_strided_batched_rank_0 = rocblas_ddot_strided_batched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batch_count,myResult) end function function rocblas_ddot_strided_batched_rank_1(handle,n,x,incx,stridex,y,incy,stridey, & batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddot_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_ddot_strided_batched_rank_1 = rocblas_ddot_strided_batched_(handle,n,c_loc(x),incx, & stridex,c_loc(y),incy,stridey,batch_count,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cdotu_strided_batched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotu_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_cdotu_strided_batched_assumed_rank = rocblas_cdotu_strided_batched_(handle,n, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count,myResult) end function #else function rocblas_cdotu_strided_batched_rank_0(handle,n,x,incx,stridex,y,incy,stridey, & batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotu_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_cdotu_strided_batched_rank_0 = rocblas_cdotu_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count,myResult) end function function rocblas_cdotu_strided_batched_rank_1(handle,n,x,incx,stridex,y,incy,stridey, & batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotu_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_cdotu_strided_batched_rank_1 = rocblas_cdotu_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zdotu_strided_batched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotu_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_zdotu_strided_batched_assumed_rank = rocblas_zdotu_strided_batched_(handle,n, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count,myResult) end function #else function rocblas_zdotu_strided_batched_rank_0(handle,n,x,incx,stridex,y,incy,stridey, & batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotu_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_zdotu_strided_batched_rank_0 = rocblas_zdotu_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count,myResult) end function function rocblas_zdotu_strided_batched_rank_1(handle,n,x,incx,stridex,y,incy,stridey, & batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotu_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_zdotu_strided_batched_rank_1 = rocblas_zdotu_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cdotc_strided_batched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotc_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_cdotc_strided_batched_assumed_rank = rocblas_cdotc_strided_batched_(handle,n, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count,myResult) end function #else function rocblas_cdotc_strided_batched_rank_0(handle,n,x,incx,stridex,y,incy,stridey, & batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotc_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_cdotc_strided_batched_rank_0 = rocblas_cdotc_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count,myResult) end function function rocblas_cdotc_strided_batched_rank_1(handle,n,x,incx,stridex,y,incy,stridey, & batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdotc_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_cdotc_strided_batched_rank_1 = rocblas_cdotc_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zdotc_strided_batched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotc_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_zdotc_strided_batched_assumed_rank = rocblas_zdotc_strided_batched_(handle,n, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count,myResult) end function #else function rocblas_zdotc_strided_batched_rank_0(handle,n,x,incx,stridex,y,incy,stridey, & batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotc_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_zdotc_strided_batched_rank_0 = rocblas_zdotc_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count,myResult) end function function rocblas_zdotc_strided_batched_rank_1(handle,n,x,incx,stridex,y,incy,stridey, & batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdotc_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_zdotc_strided_batched_rank_1 = rocblas_zdotc_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cswap_assumed_rank(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cswap_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_cswap_assumed_rank = rocblas_cswap_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #else function rocblas_cswap_rank_0(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cswap_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy ! rocblas_cswap_rank_0 = rocblas_cswap_(handle,n,c_loc(x),incx,c_loc(y),incy) end function function rocblas_cswap_rank_1(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cswap_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_cswap_rank_1 = rocblas_cswap_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zswap_assumed_rank(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zswap_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_zswap_assumed_rank = rocblas_zswap_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #else function rocblas_zswap_rank_0(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zswap_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy ! rocblas_zswap_rank_0 = rocblas_zswap_(handle,n,c_loc(x),incx,c_loc(y),incy) end function function rocblas_zswap_rank_1(handle,n,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zswap_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_zswap_rank_1 = rocblas_zswap_(handle,n,c_loc(x),incx,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sswap_strided_batched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sswap_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_sswap_strided_batched_assumed_rank = rocblas_sswap_strided_batched_(handle,n, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_sswap_strided_batched_rank_0(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sswap_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_sswap_strided_batched_rank_0 = rocblas_sswap_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count) end function function rocblas_sswap_strided_batched_rank_1(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sswap_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_sswap_strided_batched_rank_1 = rocblas_sswap_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dswap_strided_batched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dswap_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dswap_strided_batched_assumed_rank = rocblas_dswap_strided_batched_(handle,n, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_dswap_strided_batched_rank_0(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dswap_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dswap_strided_batched_rank_0 = rocblas_dswap_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count) end function function rocblas_dswap_strided_batched_rank_1(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dswap_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dswap_strided_batched_rank_1 = rocblas_dswap_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cswap_strided_batched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cswap_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_cswap_strided_batched_assumed_rank = rocblas_cswap_strided_batched_(handle,n, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_cswap_strided_batched_rank_0(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cswap_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_cswap_strided_batched_rank_0 = rocblas_cswap_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count) end function function rocblas_cswap_strided_batched_rank_1(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cswap_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_cswap_strided_batched_rank_1 = rocblas_cswap_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zswap_strided_batched_assumed_rank(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zswap_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_zswap_strided_batched_assumed_rank = rocblas_zswap_strided_batched_(handle,n, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_zswap_strided_batched_rank_0(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zswap_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_zswap_strided_batched_rank_0 = rocblas_zswap_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count) end function function rocblas_zswap_strided_batched_rank_1(handle,n,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zswap_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_zswap_strided_batched_rank_1 = rocblas_zswap_strided_batched_(handle,n,c_loc(x), & incx,stridex,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_saxpy_assumed_rank(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_saxpy_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_saxpy_assumed_rank = rocblas_saxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function #else function rocblas_saxpy_rank_0(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_saxpy_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: y integer(c_int) :: incy ! rocblas_saxpy_rank_0 = rocblas_saxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function function rocblas_saxpy_rank_1(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_saxpy_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_saxpy_rank_1 = rocblas_saxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_daxpy_assumed_rank(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_daxpy_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_daxpy_assumed_rank = rocblas_daxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function #else function rocblas_daxpy_rank_0(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_daxpy_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: y integer(c_int) :: incy ! rocblas_daxpy_rank_0 = rocblas_daxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function function rocblas_daxpy_rank_1(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_daxpy_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_daxpy_rank_1 = rocblas_daxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_caxpy_assumed_rank(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_caxpy_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_caxpy_assumed_rank = rocblas_caxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function #else function rocblas_caxpy_rank_0(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_caxpy_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy ! rocblas_caxpy_rank_0 = rocblas_caxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function function rocblas_caxpy_rank_1(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_caxpy_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_caxpy_rank_1 = rocblas_caxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zaxpy_assumed_rank(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zaxpy_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_zaxpy_assumed_rank = rocblas_zaxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function #else function rocblas_zaxpy_rank_0(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zaxpy_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy ! rocblas_zaxpy_rank_0 = rocblas_zaxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function function rocblas_zaxpy_rank_1(handle,n,alpha,x,incx,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zaxpy_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_zaxpy_rank_1 = rocblas_zaxpy_(handle,n,alpha,c_loc(x),incx,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_saxpy_strided_batched_assumed_rank(handle,n,alpha,x,incx,stridex,y,incy, & stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_saxpy_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_saxpy_strided_batched_assumed_rank = rocblas_saxpy_strided_batched_(handle,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_saxpy_strided_batched_rank_0(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_saxpy_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_saxpy_strided_batched_rank_0 = rocblas_saxpy_strided_batched_(handle,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function function rocblas_saxpy_strided_batched_rank_1(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_saxpy_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_saxpy_strided_batched_rank_1 = rocblas_saxpy_strided_batched_(handle,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_daxpy_strided_batched_assumed_rank(handle,n,alpha,x,incx,stridex,y,incy, & stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_daxpy_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_daxpy_strided_batched_assumed_rank = rocblas_daxpy_strided_batched_(handle,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_daxpy_strided_batched_rank_0(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_daxpy_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_daxpy_strided_batched_rank_0 = rocblas_daxpy_strided_batched_(handle,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function function rocblas_daxpy_strided_batched_rank_1(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_daxpy_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_daxpy_strided_batched_rank_1 = rocblas_daxpy_strided_batched_(handle,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_caxpy_strided_batched_assumed_rank(handle,n,alpha,x,incx,stridex,y,incy, & stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_caxpy_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_caxpy_strided_batched_assumed_rank = rocblas_caxpy_strided_batched_(handle,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_caxpy_strided_batched_rank_0(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_caxpy_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_caxpy_strided_batched_rank_0 = rocblas_caxpy_strided_batched_(handle,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function function rocblas_caxpy_strided_batched_rank_1(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_caxpy_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_caxpy_strided_batched_rank_1 = rocblas_caxpy_strided_batched_(handle,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zaxpy_strided_batched_assumed_rank(handle,n,alpha,x,incx,stridex,y,incy, & stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zaxpy_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_zaxpy_strided_batched_assumed_rank = rocblas_zaxpy_strided_batched_(handle,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_zaxpy_strided_batched_rank_0(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zaxpy_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_zaxpy_strided_batched_rank_0 = rocblas_zaxpy_strided_batched_(handle,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function function rocblas_zaxpy_strided_batched_rank_1(handle,n,alpha,x,incx,stridex,y,incy,stridey, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zaxpy_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_zaxpy_strided_batched_rank_1 = rocblas_zaxpy_strided_batched_(handle,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_scasum_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scasum_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_scasum_assumed_rank = rocblas_scasum_(handle,n,c_loc(x),incx,myResult) end function #else function rocblas_scasum_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scasum_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_scasum_rank_0 = rocblas_scasum_(handle,n,c_loc(x),incx,myResult) end function function rocblas_scasum_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scasum_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_scasum_rank_1 = rocblas_scasum_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dzasum_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dzasum_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_dzasum_assumed_rank = rocblas_dzasum_(handle,n,c_loc(x),incx,myResult) end function #else function rocblas_dzasum_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dzasum_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_dzasum_rank_0 = rocblas_dzasum_(handle,n,c_loc(x),incx,myResult) end function function rocblas_dzasum_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dzasum_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_dzasum_rank_1 = rocblas_dzasum_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sasum_strided_batched_assumed_rank(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sasum_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_sasum_strided_batched_assumed_rank = rocblas_sasum_strided_batched_(handle,n, & c_loc(x),incx,stridex,batch_count,results) end function #else function rocblas_sasum_strided_batched_rank_0(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sasum_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_sasum_strided_batched_rank_0 = rocblas_sasum_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,results) end function function rocblas_sasum_strided_batched_rank_1(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sasum_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_sasum_strided_batched_rank_1 = rocblas_sasum_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,results) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dasum_strided_batched_assumed_rank(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dasum_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_dasum_strided_batched_assumed_rank = rocblas_dasum_strided_batched_(handle,n, & c_loc(x),incx,stridex,batch_count,results) end function #else function rocblas_dasum_strided_batched_rank_0(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dasum_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_dasum_strided_batched_rank_0 = rocblas_dasum_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,results) end function function rocblas_dasum_strided_batched_rank_1(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dasum_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_dasum_strided_batched_rank_1 = rocblas_dasum_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,results) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_scasum_strided_batched_assumed_rank(handle,n,x,incx,stridex,batch_count, & results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scasum_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_scasum_strided_batched_assumed_rank = rocblas_scasum_strided_batched_(handle,n, & c_loc(x),incx,stridex,batch_count,results) end function #else function rocblas_scasum_strided_batched_rank_0(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scasum_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_scasum_strided_batched_rank_0 = rocblas_scasum_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,results) end function function rocblas_scasum_strided_batched_rank_1(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scasum_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_scasum_strided_batched_rank_1 = rocblas_scasum_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,results) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dzasum_strided_batched_assumed_rank(handle,n,x,incx,stridex,batch_count, & results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dzasum_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_dzasum_strided_batched_assumed_rank = rocblas_dzasum_strided_batched_(handle,n, & c_loc(x),incx,stridex,batch_count,results) end function #else function rocblas_dzasum_strided_batched_rank_0(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dzasum_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_dzasum_strided_batched_rank_0 = rocblas_dzasum_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,results) end function function rocblas_dzasum_strided_batched_rank_1(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dzasum_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_dzasum_strided_batched_rank_1 = rocblas_dzasum_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,results) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_scnrm2_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scnrm2_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_scnrm2_assumed_rank = rocblas_scnrm2_(handle,n,c_loc(x),incx,myResult) end function #else function rocblas_scnrm2_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scnrm2_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_scnrm2_rank_0 = rocblas_scnrm2_(handle,n,c_loc(x),incx,myResult) end function function rocblas_scnrm2_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scnrm2_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_scnrm2_rank_1 = rocblas_scnrm2_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dznrm2_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dznrm2_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_dznrm2_assumed_rank = rocblas_dznrm2_(handle,n,c_loc(x),incx,myResult) end function #else function rocblas_dznrm2_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dznrm2_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_dznrm2_rank_0 = rocblas_dznrm2_(handle,n,c_loc(x),incx,myResult) end function function rocblas_dznrm2_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dznrm2_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_dznrm2_rank_1 = rocblas_dznrm2_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_snrm2_strided_batched_assumed_rank(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_snrm2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_snrm2_strided_batched_assumed_rank = rocblas_snrm2_strided_batched_(handle,n, & c_loc(x),incx,stridex,batch_count,results) end function #else function rocblas_snrm2_strided_batched_rank_0(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_snrm2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_snrm2_strided_batched_rank_0 = rocblas_snrm2_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,results) end function function rocblas_snrm2_strided_batched_rank_1(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_snrm2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_snrm2_strided_batched_rank_1 = rocblas_snrm2_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,results) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dnrm2_strided_batched_assumed_rank(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dnrm2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_dnrm2_strided_batched_assumed_rank = rocblas_dnrm2_strided_batched_(handle,n, & c_loc(x),incx,stridex,batch_count,results) end function #else function rocblas_dnrm2_strided_batched_rank_0(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dnrm2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_dnrm2_strided_batched_rank_0 = rocblas_dnrm2_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,results) end function function rocblas_dnrm2_strided_batched_rank_1(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dnrm2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_dnrm2_strided_batched_rank_1 = rocblas_dnrm2_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,results) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_scnrm2_strided_batched_assumed_rank(handle,n,x,incx,stridex,batch_count, & results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scnrm2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_scnrm2_strided_batched_assumed_rank = rocblas_scnrm2_strided_batched_(handle,n, & c_loc(x),incx,stridex,batch_count,results) end function #else function rocblas_scnrm2_strided_batched_rank_0(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scnrm2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_scnrm2_strided_batched_rank_0 = rocblas_scnrm2_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,results) end function function rocblas_scnrm2_strided_batched_rank_1(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_scnrm2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_scnrm2_strided_batched_rank_1 = rocblas_scnrm2_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,results) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dznrm2_strided_batched_assumed_rank(handle,n,x,incx,stridex,batch_count, & results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dznrm2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_dznrm2_strided_batched_assumed_rank = rocblas_dznrm2_strided_batched_(handle,n, & c_loc(x),incx,stridex,batch_count,results) end function #else function rocblas_dznrm2_strided_batched_rank_0(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dznrm2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_dznrm2_strided_batched_rank_0 = rocblas_dznrm2_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,results) end function function rocblas_dznrm2_strided_batched_rank_1(handle,n,x,incx,stridex,batch_count,results) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dznrm2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: results ! rocblas_dznrm2_strided_batched_rank_1 = rocblas_dznrm2_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,results) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_icamax_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamax_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_icamax_assumed_rank = rocblas_icamax_(handle,n,c_loc(x),incx,myResult) end function #else function rocblas_icamax_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamax_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_icamax_rank_0 = rocblas_icamax_(handle,n,c_loc(x),incx,myResult) end function function rocblas_icamax_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamax_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_icamax_rank_1 = rocblas_icamax_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_izamax_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamax_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_izamax_assumed_rank = rocblas_izamax_(handle,n,c_loc(x),incx,myResult) end function #else function rocblas_izamax_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamax_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_izamax_rank_0 = rocblas_izamax_(handle,n,c_loc(x),incx,myResult) end function function rocblas_izamax_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamax_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_izamax_rank_1 = rocblas_izamax_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_isamax_strided_batched_assumed_rank(handle,n,x,incx,stridex,batch_count, & myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_isamax_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_isamax_strided_batched_assumed_rank = rocblas_isamax_strided_batched_(handle,n, & c_loc(x),incx,stridex,batch_count,myResult) end function #else function rocblas_isamax_strided_batched_rank_0(handle,n,x,incx,stridex,batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_isamax_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_isamax_strided_batched_rank_0 = rocblas_isamax_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,myResult) end function function rocblas_isamax_strided_batched_rank_1(handle,n,x,incx,stridex,batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_isamax_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_isamax_strided_batched_rank_1 = rocblas_isamax_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_idamax_strided_batched_assumed_rank(handle,n,x,incx,stridex,batch_count, & myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_idamax_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_idamax_strided_batched_assumed_rank = rocblas_idamax_strided_batched_(handle,n, & c_loc(x),incx,stridex,batch_count,myResult) end function #else function rocblas_idamax_strided_batched_rank_0(handle,n,x,incx,stridex,batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_idamax_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_idamax_strided_batched_rank_0 = rocblas_idamax_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,myResult) end function function rocblas_idamax_strided_batched_rank_1(handle,n,x,incx,stridex,batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_idamax_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_idamax_strided_batched_rank_1 = rocblas_idamax_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_icamax_strided_batched_assumed_rank(handle,n,x,incx,stridex,batch_count, & myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamax_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_icamax_strided_batched_assumed_rank = rocblas_icamax_strided_batched_(handle,n, & c_loc(x),incx,stridex,batch_count,myResult) end function #else function rocblas_icamax_strided_batched_rank_0(handle,n,x,incx,stridex,batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamax_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_icamax_strided_batched_rank_0 = rocblas_icamax_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,myResult) end function function rocblas_icamax_strided_batched_rank_1(handle,n,x,incx,stridex,batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamax_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_icamax_strided_batched_rank_1 = rocblas_icamax_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_izamax_strided_batched_assumed_rank(handle,n,x,incx,stridex,batch_count, & myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamax_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_izamax_strided_batched_assumed_rank = rocblas_izamax_strided_batched_(handle,n, & c_loc(x),incx,stridex,batch_count,myResult) end function #else function rocblas_izamax_strided_batched_rank_0(handle,n,x,incx,stridex,batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamax_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_izamax_strided_batched_rank_0 = rocblas_izamax_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,myResult) end function function rocblas_izamax_strided_batched_rank_1(handle,n,x,incx,stridex,batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamax_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_izamax_strided_batched_rank_1 = rocblas_izamax_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_icamin_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamin_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_icamin_assumed_rank = rocblas_icamin_(handle,n,c_loc(x),incx,myResult) end function #else function rocblas_icamin_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamin_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_icamin_rank_0 = rocblas_icamin_(handle,n,c_loc(x),incx,myResult) end function function rocblas_icamin_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamin_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_icamin_rank_1 = rocblas_icamin_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_izamin_assumed_rank(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamin_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_izamin_assumed_rank = rocblas_izamin_(handle,n,c_loc(x),incx,myResult) end function #else function rocblas_izamin_rank_0(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamin_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_izamin_rank_0 = rocblas_izamin_(handle,n,c_loc(x),incx,myResult) end function function rocblas_izamin_rank_1(handle,n,x,incx,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamin_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx type(c_ptr) :: myResult ! rocblas_izamin_rank_1 = rocblas_izamin_(handle,n,c_loc(x),incx,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_isamin_strided_batched_assumed_rank(handle,n,x,incx,stridex,batch_count, & myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_isamin_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_isamin_strided_batched_assumed_rank = rocblas_isamin_strided_batched_(handle,n, & c_loc(x),incx,stridex,batch_count,myResult) end function #else function rocblas_isamin_strided_batched_rank_0(handle,n,x,incx,stridex,batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_isamin_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_isamin_strided_batched_rank_0 = rocblas_isamin_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,myResult) end function function rocblas_isamin_strided_batched_rank_1(handle,n,x,incx,stridex,batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_isamin_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_isamin_strided_batched_rank_1 = rocblas_isamin_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_idamin_strided_batched_assumed_rank(handle,n,x,incx,stridex,batch_count, & myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_idamin_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_idamin_strided_batched_assumed_rank = rocblas_idamin_strided_batched_(handle,n, & c_loc(x),incx,stridex,batch_count,myResult) end function #else function rocblas_idamin_strided_batched_rank_0(handle,n,x,incx,stridex,batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_idamin_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_idamin_strided_batched_rank_0 = rocblas_idamin_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,myResult) end function function rocblas_idamin_strided_batched_rank_1(handle,n,x,incx,stridex,batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_idamin_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_idamin_strided_batched_rank_1 = rocblas_idamin_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_icamin_strided_batched_assumed_rank(handle,n,x,incx,stridex,batch_count, & myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamin_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_icamin_strided_batched_assumed_rank = rocblas_icamin_strided_batched_(handle,n, & c_loc(x),incx,stridex,batch_count,myResult) end function #else function rocblas_icamin_strided_batched_rank_0(handle,n,x,incx,stridex,batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamin_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_icamin_strided_batched_rank_0 = rocblas_icamin_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,myResult) end function function rocblas_icamin_strided_batched_rank_1(handle,n,x,incx,stridex,batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_icamin_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_icamin_strided_batched_rank_1 = rocblas_icamin_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_izamin_strided_batched_assumed_rank(handle,n,x,incx,stridex,batch_count, & myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamin_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_izamin_strided_batched_assumed_rank = rocblas_izamin_strided_batched_(handle,n, & c_loc(x),incx,stridex,batch_count,myResult) end function #else function rocblas_izamin_strided_batched_rank_0(handle,n,x,incx,stridex,batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamin_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_izamin_strided_batched_rank_0 = rocblas_izamin_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,myResult) end function function rocblas_izamin_strided_batched_rank_1(handle,n,x,incx,stridex,batch_count,myResult) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_izamin_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex integer(c_int) :: batch_count type(c_ptr) :: myResult ! rocblas_izamin_strided_batched_rank_1 = rocblas_izamin_strided_batched_(handle,n,c_loc(x), & incx,stridex,batch_count,myResult) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_srot_assumed_rank(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srot_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy real(c_float) :: c real(c_float) :: s ! rocblas_srot_assumed_rank = rocblas_srot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #else function rocblas_srot_rank_0(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srot_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: y integer(c_int) :: incy real(c_float) :: c real(c_float) :: s ! rocblas_srot_rank_0 = rocblas_srot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function function rocblas_srot_rank_1(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srot_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy real(c_float) :: c real(c_float) :: s ! rocblas_srot_rank_1 = rocblas_srot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_drot_assumed_rank(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drot_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy real(c_double) :: c real(c_double) :: s ! rocblas_drot_assumed_rank = rocblas_drot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #else function rocblas_drot_rank_0(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drot_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: y integer(c_int) :: incy real(c_double) :: c real(c_double) :: s ! rocblas_drot_rank_0 = rocblas_drot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function function rocblas_drot_rank_1(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drot_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy real(c_double) :: c real(c_double) :: s ! rocblas_drot_rank_1 = rocblas_drot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_crot_assumed_rank(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_crot_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy real(c_float) :: c complex(c_float_complex) :: s ! rocblas_crot_assumed_rank = rocblas_crot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #else function rocblas_crot_rank_0(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_crot_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy real(c_float) :: c complex(c_float_complex) :: s ! rocblas_crot_rank_0 = rocblas_crot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function function rocblas_crot_rank_1(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_crot_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy real(c_float) :: c complex(c_float_complex) :: s ! rocblas_crot_rank_1 = rocblas_crot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_csrot_assumed_rank(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csrot_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy real(c_float) :: c real(c_float) :: s ! rocblas_csrot_assumed_rank = rocblas_csrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #else function rocblas_csrot_rank_0(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csrot_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy real(c_float) :: c real(c_float) :: s ! rocblas_csrot_rank_0 = rocblas_csrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function function rocblas_csrot_rank_1(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csrot_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy real(c_float) :: c real(c_float) :: s ! rocblas_csrot_rank_1 = rocblas_csrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zrot_assumed_rank(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zrot_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy real(c_double) :: c complex(c_double_complex) :: s ! rocblas_zrot_assumed_rank = rocblas_zrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #else function rocblas_zrot_rank_0(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zrot_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy real(c_double) :: c complex(c_double_complex) :: s ! rocblas_zrot_rank_0 = rocblas_zrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function function rocblas_zrot_rank_1(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zrot_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy real(c_double) :: c complex(c_double_complex) :: s ! rocblas_zrot_rank_1 = rocblas_zrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zdrot_assumed_rank(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdrot_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy real(c_double) :: c real(c_double) :: s ! rocblas_zdrot_assumed_rank = rocblas_zdrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #else function rocblas_zdrot_rank_0(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdrot_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy real(c_double) :: c real(c_double) :: s ! rocblas_zdrot_rank_0 = rocblas_zdrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function function rocblas_zdrot_rank_1(handle,n,x,incx,y,incy,c,s) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdrot_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy real(c_double) :: c real(c_double) :: s ! rocblas_zdrot_rank_1 = rocblas_zdrot_(handle,n,c_loc(x),incx,c_loc(y),incy,c,s) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_srot_strided_batched_assumed_rank(handle,n,x,incx,stride_x,y,incy,stride_y,c, & s,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srot_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_float) :: c real(c_float) :: s integer(c_int) :: batch_count ! rocblas_srot_strided_batched_assumed_rank = rocblas_srot_strided_batched_(handle,n,c_loc(x), & incx,stride_x,c_loc(y),incy,stride_y,c,s,batch_count) end function #else function rocblas_srot_strided_batched_rank_0(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srot_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_float) :: c real(c_float) :: s integer(c_int) :: batch_count ! rocblas_srot_strided_batched_rank_0 = rocblas_srot_strided_batched_(handle,n,c_loc(x),incx, & stride_x,c_loc(y),incy,stride_y,c,s,batch_count) end function function rocblas_srot_strided_batched_rank_1(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srot_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_float) :: c real(c_float) :: s integer(c_int) :: batch_count ! rocblas_srot_strided_batched_rank_1 = rocblas_srot_strided_batched_(handle,n,c_loc(x),incx, & stride_x,c_loc(y),incy,stride_y,c,s,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_drot_strided_batched_assumed_rank(handle,n,x,incx,stride_x,y,incy,stride_y,c, & s,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drot_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_double) :: c real(c_double) :: s integer(c_int) :: batch_count ! rocblas_drot_strided_batched_assumed_rank = rocblas_drot_strided_batched_(handle,n,c_loc(x), & incx,stride_x,c_loc(y),incy,stride_y,c,s,batch_count) end function #else function rocblas_drot_strided_batched_rank_0(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drot_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_double) :: c real(c_double) :: s integer(c_int) :: batch_count ! rocblas_drot_strided_batched_rank_0 = rocblas_drot_strided_batched_(handle,n,c_loc(x),incx, & stride_x,c_loc(y),incy,stride_y,c,s,batch_count) end function function rocblas_drot_strided_batched_rank_1(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drot_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_double) :: c real(c_double) :: s integer(c_int) :: batch_count ! rocblas_drot_strided_batched_rank_1 = rocblas_drot_strided_batched_(handle,n,c_loc(x),incx, & stride_x,c_loc(y),incy,stride_y,c,s,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_crot_strided_batched_assumed_rank(handle,n,x,incx,stride_x,y,incy,stride_y,c, & s,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_crot_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_float) :: c complex(c_float_complex) :: s integer(c_int) :: batch_count ! rocblas_crot_strided_batched_assumed_rank = rocblas_crot_strided_batched_(handle,n,c_loc(x), & incx,stride_x,c_loc(y),incy,stride_y,c,s,batch_count) end function #else function rocblas_crot_strided_batched_rank_0(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_crot_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_float) :: c complex(c_float_complex) :: s integer(c_int) :: batch_count ! rocblas_crot_strided_batched_rank_0 = rocblas_crot_strided_batched_(handle,n,c_loc(x),incx, & stride_x,c_loc(y),incy,stride_y,c,s,batch_count) end function function rocblas_crot_strided_batched_rank_1(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_crot_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_float) :: c complex(c_float_complex) :: s integer(c_int) :: batch_count ! rocblas_crot_strided_batched_rank_1 = rocblas_crot_strided_batched_(handle,n,c_loc(x),incx, & stride_x,c_loc(y),incy,stride_y,c,s,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_csrot_strided_batched_assumed_rank(handle,n,x,incx,stride_x,y,incy,stride_y, & c,s,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csrot_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_float) :: c real(c_float) :: s integer(c_int) :: batch_count ! rocblas_csrot_strided_batched_assumed_rank = rocblas_csrot_strided_batched_(handle,n, & c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c,s,batch_count) end function #else function rocblas_csrot_strided_batched_rank_0(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csrot_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_float) :: c real(c_float) :: s integer(c_int) :: batch_count ! rocblas_csrot_strided_batched_rank_0 = rocblas_csrot_strided_batched_(handle,n,c_loc(x), & incx,stride_x,c_loc(y),incy,stride_y,c,s,batch_count) end function function rocblas_csrot_strided_batched_rank_1(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csrot_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_float) :: c real(c_float) :: s integer(c_int) :: batch_count ! rocblas_csrot_strided_batched_rank_1 = rocblas_csrot_strided_batched_(handle,n,c_loc(x), & incx,stride_x,c_loc(y),incy,stride_y,c,s,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zrot_strided_batched_assumed_rank(handle,n,x,incx,stride_x,y,incy,stride_y,c, & s,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zrot_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_double) :: c complex(c_double_complex) :: s integer(c_int) :: batch_count ! rocblas_zrot_strided_batched_assumed_rank = rocblas_zrot_strided_batched_(handle,n,c_loc(x), & incx,stride_x,c_loc(y),incy,stride_y,c,s,batch_count) end function #else function rocblas_zrot_strided_batched_rank_0(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zrot_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_double) :: c complex(c_double_complex) :: s integer(c_int) :: batch_count ! rocblas_zrot_strided_batched_rank_0 = rocblas_zrot_strided_batched_(handle,n,c_loc(x),incx, & stride_x,c_loc(y),incy,stride_y,c,s,batch_count) end function function rocblas_zrot_strided_batched_rank_1(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zrot_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_double) :: c complex(c_double_complex) :: s integer(c_int) :: batch_count ! rocblas_zrot_strided_batched_rank_1 = rocblas_zrot_strided_batched_(handle,n,c_loc(x),incx, & stride_x,c_loc(y),incy,stride_y,c,s,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zdrot_strided_batched_assumed_rank(handle,n,x,incx,stride_x,y,incy,stride_y, & c,s,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdrot_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_double) :: c real(c_double) :: s integer(c_int) :: batch_count ! rocblas_zdrot_strided_batched_assumed_rank = rocblas_zdrot_strided_batched_(handle,n, & c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c,s,batch_count) end function #else function rocblas_zdrot_strided_batched_rank_0(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdrot_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_double) :: c real(c_double) :: s integer(c_int) :: batch_count ! rocblas_zdrot_strided_batched_rank_0 = rocblas_zdrot_strided_batched_(handle,n,c_loc(x), & incx,stride_x,c_loc(y),incy,stride_y,c,s,batch_count) end function function rocblas_zdrot_strided_batched_rank_1(handle,n,x,incx,stride_x,y,incy,stride_y,c,s, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdrot_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_double) :: c real(c_double) :: s integer(c_int) :: batch_count ! rocblas_zdrot_strided_batched_rank_1 = rocblas_zdrot_strided_batched_(handle,n,c_loc(x), & incx,stride_x,c_loc(y),incy,stride_y,c,s,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_srotm_assumed_rank(handle,n,x,incx,y,incy,param) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotm_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: param ! rocblas_srotm_assumed_rank = rocblas_srotm_(handle,n,c_loc(x),incx,c_loc(y),incy,param) end function #else function rocblas_srotm_rank_0(handle,n,x,incx,y,incy,param) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotm_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: y integer(c_int) :: incy type(c_ptr) :: param ! rocblas_srotm_rank_0 = rocblas_srotm_(handle,n,c_loc(x),incx,c_loc(y),incy,param) end function function rocblas_srotm_rank_1(handle,n,x,incx,y,incy,param) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotm_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: param ! rocblas_srotm_rank_1 = rocblas_srotm_(handle,n,c_loc(x),incx,c_loc(y),incy,param) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_drotm_assumed_rank(handle,n,x,incx,y,incy,param) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotm_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy type(c_ptr) :: param ! rocblas_drotm_assumed_rank = rocblas_drotm_(handle,n,c_loc(x),incx,c_loc(y),incy,param) end function #else function rocblas_drotm_rank_0(handle,n,x,incx,y,incy,param) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotm_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: y integer(c_int) :: incy type(c_ptr) :: param ! rocblas_drotm_rank_0 = rocblas_drotm_(handle,n,c_loc(x),incx,c_loc(y),incy,param) end function function rocblas_drotm_rank_1(handle,n,x,incx,y,incy,param) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotm_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy type(c_ptr) :: param ! rocblas_drotm_rank_1 = rocblas_drotm_(handle,n,c_loc(x),incx,c_loc(y),incy,param) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_srotm_strided_batched_assumed_rank(handle,n,x,incx,stride_x,y,incy,stride_y, & param,stride_param,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotm_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y type(c_ptr) :: param integer(c_int64_t) :: stride_param integer(c_int) :: batch_count ! rocblas_srotm_strided_batched_assumed_rank = rocblas_srotm_strided_batched_(handle,n, & c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,param,stride_param,batch_count) end function #else function rocblas_srotm_strided_batched_rank_0(handle,n,x,incx,stride_x,y,incy,stride_y,param, & stride_param,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotm_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y type(c_ptr) :: param integer(c_int64_t) :: stride_param integer(c_int) :: batch_count ! rocblas_srotm_strided_batched_rank_0 = rocblas_srotm_strided_batched_(handle,n,c_loc(x), & incx,stride_x,c_loc(y),incy,stride_y,param,stride_param,batch_count) end function function rocblas_srotm_strided_batched_rank_1(handle,n,x,incx,stride_x,y,incy,stride_y,param, & stride_param,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_srotm_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y type(c_ptr) :: param integer(c_int64_t) :: stride_param integer(c_int) :: batch_count ! rocblas_srotm_strided_batched_rank_1 = rocblas_srotm_strided_batched_(handle,n,c_loc(x), & incx,stride_x,c_loc(y),incy,stride_y,param,stride_param,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_drotm_strided_batched_assumed_rank(handle,n,x,incx,stride_x,y,incy,stride_y, & param,stride_param,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotm_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y type(c_ptr) :: param integer(c_int64_t) :: stride_param integer(c_int) :: batch_count ! rocblas_drotm_strided_batched_assumed_rank = rocblas_drotm_strided_batched_(handle,n, & c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,param,stride_param,batch_count) end function #else function rocblas_drotm_strided_batched_rank_0(handle,n,x,incx,stride_x,y,incy,stride_y,param, & stride_param,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotm_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y type(c_ptr) :: param integer(c_int64_t) :: stride_param integer(c_int) :: batch_count ! rocblas_drotm_strided_batched_rank_0 = rocblas_drotm_strided_batched_(handle,n,c_loc(x), & incx,stride_x,c_loc(y),incy,stride_y,param,stride_param,batch_count) end function function rocblas_drotm_strided_batched_rank_1(handle,n,x,incx,stride_x,y,incy,stride_y,param, & stride_param,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_drotm_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y type(c_ptr) :: param integer(c_int64_t) :: stride_param integer(c_int) :: batch_count ! rocblas_drotm_strided_batched_rank_1 = rocblas_drotm_strided_batched_(handle,n,c_loc(x), & incx,stride_x,c_loc(y),incy,stride_y,param,stride_param,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sgbmv_assumed_rank(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgbmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_sgbmv_assumed_rank = rocblas_sgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(A),lda, & c_loc(x),incx,beta,c_loc(y),incy) end function #else function rocblas_sgbmv_rank_0(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgbmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy ! rocblas_sgbmv_rank_0 = rocblas_sgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function function rocblas_sgbmv_rank_1(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgbmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_sgbmv_rank_1 = rocblas_sgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function function rocblas_sgbmv_full_rank(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgbmv_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_sgbmv_full_rank = rocblas_sgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dgbmv_assumed_rank(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgbmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_dgbmv_assumed_rank = rocblas_dgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(A),lda, & c_loc(x),incx,beta,c_loc(y),incy) end function #else function rocblas_dgbmv_rank_0(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgbmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy ! rocblas_dgbmv_rank_0 = rocblas_dgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function function rocblas_dgbmv_rank_1(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgbmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_dgbmv_rank_1 = rocblas_dgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function function rocblas_dgbmv_full_rank(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgbmv_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_dgbmv_full_rank = rocblas_dgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cgbmv_assumed_rank(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgbmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_cgbmv_assumed_rank = rocblas_cgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(A),lda, & c_loc(x),incx,beta,c_loc(y),incy) end function #else function rocblas_cgbmv_rank_0(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgbmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy ! rocblas_cgbmv_rank_0 = rocblas_cgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function function rocblas_cgbmv_rank_1(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgbmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_cgbmv_rank_1 = rocblas_cgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function function rocblas_cgbmv_full_rank(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgbmv_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_cgbmv_full_rank = rocblas_cgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zgbmv_assumed_rank(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgbmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_zgbmv_assumed_rank = rocblas_zgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(A),lda, & c_loc(x),incx,beta,c_loc(y),incy) end function #else function rocblas_zgbmv_rank_0(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgbmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy ! rocblas_zgbmv_rank_0 = rocblas_zgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function function rocblas_zgbmv_rank_1(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgbmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_zgbmv_rank_1 = rocblas_zgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function function rocblas_zgbmv_full_rank(handle,trans,m,n,kl,ku,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgbmv_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_zgbmv_full_rank = rocblas_zgbmv_(handle,trans,m,n,kl,ku,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sgbmv_strided_batched_assumed_rank(handle,trans,m,n,kl,ku,alpha,A,lda, & stride_A,x,incx,stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgbmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_sgbmv_strided_batched_assumed_rank = rocblas_sgbmv_strided_batched_(handle,trans,m, & n,kl,ku,alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y, & batch_count) end function #else function rocblas_sgbmv_strided_batched_rank_0(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A,x, & incx,stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgbmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_sgbmv_strided_batched_rank_0 = rocblas_sgbmv_strided_batched_(handle,trans,m,n,kl, & ku,alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y, & batch_count) end function function rocblas_sgbmv_strided_batched_rank_1(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A,x, & incx,stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgbmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_sgbmv_strided_batched_rank_1 = rocblas_sgbmv_strided_batched_(handle,trans,m,n,kl, & ku,alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y, & batch_count) end function function rocblas_sgbmv_strided_batched_full_rank(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A, & x,incx,stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgbmv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_sgbmv_strided_batched_full_rank = rocblas_sgbmv_strided_batched_(handle,trans,m,n, & kl,ku,alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dgbmv_strided_batched_assumed_rank(handle,trans,m,n,kl,ku,alpha,A,lda, & stride_A,x,incx,stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgbmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_dgbmv_strided_batched_assumed_rank = rocblas_dgbmv_strided_batched_(handle,trans,m, & n,kl,ku,alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y, & batch_count) end function #else function rocblas_dgbmv_strided_batched_rank_0(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A,x, & incx,stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgbmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_dgbmv_strided_batched_rank_0 = rocblas_dgbmv_strided_batched_(handle,trans,m,n,kl, & ku,alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y, & batch_count) end function function rocblas_dgbmv_strided_batched_rank_1(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A,x, & incx,stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgbmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_dgbmv_strided_batched_rank_1 = rocblas_dgbmv_strided_batched_(handle,trans,m,n,kl, & ku,alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y, & batch_count) end function function rocblas_dgbmv_strided_batched_full_rank(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A, & x,incx,stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgbmv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_dgbmv_strided_batched_full_rank = rocblas_dgbmv_strided_batched_(handle,trans,m,n, & kl,ku,alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cgbmv_strided_batched_assumed_rank(handle,trans,m,n,kl,ku,alpha,A,lda, & stride_A,x,incx,stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgbmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_cgbmv_strided_batched_assumed_rank = rocblas_cgbmv_strided_batched_(handle,trans,m, & n,kl,ku,alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y, & batch_count) end function #else function rocblas_cgbmv_strided_batched_rank_0(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A,x, & incx,stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgbmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_cgbmv_strided_batched_rank_0 = rocblas_cgbmv_strided_batched_(handle,trans,m,n,kl, & ku,alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y, & batch_count) end function function rocblas_cgbmv_strided_batched_rank_1(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A,x, & incx,stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgbmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_cgbmv_strided_batched_rank_1 = rocblas_cgbmv_strided_batched_(handle,trans,m,n,kl, & ku,alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y, & batch_count) end function function rocblas_cgbmv_strided_batched_full_rank(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A, & x,incx,stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgbmv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_cgbmv_strided_batched_full_rank = rocblas_cgbmv_strided_batched_(handle,trans,m,n, & kl,ku,alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zgbmv_strided_batched_assumed_rank(handle,trans,m,n,kl,ku,alpha,A,lda, & stride_A,x,incx,stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgbmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_zgbmv_strided_batched_assumed_rank = rocblas_zgbmv_strided_batched_(handle,trans,m, & n,kl,ku,alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y, & batch_count) end function #else function rocblas_zgbmv_strided_batched_rank_0(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A,x, & incx,stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgbmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_zgbmv_strided_batched_rank_0 = rocblas_zgbmv_strided_batched_(handle,trans,m,n,kl, & ku,alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y, & batch_count) end function function rocblas_zgbmv_strided_batched_rank_1(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A,x, & incx,stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgbmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_zgbmv_strided_batched_rank_1 = rocblas_zgbmv_strided_batched_(handle,trans,m,n,kl, & ku,alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y, & batch_count) end function function rocblas_zgbmv_strided_batched_full_rank(handle,trans,m,n,kl,ku,alpha,A,lda,stride_A, & x,incx,stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgbmv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: kl integer(c_int) :: ku complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_zgbmv_strided_batched_full_rank = rocblas_zgbmv_strided_batched_(handle,trans,m,n, & kl,ku,alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sgemv_assumed_rank(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_sgemv_assumed_rank = rocblas_sgemv_(handle,trans,m,n,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #else function rocblas_sgemv_rank_0(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy ! rocblas_sgemv_rank_0 = rocblas_sgemv_(handle,trans,m,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function function rocblas_sgemv_rank_1(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_sgemv_rank_1 = rocblas_sgemv_(handle,trans,m,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function function rocblas_sgemv_full_rank(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemv_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_sgemv_full_rank = rocblas_sgemv_(handle,trans,m,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dgemv_assumed_rank(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_dgemv_assumed_rank = rocblas_dgemv_(handle,trans,m,n,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #else function rocblas_dgemv_rank_0(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy ! rocblas_dgemv_rank_0 = rocblas_dgemv_(handle,trans,m,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function function rocblas_dgemv_rank_1(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_dgemv_rank_1 = rocblas_dgemv_(handle,trans,m,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function function rocblas_dgemv_full_rank(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemv_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_dgemv_full_rank = rocblas_dgemv_(handle,trans,m,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cgemv_assumed_rank(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_cgemv_assumed_rank = rocblas_cgemv_(handle,trans,m,n,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #else function rocblas_cgemv_rank_0(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy ! rocblas_cgemv_rank_0 = rocblas_cgemv_(handle,trans,m,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function function rocblas_cgemv_rank_1(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_cgemv_rank_1 = rocblas_cgemv_(handle,trans,m,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function function rocblas_cgemv_full_rank(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemv_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_cgemv_full_rank = rocblas_cgemv_(handle,trans,m,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zgemv_assumed_rank(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_zgemv_assumed_rank = rocblas_zgemv_(handle,trans,m,n,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #else function rocblas_zgemv_rank_0(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy ! rocblas_zgemv_rank_0 = rocblas_zgemv_(handle,trans,m,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function function rocblas_zgemv_rank_1(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_zgemv_rank_1 = rocblas_zgemv_(handle,trans,m,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function function rocblas_zgemv_full_rank(handle,trans,m,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemv_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_zgemv_full_rank = rocblas_zgemv_(handle,trans,m,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sgemv_strided_batched_assumed_rank(handle,transA,m,n,alpha,A,lda,strideA,x, & incx,stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_sgemv_strided_batched_assumed_rank = rocblas_sgemv_strided_batched_(handle,transA,m, & n,alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_sgemv_strided_batched_rank_0(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_sgemv_strided_batched_rank_0 = rocblas_sgemv_strided_batched_(handle,transA,m,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_sgemv_strided_batched_rank_1(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_sgemv_strided_batched_rank_1 = rocblas_sgemv_strided_batched_(handle,transA,m,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_sgemv_strided_batched_full_rank(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_sgemv_strided_batched_full_rank = rocblas_sgemv_strided_batched_(handle,transA,m,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dgemv_strided_batched_assumed_rank(handle,transA,m,n,alpha,A,lda,strideA,x, & incx,stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dgemv_strided_batched_assumed_rank = rocblas_dgemv_strided_batched_(handle,transA,m, & n,alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_dgemv_strided_batched_rank_0(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dgemv_strided_batched_rank_0 = rocblas_dgemv_strided_batched_(handle,transA,m,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_dgemv_strided_batched_rank_1(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dgemv_strided_batched_rank_1 = rocblas_dgemv_strided_batched_(handle,transA,m,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_dgemv_strided_batched_full_rank(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dgemv_strided_batched_full_rank = rocblas_dgemv_strided_batched_(handle,transA,m,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cgemv_strided_batched_assumed_rank(handle,transA,m,n,alpha,A,lda,strideA,x, & incx,stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_cgemv_strided_batched_assumed_rank = rocblas_cgemv_strided_batched_(handle,transA,m, & n,alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_cgemv_strided_batched_rank_0(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_cgemv_strided_batched_rank_0 = rocblas_cgemv_strided_batched_(handle,transA,m,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_cgemv_strided_batched_rank_1(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_cgemv_strided_batched_rank_1 = rocblas_cgemv_strided_batched_(handle,transA,m,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_cgemv_strided_batched_full_rank(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_cgemv_strided_batched_full_rank = rocblas_cgemv_strided_batched_(handle,transA,m,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zgemv_strided_batched_assumed_rank(handle,transA,m,n,alpha,A,lda,strideA,x, & incx,stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_zgemv_strided_batched_assumed_rank = rocblas_zgemv_strided_batched_(handle,transA,m, & n,alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_zgemv_strided_batched_rank_0(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_zgemv_strided_batched_rank_0 = rocblas_zgemv_strided_batched_(handle,transA,m,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_zgemv_strided_batched_rank_1(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_zgemv_strided_batched_rank_1 = rocblas_zgemv_strided_batched_(handle,transA,m,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_zgemv_strided_batched_full_rank(handle,transA,m,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_zgemv_strided_batched_full_rank = rocblas_zgemv_strided_batched_(handle,transA,m,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_chbmv_assumed_rank(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chbmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_chbmv_assumed_rank = rocblas_chbmv_(handle,uplo,n,k,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #else function rocblas_chbmv_rank_0(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chbmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy ! rocblas_chbmv_rank_0 = rocblas_chbmv_(handle,uplo,n,k,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_chbmv_rank_1(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chbmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_chbmv_rank_1 = rocblas_chbmv_(handle,uplo,n,k,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_chbmv_full_rank(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chbmv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_chbmv_full_rank = rocblas_chbmv_(handle,uplo,n,k,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zhbmv_assumed_rank(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhbmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_zhbmv_assumed_rank = rocblas_zhbmv_(handle,uplo,n,k,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #else function rocblas_zhbmv_rank_0(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhbmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy ! rocblas_zhbmv_rank_0 = rocblas_zhbmv_(handle,uplo,n,k,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_zhbmv_rank_1(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhbmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_zhbmv_rank_1 = rocblas_zhbmv_(handle,uplo,n,k,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_zhbmv_full_rank(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhbmv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_zhbmv_full_rank = rocblas_zhbmv_(handle,uplo,n,k,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_chbmv_strided_batched_assumed_rank(handle,uplo,n,k,alpha,A,lda,stride_A,x, & incx,stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chbmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_chbmv_strided_batched_assumed_rank = rocblas_chbmv_strided_batched_(handle,uplo,n,k, & alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function #else function rocblas_chbmv_strided_batched_rank_0(handle,uplo,n,k,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chbmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_chbmv_strided_batched_rank_0 = rocblas_chbmv_strided_batched_(handle,uplo,n,k,alpha, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function function rocblas_chbmv_strided_batched_rank_1(handle,uplo,n,k,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chbmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_chbmv_strided_batched_rank_1 = rocblas_chbmv_strided_batched_(handle,uplo,n,k,alpha, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function function rocblas_chbmv_strided_batched_full_rank(handle,uplo,n,k,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chbmv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_chbmv_strided_batched_full_rank = rocblas_chbmv_strided_batched_(handle,uplo,n,k, & alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zhbmv_strided_batched_assumed_rank(handle,uplo,n,k,alpha,A,lda,stride_A,x, & incx,stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhbmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_zhbmv_strided_batched_assumed_rank = rocblas_zhbmv_strided_batched_(handle,uplo,n,k, & alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function #else function rocblas_zhbmv_strided_batched_rank_0(handle,uplo,n,k,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhbmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_zhbmv_strided_batched_rank_0 = rocblas_zhbmv_strided_batched_(handle,uplo,n,k,alpha, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function function rocblas_zhbmv_strided_batched_rank_1(handle,uplo,n,k,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhbmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_zhbmv_strided_batched_rank_1 = rocblas_zhbmv_strided_batched_(handle,uplo,n,k,alpha, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function function rocblas_zhbmv_strided_batched_full_rank(handle,uplo,n,k,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhbmv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_zhbmv_strided_batched_full_rank = rocblas_zhbmv_strided_batched_(handle,uplo,n,k, & alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_chemv_assumed_rank(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_chemv_assumed_rank = rocblas_chemv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #else function rocblas_chemv_rank_0(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy ! rocblas_chemv_rank_0 = rocblas_chemv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_chemv_rank_1(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_chemv_rank_1 = rocblas_chemv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_chemv_full_rank(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_chemv_full_rank = rocblas_chemv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zhemv_assumed_rank(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_zhemv_assumed_rank = rocblas_zhemv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #else function rocblas_zhemv_rank_0(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy ! rocblas_zhemv_rank_0 = rocblas_zhemv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_zhemv_rank_1(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_zhemv_rank_1 = rocblas_zhemv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_zhemv_full_rank(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_zhemv_full_rank = rocblas_zhemv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_chemv_strided_batched_assumed_rank(handle,uplo,n,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_chemv_strided_batched_assumed_rank = rocblas_chemv_strided_batched_(handle,uplo,n, & alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function #else function rocblas_chemv_strided_batched_rank_0(handle,uplo,n,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_chemv_strided_batched_rank_0 = rocblas_chemv_strided_batched_(handle,uplo,n,alpha, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function function rocblas_chemv_strided_batched_rank_1(handle,uplo,n,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_chemv_strided_batched_rank_1 = rocblas_chemv_strided_batched_(handle,uplo,n,alpha, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function function rocblas_chemv_strided_batched_full_rank(handle,uplo,n,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_chemv_strided_batched_full_rank = rocblas_chemv_strided_batched_(handle,uplo,n, & alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zhemv_strided_batched_assumed_rank(handle,uplo,n,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_zhemv_strided_batched_assumed_rank = rocblas_zhemv_strided_batched_(handle,uplo,n, & alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function #else function rocblas_zhemv_strided_batched_rank_0(handle,uplo,n,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_zhemv_strided_batched_rank_0 = rocblas_zhemv_strided_batched_(handle,uplo,n,alpha, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function function rocblas_zhemv_strided_batched_rank_1(handle,uplo,n,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_zhemv_strided_batched_rank_1 = rocblas_zhemv_strided_batched_(handle,uplo,n,alpha, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function function rocblas_zhemv_strided_batched_full_rank(handle,uplo,n,alpha,A,lda,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_zhemv_strided_batched_full_rank = rocblas_zhemv_strided_batched_(handle,uplo,n, & alpha,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cher_assumed_rank(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocblas_cher_assumed_rank = rocblas_cher_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function #else function rocblas_cher_rank_0(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: A integer(c_int) :: lda ! rocblas_cher_rank_0 = rocblas_cher_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function function rocblas_cher_rank_1(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda ! rocblas_cher_rank_1 = rocblas_cher_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function function rocblas_cher_full_rank(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda ! rocblas_cher_full_rank = rocblas_cher_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zher_assumed_rank(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocblas_zher_assumed_rank = rocblas_zher_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function #else function rocblas_zher_rank_0(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: A integer(c_int) :: lda ! rocblas_zher_rank_0 = rocblas_zher_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function function rocblas_zher_rank_1(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda ! rocblas_zher_rank_1 = rocblas_zher_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function function rocblas_zher_full_rank(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda ! rocblas_zher_full_rank = rocblas_zher_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cher_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stride_x,A,lda, & stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_cher_strided_batched_assumed_rank = rocblas_cher_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stride_x,c_loc(A),lda,stride_A,batch_count) end function #else function rocblas_cher_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stride_x,A,lda, & stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_cher_strided_batched_rank_0 = rocblas_cher_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(A),lda,stride_A,batch_count) end function function rocblas_cher_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stride_x,A,lda, & stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_cher_strided_batched_rank_1 = rocblas_cher_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(A),lda,stride_A,batch_count) end function function rocblas_cher_strided_batched_full_rank(handle,uplo,n,alpha,x,incx,stride_x,A,lda, & stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_cher_strided_batched_full_rank = rocblas_cher_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(A),lda,stride_A,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zher_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stride_x,A,lda, & stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_zher_strided_batched_assumed_rank = rocblas_zher_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stride_x,c_loc(A),lda,stride_A,batch_count) end function #else function rocblas_zher_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stride_x,A,lda, & stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_zher_strided_batched_rank_0 = rocblas_zher_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(A),lda,stride_A,batch_count) end function function rocblas_zher_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stride_x,A,lda, & stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_zher_strided_batched_rank_1 = rocblas_zher_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(A),lda,stride_A,batch_count) end function function rocblas_zher_strided_batched_full_rank(handle,uplo,n,alpha,x,incx,stride_x,A,lda, & stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_zher_strided_batched_full_rank = rocblas_zher_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(A),lda,stride_A,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cher2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocblas_cher2_assumed_rank = rocblas_cher2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #else function rocblas_cher2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy complex(c_float_complex),target :: A integer(c_int) :: lda ! rocblas_cher2_rank_0 = rocblas_cher2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function function rocblas_cher2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda ! rocblas_cher2_rank_1 = rocblas_cher2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function function rocblas_cher2_full_rank(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda ! rocblas_cher2_full_rank = rocblas_cher2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zher2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocblas_zher2_assumed_rank = rocblas_zher2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #else function rocblas_zher2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy complex(c_double_complex),target :: A integer(c_int) :: lda ! rocblas_zher2_rank_0 = rocblas_zher2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function function rocblas_zher2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda ! rocblas_zher2_rank_1 = rocblas_zher2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function function rocblas_zher2_full_rank(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda ! rocblas_zher2_full_rank = rocblas_zher2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cher2_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stride_x,y, & incy,stride_y,A,lda,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_cher2_strided_batched_assumed_rank = rocblas_cher2_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(A),lda,stride_A,batch_count) end function #else function rocblas_cher2_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,A,lda,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_cher2_strided_batched_rank_0 = rocblas_cher2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(A),lda,stride_A,batch_count) end function function rocblas_cher2_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,A,lda,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_cher2_strided_batched_rank_1 = rocblas_cher2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(A),lda,stride_A,batch_count) end function function rocblas_cher2_strided_batched_full_rank(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,A,lda,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_cher2_strided_batched_full_rank = rocblas_cher2_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(A),lda,stride_A,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zher2_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stride_x,y, & incy,stride_y,A,lda,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_zher2_strided_batched_assumed_rank = rocblas_zher2_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(A),lda,stride_A,batch_count) end function #else function rocblas_zher2_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,A,lda,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_zher2_strided_batched_rank_0 = rocblas_zher2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(A),lda,stride_A,batch_count) end function function rocblas_zher2_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,A,lda,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_zher2_strided_batched_rank_1 = rocblas_zher2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(A),lda,stride_A,batch_count) end function function rocblas_zher2_strided_batched_full_rank(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,A,lda,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_zher2_strided_batched_full_rank = rocblas_zher2_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(A),lda,stride_A,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_chpmv_assumed_rank(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_chpmv_assumed_rank = rocblas_chpmv_(handle,uplo,n,alpha,c_loc(AP),c_loc(x),incx, & beta,c_loc(y),incy) end function #else function rocblas_chpmv_rank_0(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy ! rocblas_chpmv_rank_0 = rocblas_chpmv_(handle,uplo,n,alpha,c_loc(AP),c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_chpmv_rank_1(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_chpmv_rank_1 = rocblas_chpmv_(handle,uplo,n,alpha,c_loc(AP),c_loc(x),incx,beta, & c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zhpmv_assumed_rank(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_zhpmv_assumed_rank = rocblas_zhpmv_(handle,uplo,n,alpha,c_loc(AP),c_loc(x),incx, & beta,c_loc(y),incy) end function #else function rocblas_zhpmv_rank_0(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy ! rocblas_zhpmv_rank_0 = rocblas_zhpmv_(handle,uplo,n,alpha,c_loc(AP),c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_zhpmv_rank_1(handle,uplo,n,alpha,AP,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_zhpmv_rank_1 = rocblas_zhpmv_(handle,uplo,n,alpha,c_loc(AP),c_loc(x),incx,beta, & c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_chpmv_strided_batched_assumed_rank(handle,uplo,n,alpha,AP,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: stride_A complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_chpmv_strided_batched_assumed_rank = rocblas_chpmv_strided_batched_(handle,uplo,n, & alpha,c_loc(AP),stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function #else function rocblas_chpmv_strided_batched_rank_0(handle,uplo,n,alpha,AP,stride_A,x,incx,stride_x, & beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: AP integer(c_int64_t) :: stride_A complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_chpmv_strided_batched_rank_0 = rocblas_chpmv_strided_batched_(handle,uplo,n,alpha, & c_loc(AP),stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function function rocblas_chpmv_strided_batched_rank_1(handle,uplo,n,alpha,AP,stride_A,x,incx,stride_x, & beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: AP integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_chpmv_strided_batched_rank_1 = rocblas_chpmv_strided_batched_(handle,uplo,n,alpha, & c_loc(AP),stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zhpmv_strided_batched_assumed_rank(handle,uplo,n,alpha,AP,stride_A,x,incx, & stride_x,beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: stride_A complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_zhpmv_strided_batched_assumed_rank = rocblas_zhpmv_strided_batched_(handle,uplo,n, & alpha,c_loc(AP),stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function #else function rocblas_zhpmv_strided_batched_rank_0(handle,uplo,n,alpha,AP,stride_A,x,incx,stride_x, & beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: AP integer(c_int64_t) :: stride_A complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_zhpmv_strided_batched_rank_0 = rocblas_zhpmv_strided_batched_(handle,uplo,n,alpha, & c_loc(AP),stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function function rocblas_zhpmv_strided_batched_rank_1(handle,uplo,n,alpha,AP,stride_A,x,incx,stride_x, & beta,y,incy,stride_y,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: AP integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y integer(c_int) :: batch_count ! rocblas_zhpmv_strided_batched_rank_1 = rocblas_zhpmv_strided_batched_(handle,uplo,n,alpha, & c_loc(AP),stride_A,c_loc(x),incx,stride_x,beta,c_loc(y),incy,stride_y,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_chpr_assumed_rank(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: AP ! rocblas_chpr_assumed_rank = rocblas_chpr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #else function rocblas_chpr_rank_0(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: AP ! rocblas_chpr_rank_0 = rocblas_chpr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function function rocblas_chpr_rank_1(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: AP ! rocblas_chpr_rank_1 = rocblas_chpr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zhpr_assumed_rank(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: AP ! rocblas_zhpr_assumed_rank = rocblas_zhpr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #else function rocblas_zhpr_rank_0(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: AP ! rocblas_zhpr_rank_0 = rocblas_zhpr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function function rocblas_zhpr_rank_1(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: AP ! rocblas_zhpr_rank_1 = rocblas_zhpr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_chpr_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stride_x,AP, & stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_chpr_strided_batched_assumed_rank = rocblas_chpr_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stride_x,c_loc(AP),stride_A,batch_count) end function #else function rocblas_chpr_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_chpr_strided_batched_rank_0 = rocblas_chpr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(AP),stride_A,batch_count) end function function rocblas_chpr_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target,dimension(:) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_chpr_strided_batched_rank_1 = rocblas_chpr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(AP),stride_A,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zhpr_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stride_x,AP, & stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_zhpr_strided_batched_assumed_rank = rocblas_zhpr_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stride_x,c_loc(AP),stride_A,batch_count) end function #else function rocblas_zhpr_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_zhpr_strided_batched_rank_0 = rocblas_zhpr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(AP),stride_A,batch_count) end function function rocblas_zhpr_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target,dimension(:) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_zhpr_strided_batched_rank_1 = rocblas_zhpr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(AP),stride_A,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_chpr2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_float_complex),target,contiguous,dimension(..) :: AP ! rocblas_chpr2_assumed_rank = rocblas_chpr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP)) end function #else function rocblas_chpr2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy complex(c_float_complex),target :: AP ! rocblas_chpr2_rank_0 = rocblas_chpr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP)) end function function rocblas_chpr2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_float_complex),target,dimension(:) :: AP ! rocblas_chpr2_rank_1 = rocblas_chpr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zhpr2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_double_complex),target,contiguous,dimension(..) :: AP ! rocblas_zhpr2_assumed_rank = rocblas_zhpr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP)) end function #else function rocblas_zhpr2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy complex(c_double_complex),target :: AP ! rocblas_zhpr2_rank_0 = rocblas_zhpr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP)) end function function rocblas_zhpr2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_double_complex),target,dimension(:) :: AP ! rocblas_zhpr2_rank_1 = rocblas_zhpr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_chpr2_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stride_x,y, & incy,stride_y,AP,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_chpr2_strided_batched_assumed_rank = rocblas_chpr2_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(AP),stride_A,batch_count) end function #else function rocblas_chpr2_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,AP,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y complex(c_float_complex),target :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_chpr2_strided_batched_rank_0 = rocblas_chpr2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(AP),stride_A,batch_count) end function function rocblas_chpr2_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,AP,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chpr2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y complex(c_float_complex),target,dimension(:) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_chpr2_strided_batched_rank_1 = rocblas_chpr2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(AP),stride_A,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zhpr2_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stride_x,y, & incy,stride_y,AP,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_zhpr2_strided_batched_assumed_rank = rocblas_zhpr2_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(AP),stride_A,batch_count) end function #else function rocblas_zhpr2_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,AP,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y complex(c_double_complex),target :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_zhpr2_strided_batched_rank_0 = rocblas_zhpr2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(AP),stride_A,batch_count) end function function rocblas_zhpr2_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,AP,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhpr2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y complex(c_double_complex),target,dimension(:) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_zhpr2_strided_batched_rank_1 = rocblas_zhpr2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(AP),stride_A,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_strmv_assumed_rank(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_strmv_assumed_rank = rocblas_strmv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x), & incx) end function #else function rocblas_strmv_rank_0(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: x integer(c_int) :: incx ! rocblas_strmv_rank_0 = rocblas_strmv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function function rocblas_strmv_rank_1(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_strmv_rank_1 = rocblas_strmv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function function rocblas_strmv_full_rank(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_strmv_full_rank = rocblas_strmv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dtrmv_assumed_rank(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_dtrmv_assumed_rank = rocblas_dtrmv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x), & incx) end function #else function rocblas_dtrmv_rank_0(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: x integer(c_int) :: incx ! rocblas_dtrmv_rank_0 = rocblas_dtrmv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function function rocblas_dtrmv_rank_1(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_dtrmv_rank_1 = rocblas_dtrmv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function function rocblas_dtrmv_full_rank(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_dtrmv_full_rank = rocblas_dtrmv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ctrmv_assumed_rank(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_ctrmv_assumed_rank = rocblas_ctrmv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x), & incx) end function #else function rocblas_ctrmv_rank_0(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx ! rocblas_ctrmv_rank_0 = rocblas_ctrmv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function function rocblas_ctrmv_rank_1(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ctrmv_rank_1 = rocblas_ctrmv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function function rocblas_ctrmv_full_rank(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ctrmv_full_rank = rocblas_ctrmv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ztrmv_assumed_rank(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_ztrmv_assumed_rank = rocblas_ztrmv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x), & incx) end function #else function rocblas_ztrmv_rank_0(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx ! rocblas_ztrmv_rank_0 = rocblas_ztrmv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function function rocblas_ztrmv_rank_1(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ztrmv_rank_1 = rocblas_ztrmv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function function rocblas_ztrmv_full_rank(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ztrmv_full_rank = rocblas_ztrmv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_strmv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,A,lda,stride_A, & x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_strmv_strided_batched_assumed_rank = rocblas_strmv_strided_batched_(handle,uplo, & transA,diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_strmv_strided_batched_rank_0(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_strmv_strided_batched_rank_0 = rocblas_strmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_strmv_strided_batched_rank_1(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_strmv_strided_batched_rank_1 = rocblas_strmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_strmv_strided_batched_full_rank(handle,uplo,transA,diag,n,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_strmv_strided_batched_full_rank = rocblas_strmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dtrmv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,A,lda,stride_A, & x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtrmv_strided_batched_assumed_rank = rocblas_dtrmv_strided_batched_(handle,uplo, & transA,diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_dtrmv_strided_batched_rank_0(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtrmv_strided_batched_rank_0 = rocblas_dtrmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_dtrmv_strided_batched_rank_1(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtrmv_strided_batched_rank_1 = rocblas_dtrmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_dtrmv_strided_batched_full_rank(handle,uplo,transA,diag,n,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtrmv_strided_batched_full_rank = rocblas_dtrmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ctrmv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,A,lda,stride_A, & x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctrmv_strided_batched_assumed_rank = rocblas_ctrmv_strided_batched_(handle,uplo, & transA,diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_ctrmv_strided_batched_rank_0(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctrmv_strided_batched_rank_0 = rocblas_ctrmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ctrmv_strided_batched_rank_1(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctrmv_strided_batched_rank_1 = rocblas_ctrmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ctrmv_strided_batched_full_rank(handle,uplo,transA,diag,n,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctrmv_strided_batched_full_rank = rocblas_ctrmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ztrmv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,A,lda,stride_A, & x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztrmv_strided_batched_assumed_rank = rocblas_ztrmv_strided_batched_(handle,uplo, & transA,diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_ztrmv_strided_batched_rank_0(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztrmv_strided_batched_rank_0 = rocblas_ztrmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ztrmv_strided_batched_rank_1(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztrmv_strided_batched_rank_1 = rocblas_ztrmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ztrmv_strided_batched_full_rank(handle,uplo,transA,diag,n,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztrmv_strided_batched_full_rank = rocblas_ztrmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_stpmv_assumed_rank(handle,uplo,transA,diag,n,A,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_stpmv_assumed_rank = rocblas_stpmv_(handle,uplo,transA,diag,n,c_loc(A),c_loc(x),incx) end function #else function rocblas_stpmv_rank_0(handle,uplo,transA,diag,n,A,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target :: A real(c_float),target :: x integer(c_int) :: incx ! rocblas_stpmv_rank_0 = rocblas_stpmv_(handle,uplo,transA,diag,n,c_loc(A),c_loc(x),incx) end function function rocblas_stpmv_rank_1(handle,uplo,transA,diag,n,A,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: A real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_stpmv_rank_1 = rocblas_stpmv_(handle,uplo,transA,diag,n,c_loc(A),c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dtpmv_assumed_rank(handle,uplo,transA,diag,n,A,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_dtpmv_assumed_rank = rocblas_dtpmv_(handle,uplo,transA,diag,n,c_loc(A),c_loc(x),incx) end function #else function rocblas_dtpmv_rank_0(handle,uplo,transA,diag,n,A,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target :: A real(c_double),target :: x integer(c_int) :: incx ! rocblas_dtpmv_rank_0 = rocblas_dtpmv_(handle,uplo,transA,diag,n,c_loc(A),c_loc(x),incx) end function function rocblas_dtpmv_rank_1(handle,uplo,transA,diag,n,A,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: A real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_dtpmv_rank_1 = rocblas_dtpmv_(handle,uplo,transA,diag,n,c_loc(A),c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ctpmv_assumed_rank(handle,uplo,transA,diag,n,A,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_ctpmv_assumed_rank = rocblas_ctpmv_(handle,uplo,transA,diag,n,c_loc(A),c_loc(x),incx) end function #else function rocblas_ctpmv_rank_0(handle,uplo,transA,diag,n,A,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target :: A complex(c_float_complex),target :: x integer(c_int) :: incx ! rocblas_ctpmv_rank_0 = rocblas_ctpmv_(handle,uplo,transA,diag,n,c_loc(A),c_loc(x),incx) end function function rocblas_ctpmv_rank_1(handle,uplo,transA,diag,n,A,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ctpmv_rank_1 = rocblas_ctpmv_(handle,uplo,transA,diag,n,c_loc(A),c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ztpmv_assumed_rank(handle,uplo,transA,diag,n,A,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_ztpmv_assumed_rank = rocblas_ztpmv_(handle,uplo,transA,diag,n,c_loc(A),c_loc(x),incx) end function #else function rocblas_ztpmv_rank_0(handle,uplo,transA,diag,n,A,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target :: A complex(c_double_complex),target :: x integer(c_int) :: incx ! rocblas_ztpmv_rank_0 = rocblas_ztpmv_(handle,uplo,transA,diag,n,c_loc(A),c_loc(x),incx) end function function rocblas_ztpmv_rank_1(handle,uplo,transA,diag,n,A,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ztpmv_rank_1 = rocblas_ztpmv_(handle,uplo,transA,diag,n,c_loc(A),c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_stpmv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,A,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int64_t) :: stride_A real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_stpmv_strided_batched_assumed_rank = rocblas_stpmv_strided_batched_(handle,uplo, & transA,diag,n,c_loc(A),stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_stpmv_strided_batched_rank_0(handle,uplo,transA,diag,n,A,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target :: A integer(c_int64_t) :: stride_A real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_stpmv_strided_batched_rank_0 = rocblas_stpmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_stpmv_strided_batched_rank_1(handle,uplo,transA,diag,n,A,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int64_t) :: stride_A real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_stpmv_strided_batched_rank_1 = rocblas_stpmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dtpmv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,A,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int64_t) :: stride_A real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtpmv_strided_batched_assumed_rank = rocblas_dtpmv_strided_batched_(handle,uplo, & transA,diag,n,c_loc(A),stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_dtpmv_strided_batched_rank_0(handle,uplo,transA,diag,n,A,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target :: A integer(c_int64_t) :: stride_A real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtpmv_strided_batched_rank_0 = rocblas_dtpmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_dtpmv_strided_batched_rank_1(handle,uplo,transA,diag,n,A,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int64_t) :: stride_A real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtpmv_strided_batched_rank_1 = rocblas_dtpmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ctpmv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,A,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int64_t) :: stride_A complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctpmv_strided_batched_assumed_rank = rocblas_ctpmv_strided_batched_(handle,uplo, & transA,diag,n,c_loc(A),stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_ctpmv_strided_batched_rank_0(handle,uplo,transA,diag,n,A,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int64_t) :: stride_A complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctpmv_strided_batched_rank_0 = rocblas_ctpmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ctpmv_strided_batched_rank_1(handle,uplo,transA,diag,n,A,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctpmv_strided_batched_rank_1 = rocblas_ctpmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ztpmv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,A,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int64_t) :: stride_A complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztpmv_strided_batched_assumed_rank = rocblas_ztpmv_strided_batched_(handle,uplo, & transA,diag,n,c_loc(A),stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_ztpmv_strided_batched_rank_0(handle,uplo,transA,diag,n,A,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int64_t) :: stride_A complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztpmv_strided_batched_rank_0 = rocblas_ztpmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ztpmv_strided_batched_rank_1(handle,uplo,transA,diag,n,A,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztpmv_strided_batched_rank_1 = rocblas_ztpmv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_stbmv_assumed_rank(handle,uplo,trans,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_stbmv_assumed_rank = rocblas_stbmv_(handle,uplo,trans,diag,n,k,c_loc(A),lda, & c_loc(x),incx) end function #else function rocblas_stbmv_rank_0(handle,uplo,trans,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: x integer(c_int) :: incx ! rocblas_stbmv_rank_0 = rocblas_stbmv_(handle,uplo,trans,diag,n,k,c_loc(A),lda,c_loc(x),incx) end function function rocblas_stbmv_rank_1(handle,uplo,trans,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_stbmv_rank_1 = rocblas_stbmv_(handle,uplo,trans,diag,n,k,c_loc(A),lda,c_loc(x),incx) end function function rocblas_stbmv_full_rank(handle,uplo,trans,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbmv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_stbmv_full_rank = rocblas_stbmv_(handle,uplo,trans,diag,n,k,c_loc(A),lda,c_loc(x), & incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dtbmv_assumed_rank(handle,uplo,trans,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_dtbmv_assumed_rank = rocblas_dtbmv_(handle,uplo,trans,diag,n,k,c_loc(A),lda, & c_loc(x),incx) end function #else function rocblas_dtbmv_rank_0(handle,uplo,trans,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: x integer(c_int) :: incx ! rocblas_dtbmv_rank_0 = rocblas_dtbmv_(handle,uplo,trans,diag,n,k,c_loc(A),lda,c_loc(x),incx) end function function rocblas_dtbmv_rank_1(handle,uplo,trans,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_dtbmv_rank_1 = rocblas_dtbmv_(handle,uplo,trans,diag,n,k,c_loc(A),lda,c_loc(x),incx) end function function rocblas_dtbmv_full_rank(handle,uplo,trans,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbmv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_dtbmv_full_rank = rocblas_dtbmv_(handle,uplo,trans,diag,n,k,c_loc(A),lda,c_loc(x), & incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ctbmv_assumed_rank(handle,uplo,trans,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_ctbmv_assumed_rank = rocblas_ctbmv_(handle,uplo,trans,diag,n,k,c_loc(A),lda, & c_loc(x),incx) end function #else function rocblas_ctbmv_rank_0(handle,uplo,trans,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx ! rocblas_ctbmv_rank_0 = rocblas_ctbmv_(handle,uplo,trans,diag,n,k,c_loc(A),lda,c_loc(x),incx) end function function rocblas_ctbmv_rank_1(handle,uplo,trans,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ctbmv_rank_1 = rocblas_ctbmv_(handle,uplo,trans,diag,n,k,c_loc(A),lda,c_loc(x),incx) end function function rocblas_ctbmv_full_rank(handle,uplo,trans,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbmv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ctbmv_full_rank = rocblas_ctbmv_(handle,uplo,trans,diag,n,k,c_loc(A),lda,c_loc(x), & incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ztbmv_assumed_rank(handle,uplo,trans,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_ztbmv_assumed_rank = rocblas_ztbmv_(handle,uplo,trans,diag,n,k,c_loc(A),lda, & c_loc(x),incx) end function #else function rocblas_ztbmv_rank_0(handle,uplo,trans,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx ! rocblas_ztbmv_rank_0 = rocblas_ztbmv_(handle,uplo,trans,diag,n,k,c_loc(A),lda,c_loc(x),incx) end function function rocblas_ztbmv_rank_1(handle,uplo,trans,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ztbmv_rank_1 = rocblas_ztbmv_(handle,uplo,trans,diag,n,k,c_loc(A),lda,c_loc(x),incx) end function function rocblas_ztbmv_full_rank(handle,uplo,trans,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbmv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ztbmv_full_rank = rocblas_ztbmv_(handle,uplo,trans,diag,n,k,c_loc(A),lda,c_loc(x), & incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_stbmv_strided_batched_assumed_rank(handle,uplo,trans,diag,n,k,A,lda,stride_A, & x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_stbmv_strided_batched_assumed_rank = rocblas_stbmv_strided_batched_(handle,uplo, & trans,diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_stbmv_strided_batched_rank_0(handle,uplo,trans,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_stbmv_strided_batched_rank_0 = rocblas_stbmv_strided_batched_(handle,uplo,trans, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_stbmv_strided_batched_rank_1(handle,uplo,trans,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_stbmv_strided_batched_rank_1 = rocblas_stbmv_strided_batched_(handle,uplo,trans, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_stbmv_strided_batched_full_rank(handle,uplo,trans,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbmv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_stbmv_strided_batched_full_rank = rocblas_stbmv_strided_batched_(handle,uplo,trans, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dtbmv_strided_batched_assumed_rank(handle,uplo,trans,diag,n,k,A,lda,stride_A, & x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtbmv_strided_batched_assumed_rank = rocblas_dtbmv_strided_batched_(handle,uplo, & trans,diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_dtbmv_strided_batched_rank_0(handle,uplo,trans,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtbmv_strided_batched_rank_0 = rocblas_dtbmv_strided_batched_(handle,uplo,trans, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_dtbmv_strided_batched_rank_1(handle,uplo,trans,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtbmv_strided_batched_rank_1 = rocblas_dtbmv_strided_batched_(handle,uplo,trans, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_dtbmv_strided_batched_full_rank(handle,uplo,trans,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbmv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtbmv_strided_batched_full_rank = rocblas_dtbmv_strided_batched_(handle,uplo,trans, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ctbmv_strided_batched_assumed_rank(handle,uplo,trans,diag,n,k,A,lda,stride_A, & x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctbmv_strided_batched_assumed_rank = rocblas_ctbmv_strided_batched_(handle,uplo, & trans,diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_ctbmv_strided_batched_rank_0(handle,uplo,trans,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctbmv_strided_batched_rank_0 = rocblas_ctbmv_strided_batched_(handle,uplo,trans, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ctbmv_strided_batched_rank_1(handle,uplo,trans,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctbmv_strided_batched_rank_1 = rocblas_ctbmv_strided_batched_(handle,uplo,trans, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ctbmv_strided_batched_full_rank(handle,uplo,trans,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbmv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctbmv_strided_batched_full_rank = rocblas_ctbmv_strided_batched_(handle,uplo,trans, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ztbmv_strided_batched_assumed_rank(handle,uplo,trans,diag,n,k,A,lda,stride_A, & x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztbmv_strided_batched_assumed_rank = rocblas_ztbmv_strided_batched_(handle,uplo, & trans,diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_ztbmv_strided_batched_rank_0(handle,uplo,trans,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztbmv_strided_batched_rank_0 = rocblas_ztbmv_strided_batched_(handle,uplo,trans, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ztbmv_strided_batched_rank_1(handle,uplo,trans,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztbmv_strided_batched_rank_1 = rocblas_ztbmv_strided_batched_(handle,uplo,trans, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ztbmv_strided_batched_full_rank(handle,uplo,trans,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbmv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztbmv_strided_batched_full_rank = rocblas_ztbmv_strided_batched_(handle,uplo,trans, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_stbsv_assumed_rank(handle,uplo,transA,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbsv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_stbsv_assumed_rank = rocblas_stbsv_(handle,uplo,transA,diag,n,k,c_loc(A),lda, & c_loc(x),incx) end function #else function rocblas_stbsv_rank_0(handle,uplo,transA,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbsv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: x integer(c_int) :: incx ! rocblas_stbsv_rank_0 = rocblas_stbsv_(handle,uplo,transA,diag,n,k,c_loc(A),lda,c_loc(x),incx) end function function rocblas_stbsv_rank_1(handle,uplo,transA,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbsv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_stbsv_rank_1 = rocblas_stbsv_(handle,uplo,transA,diag,n,k,c_loc(A),lda,c_loc(x),incx) end function function rocblas_stbsv_full_rank(handle,uplo,transA,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbsv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_stbsv_full_rank = rocblas_stbsv_(handle,uplo,transA,diag,n,k,c_loc(A),lda,c_loc(x), & incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dtbsv_assumed_rank(handle,uplo,transA,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbsv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_dtbsv_assumed_rank = rocblas_dtbsv_(handle,uplo,transA,diag,n,k,c_loc(A),lda, & c_loc(x),incx) end function #else function rocblas_dtbsv_rank_0(handle,uplo,transA,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbsv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: x integer(c_int) :: incx ! rocblas_dtbsv_rank_0 = rocblas_dtbsv_(handle,uplo,transA,diag,n,k,c_loc(A),lda,c_loc(x),incx) end function function rocblas_dtbsv_rank_1(handle,uplo,transA,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbsv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_dtbsv_rank_1 = rocblas_dtbsv_(handle,uplo,transA,diag,n,k,c_loc(A),lda,c_loc(x),incx) end function function rocblas_dtbsv_full_rank(handle,uplo,transA,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbsv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_dtbsv_full_rank = rocblas_dtbsv_(handle,uplo,transA,diag,n,k,c_loc(A),lda,c_loc(x), & incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ctbsv_assumed_rank(handle,uplo,transA,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbsv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_ctbsv_assumed_rank = rocblas_ctbsv_(handle,uplo,transA,diag,n,k,c_loc(A),lda, & c_loc(x),incx) end function #else function rocblas_ctbsv_rank_0(handle,uplo,transA,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbsv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx ! rocblas_ctbsv_rank_0 = rocblas_ctbsv_(handle,uplo,transA,diag,n,k,c_loc(A),lda,c_loc(x),incx) end function function rocblas_ctbsv_rank_1(handle,uplo,transA,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbsv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ctbsv_rank_1 = rocblas_ctbsv_(handle,uplo,transA,diag,n,k,c_loc(A),lda,c_loc(x),incx) end function function rocblas_ctbsv_full_rank(handle,uplo,transA,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbsv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ctbsv_full_rank = rocblas_ctbsv_(handle,uplo,transA,diag,n,k,c_loc(A),lda,c_loc(x), & incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ztbsv_assumed_rank(handle,uplo,transA,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbsv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_ztbsv_assumed_rank = rocblas_ztbsv_(handle,uplo,transA,diag,n,k,c_loc(A),lda, & c_loc(x),incx) end function #else function rocblas_ztbsv_rank_0(handle,uplo,transA,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbsv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx ! rocblas_ztbsv_rank_0 = rocblas_ztbsv_(handle,uplo,transA,diag,n,k,c_loc(A),lda,c_loc(x),incx) end function function rocblas_ztbsv_rank_1(handle,uplo,transA,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbsv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ztbsv_rank_1 = rocblas_ztbsv_(handle,uplo,transA,diag,n,k,c_loc(A),lda,c_loc(x),incx) end function function rocblas_ztbsv_full_rank(handle,uplo,transA,diag,n,k,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbsv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ztbsv_full_rank = rocblas_ztbsv_(handle,uplo,transA,diag,n,k,c_loc(A),lda,c_loc(x), & incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_stbsv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,k,A,lda, & stride_A,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbsv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_stbsv_strided_batched_assumed_rank = rocblas_stbsv_strided_batched_(handle,uplo, & transA,diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_stbsv_strided_batched_rank_0(handle,uplo,transA,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbsv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_stbsv_strided_batched_rank_0 = rocblas_stbsv_strided_batched_(handle,uplo,transA, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_stbsv_strided_batched_rank_1(handle,uplo,transA,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbsv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_stbsv_strided_batched_rank_1 = rocblas_stbsv_strided_batched_(handle,uplo,transA, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_stbsv_strided_batched_full_rank(handle,uplo,transA,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stbsv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_stbsv_strided_batched_full_rank = rocblas_stbsv_strided_batched_(handle,uplo,transA, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dtbsv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,k,A,lda, & stride_A,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbsv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtbsv_strided_batched_assumed_rank = rocblas_dtbsv_strided_batched_(handle,uplo, & transA,diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_dtbsv_strided_batched_rank_0(handle,uplo,transA,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbsv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtbsv_strided_batched_rank_0 = rocblas_dtbsv_strided_batched_(handle,uplo,transA, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_dtbsv_strided_batched_rank_1(handle,uplo,transA,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbsv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtbsv_strided_batched_rank_1 = rocblas_dtbsv_strided_batched_(handle,uplo,transA, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_dtbsv_strided_batched_full_rank(handle,uplo,transA,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtbsv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtbsv_strided_batched_full_rank = rocblas_dtbsv_strided_batched_(handle,uplo,transA, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ctbsv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,k,A,lda, & stride_A,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbsv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctbsv_strided_batched_assumed_rank = rocblas_ctbsv_strided_batched_(handle,uplo, & transA,diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_ctbsv_strided_batched_rank_0(handle,uplo,transA,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbsv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctbsv_strided_batched_rank_0 = rocblas_ctbsv_strided_batched_(handle,uplo,transA, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ctbsv_strided_batched_rank_1(handle,uplo,transA,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbsv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctbsv_strided_batched_rank_1 = rocblas_ctbsv_strided_batched_(handle,uplo,transA, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ctbsv_strided_batched_full_rank(handle,uplo,transA,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctbsv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctbsv_strided_batched_full_rank = rocblas_ctbsv_strided_batched_(handle,uplo,transA, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ztbsv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,k,A,lda, & stride_A,x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbsv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztbsv_strided_batched_assumed_rank = rocblas_ztbsv_strided_batched_(handle,uplo, & transA,diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_ztbsv_strided_batched_rank_0(handle,uplo,transA,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbsv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztbsv_strided_batched_rank_0 = rocblas_ztbsv_strided_batched_(handle,uplo,transA, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ztbsv_strided_batched_rank_1(handle,uplo,transA,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbsv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztbsv_strided_batched_rank_1 = rocblas_ztbsv_strided_batched_(handle,uplo,transA, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ztbsv_strided_batched_full_rank(handle,uplo,transA,diag,n,k,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztbsv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztbsv_strided_batched_full_rank = rocblas_ztbsv_strided_batched_(handle,uplo,transA, & diag,n,k,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_strsv_assumed_rank(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_strsv_assumed_rank = rocblas_strsv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x), & incx) end function #else function rocblas_strsv_rank_0(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: x integer(c_int) :: incx ! rocblas_strsv_rank_0 = rocblas_strsv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function function rocblas_strsv_rank_1(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_strsv_rank_1 = rocblas_strsv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function function rocblas_strsv_full_rank(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_strsv_full_rank = rocblas_strsv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dtrsv_assumed_rank(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_dtrsv_assumed_rank = rocblas_dtrsv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x), & incx) end function #else function rocblas_dtrsv_rank_0(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: x integer(c_int) :: incx ! rocblas_dtrsv_rank_0 = rocblas_dtrsv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function function rocblas_dtrsv_rank_1(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_dtrsv_rank_1 = rocblas_dtrsv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function function rocblas_dtrsv_full_rank(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_dtrsv_full_rank = rocblas_dtrsv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ctrsv_assumed_rank(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_ctrsv_assumed_rank = rocblas_ctrsv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x), & incx) end function #else function rocblas_ctrsv_rank_0(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx ! rocblas_ctrsv_rank_0 = rocblas_ctrsv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function function rocblas_ctrsv_rank_1(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ctrsv_rank_1 = rocblas_ctrsv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function function rocblas_ctrsv_full_rank(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ctrsv_full_rank = rocblas_ctrsv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ztrsv_assumed_rank(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_ztrsv_assumed_rank = rocblas_ztrsv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x), & incx) end function #else function rocblas_ztrsv_rank_0(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx ! rocblas_ztrsv_rank_0 = rocblas_ztrsv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function function rocblas_ztrsv_rank_1(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ztrsv_rank_1 = rocblas_ztrsv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function function rocblas_ztrsv_full_rank(handle,uplo,transA,diag,n,A,lda,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ztrsv_full_rank = rocblas_ztrsv_(handle,uplo,transA,diag,n,c_loc(A),lda,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_strsv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,A,lda,stride_A, & x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_strsv_strided_batched_assumed_rank = rocblas_strsv_strided_batched_(handle,uplo, & transA,diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_strsv_strided_batched_rank_0(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_strsv_strided_batched_rank_0 = rocblas_strsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_strsv_strided_batched_rank_1(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_strsv_strided_batched_rank_1 = rocblas_strsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_strsv_strided_batched_full_rank(handle,uplo,transA,diag,n,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_strsv_strided_batched_full_rank = rocblas_strsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dtrsv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,A,lda,stride_A, & x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtrsv_strided_batched_assumed_rank = rocblas_dtrsv_strided_batched_(handle,uplo, & transA,diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_dtrsv_strided_batched_rank_0(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtrsv_strided_batched_rank_0 = rocblas_dtrsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_dtrsv_strided_batched_rank_1(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtrsv_strided_batched_rank_1 = rocblas_dtrsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_dtrsv_strided_batched_full_rank(handle,uplo,transA,diag,n,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtrsv_strided_batched_full_rank = rocblas_dtrsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ctrsv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,A,lda,stride_A, & x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctrsv_strided_batched_assumed_rank = rocblas_ctrsv_strided_batched_(handle,uplo, & transA,diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_ctrsv_strided_batched_rank_0(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctrsv_strided_batched_rank_0 = rocblas_ctrsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ctrsv_strided_batched_rank_1(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctrsv_strided_batched_rank_1 = rocblas_ctrsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ctrsv_strided_batched_full_rank(handle,uplo,transA,diag,n,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctrsv_strided_batched_full_rank = rocblas_ctrsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ztrsv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,A,lda,stride_A, & x,incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztrsv_strided_batched_assumed_rank = rocblas_ztrsv_strided_batched_(handle,uplo, & transA,diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_ztrsv_strided_batched_rank_0(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztrsv_strided_batched_rank_0 = rocblas_ztrsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ztrsv_strided_batched_rank_1(handle,uplo,transA,diag,n,A,lda,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztrsv_strided_batched_rank_1 = rocblas_ztrsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ztrsv_strided_batched_full_rank(handle,uplo,transA,diag,n,A,lda,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztrsv_strided_batched_full_rank = rocblas_ztrsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_stpsv_assumed_rank(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpsv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: AP real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_stpsv_assumed_rank = rocblas_stpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #else function rocblas_stpsv_rank_0(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpsv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target :: AP real(c_float),target :: x integer(c_int) :: incx ! rocblas_stpsv_rank_0 = rocblas_stpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function function rocblas_stpsv_rank_1(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpsv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: AP real(c_float),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_stpsv_rank_1 = rocblas_stpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dtpsv_assumed_rank(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpsv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: AP real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_dtpsv_assumed_rank = rocblas_dtpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #else function rocblas_dtpsv_rank_0(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpsv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target :: AP real(c_double),target :: x integer(c_int) :: incx ! rocblas_dtpsv_rank_0 = rocblas_dtpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function function rocblas_dtpsv_rank_1(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpsv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: AP real(c_double),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_dtpsv_rank_1 = rocblas_dtpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ctpsv_assumed_rank(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpsv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: AP complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_ctpsv_assumed_rank = rocblas_ctpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #else function rocblas_ctpsv_rank_0(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpsv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target :: AP complex(c_float_complex),target :: x integer(c_int) :: incx ! rocblas_ctpsv_rank_0 = rocblas_ctpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function function rocblas_ctpsv_rank_1(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpsv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: AP complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ctpsv_rank_1 = rocblas_ctpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ztpsv_assumed_rank(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpsv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: AP complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocblas_ztpsv_assumed_rank = rocblas_ztpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #else function rocblas_ztpsv_rank_0(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpsv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target :: AP complex(c_double_complex),target :: x integer(c_int) :: incx ! rocblas_ztpsv_rank_0 = rocblas_ztpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function function rocblas_ztpsv_rank_1(handle,uplo,transA,diag,n,AP,x,incx) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpsv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: AP complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocblas_ztpsv_rank_1 = rocblas_ztpsv_(handle,uplo,transA,diag,n,c_loc(AP),c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_stpsv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,AP,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpsv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: stride_A real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_stpsv_strided_batched_assumed_rank = rocblas_stpsv_strided_batched_(handle,uplo, & transA,diag,n,c_loc(AP),stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_stpsv_strided_batched_rank_0(handle,uplo,transA,diag,n,AP,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpsv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target :: AP integer(c_int64_t) :: stride_A real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_stpsv_strided_batched_rank_0 = rocblas_stpsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(AP),stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_stpsv_strided_batched_rank_1(handle,uplo,transA,diag,n,AP,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_stpsv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: AP integer(c_int64_t) :: stride_A real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_stpsv_strided_batched_rank_1 = rocblas_stpsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(AP),stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dtpsv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,AP,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpsv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: stride_A real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtpsv_strided_batched_assumed_rank = rocblas_dtpsv_strided_batched_(handle,uplo, & transA,diag,n,c_loc(AP),stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_dtpsv_strided_batched_rank_0(handle,uplo,transA,diag,n,AP,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpsv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target :: AP integer(c_int64_t) :: stride_A real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtpsv_strided_batched_rank_0 = rocblas_dtpsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(AP),stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_dtpsv_strided_batched_rank_1(handle,uplo,transA,diag,n,AP,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtpsv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: AP integer(c_int64_t) :: stride_A real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_dtpsv_strided_batched_rank_1 = rocblas_dtpsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(AP),stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ctpsv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,AP,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpsv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: stride_A complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctpsv_strided_batched_assumed_rank = rocblas_ctpsv_strided_batched_(handle,uplo, & transA,diag,n,c_loc(AP),stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_ctpsv_strided_batched_rank_0(handle,uplo,transA,diag,n,AP,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpsv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target :: AP integer(c_int64_t) :: stride_A complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctpsv_strided_batched_rank_0 = rocblas_ctpsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(AP),stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ctpsv_strided_batched_rank_1(handle,uplo,transA,diag,n,AP,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctpsv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: AP integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ctpsv_strided_batched_rank_1 = rocblas_ctpsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(AP),stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ztpsv_strided_batched_assumed_rank(handle,uplo,transA,diag,n,AP,stride_A,x, & incx,stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpsv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: stride_A complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztpsv_strided_batched_assumed_rank = rocblas_ztpsv_strided_batched_(handle,uplo, & transA,diag,n,c_loc(AP),stride_A,c_loc(x),incx,stride_x,batch_count) end function #else function rocblas_ztpsv_strided_batched_rank_0(handle,uplo,transA,diag,n,AP,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpsv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target :: AP integer(c_int64_t) :: stride_A complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztpsv_strided_batched_rank_0 = rocblas_ztpsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(AP),stride_A,c_loc(x),incx,stride_x,batch_count) end function function rocblas_ztpsv_strided_batched_rank_1(handle,uplo,transA,diag,n,AP,stride_A,x,incx, & stride_x,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztpsv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: AP integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x integer(c_int) :: batch_count ! rocblas_ztpsv_strided_batched_rank_1 = rocblas_ztpsv_strided_batched_(handle,uplo,transA, & diag,n,c_loc(AP),stride_A,c_loc(x),incx,stride_x,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ssymv_assumed_rank(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_ssymv_assumed_rank = rocblas_ssymv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #else function rocblas_ssymv_rank_0(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy ! rocblas_ssymv_rank_0 = rocblas_ssymv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_ssymv_rank_1(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_ssymv_rank_1 = rocblas_ssymv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_ssymv_full_rank(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_ssymv_full_rank = rocblas_ssymv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dsymv_assumed_rank(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_dsymv_assumed_rank = rocblas_dsymv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #else function rocblas_dsymv_rank_0(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy ! rocblas_dsymv_rank_0 = rocblas_dsymv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_dsymv_rank_1(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_dsymv_rank_1 = rocblas_dsymv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_dsymv_full_rank(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_dsymv_full_rank = rocblas_dsymv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_csymv_assumed_rank(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_csymv_assumed_rank = rocblas_csymv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #else function rocblas_csymv_rank_0(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy ! rocblas_csymv_rank_0 = rocblas_csymv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_csymv_rank_1(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_csymv_rank_1 = rocblas_csymv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_csymv_full_rank(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_csymv_full_rank = rocblas_csymv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zsymv_assumed_rank(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_zsymv_assumed_rank = rocblas_zsymv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #else function rocblas_zsymv_rank_0(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy ! rocblas_zsymv_rank_0 = rocblas_zsymv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_zsymv_rank_1(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_zsymv_rank_1 = rocblas_zsymv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_zsymv_full_rank(handle,uplo,n,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_zsymv_full_rank = rocblas_zsymv_(handle,uplo,n,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ssymv_strided_batched_assumed_rank(handle,uplo,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_ssymv_strided_batched_assumed_rank = rocblas_ssymv_strided_batched_(handle,uplo,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_ssymv_strided_batched_rank_0(handle,uplo,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_ssymv_strided_batched_rank_0 = rocblas_ssymv_strided_batched_(handle,uplo,n,alpha, & c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_ssymv_strided_batched_rank_1(handle,uplo,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_ssymv_strided_batched_rank_1 = rocblas_ssymv_strided_batched_(handle,uplo,n,alpha, & c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_ssymv_strided_batched_full_rank(handle,uplo,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_ssymv_strided_batched_full_rank = rocblas_ssymv_strided_batched_(handle,uplo,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dsymv_strided_batched_assumed_rank(handle,uplo,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dsymv_strided_batched_assumed_rank = rocblas_dsymv_strided_batched_(handle,uplo,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_dsymv_strided_batched_rank_0(handle,uplo,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dsymv_strided_batched_rank_0 = rocblas_dsymv_strided_batched_(handle,uplo,n,alpha, & c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_dsymv_strided_batched_rank_1(handle,uplo,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dsymv_strided_batched_rank_1 = rocblas_dsymv_strided_batched_(handle,uplo,n,alpha, & c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_dsymv_strided_batched_full_rank(handle,uplo,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dsymv_strided_batched_full_rank = rocblas_dsymv_strided_batched_(handle,uplo,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_csymv_strided_batched_assumed_rank(handle,uplo,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_csymv_strided_batched_assumed_rank = rocblas_csymv_strided_batched_(handle,uplo,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_csymv_strided_batched_rank_0(handle,uplo,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_csymv_strided_batched_rank_0 = rocblas_csymv_strided_batched_(handle,uplo,n,alpha, & c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_csymv_strided_batched_rank_1(handle,uplo,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_csymv_strided_batched_rank_1 = rocblas_csymv_strided_batched_(handle,uplo,n,alpha, & c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_csymv_strided_batched_full_rank(handle,uplo,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_csymv_strided_batched_full_rank = rocblas_csymv_strided_batched_(handle,uplo,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zsymv_strided_batched_assumed_rank(handle,uplo,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_zsymv_strided_batched_assumed_rank = rocblas_zsymv_strided_batched_(handle,uplo,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_zsymv_strided_batched_rank_0(handle,uplo,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_zsymv_strided_batched_rank_0 = rocblas_zsymv_strided_batched_(handle,uplo,n,alpha, & c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_zsymv_strided_batched_rank_1(handle,uplo,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_zsymv_strided_batched_rank_1 = rocblas_zsymv_strided_batched_(handle,uplo,n,alpha, & c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_zsymv_strided_batched_full_rank(handle,uplo,n,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_zsymv_strided_batched_full_rank = rocblas_zsymv_strided_batched_(handle,uplo,n, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sspmv_assumed_rank(handle,uplo,n,alpha,A,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_sspmv_assumed_rank = rocblas_sspmv_(handle,uplo,n,alpha,c_loc(A),c_loc(x),incx,beta, & c_loc(y),incy) end function #else function rocblas_sspmv_rank_0(handle,uplo,n,alpha,A,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: A real(c_float),target :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy ! rocblas_sspmv_rank_0 = rocblas_sspmv_(handle,uplo,n,alpha,c_loc(A),c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_sspmv_rank_1(handle,uplo,n,alpha,A,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: A real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_sspmv_rank_1 = rocblas_sspmv_(handle,uplo,n,alpha,c_loc(A),c_loc(x),incx,beta, & c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dspmv_assumed_rank(handle,uplo,n,alpha,A,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_dspmv_assumed_rank = rocblas_dspmv_(handle,uplo,n,alpha,c_loc(A),c_loc(x),incx,beta, & c_loc(y),incy) end function #else function rocblas_dspmv_rank_0(handle,uplo,n,alpha,A,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: A real(c_double),target :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy ! rocblas_dspmv_rank_0 = rocblas_dspmv_(handle,uplo,n,alpha,c_loc(A),c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_dspmv_rank_1(handle,uplo,n,alpha,A,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: A real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_dspmv_rank_1 = rocblas_dspmv_(handle,uplo,n,alpha,c_loc(A),c_loc(x),incx,beta, & c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sspmv_strided_batched_assumed_rank(handle,uplo,n,alpha,A,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_sspmv_strided_batched_assumed_rank = rocblas_sspmv_strided_batched_(handle,uplo,n, & alpha,c_loc(A),strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_sspmv_strided_batched_rank_0(handle,uplo,n,alpha,A,strideA,x,incx,stridex, & beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: A integer(c_int64_t) :: strideA real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_sspmv_strided_batched_rank_0 = rocblas_sspmv_strided_batched_(handle,uplo,n,alpha, & c_loc(A),strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_sspmv_strided_batched_rank_1(handle,uplo,n,alpha,A,strideA,x,incx,stridex, & beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_sspmv_strided_batched_rank_1 = rocblas_sspmv_strided_batched_(handle,uplo,n,alpha, & c_loc(A),strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dspmv_strided_batched_assumed_rank(handle,uplo,n,alpha,A,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dspmv_strided_batched_assumed_rank = rocblas_dspmv_strided_batched_(handle,uplo,n, & alpha,c_loc(A),strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_dspmv_strided_batched_rank_0(handle,uplo,n,alpha,A,strideA,x,incx,stridex, & beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: A integer(c_int64_t) :: strideA real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dspmv_strided_batched_rank_0 = rocblas_dspmv_strided_batched_(handle,uplo,n,alpha, & c_loc(A),strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_dspmv_strided_batched_rank_1(handle,uplo,n,alpha,A,strideA,x,incx,stridex, & beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dspmv_strided_batched_rank_1 = rocblas_dspmv_strided_batched_(handle,uplo,n,alpha, & c_loc(A),strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ssbmv_assumed_rank(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssbmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_ssbmv_assumed_rank = rocblas_ssbmv_(handle,uplo,n,k,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #else function rocblas_ssbmv_rank_0(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssbmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy ! rocblas_ssbmv_rank_0 = rocblas_ssbmv_(handle,uplo,n,k,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_ssbmv_rank_1(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssbmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_ssbmv_rank_1 = rocblas_ssbmv_(handle,uplo,n,k,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_ssbmv_full_rank(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssbmv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_ssbmv_full_rank = rocblas_ssbmv_(handle,uplo,n,k,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dsbmv_assumed_rank(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsbmv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy ! rocblas_dsbmv_assumed_rank = rocblas_dsbmv_(handle,uplo,n,k,alpha,c_loc(A),lda,c_loc(x), & incx,beta,c_loc(y),incy) end function #else function rocblas_dsbmv_rank_0(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsbmv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy ! rocblas_dsbmv_rank_0 = rocblas_dsbmv_(handle,uplo,n,k,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_dsbmv_rank_1(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsbmv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_dsbmv_rank_1 = rocblas_dsbmv_(handle,uplo,n,k,alpha,c_loc(A),lda,c_loc(x),incx,beta, & c_loc(y),incy) end function function rocblas_dsbmv_full_rank(handle,uplo,n,k,alpha,A,lda,x,incx,beta,y,incy) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsbmv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy ! rocblas_dsbmv_full_rank = rocblas_dsbmv_(handle,uplo,n,k,alpha,c_loc(A),lda,c_loc(x),incx, & beta,c_loc(y),incy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ssbmv_strided_batched_assumed_rank(handle,uplo,n,k,alpha,A,lda,strideA,x, & incx,stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssbmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_ssbmv_strided_batched_assumed_rank = rocblas_ssbmv_strided_batched_(handle,uplo,n,k, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_ssbmv_strided_batched_rank_0(handle,uplo,n,k,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssbmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_ssbmv_strided_batched_rank_0 = rocblas_ssbmv_strided_batched_(handle,uplo,n,k,alpha, & c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_ssbmv_strided_batched_rank_1(handle,uplo,n,k,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssbmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_ssbmv_strided_batched_rank_1 = rocblas_ssbmv_strided_batched_(handle,uplo,n,k,alpha, & c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_ssbmv_strided_batched_full_rank(handle,uplo,n,k,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssbmv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_ssbmv_strided_batched_full_rank = rocblas_ssbmv_strided_batched_(handle,uplo,n,k, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dsbmv_strided_batched_assumed_rank(handle,uplo,n,k,alpha,A,lda,strideA,x, & incx,stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsbmv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dsbmv_strided_batched_assumed_rank = rocblas_dsbmv_strided_batched_(handle,uplo,n,k, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #else function rocblas_dsbmv_strided_batched_rank_0(handle,uplo,n,k,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsbmv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dsbmv_strided_batched_rank_0 = rocblas_dsbmv_strided_batched_(handle,uplo,n,k,alpha, & c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_dsbmv_strided_batched_rank_1(handle,uplo,n,k,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsbmv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dsbmv_strided_batched_rank_1 = rocblas_dsbmv_strided_batched_(handle,uplo,n,k,alpha, & c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function function rocblas_dsbmv_strided_batched_full_rank(handle,uplo,n,k,alpha,A,lda,strideA,x,incx, & stridex,beta,y,incy,stridey,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsbmv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey integer(c_int) :: batch_count ! rocblas_dsbmv_strided_batched_full_rank = rocblas_dsbmv_strided_batched_(handle,uplo,n,k, & alpha,c_loc(A),lda,strideA,c_loc(x),incx,stridex,beta,c_loc(y),incy,stridey,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sger_assumed_rank(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sger_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocblas_sger_assumed_rank = rocblas_sger_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #else function rocblas_sger_rank_0(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sger_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: y integer(c_int) :: incy real(c_float),target :: A integer(c_int) :: lda ! rocblas_sger_rank_0 = rocblas_sger_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(A),lda) end function function rocblas_sger_rank_1(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sger_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy real(c_float),target,dimension(:) :: A integer(c_int) :: lda ! rocblas_sger_rank_1 = rocblas_sger_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(A),lda) end function function rocblas_sger_full_rank(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sger_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda ! rocblas_sger_full_rank = rocblas_sger_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dger_assumed_rank(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dger_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocblas_dger_assumed_rank = rocblas_dger_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #else function rocblas_dger_rank_0(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dger_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: y integer(c_int) :: incy real(c_double),target :: A integer(c_int) :: lda ! rocblas_dger_rank_0 = rocblas_dger_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(A),lda) end function function rocblas_dger_rank_1(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dger_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy real(c_double),target,dimension(:) :: A integer(c_int) :: lda ! rocblas_dger_rank_1 = rocblas_dger_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(A),lda) end function function rocblas_dger_full_rank(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dger_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda ! rocblas_dger_full_rank = rocblas_dger_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cgeru_assumed_rank(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeru_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocblas_cgeru_assumed_rank = rocblas_cgeru_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #else function rocblas_cgeru_rank_0(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeru_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy complex(c_float_complex),target :: A integer(c_int) :: lda ! rocblas_cgeru_rank_0 = rocblas_cgeru_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(A), & lda) end function function rocblas_cgeru_rank_1(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeru_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda ! rocblas_cgeru_rank_1 = rocblas_cgeru_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(A), & lda) end function function rocblas_cgeru_full_rank(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeru_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda ! rocblas_cgeru_full_rank = rocblas_cgeru_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zgeru_assumed_rank(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeru_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocblas_zgeru_assumed_rank = rocblas_zgeru_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #else function rocblas_zgeru_rank_0(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeru_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy complex(c_double_complex),target :: A integer(c_int) :: lda ! rocblas_zgeru_rank_0 = rocblas_zgeru_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(A), & lda) end function function rocblas_zgeru_rank_1(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeru_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda ! rocblas_zgeru_rank_1 = rocblas_zgeru_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(A), & lda) end function function rocblas_zgeru_full_rank(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeru_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda ! rocblas_zgeru_full_rank = rocblas_zgeru_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cgerc_assumed_rank(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgerc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocblas_cgerc_assumed_rank = rocblas_cgerc_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #else function rocblas_cgerc_rank_0(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgerc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy complex(c_float_complex),target :: A integer(c_int) :: lda ! rocblas_cgerc_rank_0 = rocblas_cgerc_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(A), & lda) end function function rocblas_cgerc_rank_1(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgerc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda ! rocblas_cgerc_rank_1 = rocblas_cgerc_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(A), & lda) end function function rocblas_cgerc_full_rank(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgerc_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda ! rocblas_cgerc_full_rank = rocblas_cgerc_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zgerc_assumed_rank(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgerc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocblas_zgerc_assumed_rank = rocblas_zgerc_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #else function rocblas_zgerc_rank_0(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgerc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy complex(c_double_complex),target :: A integer(c_int) :: lda ! rocblas_zgerc_rank_0 = rocblas_zgerc_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(A), & lda) end function function rocblas_zgerc_rank_1(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgerc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda ! rocblas_zgerc_rank_1 = rocblas_zgerc_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy,c_loc(A), & lda) end function function rocblas_zgerc_full_rank(handle,m,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgerc_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda ! rocblas_zgerc_full_rank = rocblas_zgerc_(handle,m,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sger_strided_batched_assumed_rank(handle,m,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sger_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_sger_strided_batched_assumed_rank = rocblas_sger_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #else function rocblas_sger_strided_batched_rank_0(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,A, & lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sger_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_sger_strided_batched_rank_0 = rocblas_sger_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_sger_strided_batched_rank_1(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,A, & lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sger_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_sger_strided_batched_rank_1 = rocblas_sger_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_sger_strided_batched_full_rank(handle,m,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sger_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_sger_strided_batched_full_rank = rocblas_sger_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dger_strided_batched_assumed_rank(handle,m,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dger_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_dger_strided_batched_assumed_rank = rocblas_dger_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #else function rocblas_dger_strided_batched_rank_0(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,A, & lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dger_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_dger_strided_batched_rank_0 = rocblas_dger_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_dger_strided_batched_rank_1(handle,m,n,alpha,x,incx,stridex,y,incy,stridey,A, & lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dger_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_dger_strided_batched_rank_1 = rocblas_dger_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_dger_strided_batched_full_rank(handle,m,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dger_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_dger_strided_batched_full_rank = rocblas_dger_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cgeru_strided_batched_assumed_rank(handle,m,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeru_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_cgeru_strided_batched_assumed_rank = rocblas_cgeru_strided_batched_(handle,m,n, & alpha,c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #else function rocblas_cgeru_strided_batched_rank_0(handle,m,n,alpha,x,incx,stridex,y,incy,stridey, & A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeru_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_cgeru_strided_batched_rank_0 = rocblas_cgeru_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_cgeru_strided_batched_rank_1(handle,m,n,alpha,x,incx,stridex,y,incy,stridey, & A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeru_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_cgeru_strided_batched_rank_1 = rocblas_cgeru_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_cgeru_strided_batched_full_rank(handle,m,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeru_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_cgeru_strided_batched_full_rank = rocblas_cgeru_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zgeru_strided_batched_assumed_rank(handle,m,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeru_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_zgeru_strided_batched_assumed_rank = rocblas_zgeru_strided_batched_(handle,m,n, & alpha,c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #else function rocblas_zgeru_strided_batched_rank_0(handle,m,n,alpha,x,incx,stridex,y,incy,stridey, & A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeru_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_zgeru_strided_batched_rank_0 = rocblas_zgeru_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_zgeru_strided_batched_rank_1(handle,m,n,alpha,x,incx,stridex,y,incy,stridey, & A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeru_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_zgeru_strided_batched_rank_1 = rocblas_zgeru_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_zgeru_strided_batched_full_rank(handle,m,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeru_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_zgeru_strided_batched_full_rank = rocblas_zgeru_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cgerc_strided_batched_assumed_rank(handle,m,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgerc_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_cgerc_strided_batched_assumed_rank = rocblas_cgerc_strided_batched_(handle,m,n, & alpha,c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #else function rocblas_cgerc_strided_batched_rank_0(handle,m,n,alpha,x,incx,stridex,y,incy,stridey, & A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgerc_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_cgerc_strided_batched_rank_0 = rocblas_cgerc_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_cgerc_strided_batched_rank_1(handle,m,n,alpha,x,incx,stridex,y,incy,stridey, & A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgerc_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_cgerc_strided_batched_rank_1 = rocblas_cgerc_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_cgerc_strided_batched_full_rank(handle,m,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgerc_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_cgerc_strided_batched_full_rank = rocblas_cgerc_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zgerc_strided_batched_assumed_rank(handle,m,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgerc_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_zgerc_strided_batched_assumed_rank = rocblas_zgerc_strided_batched_(handle,m,n, & alpha,c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #else function rocblas_zgerc_strided_batched_rank_0(handle,m,n,alpha,x,incx,stridex,y,incy,stridey, & A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgerc_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_zgerc_strided_batched_rank_0 = rocblas_zgerc_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_zgerc_strided_batched_rank_1(handle,m,n,alpha,x,incx,stridex,y,incy,stridey, & A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgerc_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_zgerc_strided_batched_rank_1 = rocblas_zgerc_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_zgerc_strided_batched_full_rank(handle,m,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgerc_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_zgerc_strided_batched_full_rank = rocblas_zgerc_strided_batched_(handle,m,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sspr_assumed_rank(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: AP ! rocblas_sspr_assumed_rank = rocblas_sspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #else function rocblas_sspr_rank_0(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: AP ! rocblas_sspr_rank_0 = rocblas_sspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function function rocblas_sspr_rank_1(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: AP ! rocblas_sspr_rank_1 = rocblas_sspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dspr_assumed_rank(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: AP ! rocblas_dspr_assumed_rank = rocblas_dspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #else function rocblas_dspr_rank_0(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: AP ! rocblas_dspr_rank_0 = rocblas_dspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function function rocblas_dspr_rank_1(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: AP ! rocblas_dspr_rank_1 = rocblas_dspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cspr_assumed_rank(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cspr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: AP ! rocblas_cspr_assumed_rank = rocblas_cspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #else function rocblas_cspr_rank_0(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cspr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: AP ! rocblas_cspr_rank_0 = rocblas_cspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function function rocblas_cspr_rank_1(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cspr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: AP ! rocblas_cspr_rank_1 = rocblas_cspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zspr_assumed_rank(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zspr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: AP ! rocblas_zspr_assumed_rank = rocblas_zspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #else function rocblas_zspr_rank_0(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zspr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: AP ! rocblas_zspr_rank_0 = rocblas_zspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function function rocblas_zspr_rank_1(handle,uplo,n,alpha,x,incx,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zspr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: AP ! rocblas_zspr_rank_1 = rocblas_zspr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(AP)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sspr_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stride_x,AP, & stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_sspr_strided_batched_assumed_rank = rocblas_sspr_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stride_x,c_loc(AP),stride_A,batch_count) end function #else function rocblas_sspr_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float),target :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_sspr_strided_batched_rank_0 = rocblas_sspr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(AP),stride_A,batch_count) end function function rocblas_sspr_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float),target,dimension(:) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_sspr_strided_batched_rank_1 = rocblas_sspr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(AP),stride_A,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dspr_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stride_x,AP, & stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_dspr_strided_batched_assumed_rank = rocblas_dspr_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stride_x,c_loc(AP),stride_A,batch_count) end function #else function rocblas_dspr_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double),target :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_dspr_strided_batched_rank_0 = rocblas_dspr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(AP),stride_A,batch_count) end function function rocblas_dspr_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double),target,dimension(:) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_dspr_strided_batched_rank_1 = rocblas_dspr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(AP),stride_A,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cspr_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stride_x,AP, & stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cspr_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_cspr_strided_batched_assumed_rank = rocblas_cspr_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stride_x,c_loc(AP),stride_A,batch_count) end function #else function rocblas_cspr_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cspr_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_cspr_strided_batched_rank_0 = rocblas_cspr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(AP),stride_A,batch_count) end function function rocblas_cspr_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cspr_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target,dimension(:) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_cspr_strided_batched_rank_1 = rocblas_cspr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(AP),stride_A,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zspr_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stride_x,AP, & stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zspr_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_zspr_strided_batched_assumed_rank = rocblas_zspr_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stride_x,c_loc(AP),stride_A,batch_count) end function #else function rocblas_zspr_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zspr_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_zspr_strided_batched_rank_0 = rocblas_zspr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(AP),stride_A,batch_count) end function function rocblas_zspr_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stride_x,AP,stride_A, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zspr_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target,dimension(:) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_zspr_strided_batched_rank_1 = rocblas_zspr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(AP),stride_A,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sspr2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy real(c_float),target,contiguous,dimension(..) :: AP ! rocblas_sspr2_assumed_rank = rocblas_sspr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP)) end function #else function rocblas_sspr2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: y integer(c_int) :: incy real(c_float),target :: AP ! rocblas_sspr2_rank_0 = rocblas_sspr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP)) end function function rocblas_sspr2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy real(c_float),target,dimension(:) :: AP ! rocblas_sspr2_rank_1 = rocblas_sspr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dspr2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy real(c_double),target,contiguous,dimension(..) :: AP ! rocblas_dspr2_assumed_rank = rocblas_dspr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP)) end function #else function rocblas_dspr2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: y integer(c_int) :: incy real(c_double),target :: AP ! rocblas_dspr2_rank_0 = rocblas_dspr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP)) end function function rocblas_dspr2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,AP) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy real(c_double),target,dimension(:) :: AP ! rocblas_dspr2_rank_1 = rocblas_dspr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(AP)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sspr2_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stride_x,y, & incy,stride_y,AP,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_float),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_sspr2_strided_batched_assumed_rank = rocblas_sspr2_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(AP),stride_A,batch_count) end function #else function rocblas_sspr2_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,AP,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_float),target :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_sspr2_strided_batched_rank_0 = rocblas_sspr2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(AP),stride_A,batch_count) end function function rocblas_sspr2_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,AP,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sspr2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_float),target,dimension(:) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_sspr2_strided_batched_rank_1 = rocblas_sspr2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(AP),stride_A,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dspr2_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stride_x,y, & incy,stride_y,AP,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_double),target,contiguous,dimension(..) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_dspr2_strided_batched_assumed_rank = rocblas_dspr2_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(AP),stride_A,batch_count) end function #else function rocblas_dspr2_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,AP,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_double),target :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_dspr2_strided_batched_rank_0 = rocblas_dspr2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(AP),stride_A,batch_count) end function function rocblas_dspr2_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stride_x,y,incy, & stride_y,AP,stride_A,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dspr2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stride_y real(c_double),target,dimension(:) :: AP integer(c_int64_t) :: stride_A integer(c_int) :: batch_count ! rocblas_dspr2_strided_batched_rank_1 = rocblas_dspr2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stride_x,c_loc(y),incy,stride_y,c_loc(AP),stride_A,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ssyr_assumed_rank(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocblas_ssyr_assumed_rank = rocblas_ssyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function #else function rocblas_ssyr_rank_0(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: A integer(c_int) :: lda ! rocblas_ssyr_rank_0 = rocblas_ssyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function function rocblas_ssyr_rank_1(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: A integer(c_int) :: lda ! rocblas_ssyr_rank_1 = rocblas_ssyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function function rocblas_ssyr_full_rank(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda ! rocblas_ssyr_full_rank = rocblas_ssyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dsyr_assumed_rank(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocblas_dsyr_assumed_rank = rocblas_dsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function #else function rocblas_dsyr_rank_0(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: A integer(c_int) :: lda ! rocblas_dsyr_rank_0 = rocblas_dsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function function rocblas_dsyr_rank_1(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: A integer(c_int) :: lda ! rocblas_dsyr_rank_1 = rocblas_dsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function function rocblas_dsyr_full_rank(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda ! rocblas_dsyr_full_rank = rocblas_dsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_csyr_assumed_rank(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocblas_csyr_assumed_rank = rocblas_csyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function #else function rocblas_csyr_rank_0(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: A integer(c_int) :: lda ! rocblas_csyr_rank_0 = rocblas_csyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function function rocblas_csyr_rank_1(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda ! rocblas_csyr_rank_1 = rocblas_csyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function function rocblas_csyr_full_rank(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda ! rocblas_csyr_full_rank = rocblas_csyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zsyr_assumed_rank(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocblas_zsyr_assumed_rank = rocblas_zsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function #else function rocblas_zsyr_rank_0(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: A integer(c_int) :: lda ! rocblas_zsyr_rank_0 = rocblas_zsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function function rocblas_zsyr_rank_1(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda ! rocblas_zsyr_rank_1 = rocblas_zsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function function rocblas_zsyr_full_rank(handle,uplo,n,alpha,x,incx,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda ! rocblas_zsyr_full_rank = rocblas_zsyr_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ssyr_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,A,lda, & strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_ssyr_strided_batched_assumed_rank = rocblas_ssyr_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stridex,c_loc(A),lda,strideA,batch_count) end function #else function rocblas_ssyr_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stridex,A,lda,strideA, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_ssyr_strided_batched_rank_0 = rocblas_ssyr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(A),lda,strideA,batch_count) end function function rocblas_ssyr_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stridex,A,lda,strideA, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_ssyr_strided_batched_rank_1 = rocblas_ssyr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(A),lda,strideA,batch_count) end function function rocblas_ssyr_strided_batched_full_rank(handle,uplo,n,alpha,x,incx,stridex,A,lda, & strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_ssyr_strided_batched_full_rank = rocblas_ssyr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(A),lda,strideA,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dsyr_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,A,lda, & strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_dsyr_strided_batched_assumed_rank = rocblas_dsyr_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stridex,c_loc(A),lda,strideA,batch_count) end function #else function rocblas_dsyr_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stridex,A,lda,strideA, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_dsyr_strided_batched_rank_0 = rocblas_dsyr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(A),lda,strideA,batch_count) end function function rocblas_dsyr_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stridex,A,lda,strideA, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_dsyr_strided_batched_rank_1 = rocblas_dsyr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(A),lda,strideA,batch_count) end function function rocblas_dsyr_strided_batched_full_rank(handle,uplo,n,alpha,x,incx,stridex,A,lda, & strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_dsyr_strided_batched_full_rank = rocblas_dsyr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(A),lda,strideA,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_csyr_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,A,lda, & strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_csyr_strided_batched_assumed_rank = rocblas_csyr_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stridex,c_loc(A),lda,strideA,batch_count) end function #else function rocblas_csyr_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stridex,A,lda,strideA, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_csyr_strided_batched_rank_0 = rocblas_csyr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(A),lda,strideA,batch_count) end function function rocblas_csyr_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stridex,A,lda,strideA, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_csyr_strided_batched_rank_1 = rocblas_csyr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(A),lda,strideA,batch_count) end function function rocblas_csyr_strided_batched_full_rank(handle,uplo,n,alpha,x,incx,stridex,A,lda, & strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_csyr_strided_batched_full_rank = rocblas_csyr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(A),lda,strideA,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zsyr_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,A,lda, & strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_zsyr_strided_batched_assumed_rank = rocblas_zsyr_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stridex,c_loc(A),lda,strideA,batch_count) end function #else function rocblas_zsyr_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stridex,A,lda,strideA, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_zsyr_strided_batched_rank_0 = rocblas_zsyr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(A),lda,strideA,batch_count) end function function rocblas_zsyr_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stridex,A,lda,strideA, & batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_zsyr_strided_batched_rank_1 = rocblas_zsyr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(A),lda,strideA,batch_count) end function function rocblas_zsyr_strided_batched_full_rank(handle,uplo,n,alpha,x,incx,stridex,A,lda, & strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_zsyr_strided_batched_full_rank = rocblas_zsyr_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(A),lda,strideA,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ssyr2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocblas_ssyr2_assumed_rank = rocblas_ssyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #else function rocblas_ssyr2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: y integer(c_int) :: incy real(c_float),target :: A integer(c_int) :: lda ! rocblas_ssyr2_rank_0 = rocblas_ssyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function function rocblas_ssyr2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy real(c_float),target,dimension(:) :: A integer(c_int) :: lda ! rocblas_ssyr2_rank_1 = rocblas_ssyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function function rocblas_ssyr2_full_rank(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: y integer(c_int) :: incy real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda ! rocblas_ssyr2_full_rank = rocblas_ssyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dsyr2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocblas_dsyr2_assumed_rank = rocblas_dsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #else function rocblas_dsyr2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: y integer(c_int) :: incy real(c_double),target :: A integer(c_int) :: lda ! rocblas_dsyr2_rank_0 = rocblas_dsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function function rocblas_dsyr2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy real(c_double),target,dimension(:) :: A integer(c_int) :: lda ! rocblas_dsyr2_rank_1 = rocblas_dsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function function rocblas_dsyr2_full_rank(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: y integer(c_int) :: incy real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda ! rocblas_dsyr2_full_rank = rocblas_dsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_csyr2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocblas_csyr2_assumed_rank = rocblas_csyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #else function rocblas_csyr2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: y integer(c_int) :: incy complex(c_float_complex),target :: A integer(c_int) :: lda ! rocblas_csyr2_rank_0 = rocblas_csyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function function rocblas_csyr2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda ! rocblas_csyr2_rank_1 = rocblas_csyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function function rocblas_csyr2_full_rank(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda ! rocblas_csyr2_full_rank = rocblas_csyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zsyr2_assumed_rank(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocblas_zsyr2_assumed_rank = rocblas_zsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #else function rocblas_zsyr2_rank_0(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: y integer(c_int) :: incy complex(c_double_complex),target :: A integer(c_int) :: lda ! rocblas_zsyr2_rank_0 = rocblas_zsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function function rocblas_zsyr2_rank_1(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda ! rocblas_zsyr2_rank_1 = rocblas_zsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function function rocblas_zsyr2_full_rank(handle,uplo,n,alpha,x,incx,y,incy,A,lda) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda ! rocblas_zsyr2_full_rank = rocblas_zsyr2_(handle,uplo,n,alpha,c_loc(x),incx,c_loc(y),incy, & c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ssyr2_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_ssyr2_strided_batched_assumed_rank = rocblas_ssyr2_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #else function rocblas_ssyr2_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_ssyr2_strided_batched_rank_0 = rocblas_ssyr2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_ssyr2_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_ssyr2_strided_batched_rank_1 = rocblas_ssyr2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_ssyr2_strided_batched_full_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_float),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_ssyr2_strided_batched_full_rank = rocblas_ssyr2_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dsyr2_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_dsyr2_strided_batched_assumed_rank = rocblas_dsyr2_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #else function rocblas_dsyr2_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_dsyr2_strided_batched_rank_0 = rocblas_dsyr2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_dsyr2_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_dsyr2_strided_batched_rank_1 = rocblas_dsyr2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_dsyr2_strided_batched_full_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex real(c_double),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_dsyr2_strided_batched_full_rank = rocblas_dsyr2_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_csyr2_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_csyr2_strided_batched_assumed_rank = rocblas_csyr2_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #else function rocblas_csyr2_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_csyr2_strided_batched_rank_0 = rocblas_csyr2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_csyr2_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_csyr2_strided_batched_rank_1 = rocblas_csyr2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_csyr2_strided_batched_full_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_float_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_csyr2_strided_batched_full_rank = rocblas_csyr2_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zsyr2_strided_batched_assumed_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_zsyr2_strided_batched_assumed_rank = rocblas_zsyr2_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #else function rocblas_zsyr2_strided_batched_rank_0(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_zsyr2_strided_batched_rank_0 = rocblas_zsyr2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_zsyr2_strided_batched_rank_1(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_zsyr2_strided_batched_rank_1 = rocblas_zsyr2_strided_batched_(handle,uplo,n,alpha, & c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function function rocblas_zsyr2_strided_batched_full_rank(handle,uplo,n,alpha,x,incx,stridex,y,incy, & stridey,A,lda,strideA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stridex complex(c_double_complex),target,dimension(:) :: y integer(c_int) :: incy integer(c_int64_t) :: stridey complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int) :: batch_count ! rocblas_zsyr2_strided_batched_full_rank = rocblas_zsyr2_strided_batched_(handle,uplo,n, & alpha,c_loc(x),incx,stridex,c_loc(y),incy,stridey,c_loc(A),lda,strideA,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_chemm_assumed_rank(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_chemm_assumed_rank = rocblas_chemm_(handle,side,uplo,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_chemm_rank_0(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocblas_chemm_rank_0 = rocblas_chemm_(handle,side,uplo,m,n,alpha,c_loc(A),lda,c_loc(B),ldb, & beta,c_loc(C),ldc) end function function rocblas_chemm_rank_1(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_chemm_rank_1 = rocblas_chemm_(handle,side,uplo,m,n,alpha,c_loc(A),lda,c_loc(B),ldb, & beta,c_loc(C),ldc) end function function rocblas_chemm_full_rank(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemm_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_chemm_full_rank = rocblas_chemm_(handle,side,uplo,m,n,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zhemm_assumed_rank(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_zhemm_assumed_rank = rocblas_zhemm_(handle,side,uplo,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_zhemm_rank_0(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocblas_zhemm_rank_0 = rocblas_zhemm_(handle,side,uplo,m,n,alpha,c_loc(A),lda,c_loc(B),ldb, & beta,c_loc(C),ldc) end function function rocblas_zhemm_rank_1(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_zhemm_rank_1 = rocblas_zhemm_(handle,side,uplo,m,n,alpha,c_loc(A),lda,c_loc(B),ldb, & beta,c_loc(C),ldc) end function function rocblas_zhemm_full_rank(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemm_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_zhemm_full_rank = rocblas_zhemm_(handle,side,uplo,m,n,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_chemm_strided_batched_assumed_rank(handle,side,uplo,m,n,alpha,A,lda,stride_A, & B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemm_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_chemm_strided_batched_assumed_rank = rocblas_chemm_strided_batched_(handle,side, & uplo,m,n,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_chemm_strided_batched_rank_0(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemm_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_chemm_strided_batched_rank_0 = rocblas_chemm_strided_batched_(handle,side,uplo,m,n, & alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_chemm_strided_batched_rank_1(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemm_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_chemm_strided_batched_rank_1 = rocblas_chemm_strided_batched_(handle,side,uplo,m,n, & alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_chemm_strided_batched_full_rank(handle,side,uplo,m,n,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_chemm_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_chemm_strided_batched_full_rank = rocblas_chemm_strided_batched_(handle,side,uplo,m, & n,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zhemm_strided_batched_assumed_rank(handle,side,uplo,m,n,alpha,A,lda,stride_A, & B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemm_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zhemm_strided_batched_assumed_rank = rocblas_zhemm_strided_batched_(handle,side, & uplo,m,n,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_zhemm_strided_batched_rank_0(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemm_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zhemm_strided_batched_rank_0 = rocblas_zhemm_strided_batched_(handle,side,uplo,m,n, & alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_zhemm_strided_batched_rank_1(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemm_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zhemm_strided_batched_rank_1 = rocblas_zhemm_strided_batched_(handle,side,uplo,m,n, & alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_zhemm_strided_batched_full_rank(handle,side,uplo,m,n,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zhemm_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zhemm_strided_batched_full_rank = rocblas_zhemm_strided_batched_(handle,side,uplo,m, & n,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cherk_assumed_rank(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherk_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_cherk_assumed_rank = rocblas_cherk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function #else function rocblas_cherk_rank_0(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherk_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda real(c_float) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocblas_cherk_rank_0 = rocblas_cherk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function function rocblas_cherk_rank_1(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherk_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_cherk_rank_1 = rocblas_cherk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function function rocblas_cherk_full_rank(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherk_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_cherk_full_rank = rocblas_cherk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zherk_assumed_rank(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherk_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_zherk_assumed_rank = rocblas_zherk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function #else function rocblas_zherk_rank_0(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherk_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda real(c_double) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocblas_zherk_rank_0 = rocblas_zherk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function function rocblas_zherk_rank_1(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherk_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_zherk_rank_1 = rocblas_zherk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function function rocblas_zherk_full_rank(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherk_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_zherk_full_rank = rocblas_zherk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cherk_strided_batched_assumed_rank(handle,uplo,transA,n,k,alpha,A,lda, & stride_A,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherk_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cherk_strided_batched_assumed_rank = rocblas_cherk_strided_batched_(handle,uplo, & transA,n,k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function #else function rocblas_cherk_strided_batched_rank_0(handle,uplo,transA,n,k,alpha,A,lda,stride_A, & beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherk_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cherk_strided_batched_rank_0 = rocblas_cherk_strided_batched_(handle,uplo,transA,n, & k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_cherk_strided_batched_rank_1(handle,uplo,transA,n,k,alpha,A,lda,stride_A, & beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherk_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cherk_strided_batched_rank_1 = rocblas_cherk_strided_batched_(handle,uplo,transA,n, & k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_cherk_strided_batched_full_rank(handle,uplo,transA,n,k,alpha,A,lda,stride_A, & beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherk_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cherk_strided_batched_full_rank = rocblas_cherk_strided_batched_(handle,uplo,transA, & n,k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zherk_strided_batched_assumed_rank(handle,uplo,transA,n,k,alpha,A,lda, & stride_A,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherk_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zherk_strided_batched_assumed_rank = rocblas_zherk_strided_batched_(handle,uplo, & transA,n,k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function #else function rocblas_zherk_strided_batched_rank_0(handle,uplo,transA,n,k,alpha,A,lda,stride_A, & beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherk_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zherk_strided_batched_rank_0 = rocblas_zherk_strided_batched_(handle,uplo,transA,n, & k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_zherk_strided_batched_rank_1(handle,uplo,transA,n,k,alpha,A,lda,stride_A, & beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherk_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zherk_strided_batched_rank_1 = rocblas_zherk_strided_batched_(handle,uplo,transA,n, & k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_zherk_strided_batched_full_rank(handle,uplo,transA,n,k,alpha,A,lda,stride_A, & beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherk_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zherk_strided_batched_full_rank = rocblas_zherk_strided_batched_(handle,uplo,transA, & n,k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cher2k_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2k_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_cher2k_assumed_rank = rocblas_cher2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_cher2k_rank_0(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2k_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb real(c_float) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocblas_cher2k_rank_0 = rocblas_cher2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_cher2k_rank_1(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2k_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb real(c_float) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_cher2k_rank_1 = rocblas_cher2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_cher2k_full_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2k_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_cher2k_full_rank = rocblas_cher2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zher2k_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2k_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_zher2k_assumed_rank = rocblas_zher2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_zher2k_rank_0(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2k_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb real(c_double) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocblas_zher2k_rank_0 = rocblas_zher2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_zher2k_rank_1(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2k_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb real(c_double) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_zher2k_rank_1 = rocblas_zher2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_zher2k_full_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2k_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_zher2k_full_rank = rocblas_zher2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cher2k_strided_batched_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda, & stride_A,B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2k_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cher2k_strided_batched_assumed_rank = rocblas_cher2k_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_cher2k_strided_batched_rank_0(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2k_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cher2k_strided_batched_rank_0 = rocblas_cher2k_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_cher2k_strided_batched_rank_1(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2k_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cher2k_strided_batched_rank_1 = rocblas_cher2k_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_cher2k_strided_batched_full_rank(handle,uplo,trans,n,k,alpha,A,lda,stride_A, & B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cher2k_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cher2k_strided_batched_full_rank = rocblas_cher2k_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zher2k_strided_batched_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda, & stride_A,B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2k_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zher2k_strided_batched_assumed_rank = rocblas_zher2k_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_zher2k_strided_batched_rank_0(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2k_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zher2k_strided_batched_rank_0 = rocblas_zher2k_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_zher2k_strided_batched_rank_1(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2k_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zher2k_strided_batched_rank_1 = rocblas_zher2k_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_zher2k_strided_batched_full_rank(handle,uplo,trans,n,k,alpha,A,lda,stride_A, & B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zher2k_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zher2k_strided_batched_full_rank = rocblas_zher2k_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cherkx_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherkx_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_cherkx_assumed_rank = rocblas_cherkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_cherkx_rank_0(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherkx_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb real(c_float) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocblas_cherkx_rank_0 = rocblas_cherkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_cherkx_rank_1(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherkx_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb real(c_float) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_cherkx_rank_1 = rocblas_cherkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_cherkx_full_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherkx_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_cherkx_full_rank = rocblas_cherkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zherkx_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherkx_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_zherkx_assumed_rank = rocblas_zherkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_zherkx_rank_0(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherkx_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb real(c_double) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocblas_zherkx_rank_0 = rocblas_zherkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_zherkx_rank_1(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherkx_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb real(c_double) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_zherkx_rank_1 = rocblas_zherkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_zherkx_full_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherkx_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_zherkx_full_rank = rocblas_zherkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cherkx_strided_batched_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda, & stride_A,B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherkx_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cherkx_strided_batched_assumed_rank = rocblas_cherkx_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_cherkx_strided_batched_rank_0(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherkx_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cherkx_strided_batched_rank_0 = rocblas_cherkx_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_cherkx_strided_batched_rank_1(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherkx_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cherkx_strided_batched_rank_1 = rocblas_cherkx_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_cherkx_strided_batched_full_rank(handle,uplo,trans,n,k,alpha,A,lda,stride_A, & B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cherkx_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cherkx_strided_batched_full_rank = rocblas_cherkx_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zherkx_strided_batched_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda, & stride_A,B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherkx_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zherkx_strided_batched_assumed_rank = rocblas_zherkx_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_zherkx_strided_batched_rank_0(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherkx_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zherkx_strided_batched_rank_0 = rocblas_zherkx_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_zherkx_strided_batched_rank_1(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherkx_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zherkx_strided_batched_rank_1 = rocblas_zherkx_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_zherkx_strided_batched_full_rank(handle,uplo,trans,n,k,alpha,A,lda,stride_A, & B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zherkx_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zherkx_strided_batched_full_rank = rocblas_zherkx_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ssymm_assumed_rank(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_ssymm_assumed_rank = rocblas_ssymm_(handle,side,uplo,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_ssymm_rank_0(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target :: C integer(c_int) :: ldc ! rocblas_ssymm_rank_0 = rocblas_ssymm_(handle,side,uplo,m,n,alpha,c_loc(A),lda,c_loc(B),ldb, & beta,c_loc(C),ldc) end function function rocblas_ssymm_rank_1(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_ssymm_rank_1 = rocblas_ssymm_(handle,side,uplo,m,n,alpha,c_loc(A),lda,c_loc(B),ldb, & beta,c_loc(C),ldc) end function function rocblas_ssymm_full_rank(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymm_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_ssymm_full_rank = rocblas_ssymm_(handle,side,uplo,m,n,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dsymm_assumed_rank(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_dsymm_assumed_rank = rocblas_dsymm_(handle,side,uplo,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_dsymm_rank_0(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target :: C integer(c_int) :: ldc ! rocblas_dsymm_rank_0 = rocblas_dsymm_(handle,side,uplo,m,n,alpha,c_loc(A),lda,c_loc(B),ldb, & beta,c_loc(C),ldc) end function function rocblas_dsymm_rank_1(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_dsymm_rank_1 = rocblas_dsymm_(handle,side,uplo,m,n,alpha,c_loc(A),lda,c_loc(B),ldb, & beta,c_loc(C),ldc) end function function rocblas_dsymm_full_rank(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymm_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_dsymm_full_rank = rocblas_dsymm_(handle,side,uplo,m,n,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_csymm_assumed_rank(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_csymm_assumed_rank = rocblas_csymm_(handle,side,uplo,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_csymm_rank_0(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocblas_csymm_rank_0 = rocblas_csymm_(handle,side,uplo,m,n,alpha,c_loc(A),lda,c_loc(B),ldb, & beta,c_loc(C),ldc) end function function rocblas_csymm_rank_1(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_csymm_rank_1 = rocblas_csymm_(handle,side,uplo,m,n,alpha,c_loc(A),lda,c_loc(B),ldb, & beta,c_loc(C),ldc) end function function rocblas_csymm_full_rank(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymm_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_csymm_full_rank = rocblas_csymm_(handle,side,uplo,m,n,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zsymm_assumed_rank(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_zsymm_assumed_rank = rocblas_zsymm_(handle,side,uplo,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_zsymm_rank_0(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocblas_zsymm_rank_0 = rocblas_zsymm_(handle,side,uplo,m,n,alpha,c_loc(A),lda,c_loc(B),ldb, & beta,c_loc(C),ldc) end function function rocblas_zsymm_rank_1(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_zsymm_rank_1 = rocblas_zsymm_(handle,side,uplo,m,n,alpha,c_loc(A),lda,c_loc(B),ldb, & beta,c_loc(C),ldc) end function function rocblas_zsymm_full_rank(handle,side,uplo,m,n,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymm_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_zsymm_full_rank = rocblas_zsymm_(handle,side,uplo,m,n,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ssymm_strided_batched_assumed_rank(handle,side,uplo,m,n,alpha,A,lda,stride_A, & B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymm_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ssymm_strided_batched_assumed_rank = rocblas_ssymm_strided_batched_(handle,side, & uplo,m,n,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_ssymm_strided_batched_rank_0(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymm_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta real(c_float),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ssymm_strided_batched_rank_0 = rocblas_ssymm_strided_batched_(handle,side,uplo,m,n, & alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_ssymm_strided_batched_rank_1(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymm_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta real(c_float),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ssymm_strided_batched_rank_1 = rocblas_ssymm_strided_batched_(handle,side,uplo,m,n, & alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_ssymm_strided_batched_full_rank(handle,side,uplo,m,n,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssymm_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ssymm_strided_batched_full_rank = rocblas_ssymm_strided_batched_(handle,side,uplo,m, & n,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dsymm_strided_batched_assumed_rank(handle,side,uplo,m,n,alpha,A,lda,stride_A, & B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymm_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dsymm_strided_batched_assumed_rank = rocblas_dsymm_strided_batched_(handle,side, & uplo,m,n,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_dsymm_strided_batched_rank_0(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymm_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta real(c_double),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dsymm_strided_batched_rank_0 = rocblas_dsymm_strided_batched_(handle,side,uplo,m,n, & alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_dsymm_strided_batched_rank_1(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymm_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta real(c_double),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dsymm_strided_batched_rank_1 = rocblas_dsymm_strided_batched_(handle,side,uplo,m,n, & alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_dsymm_strided_batched_full_rank(handle,side,uplo,m,n,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsymm_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dsymm_strided_batched_full_rank = rocblas_dsymm_strided_batched_(handle,side,uplo,m, & n,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_csymm_strided_batched_assumed_rank(handle,side,uplo,m,n,alpha,A,lda,stride_A, & B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymm_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_csymm_strided_batched_assumed_rank = rocblas_csymm_strided_batched_(handle,side, & uplo,m,n,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_csymm_strided_batched_rank_0(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymm_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_csymm_strided_batched_rank_0 = rocblas_csymm_strided_batched_(handle,side,uplo,m,n, & alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_csymm_strided_batched_rank_1(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymm_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_csymm_strided_batched_rank_1 = rocblas_csymm_strided_batched_(handle,side,uplo,m,n, & alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_csymm_strided_batched_full_rank(handle,side,uplo,m,n,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csymm_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_csymm_strided_batched_full_rank = rocblas_csymm_strided_batched_(handle,side,uplo,m, & n,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zsymm_strided_batched_assumed_rank(handle,side,uplo,m,n,alpha,A,lda,stride_A, & B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymm_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zsymm_strided_batched_assumed_rank = rocblas_zsymm_strided_batched_(handle,side, & uplo,m,n,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_zsymm_strided_batched_rank_0(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymm_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zsymm_strided_batched_rank_0 = rocblas_zsymm_strided_batched_(handle,side,uplo,m,n, & alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_zsymm_strided_batched_rank_1(handle,side,uplo,m,n,alpha,A,lda,stride_A,B,ldb, & stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymm_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zsymm_strided_batched_rank_1 = rocblas_zsymm_strided_batched_(handle,side,uplo,m,n, & alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_zsymm_strided_batched_full_rank(handle,side,uplo,m,n,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsymm_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zsymm_strided_batched_full_rank = rocblas_zsymm_strided_batched_(handle,side,uplo,m, & n,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ssyrk_assumed_rank(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrk_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_ssyrk_assumed_rank = rocblas_ssyrk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function #else function rocblas_ssyrk_rank_0(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrk_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda real(c_float) :: beta real(c_float),target :: C integer(c_int) :: ldc ! rocblas_ssyrk_rank_0 = rocblas_ssyrk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function function rocblas_ssyrk_rank_1(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrk_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: beta real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_ssyrk_rank_1 = rocblas_ssyrk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function function rocblas_ssyrk_full_rank(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrk_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: beta real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_ssyrk_full_rank = rocblas_ssyrk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dsyrk_assumed_rank(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrk_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_dsyrk_assumed_rank = rocblas_dsyrk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function #else function rocblas_dsyrk_rank_0(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrk_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda real(c_double) :: beta real(c_double),target :: C integer(c_int) :: ldc ! rocblas_dsyrk_rank_0 = rocblas_dsyrk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function function rocblas_dsyrk_rank_1(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrk_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: beta real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_dsyrk_rank_1 = rocblas_dsyrk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function function rocblas_dsyrk_full_rank(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrk_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: beta real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_dsyrk_full_rank = rocblas_dsyrk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_csyrk_assumed_rank(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrk_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_csyrk_assumed_rank = rocblas_csyrk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function #else function rocblas_csyrk_rank_0(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrk_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocblas_csyrk_rank_0 = rocblas_csyrk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function function rocblas_csyrk_rank_1(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrk_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_csyrk_rank_1 = rocblas_csyrk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function function rocblas_csyrk_full_rank(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrk_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_csyrk_full_rank = rocblas_csyrk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zsyrk_assumed_rank(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrk_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_zsyrk_assumed_rank = rocblas_zsyrk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function #else function rocblas_zsyrk_rank_0(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrk_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocblas_zsyrk_rank_0 = rocblas_zsyrk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function function rocblas_zsyrk_rank_1(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrk_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_zsyrk_rank_1 = rocblas_zsyrk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function function rocblas_zsyrk_full_rank(handle,uplo,transA,n,k,alpha,A,lda,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrk_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_zsyrk_full_rank = rocblas_zsyrk_(handle,uplo,transA,n,k,alpha,c_loc(A),lda,beta, & c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ssyrk_strided_batched_assumed_rank(handle,uplo,transA,n,k,alpha,A,lda, & stride_A,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrk_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ssyrk_strided_batched_assumed_rank = rocblas_ssyrk_strided_batched_(handle,uplo, & transA,n,k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function #else function rocblas_ssyrk_strided_batched_rank_0(handle,uplo,transA,n,k,alpha,A,lda,stride_A, & beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrk_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float) :: beta real(c_float),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ssyrk_strided_batched_rank_0 = rocblas_ssyrk_strided_batched_(handle,uplo,transA,n, & k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_ssyrk_strided_batched_rank_1(handle,uplo,transA,n,k,alpha,A,lda,stride_A, & beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrk_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float) :: beta real(c_float),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ssyrk_strided_batched_rank_1 = rocblas_ssyrk_strided_batched_(handle,uplo,transA,n, & k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_ssyrk_strided_batched_full_rank(handle,uplo,transA,n,k,alpha,A,lda,stride_A, & beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrk_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float) :: beta real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ssyrk_strided_batched_full_rank = rocblas_ssyrk_strided_batched_(handle,uplo,transA, & n,k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dsyrk_strided_batched_assumed_rank(handle,uplo,transA,n,k,alpha,A,lda, & stride_A,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrk_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dsyrk_strided_batched_assumed_rank = rocblas_dsyrk_strided_batched_(handle,uplo, & transA,n,k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function #else function rocblas_dsyrk_strided_batched_rank_0(handle,uplo,transA,n,k,alpha,A,lda,stride_A, & beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrk_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double) :: beta real(c_double),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dsyrk_strided_batched_rank_0 = rocblas_dsyrk_strided_batched_(handle,uplo,transA,n, & k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_dsyrk_strided_batched_rank_1(handle,uplo,transA,n,k,alpha,A,lda,stride_A, & beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrk_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double) :: beta real(c_double),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dsyrk_strided_batched_rank_1 = rocblas_dsyrk_strided_batched_(handle,uplo,transA,n, & k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_dsyrk_strided_batched_full_rank(handle,uplo,transA,n,k,alpha,A,lda,stride_A, & beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrk_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double) :: beta real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dsyrk_strided_batched_full_rank = rocblas_dsyrk_strided_batched_(handle,uplo,transA, & n,k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_csyrk_strided_batched_assumed_rank(handle,uplo,transA,n,k,alpha,A,lda, & stride_A,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrk_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_csyrk_strided_batched_assumed_rank = rocblas_csyrk_strided_batched_(handle,uplo, & transA,n,k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function #else function rocblas_csyrk_strided_batched_rank_0(handle,uplo,transA,n,k,alpha,A,lda,stride_A, & beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrk_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_csyrk_strided_batched_rank_0 = rocblas_csyrk_strided_batched_(handle,uplo,transA,n, & k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_csyrk_strided_batched_rank_1(handle,uplo,transA,n,k,alpha,A,lda,stride_A, & beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrk_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_csyrk_strided_batched_rank_1 = rocblas_csyrk_strided_batched_(handle,uplo,transA,n, & k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_csyrk_strided_batched_full_rank(handle,uplo,transA,n,k,alpha,A,lda,stride_A, & beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrk_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_csyrk_strided_batched_full_rank = rocblas_csyrk_strided_batched_(handle,uplo,transA, & n,k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zsyrk_strided_batched_assumed_rank(handle,uplo,transA,n,k,alpha,A,lda, & stride_A,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrk_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zsyrk_strided_batched_assumed_rank = rocblas_zsyrk_strided_batched_(handle,uplo, & transA,n,k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function #else function rocblas_zsyrk_strided_batched_rank_0(handle,uplo,transA,n,k,alpha,A,lda,stride_A, & beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrk_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zsyrk_strided_batched_rank_0 = rocblas_zsyrk_strided_batched_(handle,uplo,transA,n, & k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_zsyrk_strided_batched_rank_1(handle,uplo,transA,n,k,alpha,A,lda,stride_A, & beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrk_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zsyrk_strided_batched_rank_1 = rocblas_zsyrk_strided_batched_(handle,uplo,transA,n, & k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_zsyrk_strided_batched_full_rank(handle,uplo,transA,n,k,alpha,A,lda,stride_A, & beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrk_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zsyrk_strided_batched_full_rank = rocblas_zsyrk_strided_batched_(handle,uplo,transA, & n,k,alpha,c_loc(A),lda,stride_A,beta,c_loc(C),ldc,stride_C,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ssyr2k_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2k_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_ssyr2k_assumed_rank = rocblas_ssyr2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_ssyr2k_rank_0(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2k_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target :: C integer(c_int) :: ldc ! rocblas_ssyr2k_rank_0 = rocblas_ssyr2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_ssyr2k_rank_1(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2k_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_ssyr2k_rank_1 = rocblas_ssyr2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_ssyr2k_full_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2k_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_ssyr2k_full_rank = rocblas_ssyr2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dsyr2k_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2k_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_dsyr2k_assumed_rank = rocblas_dsyr2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_dsyr2k_rank_0(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2k_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target :: C integer(c_int) :: ldc ! rocblas_dsyr2k_rank_0 = rocblas_dsyr2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_dsyr2k_rank_1(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2k_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_dsyr2k_rank_1 = rocblas_dsyr2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_dsyr2k_full_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2k_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_dsyr2k_full_rank = rocblas_dsyr2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_csyr2k_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2k_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_csyr2k_assumed_rank = rocblas_csyr2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_csyr2k_rank_0(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2k_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocblas_csyr2k_rank_0 = rocblas_csyr2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_csyr2k_rank_1(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2k_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_csyr2k_rank_1 = rocblas_csyr2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_csyr2k_full_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2k_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_csyr2k_full_rank = rocblas_csyr2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zsyr2k_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2k_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_zsyr2k_assumed_rank = rocblas_zsyr2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_zsyr2k_rank_0(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2k_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocblas_zsyr2k_rank_0 = rocblas_zsyr2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_zsyr2k_rank_1(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2k_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_zsyr2k_rank_1 = rocblas_zsyr2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_zsyr2k_full_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2k_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_zsyr2k_full_rank = rocblas_zsyr2k_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ssyr2k_strided_batched_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda, & stride_A,B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2k_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ssyr2k_strided_batched_assumed_rank = rocblas_ssyr2k_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_ssyr2k_strided_batched_rank_0(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2k_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta real(c_float),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ssyr2k_strided_batched_rank_0 = rocblas_ssyr2k_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_ssyr2k_strided_batched_rank_1(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2k_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta real(c_float),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ssyr2k_strided_batched_rank_1 = rocblas_ssyr2k_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_ssyr2k_strided_batched_full_rank(handle,uplo,trans,n,k,alpha,A,lda,stride_A, & B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyr2k_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ssyr2k_strided_batched_full_rank = rocblas_ssyr2k_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dsyr2k_strided_batched_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda, & stride_A,B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2k_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dsyr2k_strided_batched_assumed_rank = rocblas_dsyr2k_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_dsyr2k_strided_batched_rank_0(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2k_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta real(c_double),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dsyr2k_strided_batched_rank_0 = rocblas_dsyr2k_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_dsyr2k_strided_batched_rank_1(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2k_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta real(c_double),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dsyr2k_strided_batched_rank_1 = rocblas_dsyr2k_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_dsyr2k_strided_batched_full_rank(handle,uplo,trans,n,k,alpha,A,lda,stride_A, & B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyr2k_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dsyr2k_strided_batched_full_rank = rocblas_dsyr2k_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_csyr2k_strided_batched_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda, & stride_A,B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2k_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_csyr2k_strided_batched_assumed_rank = rocblas_csyr2k_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_csyr2k_strided_batched_rank_0(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2k_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_csyr2k_strided_batched_rank_0 = rocblas_csyr2k_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_csyr2k_strided_batched_rank_1(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2k_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_csyr2k_strided_batched_rank_1 = rocblas_csyr2k_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_csyr2k_strided_batched_full_rank(handle,uplo,trans,n,k,alpha,A,lda,stride_A, & B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyr2k_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_csyr2k_strided_batched_full_rank = rocblas_csyr2k_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zsyr2k_strided_batched_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda, & stride_A,B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2k_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zsyr2k_strided_batched_assumed_rank = rocblas_zsyr2k_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_zsyr2k_strided_batched_rank_0(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2k_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zsyr2k_strided_batched_rank_0 = rocblas_zsyr2k_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_zsyr2k_strided_batched_rank_1(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2k_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zsyr2k_strided_batched_rank_1 = rocblas_zsyr2k_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_zsyr2k_strided_batched_full_rank(handle,uplo,trans,n,k,alpha,A,lda,stride_A, & B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyr2k_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zsyr2k_strided_batched_full_rank = rocblas_zsyr2k_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ssyrkx_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrkx_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_ssyrkx_assumed_rank = rocblas_ssyrkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_ssyrkx_rank_0(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrkx_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target :: C integer(c_int) :: ldc ! rocblas_ssyrkx_rank_0 = rocblas_ssyrkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_ssyrkx_rank_1(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrkx_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_ssyrkx_rank_1 = rocblas_ssyrkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_ssyrkx_full_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrkx_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_ssyrkx_full_rank = rocblas_ssyrkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dsyrkx_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrkx_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_dsyrkx_assumed_rank = rocblas_dsyrkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_dsyrkx_rank_0(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrkx_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target :: C integer(c_int) :: ldc ! rocblas_dsyrkx_rank_0 = rocblas_dsyrkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_dsyrkx_rank_1(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrkx_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_dsyrkx_rank_1 = rocblas_dsyrkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_dsyrkx_full_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrkx_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_dsyrkx_full_rank = rocblas_dsyrkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_csyrkx_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrkx_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_csyrkx_assumed_rank = rocblas_csyrkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_csyrkx_rank_0(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrkx_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocblas_csyrkx_rank_0 = rocblas_csyrkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_csyrkx_rank_1(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrkx_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_csyrkx_rank_1 = rocblas_csyrkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_csyrkx_full_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrkx_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_csyrkx_full_rank = rocblas_csyrkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zsyrkx_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrkx_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_zsyrkx_assumed_rank = rocblas_zsyrkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_zsyrkx_rank_0(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrkx_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocblas_zsyrkx_rank_0 = rocblas_zsyrkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_zsyrkx_rank_1(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrkx_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_zsyrkx_rank_1 = rocblas_zsyrkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda,c_loc(B), & ldb,beta,c_loc(C),ldc) end function function rocblas_zsyrkx_full_rank(handle,uplo,trans,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrkx_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_zsyrkx_full_rank = rocblas_zsyrkx_(handle,uplo,trans,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ssyrkx_strided_batched_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda, & stride_A,B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrkx_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ssyrkx_strided_batched_assumed_rank = rocblas_ssyrkx_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_ssyrkx_strided_batched_rank_0(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrkx_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta real(c_float),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ssyrkx_strided_batched_rank_0 = rocblas_ssyrkx_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_ssyrkx_strided_batched_rank_1(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrkx_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta real(c_float),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ssyrkx_strided_batched_rank_1 = rocblas_ssyrkx_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_ssyrkx_strided_batched_full_rank(handle,uplo,trans,n,k,alpha,A,lda,stride_A, & B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ssyrkx_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float) :: beta real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ssyrkx_strided_batched_full_rank = rocblas_ssyrkx_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dsyrkx_strided_batched_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda, & stride_A,B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrkx_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dsyrkx_strided_batched_assumed_rank = rocblas_dsyrkx_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_dsyrkx_strided_batched_rank_0(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrkx_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta real(c_double),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dsyrkx_strided_batched_rank_0 = rocblas_dsyrkx_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_dsyrkx_strided_batched_rank_1(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrkx_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta real(c_double),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dsyrkx_strided_batched_rank_1 = rocblas_dsyrkx_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_dsyrkx_strided_batched_full_rank(handle,uplo,trans,n,k,alpha,A,lda,stride_A, & B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dsyrkx_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double) :: beta real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dsyrkx_strided_batched_full_rank = rocblas_dsyrkx_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_csyrkx_strided_batched_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda, & stride_A,B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrkx_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_csyrkx_strided_batched_assumed_rank = rocblas_csyrkx_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_csyrkx_strided_batched_rank_0(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrkx_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_csyrkx_strided_batched_rank_0 = rocblas_csyrkx_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_csyrkx_strided_batched_rank_1(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrkx_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_csyrkx_strided_batched_rank_1 = rocblas_csyrkx_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_csyrkx_strided_batched_full_rank(handle,uplo,trans,n,k,alpha,A,lda,stride_A, & B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_csyrkx_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_csyrkx_strided_batched_full_rank = rocblas_csyrkx_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zsyrkx_strided_batched_assumed_rank(handle,uplo,trans,n,k,alpha,A,lda, & stride_A,B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrkx_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zsyrkx_strided_batched_assumed_rank = rocblas_zsyrkx_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_zsyrkx_strided_batched_rank_0(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrkx_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zsyrkx_strided_batched_rank_0 = rocblas_zsyrkx_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_zsyrkx_strided_batched_rank_1(handle,uplo,trans,n,k,alpha,A,lda,stride_A,B, & ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrkx_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zsyrkx_strided_batched_rank_1 = rocblas_zsyrkx_strided_batched_(handle,uplo,trans,n, & k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_zsyrkx_strided_batched_full_rank(handle,uplo,trans,n,k,alpha,A,lda,stride_A, & B,ldb,stride_B,beta,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zsyrkx_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zsyrkx_strided_batched_full_rank = rocblas_zsyrkx_strided_batched_(handle,uplo, & trans,n,k,alpha,c_loc(A),lda,stride_A,c_loc(B),ldb,stride_B,beta,c_loc(C),ldc,stride_C, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_strmm_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_strmm_assumed_rank = rocblas_strmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb,c_loc(C),ldc) end function #else function rocblas_strmm_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: B integer(c_int) :: ldb real(c_float),target :: C integer(c_int) :: ldc ! rocblas_strmm_rank_0 = rocblas_strmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function function rocblas_strmm_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_strmm_rank_1 = rocblas_strmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function function rocblas_strmm_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strmm_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_strmm_full_rank = rocblas_strmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dtrmm_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_dtrmm_assumed_rank = rocblas_dtrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb,c_loc(C),ldc) end function #else function rocblas_dtrmm_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: B integer(c_int) :: ldb real(c_double),target :: C integer(c_int) :: ldc ! rocblas_dtrmm_rank_0 = rocblas_dtrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function function rocblas_dtrmm_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_dtrmm_rank_1 = rocblas_dtrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function function rocblas_dtrmm_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrmm_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_dtrmm_full_rank = rocblas_dtrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ctrmm_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_ctrmm_assumed_rank = rocblas_ctrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb,c_loc(C),ldc) end function #else function rocblas_ctrmm_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocblas_ctrmm_rank_0 = rocblas_ctrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function function rocblas_ctrmm_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_ctrmm_rank_1 = rocblas_ctrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function function rocblas_ctrmm_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrmm_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_ctrmm_full_rank = rocblas_ctrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ztrmm_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_ztrmm_assumed_rank = rocblas_ztrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb,c_loc(C),ldc) end function #else function rocblas_ztrmm_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocblas_ztrmm_rank_0 = rocblas_ztrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function function rocblas_ztrmm_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_ztrmm_rank_1 = rocblas_ztrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb,c_loc(C),ldc) end function function rocblas_ztrmm_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrmm_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_ztrmm_full_rank = rocblas_ztrmm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_strtri_assumed_rank(handle,uplo,diag,n,A,lda,invA,ldinvA) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strtri_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: invA integer(c_int) :: ldinvA ! rocblas_strtri_assumed_rank = rocblas_strtri_(handle,uplo,diag,n,c_loc(A),lda,c_loc(invA), & ldinvA) end function #else function rocblas_strtri_rank_0(handle,uplo,diag,n,A,lda,invA,ldinvA) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strtri_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: invA integer(c_int) :: ldinvA ! rocblas_strtri_rank_0 = rocblas_strtri_(handle,uplo,diag,n,c_loc(A),lda,c_loc(invA),ldinvA) end function function rocblas_strtri_rank_1(handle,uplo,diag,n,A,lda,invA,ldinvA) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strtri_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: invA integer(c_int) :: ldinvA ! rocblas_strtri_rank_1 = rocblas_strtri_(handle,uplo,diag,n,c_loc(A),lda,c_loc(invA),ldinvA) end function function rocblas_strtri_full_rank(handle,uplo,diag,n,A,lda,invA,ldinvA) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strtri_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: invA integer(c_int) :: ldinvA ! rocblas_strtri_full_rank = rocblas_strtri_(handle,uplo,diag,n,c_loc(A),lda,c_loc(invA),ldinvA) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dtrtri_assumed_rank(handle,uplo,diag,n,A,lda,invA,ldinvA) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrtri_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: invA integer(c_int) :: ldinvA ! rocblas_dtrtri_assumed_rank = rocblas_dtrtri_(handle,uplo,diag,n,c_loc(A),lda,c_loc(invA), & ldinvA) end function #else function rocblas_dtrtri_rank_0(handle,uplo,diag,n,A,lda,invA,ldinvA) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrtri_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: invA integer(c_int) :: ldinvA ! rocblas_dtrtri_rank_0 = rocblas_dtrtri_(handle,uplo,diag,n,c_loc(A),lda,c_loc(invA),ldinvA) end function function rocblas_dtrtri_rank_1(handle,uplo,diag,n,A,lda,invA,ldinvA) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrtri_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: invA integer(c_int) :: ldinvA ! rocblas_dtrtri_rank_1 = rocblas_dtrtri_(handle,uplo,diag,n,c_loc(A),lda,c_loc(invA),ldinvA) end function function rocblas_dtrtri_full_rank(handle,uplo,diag,n,A,lda,invA,ldinvA) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrtri_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: invA integer(c_int) :: ldinvA ! rocblas_dtrtri_full_rank = rocblas_dtrtri_(handle,uplo,diag,n,c_loc(A),lda,c_loc(invA),ldinvA) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ctrtri_assumed_rank(handle,uplo,diag,n,A,lda,invA,ldinvA) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrtri_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: invA integer(c_int) :: ldinvA ! rocblas_ctrtri_assumed_rank = rocblas_ctrtri_(handle,uplo,diag,n,c_loc(A),lda,c_loc(invA), & ldinvA) end function #else function rocblas_ctrtri_rank_0(handle,uplo,diag,n,A,lda,invA,ldinvA) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrtri_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: invA integer(c_int) :: ldinvA ! rocblas_ctrtri_rank_0 = rocblas_ctrtri_(handle,uplo,diag,n,c_loc(A),lda,c_loc(invA),ldinvA) end function function rocblas_ctrtri_rank_1(handle,uplo,diag,n,A,lda,invA,ldinvA) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrtri_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: invA integer(c_int) :: ldinvA ! rocblas_ctrtri_rank_1 = rocblas_ctrtri_(handle,uplo,diag,n,c_loc(A),lda,c_loc(invA),ldinvA) end function function rocblas_ctrtri_full_rank(handle,uplo,diag,n,A,lda,invA,ldinvA) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrtri_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: invA integer(c_int) :: ldinvA ! rocblas_ctrtri_full_rank = rocblas_ctrtri_(handle,uplo,diag,n,c_loc(A),lda,c_loc(invA),ldinvA) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ztrtri_assumed_rank(handle,uplo,diag,n,A,lda,invA,ldinvA) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrtri_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: invA integer(c_int) :: ldinvA ! rocblas_ztrtri_assumed_rank = rocblas_ztrtri_(handle,uplo,diag,n,c_loc(A),lda,c_loc(invA), & ldinvA) end function #else function rocblas_ztrtri_rank_0(handle,uplo,diag,n,A,lda,invA,ldinvA) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrtri_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: invA integer(c_int) :: ldinvA ! rocblas_ztrtri_rank_0 = rocblas_ztrtri_(handle,uplo,diag,n,c_loc(A),lda,c_loc(invA),ldinvA) end function function rocblas_ztrtri_rank_1(handle,uplo,diag,n,A,lda,invA,ldinvA) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrtri_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: invA integer(c_int) :: ldinvA ! rocblas_ztrtri_rank_1 = rocblas_ztrtri_(handle,uplo,diag,n,c_loc(A),lda,c_loc(invA),ldinvA) end function function rocblas_ztrtri_full_rank(handle,uplo,diag,n,A,lda,invA,ldinvA) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrtri_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: invA integer(c_int) :: ldinvA ! rocblas_ztrtri_full_rank = rocblas_ztrtri_(handle,uplo,diag,n,c_loc(A),lda,c_loc(invA),ldinvA) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_strtri_strided_batched_assumed_rank(handle,uplo,diag,n,A,lda,stride_a,invA, & ldinvA,stride_invA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strtri_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_float),target,contiguous,dimension(..) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batch_count ! rocblas_strtri_strided_batched_assumed_rank = rocblas_strtri_strided_batched_(handle,uplo, & diag,n,c_loc(A),lda,stride_a,c_loc(invA),ldinvA,stride_invA,batch_count) end function #else function rocblas_strtri_strided_batched_rank_0(handle,uplo,diag,n,A,lda,stride_a,invA,ldinvA, & stride_invA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strtri_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_float),target :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batch_count ! rocblas_strtri_strided_batched_rank_0 = rocblas_strtri_strided_batched_(handle,uplo,diag,n, & c_loc(A),lda,stride_a,c_loc(invA),ldinvA,stride_invA,batch_count) end function function rocblas_strtri_strided_batched_rank_1(handle,uplo,diag,n,A,lda,stride_a,invA,ldinvA, & stride_invA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strtri_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_float),target,dimension(:) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batch_count ! rocblas_strtri_strided_batched_rank_1 = rocblas_strtri_strided_batched_(handle,uplo,diag,n, & c_loc(A),lda,stride_a,c_loc(invA),ldinvA,stride_invA,batch_count) end function function rocblas_strtri_strided_batched_full_rank(handle,uplo,diag,n,A,lda,stride_a,invA, & ldinvA,stride_invA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strtri_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_float),target,dimension(:,:) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batch_count ! rocblas_strtri_strided_batched_full_rank = rocblas_strtri_strided_batched_(handle,uplo,diag, & n,c_loc(A),lda,stride_a,c_loc(invA),ldinvA,stride_invA,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dtrtri_strided_batched_assumed_rank(handle,uplo,diag,n,A,lda,stride_a,invA, & ldinvA,stride_invA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrtri_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_double),target,contiguous,dimension(..) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batch_count ! rocblas_dtrtri_strided_batched_assumed_rank = rocblas_dtrtri_strided_batched_(handle,uplo, & diag,n,c_loc(A),lda,stride_a,c_loc(invA),ldinvA,stride_invA,batch_count) end function #else function rocblas_dtrtri_strided_batched_rank_0(handle,uplo,diag,n,A,lda,stride_a,invA,ldinvA, & stride_invA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrtri_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_double),target :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batch_count ! rocblas_dtrtri_strided_batched_rank_0 = rocblas_dtrtri_strided_batched_(handle,uplo,diag,n, & c_loc(A),lda,stride_a,c_loc(invA),ldinvA,stride_invA,batch_count) end function function rocblas_dtrtri_strided_batched_rank_1(handle,uplo,diag,n,A,lda,stride_a,invA,ldinvA, & stride_invA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrtri_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_double),target,dimension(:) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batch_count ! rocblas_dtrtri_strided_batched_rank_1 = rocblas_dtrtri_strided_batched_(handle,uplo,diag,n, & c_loc(A),lda,stride_a,c_loc(invA),ldinvA,stride_invA,batch_count) end function function rocblas_dtrtri_strided_batched_full_rank(handle,uplo,diag,n,A,lda,stride_a,invA, & ldinvA,stride_invA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrtri_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_double),target,dimension(:,:) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batch_count ! rocblas_dtrtri_strided_batched_full_rank = rocblas_dtrtri_strided_batched_(handle,uplo,diag, & n,c_loc(A),lda,stride_a,c_loc(invA),ldinvA,stride_invA,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ctrtri_strided_batched_assumed_rank(handle,uplo,diag,n,A,lda,stride_a,invA, & ldinvA,stride_invA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrtri_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_float_complex),target,contiguous,dimension(..) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batch_count ! rocblas_ctrtri_strided_batched_assumed_rank = rocblas_ctrtri_strided_batched_(handle,uplo, & diag,n,c_loc(A),lda,stride_a,c_loc(invA),ldinvA,stride_invA,batch_count) end function #else function rocblas_ctrtri_strided_batched_rank_0(handle,uplo,diag,n,A,lda,stride_a,invA,ldinvA, & stride_invA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrtri_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_float_complex),target :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batch_count ! rocblas_ctrtri_strided_batched_rank_0 = rocblas_ctrtri_strided_batched_(handle,uplo,diag,n, & c_loc(A),lda,stride_a,c_loc(invA),ldinvA,stride_invA,batch_count) end function function rocblas_ctrtri_strided_batched_rank_1(handle,uplo,diag,n,A,lda,stride_a,invA,ldinvA, & stride_invA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrtri_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_float_complex),target,dimension(:) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batch_count ! rocblas_ctrtri_strided_batched_rank_1 = rocblas_ctrtri_strided_batched_(handle,uplo,diag,n, & c_loc(A),lda,stride_a,c_loc(invA),ldinvA,stride_invA,batch_count) end function function rocblas_ctrtri_strided_batched_full_rank(handle,uplo,diag,n,A,lda,stride_a,invA, & ldinvA,stride_invA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrtri_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_float_complex),target,dimension(:,:) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batch_count ! rocblas_ctrtri_strided_batched_full_rank = rocblas_ctrtri_strided_batched_(handle,uplo,diag, & n,c_loc(A),lda,stride_a,c_loc(invA),ldinvA,stride_invA,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ztrtri_strided_batched_assumed_rank(handle,uplo,diag,n,A,lda,stride_a,invA, & ldinvA,stride_invA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrtri_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_double_complex),target,contiguous,dimension(..) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batch_count ! rocblas_ztrtri_strided_batched_assumed_rank = rocblas_ztrtri_strided_batched_(handle,uplo, & diag,n,c_loc(A),lda,stride_a,c_loc(invA),ldinvA,stride_invA,batch_count) end function #else function rocblas_ztrtri_strided_batched_rank_0(handle,uplo,diag,n,A,lda,stride_a,invA,ldinvA, & stride_invA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrtri_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_double_complex),target :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batch_count ! rocblas_ztrtri_strided_batched_rank_0 = rocblas_ztrtri_strided_batched_(handle,uplo,diag,n, & c_loc(A),lda,stride_a,c_loc(invA),ldinvA,stride_invA,batch_count) end function function rocblas_ztrtri_strided_batched_rank_1(handle,uplo,diag,n,A,lda,stride_a,invA,ldinvA, & stride_invA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrtri_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_double_complex),target,dimension(:) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batch_count ! rocblas_ztrtri_strided_batched_rank_1 = rocblas_ztrtri_strided_batched_(handle,uplo,diag,n, & c_loc(A),lda,stride_a,c_loc(invA),ldinvA,stride_invA,batch_count) end function function rocblas_ztrtri_strided_batched_full_rank(handle,uplo,diag,n,A,lda,stride_a,invA, & ldinvA,stride_invA,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrtri_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_double_complex),target,dimension(:,:) :: invA integer(c_int) :: ldinvA integer(c_int64_t) :: stride_invA integer(c_int) :: batch_count ! rocblas_ztrtri_strided_batched_full_rank = rocblas_ztrtri_strided_batched_(handle,uplo,diag, & n,c_loc(A),lda,stride_a,c_loc(invA),ldinvA,stride_invA,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_strsm_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocblas_strsm_assumed_rank = rocblas_strsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb) end function #else function rocblas_strsm_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: B integer(c_int) :: ldb ! rocblas_strsm_rank_0 = rocblas_strsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb) end function function rocblas_strsm_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: B integer(c_int) :: ldb ! rocblas_strsm_rank_1 = rocblas_strsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb) end function function rocblas_strsm_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsm_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocblas_strsm_full_rank = rocblas_strsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dtrsm_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocblas_dtrsm_assumed_rank = rocblas_dtrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb) end function #else function rocblas_dtrsm_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: B integer(c_int) :: ldb ! rocblas_dtrsm_rank_0 = rocblas_dtrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb) end function function rocblas_dtrsm_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: B integer(c_int) :: ldb ! rocblas_dtrsm_rank_1 = rocblas_dtrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb) end function function rocblas_dtrsm_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsm_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocblas_dtrsm_full_rank = rocblas_dtrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ctrsm_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocblas_ctrsm_assumed_rank = rocblas_ctrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb) end function #else function rocblas_ctrsm_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb ! rocblas_ctrsm_rank_0 = rocblas_ctrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb) end function function rocblas_ctrsm_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb ! rocblas_ctrsm_rank_1 = rocblas_ctrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb) end function function rocblas_ctrsm_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsm_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocblas_ctrsm_full_rank = rocblas_ctrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ztrsm_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocblas_ztrsm_assumed_rank = rocblas_ztrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb) end function #else function rocblas_ztrsm_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb ! rocblas_ztrsm_rank_0 = rocblas_ztrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb) end function function rocblas_ztrsm_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb ! rocblas_ztrsm_rank_1 = rocblas_ztrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A),lda, & c_loc(B),ldb) end function function rocblas_ztrsm_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda,B,ldb) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsm_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocblas_ztrsm_full_rank = rocblas_ztrsm_(handle,side,uplo,transA,diag,m,n,alpha,c_loc(A), & lda,c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_strsm_strided_batched_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A, & lda,stride_a,B,ldb,stride_b,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsm_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b integer(c_int) :: batch_count ! rocblas_strsm_strided_batched_assumed_rank = rocblas_strsm_strided_batched_(handle,side, & uplo,transA,diag,m,n,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,batch_count) end function #else function rocblas_strsm_strided_batched_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_a,B,ldb,stride_b,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsm_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_float),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b integer(c_int) :: batch_count ! rocblas_strsm_strided_batched_rank_0 = rocblas_strsm_strided_batched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,batch_count) end function function rocblas_strsm_strided_batched_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_a,B,ldb,stride_b,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsm_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b integer(c_int) :: batch_count ! rocblas_strsm_strided_batched_rank_1 = rocblas_strsm_strided_batched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,batch_count) end function function rocblas_strsm_strided_batched_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_a,B,ldb,stride_b,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_strsm_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b integer(c_int) :: batch_count ! rocblas_strsm_strided_batched_full_rank = rocblas_strsm_strided_batched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dtrsm_strided_batched_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A, & lda,stride_a,B,ldb,stride_b,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsm_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b integer(c_int) :: batch_count ! rocblas_dtrsm_strided_batched_assumed_rank = rocblas_dtrsm_strided_batched_(handle,side, & uplo,transA,diag,m,n,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,batch_count) end function #else function rocblas_dtrsm_strided_batched_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_a,B,ldb,stride_b,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsm_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_double),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b integer(c_int) :: batch_count ! rocblas_dtrsm_strided_batched_rank_0 = rocblas_dtrsm_strided_batched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,batch_count) end function function rocblas_dtrsm_strided_batched_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_a,B,ldb,stride_b,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsm_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b integer(c_int) :: batch_count ! rocblas_dtrsm_strided_batched_rank_1 = rocblas_dtrsm_strided_batched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,batch_count) end function function rocblas_dtrsm_strided_batched_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_a,B,ldb,stride_b,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dtrsm_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b integer(c_int) :: batch_count ! rocblas_dtrsm_strided_batched_full_rank = rocblas_dtrsm_strided_batched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ctrsm_strided_batched_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A, & lda,stride_a,B,ldb,stride_b,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsm_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b integer(c_int) :: batch_count ! rocblas_ctrsm_strided_batched_assumed_rank = rocblas_ctrsm_strided_batched_(handle,side, & uplo,transA,diag,m,n,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,batch_count) end function #else function rocblas_ctrsm_strided_batched_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_a,B,ldb,stride_b,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsm_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b integer(c_int) :: batch_count ! rocblas_ctrsm_strided_batched_rank_0 = rocblas_ctrsm_strided_batched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,batch_count) end function function rocblas_ctrsm_strided_batched_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_a,B,ldb,stride_b,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsm_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b integer(c_int) :: batch_count ! rocblas_ctrsm_strided_batched_rank_1 = rocblas_ctrsm_strided_batched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,batch_count) end function function rocblas_ctrsm_strided_batched_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_a,B,ldb,stride_b,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ctrsm_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b integer(c_int) :: batch_count ! rocblas_ctrsm_strided_batched_full_rank = rocblas_ctrsm_strided_batched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ztrsm_strided_batched_assumed_rank(handle,side,uplo,transA,diag,m,n,alpha,A, & lda,stride_a,B,ldb,stride_b,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsm_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b integer(c_int) :: batch_count ! rocblas_ztrsm_strided_batched_assumed_rank = rocblas_ztrsm_strided_batched_(handle,side, & uplo,transA,diag,m,n,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,batch_count) end function #else function rocblas_ztrsm_strided_batched_rank_0(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_a,B,ldb,stride_b,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsm_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b integer(c_int) :: batch_count ! rocblas_ztrsm_strided_batched_rank_0 = rocblas_ztrsm_strided_batched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,batch_count) end function function rocblas_ztrsm_strided_batched_rank_1(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_a,B,ldb,stride_b,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsm_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b integer(c_int) :: batch_count ! rocblas_ztrsm_strided_batched_rank_1 = rocblas_ztrsm_strided_batched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,batch_count) end function function rocblas_ztrsm_strided_batched_full_rank(handle,side,uplo,transA,diag,m,n,alpha,A,lda, & stride_a,B,ldb,stride_b,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ztrsm_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b integer(c_int) :: batch_count ! rocblas_ztrsm_strided_batched_full_rank = rocblas_ztrsm_strided_batched_(handle,side,uplo, & transA,diag,m,n,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sgemm_assumed_rank(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_sgemm_assumed_rank = rocblas_sgemm_(handle,transA,transB,m,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_sgemm_rank_0(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target :: C integer(c_int) :: ldc ! rocblas_sgemm_rank_0 = rocblas_sgemm_(handle,transA,transB,m,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocblas_sgemm_rank_1(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_sgemm_rank_1 = rocblas_sgemm_(handle,transA,transB,m,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocblas_sgemm_full_rank(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemm_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_sgemm_full_rank = rocblas_sgemm_(handle,transA,transB,m,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dgemm_assumed_rank(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_dgemm_assumed_rank = rocblas_dgemm_(handle,transA,transB,m,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_dgemm_rank_0(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target :: C integer(c_int) :: ldc ! rocblas_dgemm_rank_0 = rocblas_dgemm_(handle,transA,transB,m,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocblas_dgemm_rank_1(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_dgemm_rank_1 = rocblas_dgemm_(handle,transA,transB,m,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocblas_dgemm_full_rank(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemm_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_dgemm_full_rank = rocblas_dgemm_(handle,transA,transB,m,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cgemm_assumed_rank(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_cgemm_assumed_rank = rocblas_cgemm_(handle,transA,transB,m,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_cgemm_rank_0(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocblas_cgemm_rank_0 = rocblas_cgemm_(handle,transA,transB,m,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocblas_cgemm_rank_1(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_cgemm_rank_1 = rocblas_cgemm_(handle,transA,transB,m,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocblas_cgemm_full_rank(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemm_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_cgemm_full_rank = rocblas_cgemm_(handle,transA,transB,m,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zgemm_assumed_rank(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_zgemm_assumed_rank = rocblas_zgemm_(handle,transA,transB,m,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocblas_zgemm_rank_0(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocblas_zgemm_rank_0 = rocblas_zgemm_(handle,transA,transB,m,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocblas_zgemm_rank_1(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_zgemm_rank_1 = rocblas_zgemm_(handle,transA,transB,m,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocblas_zgemm_full_rank(handle,transA,transB,m,n,k,alpha,A,lda,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemm_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_zgemm_full_rank = rocblas_zgemm_(handle,transA,transB,m,n,k,alpha,c_loc(A),lda, & c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sgemm_strided_batched_assumed_rank(handle,transA,transB,m,n,k,alpha,A,lda, & stride_a,B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemm_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_c integer(c_int) :: batch_count ! rocblas_sgemm_strided_batched_assumed_rank = rocblas_sgemm_strided_batched_(handle,transA, & transB,m,n,k,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,beta,c_loc(C),ldc,stride_c, & batch_count) end function #else function rocblas_sgemm_strided_batched_rank_0(handle,transA,transB,m,n,k,alpha,A,lda,stride_a, & B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemm_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_float),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b real(c_float) :: beta real(c_float),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_c integer(c_int) :: batch_count ! rocblas_sgemm_strided_batched_rank_0 = rocblas_sgemm_strided_batched_(handle,transA,transB, & m,n,k,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,beta,c_loc(C),ldc,stride_c, & batch_count) end function function rocblas_sgemm_strided_batched_rank_1(handle,transA,transB,m,n,k,alpha,A,lda,stride_a, & B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemm_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b real(c_float) :: beta real(c_float),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_c integer(c_int) :: batch_count ! rocblas_sgemm_strided_batched_rank_1 = rocblas_sgemm_strided_batched_(handle,transA,transB, & m,n,k,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,beta,c_loc(C),ldc,stride_c, & batch_count) end function function rocblas_sgemm_strided_batched_full_rank(handle,transA,transB,m,n,k,alpha,A,lda, & stride_a,B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgemm_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b real(c_float) :: beta real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_c integer(c_int) :: batch_count ! rocblas_sgemm_strided_batched_full_rank = rocblas_sgemm_strided_batched_(handle,transA, & transB,m,n,k,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,beta,c_loc(C),ldc,stride_c, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dgemm_strided_batched_assumed_rank(handle,transA,transB,m,n,k,alpha,A,lda, & stride_a,B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemm_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_c integer(c_int) :: batch_count ! rocblas_dgemm_strided_batched_assumed_rank = rocblas_dgemm_strided_batched_(handle,transA, & transB,m,n,k,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,beta,c_loc(C),ldc,stride_c, & batch_count) end function #else function rocblas_dgemm_strided_batched_rank_0(handle,transA,transB,m,n,k,alpha,A,lda,stride_a, & B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemm_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_double),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b real(c_double) :: beta real(c_double),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_c integer(c_int) :: batch_count ! rocblas_dgemm_strided_batched_rank_0 = rocblas_dgemm_strided_batched_(handle,transA,transB, & m,n,k,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,beta,c_loc(C),ldc,stride_c, & batch_count) end function function rocblas_dgemm_strided_batched_rank_1(handle,transA,transB,m,n,k,alpha,A,lda,stride_a, & B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemm_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b real(c_double) :: beta real(c_double),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_c integer(c_int) :: batch_count ! rocblas_dgemm_strided_batched_rank_1 = rocblas_dgemm_strided_batched_(handle,transA,transB, & m,n,k,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,beta,c_loc(C),ldc,stride_c, & batch_count) end function function rocblas_dgemm_strided_batched_full_rank(handle,transA,transB,m,n,k,alpha,A,lda, & stride_a,B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgemm_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b real(c_double) :: beta real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_c integer(c_int) :: batch_count ! rocblas_dgemm_strided_batched_full_rank = rocblas_dgemm_strided_batched_(handle,transA, & transB,m,n,k,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,beta,c_loc(C),ldc,stride_c, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cgemm_strided_batched_assumed_rank(handle,transA,transB,m,n,k,alpha,A,lda, & stride_a,B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemm_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_c integer(c_int) :: batch_count ! rocblas_cgemm_strided_batched_assumed_rank = rocblas_cgemm_strided_batched_(handle,transA, & transB,m,n,k,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,beta,c_loc(C),ldc,stride_c, & batch_count) end function #else function rocblas_cgemm_strided_batched_rank_0(handle,transA,transB,m,n,k,alpha,A,lda,stride_a, & B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemm_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_c integer(c_int) :: batch_count ! rocblas_cgemm_strided_batched_rank_0 = rocblas_cgemm_strided_batched_(handle,transA,transB, & m,n,k,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,beta,c_loc(C),ldc,stride_c, & batch_count) end function function rocblas_cgemm_strided_batched_rank_1(handle,transA,transB,m,n,k,alpha,A,lda,stride_a, & B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemm_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_c integer(c_int) :: batch_count ! rocblas_cgemm_strided_batched_rank_1 = rocblas_cgemm_strided_batched_(handle,transA,transB, & m,n,k,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,beta,c_loc(C),ldc,stride_c, & batch_count) end function function rocblas_cgemm_strided_batched_full_rank(handle,transA,transB,m,n,k,alpha,A,lda, & stride_a,B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgemm_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_c integer(c_int) :: batch_count ! rocblas_cgemm_strided_batched_full_rank = rocblas_cgemm_strided_batched_(handle,transA, & transB,m,n,k,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,beta,c_loc(C),ldc,stride_c, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zgemm_strided_batched_assumed_rank(handle,transA,transB,m,n,k,alpha,A,lda, & stride_a,B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemm_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_c integer(c_int) :: batch_count ! rocblas_zgemm_strided_batched_assumed_rank = rocblas_zgemm_strided_batched_(handle,transA, & transB,m,n,k,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,beta,c_loc(C),ldc,stride_c, & batch_count) end function #else function rocblas_zgemm_strided_batched_rank_0(handle,transA,transB,m,n,k,alpha,A,lda,stride_a, & B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemm_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_c integer(c_int) :: batch_count ! rocblas_zgemm_strided_batched_rank_0 = rocblas_zgemm_strided_batched_(handle,transA,transB, & m,n,k,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,beta,c_loc(C),ldc,stride_c, & batch_count) end function function rocblas_zgemm_strided_batched_rank_1(handle,transA,transB,m,n,k,alpha,A,lda,stride_a, & B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemm_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_c integer(c_int) :: batch_count ! rocblas_zgemm_strided_batched_rank_1 = rocblas_zgemm_strided_batched_(handle,transA,transB, & m,n,k,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,beta,c_loc(C),ldc,stride_c, & batch_count) end function function rocblas_zgemm_strided_batched_full_rank(handle,transA,transB,m,n,k,alpha,A,lda, & stride_a,B,ldb,stride_b,beta,C,ldc,stride_c,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgemm_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_a complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_b complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_c integer(c_int) :: batch_count ! rocblas_zgemm_strided_batched_full_rank = rocblas_zgemm_strided_batched_(handle,transA, & transB,m,n,k,alpha,c_loc(A),lda,stride_a,c_loc(B),ldb,stride_b,beta,c_loc(C),ldc,stride_c, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sdgmm_assumed_rank(handle,side,m,n,A,lda,x,incx,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdgmm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_sdgmm_assumed_rank = rocblas_sdgmm_(handle,side,m,n,c_loc(A),lda,c_loc(x),incx, & c_loc(C),ldc) end function #else function rocblas_sdgmm_rank_0(handle,side,m,n,A,lda,x,incx,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdgmm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: x integer(c_int) :: incx real(c_float),target :: C integer(c_int) :: ldc ! rocblas_sdgmm_rank_0 = rocblas_sdgmm_(handle,side,m,n,c_loc(A),lda,c_loc(x),incx,c_loc(C),ldc) end function function rocblas_sdgmm_rank_1(handle,side,m,n,A,lda,x,incx,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdgmm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_sdgmm_rank_1 = rocblas_sdgmm_(handle,side,m,n,c_loc(A),lda,c_loc(x),incx,c_loc(C),ldc) end function function rocblas_sdgmm_full_rank(handle,side,m,n,A,lda,x,incx,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdgmm_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_sdgmm_full_rank = rocblas_sdgmm_(handle,side,m,n,c_loc(A),lda,c_loc(x),incx, & c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ddgmm_assumed_rank(handle,side,m,n,A,lda,x,incx,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddgmm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_ddgmm_assumed_rank = rocblas_ddgmm_(handle,side,m,n,c_loc(A),lda,c_loc(x),incx, & c_loc(C),ldc) end function #else function rocblas_ddgmm_rank_0(handle,side,m,n,A,lda,x,incx,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddgmm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: x integer(c_int) :: incx real(c_double),target :: C integer(c_int) :: ldc ! rocblas_ddgmm_rank_0 = rocblas_ddgmm_(handle,side,m,n,c_loc(A),lda,c_loc(x),incx,c_loc(C),ldc) end function function rocblas_ddgmm_rank_1(handle,side,m,n,A,lda,x,incx,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddgmm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_ddgmm_rank_1 = rocblas_ddgmm_(handle,side,m,n,c_loc(A),lda,c_loc(x),incx,c_loc(C),ldc) end function function rocblas_ddgmm_full_rank(handle,side,m,n,A,lda,x,incx,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddgmm_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_ddgmm_full_rank = rocblas_ddgmm_(handle,side,m,n,c_loc(A),lda,c_loc(x),incx, & c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cdgmm_assumed_rank(handle,side,m,n,A,lda,x,incx,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdgmm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_cdgmm_assumed_rank = rocblas_cdgmm_(handle,side,m,n,c_loc(A),lda,c_loc(x),incx, & c_loc(C),ldc) end function #else function rocblas_cdgmm_rank_0(handle,side,m,n,A,lda,x,incx,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdgmm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocblas_cdgmm_rank_0 = rocblas_cdgmm_(handle,side,m,n,c_loc(A),lda,c_loc(x),incx,c_loc(C),ldc) end function function rocblas_cdgmm_rank_1(handle,side,m,n,A,lda,x,incx,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdgmm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_cdgmm_rank_1 = rocblas_cdgmm_(handle,side,m,n,c_loc(A),lda,c_loc(x),incx,c_loc(C),ldc) end function function rocblas_cdgmm_full_rank(handle,side,m,n,A,lda,x,incx,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdgmm_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_cdgmm_full_rank = rocblas_cdgmm_(handle,side,m,n,c_loc(A),lda,c_loc(x),incx, & c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zdgmm_assumed_rank(handle,side,m,n,A,lda,x,incx,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdgmm_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_zdgmm_assumed_rank = rocblas_zdgmm_(handle,side,m,n,c_loc(A),lda,c_loc(x),incx, & c_loc(C),ldc) end function #else function rocblas_zdgmm_rank_0(handle,side,m,n,A,lda,x,incx,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdgmm_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocblas_zdgmm_rank_0 = rocblas_zdgmm_(handle,side,m,n,c_loc(A),lda,c_loc(x),incx,c_loc(C),ldc) end function function rocblas_zdgmm_rank_1(handle,side,m,n,A,lda,x,incx,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdgmm_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_zdgmm_rank_1 = rocblas_zdgmm_(handle,side,m,n,c_loc(A),lda,c_loc(x),incx,c_loc(C),ldc) end function function rocblas_zdgmm_full_rank(handle,side,m,n,A,lda,x,incx,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdgmm_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_zdgmm_full_rank = rocblas_zdgmm_(handle,side,m,n,c_loc(A),lda,c_loc(x),incx, & c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sdgmm_strided_batched_assumed_rank(handle,side,m,n,A,lda,stride_A,x,incx, & stride_x,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdgmm_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_sdgmm_strided_batched_assumed_rank = rocblas_sdgmm_strided_batched_(handle,side,m,n, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,c_loc(C),ldc,stride_C,batch_count) end function #else function rocblas_sdgmm_strided_batched_rank_0(handle,side,m,n,A,lda,stride_A,x,incx,stride_x, & C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdgmm_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_sdgmm_strided_batched_rank_0 = rocblas_sdgmm_strided_batched_(handle,side,m,n, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_sdgmm_strided_batched_rank_1(handle,side,m,n,A,lda,stride_A,x,incx,stride_x, & C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdgmm_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_sdgmm_strided_batched_rank_1 = rocblas_sdgmm_strided_batched_(handle,side,m,n, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_sdgmm_strided_batched_full_rank(handle,side,m,n,A,lda,stride_A,x,incx, & stride_x,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sdgmm_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_sdgmm_strided_batched_full_rank = rocblas_sdgmm_strided_batched_(handle,side,m,n, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,c_loc(C),ldc,stride_C,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_ddgmm_strided_batched_assumed_rank(handle,side,m,n,A,lda,stride_A,x,incx, & stride_x,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddgmm_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ddgmm_strided_batched_assumed_rank = rocblas_ddgmm_strided_batched_(handle,side,m,n, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,c_loc(C),ldc,stride_C,batch_count) end function #else function rocblas_ddgmm_strided_batched_rank_0(handle,side,m,n,A,lda,stride_A,x,incx,stride_x, & C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddgmm_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ddgmm_strided_batched_rank_0 = rocblas_ddgmm_strided_batched_(handle,side,m,n, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_ddgmm_strided_batched_rank_1(handle,side,m,n,A,lda,stride_A,x,incx,stride_x, & C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddgmm_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ddgmm_strided_batched_rank_1 = rocblas_ddgmm_strided_batched_(handle,side,m,n, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_ddgmm_strided_batched_full_rank(handle,side,m,n,A,lda,stride_A,x,incx, & stride_x,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_ddgmm_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_ddgmm_strided_batched_full_rank = rocblas_ddgmm_strided_batched_(handle,side,m,n, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,c_loc(C),ldc,stride_C,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cdgmm_strided_batched_assumed_rank(handle,side,m,n,A,lda,stride_A,x,incx, & stride_x,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdgmm_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cdgmm_strided_batched_assumed_rank = rocblas_cdgmm_strided_batched_(handle,side,m,n, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,c_loc(C),ldc,stride_C,batch_count) end function #else function rocblas_cdgmm_strided_batched_rank_0(handle,side,m,n,A,lda,stride_A,x,incx,stride_x, & C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdgmm_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cdgmm_strided_batched_rank_0 = rocblas_cdgmm_strided_batched_(handle,side,m,n, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_cdgmm_strided_batched_rank_1(handle,side,m,n,A,lda,stride_A,x,incx,stride_x, & C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdgmm_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cdgmm_strided_batched_rank_1 = rocblas_cdgmm_strided_batched_(handle,side,m,n, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_cdgmm_strided_batched_full_rank(handle,side,m,n,A,lda,stride_A,x,incx, & stride_x,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cdgmm_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cdgmm_strided_batched_full_rank = rocblas_cdgmm_strided_batched_(handle,side,m,n, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,c_loc(C),ldc,stride_C,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zdgmm_strided_batched_assumed_rank(handle,side,m,n,A,lda,stride_A,x,incx, & stride_x,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdgmm_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zdgmm_strided_batched_assumed_rank = rocblas_zdgmm_strided_batched_(handle,side,m,n, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,c_loc(C),ldc,stride_C,batch_count) end function #else function rocblas_zdgmm_strided_batched_rank_0(handle,side,m,n,A,lda,stride_A,x,incx,stride_x, & C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdgmm_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zdgmm_strided_batched_rank_0 = rocblas_zdgmm_strided_batched_(handle,side,m,n, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_zdgmm_strided_batched_rank_1(handle,side,m,n,A,lda,stride_A,x,incx,stride_x, & C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdgmm_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zdgmm_strided_batched_rank_1 = rocblas_zdgmm_strided_batched_(handle,side,m,n, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,c_loc(C),ldc,stride_C,batch_count) end function function rocblas_zdgmm_strided_batched_full_rank(handle,side,m,n,A,lda,stride_A,x,incx, & stride_x,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zdgmm_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx integer(c_int64_t) :: stride_x complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zdgmm_strided_batched_full_rank = rocblas_zdgmm_strided_batched_(handle,side,m,n, & c_loc(A),lda,stride_A,c_loc(x),incx,stride_x,c_loc(C),ldc,stride_C,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sgeam_assumed_rank(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgeam_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_sgeam_assumed_rank = rocblas_sgeam_(handle,transA,transB,m,n,alpha,c_loc(A),lda, & beta,c_loc(B),ldb,c_loc(C),ldc) end function #else function rocblas_sgeam_rank_0(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgeam_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda real(c_float) :: beta real(c_float),target :: B integer(c_int) :: ldb real(c_float),target :: C integer(c_int) :: ldc ! rocblas_sgeam_rank_0 = rocblas_sgeam_(handle,transA,transB,m,n,alpha,c_loc(A),lda,beta, & c_loc(B),ldb,c_loc(C),ldc) end function function rocblas_sgeam_rank_1(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgeam_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: beta real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_sgeam_rank_1 = rocblas_sgeam_(handle,transA,transB,m,n,alpha,c_loc(A),lda,beta, & c_loc(B),ldb,c_loc(C),ldc) end function function rocblas_sgeam_full_rank(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgeam_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: beta real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_sgeam_full_rank = rocblas_sgeam_(handle,transA,transB,m,n,alpha,c_loc(A),lda,beta, & c_loc(B),ldb,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dgeam_assumed_rank(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgeam_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_dgeam_assumed_rank = rocblas_dgeam_(handle,transA,transB,m,n,alpha,c_loc(A),lda, & beta,c_loc(B),ldb,c_loc(C),ldc) end function #else function rocblas_dgeam_rank_0(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgeam_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda real(c_double) :: beta real(c_double),target :: B integer(c_int) :: ldb real(c_double),target :: C integer(c_int) :: ldc ! rocblas_dgeam_rank_0 = rocblas_dgeam_(handle,transA,transB,m,n,alpha,c_loc(A),lda,beta, & c_loc(B),ldb,c_loc(C),ldc) end function function rocblas_dgeam_rank_1(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgeam_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: beta real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_dgeam_rank_1 = rocblas_dgeam_(handle,transA,transB,m,n,alpha,c_loc(A),lda,beta, & c_loc(B),ldb,c_loc(C),ldc) end function function rocblas_dgeam_full_rank(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgeam_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: beta real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_dgeam_full_rank = rocblas_dgeam_(handle,transA,transB,m,n,alpha,c_loc(A),lda,beta, & c_loc(B),ldb,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cgeam_assumed_rank(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeam_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_cgeam_assumed_rank = rocblas_cgeam_(handle,transA,transB,m,n,alpha,c_loc(A),lda, & beta,c_loc(B),ldb,c_loc(C),ldc) end function #else function rocblas_cgeam_rank_0(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeam_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex) :: beta complex(c_float_complex),target :: B integer(c_int) :: ldb complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocblas_cgeam_rank_0 = rocblas_cgeam_(handle,transA,transB,m,n,alpha,c_loc(A),lda,beta, & c_loc(B),ldb,c_loc(C),ldc) end function function rocblas_cgeam_rank_1(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeam_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_cgeam_rank_1 = rocblas_cgeam_(handle,transA,transB,m,n,alpha,c_loc(A),lda,beta, & c_loc(B),ldb,c_loc(C),ldc) end function function rocblas_cgeam_full_rank(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeam_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_cgeam_full_rank = rocblas_cgeam_(handle,transA,transB,m,n,alpha,c_loc(A),lda,beta, & c_loc(B),ldb,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zgeam_assumed_rank(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeam_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocblas_zgeam_assumed_rank = rocblas_zgeam_(handle,transA,transB,m,n,alpha,c_loc(A),lda, & beta,c_loc(B),ldb,c_loc(C),ldc) end function #else function rocblas_zgeam_rank_0(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeam_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex) :: beta complex(c_double_complex),target :: B integer(c_int) :: ldb complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocblas_zgeam_rank_0 = rocblas_zgeam_(handle,transA,transB,m,n,alpha,c_loc(A),lda,beta, & c_loc(B),ldb,c_loc(C),ldc) end function function rocblas_zgeam_rank_1(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeam_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocblas_zgeam_rank_1 = rocblas_zgeam_(handle,transA,transB,m,n,alpha,c_loc(A),lda,beta, & c_loc(B),ldb,c_loc(C),ldc) end function function rocblas_zgeam_full_rank(handle,transA,transB,m,n,alpha,A,lda,beta,B,ldb,C,ldc) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeam_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocblas_zgeam_full_rank = rocblas_zgeam_(handle,transA,transB,m,n,alpha,c_loc(A),lda,beta, & c_loc(B),ldb,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_sgeam_strided_batched_assumed_rank(handle,transA,transB,m,n,alpha,A,lda, & stride_A,beta,B,ldb,stride_B,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgeam_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_sgeam_strided_batched_assumed_rank = rocblas_sgeam_strided_batched_(handle,transA, & transB,m,n,alpha,c_loc(A),lda,stride_A,beta,c_loc(B),ldb,stride_B,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_sgeam_strided_batched_rank_0(handle,transA,transB,m,n,alpha,A,lda,stride_A, & beta,B,ldb,stride_B,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgeam_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float) :: beta real(c_float),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_sgeam_strided_batched_rank_0 = rocblas_sgeam_strided_batched_(handle,transA,transB, & m,n,alpha,c_loc(A),lda,stride_A,beta,c_loc(B),ldb,stride_B,c_loc(C),ldc,stride_C, & batch_count) end function function rocblas_sgeam_strided_batched_rank_1(handle,transA,transB,m,n,alpha,A,lda,stride_A, & beta,B,ldb,stride_B,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgeam_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float) :: beta real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_sgeam_strided_batched_rank_1 = rocblas_sgeam_strided_batched_(handle,transA,transB, & m,n,alpha,c_loc(A),lda,stride_A,beta,c_loc(B),ldb,stride_B,c_loc(C),ldc,stride_C, & batch_count) end function function rocblas_sgeam_strided_batched_full_rank(handle,transA,transB,m,n,alpha,A,lda, & stride_A,beta,B,ldb,stride_B,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_sgeam_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_float) :: beta real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_sgeam_strided_batched_full_rank = rocblas_sgeam_strided_batched_(handle,transA, & transB,m,n,alpha,c_loc(A),lda,stride_A,beta,c_loc(B),ldb,stride_B,c_loc(C),ldc,stride_C, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_dgeam_strided_batched_assumed_rank(handle,transA,transB,m,n,alpha,A,lda, & stride_A,beta,B,ldb,stride_B,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgeam_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dgeam_strided_batched_assumed_rank = rocblas_dgeam_strided_batched_(handle,transA, & transB,m,n,alpha,c_loc(A),lda,stride_A,beta,c_loc(B),ldb,stride_B,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_dgeam_strided_batched_rank_0(handle,transA,transB,m,n,alpha,A,lda,stride_A, & beta,B,ldb,stride_B,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgeam_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double) :: beta real(c_double),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dgeam_strided_batched_rank_0 = rocblas_dgeam_strided_batched_(handle,transA,transB, & m,n,alpha,c_loc(A),lda,stride_A,beta,c_loc(B),ldb,stride_B,c_loc(C),ldc,stride_C, & batch_count) end function function rocblas_dgeam_strided_batched_rank_1(handle,transA,transB,m,n,alpha,A,lda,stride_A, & beta,B,ldb,stride_B,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgeam_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double) :: beta real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dgeam_strided_batched_rank_1 = rocblas_dgeam_strided_batched_(handle,transA,transB, & m,n,alpha,c_loc(A),lda,stride_A,beta,c_loc(B),ldb,stride_B,c_loc(C),ldc,stride_C, & batch_count) end function function rocblas_dgeam_strided_batched_full_rank(handle,transA,transB,m,n,alpha,A,lda, & stride_A,beta,B,ldb,stride_B,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_dgeam_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A real(c_double) :: beta real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_dgeam_strided_batched_full_rank = rocblas_dgeam_strided_batched_(handle,transA, & transB,m,n,alpha,c_loc(A),lda,stride_A,beta,c_loc(B),ldb,stride_B,c_loc(C),ldc,stride_C, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_cgeam_strided_batched_assumed_rank(handle,transA,transB,m,n,alpha,A,lda, & stride_A,beta,B,ldb,stride_B,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeam_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cgeam_strided_batched_assumed_rank = rocblas_cgeam_strided_batched_(handle,transA, & transB,m,n,alpha,c_loc(A),lda,stride_A,beta,c_loc(B),ldb,stride_B,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_cgeam_strided_batched_rank_0(handle,transA,transB,m,n,alpha,A,lda,stride_A, & beta,B,ldb,stride_B,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeam_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex) :: beta complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cgeam_strided_batched_rank_0 = rocblas_cgeam_strided_batched_(handle,transA,transB, & m,n,alpha,c_loc(A),lda,stride_A,beta,c_loc(B),ldb,stride_B,c_loc(C),ldc,stride_C, & batch_count) end function function rocblas_cgeam_strided_batched_rank_1(handle,transA,transB,m,n,alpha,A,lda,stride_A, & beta,B,ldb,stride_B,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeam_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cgeam_strided_batched_rank_1 = rocblas_cgeam_strided_batched_(handle,transA,transB, & m,n,alpha,c_loc(A),lda,stride_A,beta,c_loc(B),ldb,stride_B,c_loc(C),ldc,stride_C, & batch_count) end function function rocblas_cgeam_strided_batched_full_rank(handle,transA,transB,m,n,alpha,A,lda, & stride_A,beta,B,ldb,stride_B,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_cgeam_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_cgeam_strided_batched_full_rank = rocblas_cgeam_strided_batched_(handle,transA, & transB,m,n,alpha,c_loc(A),lda,stride_A,beta,c_loc(B),ldb,stride_B,c_loc(C),ldc,stride_C, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_zgeam_strided_batched_assumed_rank(handle,transA,transB,m,n,alpha,A,lda, & stride_A,beta,B,ldb,stride_B,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeam_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zgeam_strided_batched_assumed_rank = rocblas_zgeam_strided_batched_(handle,transA, & transB,m,n,alpha,c_loc(A),lda,stride_A,beta,c_loc(B),ldb,stride_B,c_loc(C),ldc,stride_C, & batch_count) end function #else function rocblas_zgeam_strided_batched_rank_0(handle,transA,transB,m,n,alpha,A,lda,stride_A, & beta,B,ldb,stride_B,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeam_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex) :: beta complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zgeam_strided_batched_rank_0 = rocblas_zgeam_strided_batched_(handle,transA,transB, & m,n,alpha,c_loc(A),lda,stride_A,beta,c_loc(B),ldb,stride_B,c_loc(C),ldc,stride_C, & batch_count) end function function rocblas_zgeam_strided_batched_rank_1(handle,transA,transB,m,n,alpha,A,lda,stride_A, & beta,B,ldb,stride_B,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeam_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zgeam_strided_batched_rank_1 = rocblas_zgeam_strided_batched_(handle,transA,transB, & m,n,alpha,c_loc(A),lda,stride_A,beta,c_loc(B),ldb,stride_B,c_loc(C),ldc,stride_C, & batch_count) end function function rocblas_zgeam_strided_batched_full_rank(handle,transA,transB,m,n,alpha,A,lda, & stride_A,beta,B,ldb,stride_B,C,ldc,stride_C,batch_count) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocblas_zgeam_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: transA integer(kind(rocblas_operation_none)) :: transB integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: stride_A complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: stride_B complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: stride_C integer(c_int) :: batch_count ! rocblas_zgeam_strided_batched_full_rank = rocblas_zgeam_strided_batched_(handle,transA, & transB,m,n,alpha,c_loc(A),lda,stride_A,beta,c_loc(B),ldb,stride_B,c_loc(C),ldc,stride_C, & batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocblas_set_vector_l_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n logical(c_bool),target,contiguous,dimension(..) :: x integer(c_int),value :: incx logical(c_bool),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,1,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_vector_i4_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_int),target,contiguous,dimension(..) :: x integer(c_int),value :: incx integer(c_int),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_vector_i8_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_long),target,contiguous,dimension(..) :: x integer(c_int),value :: incx integer(c_long),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_vector_r4_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int),value :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_vector_r8_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int),value :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_vector_c4_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int),value :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,2*4,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_vector_c8_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int),value :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,2*8,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_l_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n logical(c_bool),target,contiguous,dimension(..) :: x integer(c_int),value :: incx logical(c_bool),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,1,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_i4_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_int),target,contiguous,dimension(..) :: x integer(c_int),value :: incx integer(c_int),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_i8_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_long),target,contiguous,dimension(..) :: x integer(c_int),value :: incx integer(c_long),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_r4_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int),value :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_r8_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int),value :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_c4_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int),value :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,2*4,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_c8_assumed_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int),value :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,2*8,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_matrix_l_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,contiguous,dimension(..) :: A integer(c_int),value :: lda logical(c_bool),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_matrix_i4_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,contiguous,dimension(..) :: A integer(c_int),value :: lda integer(c_int),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_matrix_i8_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,contiguous,dimension(..) :: A integer(c_int),value :: lda integer(c_long),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_matrix_r4_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,contiguous,dimension(..) :: A integer(c_int),value :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_matrix_r8_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,contiguous,dimension(..) :: A integer(c_int),value :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_matrix_c4_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int),value :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_matrix_c8_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int),value :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_l_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,contiguous,dimension(..) :: A integer(c_int),value :: lda logical(c_bool),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_i4_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,contiguous,dimension(..) :: A integer(c_int),value :: lda integer(c_int),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_i8_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,contiguous,dimension(..) :: A integer(c_int),value :: lda integer(c_long),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_r4_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,contiguous,dimension(..) :: A integer(c_int),value :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_r8_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,contiguous,dimension(..) :: A integer(c_int),value :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_c4_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int),value :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_c8_assumed_rank(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int),value :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_vector_async_l_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n logical(c_bool),target,contiguous,dimension(..) :: x integer(c_int),value :: incx logical(c_bool),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,1,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_vector_async_i4_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_int),target,contiguous,dimension(..) :: x integer(c_int),value :: incx integer(c_int),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_vector_async_i8_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_long),target,contiguous,dimension(..) :: x integer(c_int),value :: incx integer(c_long),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_vector_async_r4_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int),value :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_vector_async_r8_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int),value :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_vector_async_c4_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int),value :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,2*4,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_vector_async_c8_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int),value :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,2*8,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_l_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n logical(c_bool),target,contiguous,dimension(..) :: x integer(c_int),value :: incx logical(c_bool),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,1,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_i4_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_int),target,contiguous,dimension(..) :: x integer(c_int),value :: incx integer(c_int),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_i8_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_long),target,contiguous,dimension(..) :: x integer(c_int),value :: incx integer(c_long),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_r4_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int),value :: incx real(c_float),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_r8_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int),value :: incx real(c_double),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_c4_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int),value :: incx complex(c_float_complex),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,2*4,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_c8_assumed_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int),value :: incx complex(c_double_complex),target,contiguous,dimension(..) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,2*8,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_matrix_async_l_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,contiguous,dimension(..) :: A integer(c_int),value :: lda logical(c_bool),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_set_matrix_async_i4_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,contiguous,dimension(..) :: A integer(c_int),value :: lda integer(c_int),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_set_matrix_async_i8_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,contiguous,dimension(..) :: A integer(c_int),value :: lda integer(c_long),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_set_matrix_async_r4_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,contiguous,dimension(..) :: A integer(c_int),value :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_set_matrix_async_r8_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,contiguous,dimension(..) :: A integer(c_int),value :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_set_matrix_async_c4_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int),value :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_set_matrix_async_c8_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int),value :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_l_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,contiguous,dimension(..) :: A integer(c_int),value :: lda logical(c_bool),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_i4_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,contiguous,dimension(..) :: A integer(c_int),value :: lda integer(c_int),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_i8_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,contiguous,dimension(..) :: A integer(c_int),value :: lda integer(c_long),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_r4_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,contiguous,dimension(..) :: A integer(c_int),value :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_r8_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,contiguous,dimension(..) :: A integer(c_int),value :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_c4_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int),value :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_c8_assumed_rank(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int),value :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb,stream) end function #else function rocblas_set_vector_l_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n logical(c_bool),target :: x integer(c_int),value :: incx logical(c_bool),target :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,1,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_vector_l_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n logical(c_bool),target,dimension(:) :: x integer(c_int),value :: incx logical(c_bool),target,dimension(:) :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,1,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_vector_i4_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_int),target :: x integer(c_int),value :: incx integer(c_int),target :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_vector_i4_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_int),target,dimension(:) :: x integer(c_int),value :: incx integer(c_int),target,dimension(:) :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_vector_i8_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_long),target :: x integer(c_int),value :: incx integer(c_long),target :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_vector_i8_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_long),target,dimension(:) :: x integer(c_int),value :: incx integer(c_long),target,dimension(:) :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_vector_r4_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_float),target :: x integer(c_int),value :: incx real(c_float),target :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_vector_r4_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_float),target,dimension(:) :: x integer(c_int),value :: incx real(c_float),target,dimension(:) :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_vector_r8_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_double),target :: x integer(c_int),value :: incx real(c_double),target :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_vector_r8_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_double),target,dimension(:) :: x integer(c_int),value :: incx real(c_double),target,dimension(:) :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_vector_c4_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_float_complex),target :: x integer(c_int),value :: incx complex(c_float_complex),target :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,2*4,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_vector_c4_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int),value :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,2*4,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_vector_c8_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_double_complex),target :: x integer(c_int),value :: incx complex(c_double_complex),target :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,2*8,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_vector_c8_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int),value :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int),value :: incy ! ret = rocblas_set_vector_(n,2*8,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_l_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n logical(c_bool),target :: x integer(c_int),value :: incx logical(c_bool),target :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,1,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_l_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n logical(c_bool),target,dimension(:) :: x integer(c_int),value :: incx logical(c_bool),target,dimension(:) :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,1,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_i4_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_int),target :: x integer(c_int),value :: incx integer(c_int),target :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_i4_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_int),target,dimension(:) :: x integer(c_int),value :: incx integer(c_int),target,dimension(:) :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_i8_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_long),target :: x integer(c_int),value :: incx integer(c_long),target :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_i8_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_long),target,dimension(:) :: x integer(c_int),value :: incx integer(c_long),target,dimension(:) :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_r4_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_float),target :: x integer(c_int),value :: incx real(c_float),target :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_r4_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_float),target,dimension(:) :: x integer(c_int),value :: incx real(c_float),target,dimension(:) :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,4,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_r8_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_double),target :: x integer(c_int),value :: incx real(c_double),target :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_r8_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_double),target,dimension(:) :: x integer(c_int),value :: incx real(c_double),target,dimension(:) :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,8,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_c4_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_float_complex),target :: x integer(c_int),value :: incx complex(c_float_complex),target :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,2*4,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_c4_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int),value :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,2*4,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_c8_rank_0(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_double_complex),target :: x integer(c_int),value :: incx complex(c_double_complex),target :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,2*8,c_loc(x),incx,c_loc(y),incy) end function function rocblas_get_vector_c8_full_rank(n,x,incx,y,incy) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int),value :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int),value :: incy ! ret = rocblas_get_vector_(n,2*8,c_loc(x),incx,c_loc(y),incy) end function function rocblas_set_matrix_l_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,dimension(:,:) :: A logical(c_bool),target,dimension(:,:) :: B ! ret = rocblas_set_matrix_(rows,cols,1,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function rocblas_set_matrix_l_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target :: A integer(c_int),value :: lda logical(c_bool),target :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_matrix_l_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,dimension(:) :: A integer(c_int),value :: lda logical(c_bool),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_matrix_i4_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,dimension(:,:) :: A integer(c_int),target,dimension(:,:) :: B ! ret = rocblas_set_matrix_(rows,cols,4,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function rocblas_set_matrix_i4_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target :: A integer(c_int),value :: lda integer(c_int),target :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_matrix_i4_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,dimension(:) :: A integer(c_int),value :: lda integer(c_int),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_matrix_i8_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,dimension(:,:) :: A integer(c_long),target,dimension(:,:) :: B ! ret = rocblas_set_matrix_(rows,cols,8,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function rocblas_set_matrix_i8_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target :: A integer(c_int),value :: lda integer(c_long),target :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_matrix_i8_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,dimension(:) :: A integer(c_int),value :: lda integer(c_long),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_matrix_r4_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,dimension(:,:) :: A real(c_float),target,dimension(:,:) :: B ! ret = rocblas_set_matrix_(rows,cols,4,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function rocblas_set_matrix_r4_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target :: A integer(c_int),value :: lda real(c_float),target :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_matrix_r4_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,dimension(:) :: A integer(c_int),value :: lda real(c_float),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_matrix_r8_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,dimension(:,:) :: A real(c_double),target,dimension(:,:) :: B ! ret = rocblas_set_matrix_(rows,cols,8,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function rocblas_set_matrix_r8_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target :: A integer(c_int),value :: lda real(c_double),target :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_matrix_r8_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,dimension(:) :: A integer(c_int),value :: lda real(c_double),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_matrix_c4_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,dimension(:,:) :: A complex(c_float_complex),target,dimension(:,:) :: B ! ret = rocblas_set_matrix_(rows,cols,2*4,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function rocblas_set_matrix_c4_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target :: A integer(c_int),value :: lda complex(c_float_complex),target :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_matrix_c4_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,dimension(:) :: A integer(c_int),value :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_matrix_c8_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,dimension(:,:) :: A complex(c_double_complex),target,dimension(:,:) :: B ! ret = rocblas_set_matrix_(rows,cols,2*8,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function rocblas_set_matrix_c8_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target :: A integer(c_int),value :: lda complex(c_double_complex),target :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_matrix_c8_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,dimension(:) :: A integer(c_int),value :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = rocblas_set_matrix_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_l_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,dimension(:,:) :: A logical(c_bool),target,dimension(:,:) :: B ! ret = rocblas_get_matrix_(rows,cols,1,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function rocblas_get_matrix_l_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target :: A integer(c_int),value :: lda logical(c_bool),target :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_l_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,dimension(:) :: A integer(c_int),value :: lda logical(c_bool),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_i4_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,dimension(:,:) :: A integer(c_int),target,dimension(:,:) :: B ! ret = rocblas_get_matrix_(rows,cols,4,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function rocblas_get_matrix_i4_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target :: A integer(c_int),value :: lda integer(c_int),target :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_i4_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,dimension(:) :: A integer(c_int),value :: lda integer(c_int),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_i8_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,dimension(:,:) :: A integer(c_long),target,dimension(:,:) :: B ! ret = rocblas_get_matrix_(rows,cols,8,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function rocblas_get_matrix_i8_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target :: A integer(c_int),value :: lda integer(c_long),target :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_i8_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,dimension(:) :: A integer(c_int),value :: lda integer(c_long),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_r4_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,dimension(:,:) :: A real(c_float),target,dimension(:,:) :: B ! ret = rocblas_get_matrix_(rows,cols,4,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function rocblas_get_matrix_r4_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target :: A integer(c_int),value :: lda real(c_float),target :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_r4_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,dimension(:) :: A integer(c_int),value :: lda real(c_float),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_r8_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,dimension(:,:) :: A real(c_double),target,dimension(:,:) :: B ! ret = rocblas_get_matrix_(rows,cols,8,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function rocblas_get_matrix_r8_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target :: A integer(c_int),value :: lda real(c_double),target :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_r8_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,dimension(:) :: A integer(c_int),value :: lda real(c_double),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_c4_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,dimension(:,:) :: A complex(c_float_complex),target,dimension(:,:) :: B ! ret = rocblas_get_matrix_(rows,cols,2*4,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function rocblas_get_matrix_c4_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target :: A integer(c_int),value :: lda complex(c_float_complex),target :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_c4_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,dimension(:) :: A integer(c_int),value :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_c8_full_rank(rows,cols,A,B) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,dimension(:,:) :: A complex(c_double_complex),target,dimension(:,:) :: B ! ret = rocblas_get_matrix_(rows,cols,2*8,c_loc(A),size(A,1),c_loc(B),size(B,1)) end function function rocblas_get_matrix_c8_rank_0(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target :: A integer(c_int),value :: lda complex(c_double_complex),target :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_get_matrix_c8_rank_1(rows,cols,A,lda,B,ldb) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,dimension(:) :: A integer(c_int),value :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int),value :: ldb ! ret = rocblas_get_matrix_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb) end function function rocblas_set_vector_async_l_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n logical(c_bool),target :: x integer(c_int),value :: incx logical(c_bool),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,1,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_vector_async_l_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n logical(c_bool),target,dimension(:) :: x integer(c_int),value :: incx logical(c_bool),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,1,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_vector_async_i4_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_int),target :: x integer(c_int),value :: incx integer(c_int),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_vector_async_i4_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_int),target,dimension(:) :: x integer(c_int),value :: incx integer(c_int),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_vector_async_i8_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_long),target :: x integer(c_int),value :: incx integer(c_long),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_vector_async_i8_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_long),target,dimension(:) :: x integer(c_int),value :: incx integer(c_long),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_vector_async_r4_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_float),target :: x integer(c_int),value :: incx real(c_float),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_vector_async_r4_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_float),target,dimension(:) :: x integer(c_int),value :: incx real(c_float),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_vector_async_r8_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_double),target :: x integer(c_int),value :: incx real(c_double),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_vector_async_r8_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_double),target,dimension(:) :: x integer(c_int),value :: incx real(c_double),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_vector_async_c4_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_float_complex),target :: x integer(c_int),value :: incx complex(c_float_complex),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,2*4,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_vector_async_c4_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int),value :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,2*4,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_vector_async_c8_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_double_complex),target :: x integer(c_int),value :: incx complex(c_double_complex),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,2*8,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_vector_async_c8_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int),value :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_set_vector_async_(n,2*8,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_l_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n logical(c_bool),target :: x integer(c_int),value :: incx logical(c_bool),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,1,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_l_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n logical(c_bool),target,dimension(:) :: x integer(c_int),value :: incx logical(c_bool),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,1,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_i4_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_int),target :: x integer(c_int),value :: incx integer(c_int),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_i4_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_int),target,dimension(:) :: x integer(c_int),value :: incx integer(c_int),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_i8_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_long),target :: x integer(c_int),value :: incx integer(c_long),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_i8_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n integer(c_long),target,dimension(:) :: x integer(c_int),value :: incx integer(c_long),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_r4_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_float),target :: x integer(c_int),value :: incx real(c_float),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_r4_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_float),target,dimension(:) :: x integer(c_int),value :: incx real(c_float),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,4,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_r8_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_double),target :: x integer(c_int),value :: incx real(c_double),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_r8_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n real(c_double),target,dimension(:) :: x integer(c_int),value :: incx real(c_double),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,8,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_c4_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_float_complex),target :: x integer(c_int),value :: incx complex(c_float_complex),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,2*4,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_c4_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int),value :: incx complex(c_float_complex),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,2*4,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_c8_rank_0(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_double_complex),target :: x integer(c_int),value :: incx complex(c_double_complex),target :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,2*8,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_get_vector_async_c8_full_rank(n,x,incx,y,incy,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int),value :: incx complex(c_double_complex),target,dimension(:) :: y integer(c_int),value :: incy type(c_ptr),value :: stream ! ret = rocblas_get_vector_async_(n,2*8,c_loc(x),incx,c_loc(y),incy,stream) end function function rocblas_set_matrix_async_l_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,dimension(:,:) :: A logical(c_bool),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,1,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function rocblas_set_matrix_async_l_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target :: A integer(c_int),value :: lda logical(c_bool),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_set_matrix_async_l_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,dimension(:) :: A integer(c_int),value :: lda logical(c_bool),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_set_matrix_async_i4_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,dimension(:,:) :: A integer(c_int),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,4,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function rocblas_set_matrix_async_i4_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target :: A integer(c_int),value :: lda integer(c_int),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_set_matrix_async_i4_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,dimension(:) :: A integer(c_int),value :: lda integer(c_int),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_set_matrix_async_i8_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,dimension(:,:) :: A integer(c_long),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,8,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function rocblas_set_matrix_async_i8_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target :: A integer(c_int),value :: lda integer(c_long),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_set_matrix_async_i8_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,dimension(:) :: A integer(c_int),value :: lda integer(c_long),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_set_matrix_async_r4_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,dimension(:,:) :: A real(c_float),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,4,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function rocblas_set_matrix_async_r4_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target :: A integer(c_int),value :: lda real(c_float),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_set_matrix_async_r4_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,dimension(:) :: A integer(c_int),value :: lda real(c_float),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_set_matrix_async_r8_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,dimension(:,:) :: A real(c_double),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,8,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function rocblas_set_matrix_async_r8_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target :: A integer(c_int),value :: lda real(c_double),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_set_matrix_async_r8_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,dimension(:) :: A integer(c_int),value :: lda real(c_double),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_set_matrix_async_c4_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,dimension(:,:) :: A complex(c_float_complex),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,2*4,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function rocblas_set_matrix_async_c4_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target :: A integer(c_int),value :: lda complex(c_float_complex),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_set_matrix_async_c4_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,dimension(:) :: A integer(c_int),value :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_set_matrix_async_c8_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,dimension(:,:) :: A complex(c_double_complex),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,2*8,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function rocblas_set_matrix_async_c8_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target :: A integer(c_int),value :: lda complex(c_double_complex),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_set_matrix_async_c8_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,dimension(:) :: A integer(c_int),value :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_set_matrix_async_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_l_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,dimension(:,:) :: A logical(c_bool),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,1,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function rocblas_get_matrix_async_l_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target :: A integer(c_int),value :: lda logical(c_bool),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_l_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols logical(c_bool),target,dimension(:) :: A integer(c_int),value :: lda logical(c_bool),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,1,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_i4_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,dimension(:,:) :: A integer(c_int),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,4,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function rocblas_get_matrix_async_i4_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target :: A integer(c_int),value :: lda integer(c_int),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_i4_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_int),target,dimension(:) :: A integer(c_int),value :: lda integer(c_int),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_i8_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,dimension(:,:) :: A integer(c_long),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,8,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function rocblas_get_matrix_async_i8_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target :: A integer(c_int),value :: lda integer(c_long),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_i8_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols integer(c_long),target,dimension(:) :: A integer(c_int),value :: lda integer(c_long),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_r4_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,dimension(:,:) :: A real(c_float),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,4,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function rocblas_get_matrix_async_r4_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target :: A integer(c_int),value :: lda real(c_float),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_r4_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_float),target,dimension(:) :: A integer(c_int),value :: lda real(c_float),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,4,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_r8_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,dimension(:,:) :: A real(c_double),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,8,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function rocblas_get_matrix_async_r8_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target :: A integer(c_int),value :: lda real(c_double),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_r8_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols real(c_double),target,dimension(:) :: A integer(c_int),value :: lda real(c_double),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,8,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_c4_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,dimension(:,:) :: A complex(c_float_complex),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,2*4,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function rocblas_get_matrix_async_c4_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target :: A integer(c_int),value :: lda complex(c_float_complex),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_c4_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_float_complex),target,dimension(:) :: A integer(c_int),value :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,2*4,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_c8_full_rank(rows,cols,A,B,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,dimension(:,:) :: A complex(c_double_complex),target,dimension(:,:) :: B type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,2*8,c_loc(A),size(A,1),c_loc(B),size(B,1),stream) end function function rocblas_get_matrix_async_c8_rank_0(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target :: A integer(c_int),value :: lda complex(c_double_complex),target :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb,stream) end function function rocblas_get_matrix_async_c8_rank_1(rows,cols,A,lda,B,ldb,stream) result(ret) use iso_c_binding use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: ret integer(c_int),value :: rows integer(c_int),value :: cols complex(c_double_complex),target,dimension(:) :: A integer(c_int),value :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int),value :: ldb type(c_ptr),value :: stream ! ret = rocblas_get_matrix_async_(rows,cols,2*8,c_loc(A),lda,c_loc(B),ldb,stream) end function #endif #endif end module hipfort_rocblas hipfort-rocm-10.0.0/lib/hipfort/hipfort_rocblas_enums.F90000066400000000000000000000142511524740623400233030ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_rocblas_enums use, intrinsic :: iso_c_binding implicit none ! rocblas_operation_ enum, bind(c) enumerator :: rocblas_operation_none = 111 enumerator :: rocblas_operation_transpose = 112 enumerator :: rocblas_operation_conjugate_transpose = 113 end enum ! rocblas_fill_ enum, bind(c) enumerator :: rocblas_fill_upper = 121 enumerator :: rocblas_fill_lower = 122 enumerator :: rocblas_fill_full = 123 end enum ! rocblas_diagonal_ enum, bind(c) enumerator :: rocblas_diagonal_non_unit = 131 enumerator :: rocblas_diagonal_unit = 132 end enum ! rocblas_side_ enum, bind(c) enumerator :: rocblas_side_left = 141 enumerator :: rocblas_side_right = 142 enumerator :: rocblas_side_both = 143 end enum ! rocblas_datatype_ enum, bind(c) enumerator :: rocblas_datatype_f16_r = 150 enumerator :: rocblas_datatype_f32_r = 151 enumerator :: rocblas_datatype_f64_r = 152 enumerator :: rocblas_datatype_f16_c = 153 enumerator :: rocblas_datatype_f32_c = 154 enumerator :: rocblas_datatype_f64_c = 155 enumerator :: rocblas_datatype_i8_r = 160 enumerator :: rocblas_datatype_u8_r = 161 enumerator :: rocblas_datatype_i32_r = 162 enumerator :: rocblas_datatype_u32_r = 163 enumerator :: rocblas_datatype_i8_c = 164 enumerator :: rocblas_datatype_u8_c = 165 enumerator :: rocblas_datatype_i32_c = 166 enumerator :: rocblas_datatype_u32_c = 167 enumerator :: rocblas_datatype_bf16_r = 168 enumerator :: rocblas_datatype_bf16_c = 169 enumerator :: rocblas_datatype_invalid = 255 end enum ! rocblas_status_ enum, bind(c) enumerator :: rocblas_status_success = 0 enumerator :: rocblas_status_invalid_handle = 1 enumerator :: rocblas_status_not_implemented = 2 enumerator :: rocblas_status_invalid_pointer = 3 enumerator :: rocblas_status_invalid_size = 4 enumerator :: rocblas_status_memory_error = 5 enumerator :: rocblas_status_internal_error = 6 enumerator :: rocblas_status_perf_degraded = 7 enumerator :: rocblas_status_size_query_mismatch = 8 enumerator :: rocblas_status_size_increased = 9 enumerator :: rocblas_status_size_unchanged = 10 enumerator :: rocblas_status_invalid_value = 11 enumerator :: rocblas_status_continue = 12 enumerator :: rocblas_status_check_numerics_fail = 13 enumerator :: rocblas_status_excluded_from_build = 14 enumerator :: rocblas_status_arch_mismatch = 15 end enum ! rocblas_pointer_mode_ enum, bind(c) enumerator :: rocblas_pointer_mode_host = 0 enumerator :: rocblas_pointer_mode_device = 1 end enum ! rocblas_atomics_mode_ enum, bind(c) enumerator :: rocblas_atomics_not_allowed = 0 enumerator :: rocblas_atomics_allowed = 1 end enum ! rocblas_performance_metric_ enum, bind(c) enumerator :: rocblas_default_performance_metric = 0 enumerator :: rocblas_device_efficiency_performance_metric = 1 enumerator :: rocblas_cu_efficiency_performance_metric = 2 end enum ! rocblas_layer_mode_ enum, bind(c) enumerator :: rocblas_layer_mode_none = 0 enumerator :: rocblas_layer_mode_log_trace = 1 enumerator :: rocblas_layer_mode_log_bench = 2 enumerator :: rocblas_layer_mode_log_profile = 4 enumerator :: rocblas_layer_mode_log_internal = 8 end enum ! rocblas_gemm_algo_ enum, bind(c) enumerator :: rocblas_gemm_algo_standard = 0 enumerator :: rocblas_gemm_algo_solution_index = 1 end enum ! rocblas_geam_ex_operation_ enum, bind(c) enumerator :: rocblas_geam_ex_operation_min_plus = 0 enumerator :: rocblas_geam_ex_operation_plus_min = 1 end enum ! rocblas_gemm_flags_ enum, bind(c) enumerator :: rocblas_gemm_flags_none = 0 enumerator :: rocblas_gemm_flags_use_cu_efficiency = 2 enumerator :: rocblas_gemm_flags_fp16_alt_impl = 4 enumerator :: rocblas_gemm_flags_check_solution_index = 8 enumerator :: rocblas_gemm_flags_fp16_alt_impl_rnz = 16 enumerator :: rocblas_gemm_flags_stochastic_rounding = 32 end enum ! rocblas_check_numerics_mode_ enum, bind(c) enumerator :: rocblas_check_numerics_mode_no_check = 0 enumerator :: rocblas_check_numerics_mode_info = 1 enumerator :: rocblas_check_numerics_mode_warn = 2 enumerator :: rocblas_check_numerics_mode_fail = 4 enumerator :: rocblas_check_numerics_mode_only_nan_inf = 8 end enum ! rocblas_math_mode_ enum, bind(c) enumerator :: rocblas_default_math = 0 enumerator :: rocblas_xf32_xdl_math_op = 1 end enum integer(c_int), parameter :: ROCBLAS_VERSION_MAJOR = 5 integer(c_int), parameter :: ROCBLAS_VERSION_MINOR = 6 integer(c_int), parameter :: ROCBLAS_VERSION_PATCH = 0 end module hipfort_rocblas_enums hipfort-rocm-10.0.0/lib/hipfort/hipfort_rocfft.F90000066400000000000000000001217001524740623400217300ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_rocfft use hipfort_rocfft_enums implicit none !> @brief Library setup function, called at least once in program before !> start of library use interface rocfft_setup function rocfft_setup_() bind(c, name="rocfft_setup") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_setup_ end function end interface !> @brief Library cleanup function, called exactly as many times as rocfft_setup !> in program after end of library use interface rocfft_cleanup function rocfft_cleanup_() bind(c, name="rocfft_cleanup") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_cleanup_ end function end interface !> @brief Create an FFT plan !> !> @details This API creates a plan, which the user can execute !> subsequently. This function takes many of the fundamental !> parameters needed to specify a transform. !> !> The dimensions parameter can take a value of 1, 2, or 3. The !> 'lengths' array specifies the size of data in each dimension. Note !> that lengths[0] is the size of the innermost dimension, lengths[1] !> is the next higher dimension and so on (column-major ordering). !> !> The 'number_of_transforms' parameter specifies how many !> transforms (of the same kind) needs to be computed. By specifying !> a value greater than 1, a batch of transforms can be computed !> with a single API call. !> !> Additionally, a handle to a plan description can be passed for !> more detailed transforms. For simple transforms, this parameter !> can be set to NULL. !> !> The plan must be destroyed with a call to `rocfft_plan_destroy`. !> !> @param[out] plan - plan handle !> @param[in] placement - placement of result !> @param[in] transform_type - type of transform !> @param[in] myPrecision - precision !> @param[in] dimensions - dimensions !> @param[in] lengths - dimensions-sized array of transform lengths !> @param[in] number_of_transforms - number of transforms !> @param[in] description - description handle created by !> rocfft_plan_description_create; can be !> NULL for simple transforms interface rocfft_plan_create function rocfft_plan_create_(plan,placement,transform_type,myPrecision,dimensions,lengths, & number_of_transforms,description) & bind(c, name="rocfft_plan_create") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_plan_create_ type(c_ptr) :: plan integer(kind(rocfft_placement_inplace)),value :: placement integer(kind(rocfft_transform_type_complex_forward)),value :: transform_type integer(kind(rocfft_precision_single)),value :: myPrecision integer(c_size_t),value :: dimensions type(c_ptr),value :: lengths integer(c_size_t),value :: number_of_transforms type(c_ptr),value :: description end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocfft_plan_create_assumed_rank #else module procedure & rocfft_plan_create_rank_0,& rocfft_plan_create_rank_1 #endif #endif end interface !> @brief Execute an FFT plan !> !> @details This API executes an FFT plan on buffers given by the user. !> !> If the transform is in-place, only the input buffer is needed and !> the output buffer parameter can be set to NULL. For not in-place !> transforms, output buffers have to be specified. !> !> Input and output buffers are arrays of pointers. Interleaved !> array formats are the default, and require just one pointer per !> input or output buffer. Planar array formats require two !> pointers per input or output buffer - real and imaginary !> pointers, in that order. !> !> If fields have been set for transform input or output, these !> arrays have one pointer per brick in the input or output field, !> provided in the order that the bricks were added to the field. !> !> Note that input buffers may still be overwritten during execution !> of a transform, even if the transform is not in-place. !> !> The final parameter in this function is a rocfft_execution_info !> handle. This optional parameter serves as a way for the user to control !> execution streams and work buffers. !> !> @param[in] plan - plan handle !> @param[in,out] in_buffer - array (of size 1 for interleaved data, of size 2 !> for planar data, or one per brick if an input field is set) of input buffers !> @param[in,out] out_buffer - array (of size 1 for interleaved data, of size 2 !> for planar data, or one per brick if an output field is set) of output buffers, !> ignored for in-place transforms !> @param[in] myInfo - execution info handle created by !> rocfft_execution_info_create interface rocfft_execute function rocfft_execute_(plan,in_buffer,out_buffer,myInfo) bind(c, name="rocfft_execute") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_execute_ type(c_ptr),value :: plan type(c_ptr) :: in_buffer type(c_ptr) :: out_buffer type(c_ptr),value :: myInfo end function end interface !> @brief Destroy an FFT plan !> @details This API frees the plan after it is no longer needed. !> @param[in] plan - plan handle interface rocfft_plan_destroy function rocfft_plan_destroy_(plan) bind(c, name="rocfft_plan_destroy") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_plan_destroy_ type(c_ptr),value :: plan end function end interface !> @brief Set scaling factor. !> @details rocFFT multiplies each element of the result by the given factor at the end of the !> transform. !> !> The supplied factor must be a finite number. That is, it must neither be infinity nor NaN. !> !> @param[in] description - description handle !> @param[in] scale_factor - scaling factor interface rocfft_plan_description_set_scale_factor function rocfft_plan_description_set_scale_factor_(description,scale_factor) & bind(c, name="rocfft_plan_description_set_scale_factor") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_plan_description_set_scale_factor_ type(c_ptr),value :: description real(c_double),value :: scale_factor end function end interface !> @brief Set advanced data layout parameters on a plan description !> !> @details This API specifies advanced layout of input/output !> buffers for a plan description. !> !> The following parameters are supported for inputs and outputs: !> !> * Array type (real, hermitian, or complex data, in either !> interleaved or planar format). !> * Real forward transforms require real input and hermitian output. !> * Real inverse transforms require hermitian input and real output. !> * Complex transforms require complex input and output. !> * Hermitian and complex data defaults to interleaved if a specific !> format is not specified. !> * Offset of first data element in the data buffer. Defaults to 0 if unspecified. !> * Stride between consecutive elements in each dimension. Defaults to packed data !> layout consistent with the type of transform and its placement (requested at !> plan creation), if unspecified. !> * Distance between consecutive batches. Zero values are interpreted as defaults !> to be deduced from the corresponding length and stride along the last transform !> dimension. !> !> Not all combinations of array types are supported and error codes !> will be returned for unsupported cases. !> !> Offset, stride, and distance for either input or output provided !> here is ignored if a field is set for the corresponding input or !> output. !> @note Non-zero offsets are not supported yet. !> !> @param[in, out] description - description handle !> @param[in] in_array_type - array type of input buffer !> @param[in] out_array_type - array type of output buffer !> @param[in] in_offsets - offsets, in element units, to start of data in input buffer !> @param[in] out_offsets - offsets, in element units, to start of data in output buffer !> @param[in] in_strides_size - size of in_strides array (must be equal to transform dimensions) !> @param[in] in_strides - array of strides, in each dimension, of !> input buffer; if set to null ptr library chooses defaults !> @param[in] in_distance - distance between start of each data instance in input buffer !> @param[in] out_strides_size - size of out_strides array (must be !> equal to transform dimensions) !> @param[in] out_strides - array of strides, in each dimension, of !> output buffer; if set to null ptr library chooses defaults !> @param[in] out_distance - distance between start of each data instance in output buffer interface rocfft_plan_description_set_data_layout function rocfft_plan_description_set_data_layout_(description,in_array_type,out_array_type, & in_offsets,out_offsets,in_strides_size,in_strides,in_distance,out_strides_size, & out_strides,out_distance) & bind(c, name="rocfft_plan_description_set_data_layout") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_plan_description_set_data_layout_ type(c_ptr),value :: description integer(kind(rocfft_array_type_complex_interleaved)),value :: in_array_type integer(kind(rocfft_array_type_complex_interleaved)),value :: out_array_type type(c_ptr),value :: in_offsets type(c_ptr),value :: out_offsets integer(c_size_t),value :: in_strides_size type(c_ptr),value :: in_strides integer(c_size_t),value :: in_distance integer(c_size_t),value :: out_strides_size type(c_ptr),value :: out_strides integer(c_size_t),value :: out_distance end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocfft_plan_description_set_data_layout_assumed_rank #else module procedure & rocfft_plan_description_set_data_layout_rank_0,& rocfft_plan_description_set_data_layout_rank_1 #endif #endif end interface !> @brief Create a rocfft field struct. !> !> @warning Experimental! This feature is part of an experimental API preview. interface rocfft_field_create function rocfft_field_create_(field) bind(c, name="rocfft_field_create") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_field_create_ type(c_ptr) :: field end function end interface !> @brief Destroy a rocfft field struct !> !> The field struct can be destroyed after being added to the plan description; it is not used !> for !> plan execution. !> !> @warning Experimental! This feature is part of an experimental API preview. interface rocfft_field_destroy function rocfft_field_destroy_(field) bind(c, name="rocfft_field_destroy") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_field_destroy_ type(c_ptr),value :: field end function end interface !> @brief Get library version string !> !> @param[in, out] buf - buffer that receives the version string !> @param[in] len - length of buf, minimum 30 characters interface rocfft_get_version_string function rocfft_get_version_string_(buf,len) bind(c, name="rocfft_get_version_string") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_get_version_string_ type(c_ptr),value :: buf integer(c_size_t),value :: len end function end interface !> @brief Set the communication library for distributed transforms. !> !> @details Set the multi-processing communication library for a plan. !> !> Multi-processing communication libraries require library-specific !> handle to also be specified. For MPI libraries, this is a !> pointer to an MPI communicator. !> !> @param[in] description - description handle !> @param[in] comm_type - communicator type !> @param[in] comm_handle - handle to communication-library-specific state interface rocfft_plan_description_set_comm function rocfft_plan_description_set_comm_(description,comm_type,comm_handle) & bind(c, name="rocfft_plan_description_set_comm") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_plan_description_set_comm_ type(c_ptr),value :: description integer(kind(rocfft_comm_none)),value :: comm_type type(c_ptr),value :: comm_handle end function end interface !> @brief Define a brick as part of a decomposition of a field. !> !> Fields can contain a full-dimensional data distribution. The !> decomposition is specified by providing a lower coordinate and an !> upper coordinate in the field's index space. The lower coordinate !> is inclusive (contained within the brick) and the upper coordinate !> is exclusive (first index past the end of the brick). !> !> One must also provide a stride for the brick data which specifies !> how the brick's data is arranged in memory. !> !> All coordinates and strides must include batch dimensions, and are in !> column-major order (fastest-moving dimension first). !> !> A HIP device ID is also provided - each brick may reside on a !> different device. !> !> All arrays may be re-used or freed immediately after the function returns. !> !> @param[out] brick - : brick structure !> @param[in] field_lower - : array of length `dim_with_batch` specifying the lower index !> (inclusive) for the brick in the field's index space. !> @param[in] field_upper - : array of length `dim_with_batch` specifying the upper index !> (exclusive) for the brick in the field's index space. !> @param[in] brick_stride - : array of length `dim_with_batch` specifying the brick's stride in !> memory !> @param[in] dim_with_batch - : length of the arrays; this must match the dimension of !> the FFT plus one for the batch dimension. !> @param[in] deviceID - : HIP device ID for the device on which the brick's data is resident. !> !> @warning Experimental! This feature is part of an experimental API preview. interface rocfft_brick_create function rocfft_brick_create_(brick,field_lower,field_upper,brick_stride,dim_with_batch, & deviceID) & bind(c, name="rocfft_brick_create") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_brick_create_ type(c_ptr) :: brick type(c_ptr),value :: field_lower type(c_ptr),value :: field_upper type(c_ptr),value :: brick_stride integer(c_size_t),value :: dim_with_batch integer(c_int),value :: deviceID end function end interface !> @brief Deallocate a brick created with rocfft_brick_create. !> !> @warning Experimental! This feature is part of an experimental API preview. interface rocfft_brick_destroy function rocfft_brick_destroy_(brick) bind(c, name="rocfft_brick_destroy") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_brick_destroy_ type(c_ptr),value :: brick end function end interface !> @brief Add a brick to a field. !> !> Note that the order in which the bricks are added is significant; !> the pointers provided for each brick to `rocfft_execute` are in !> the same order that the bricks were added to the field. !> !> The brick may be added to another field or destroyed any time !> after this function returns. !> !> @param[in, out] field - : `rocfft_field` struct which holds the brick decomposition. !> @param[in] brick - : `rocfft_brick` struct to add to the field. !> !> @warning Experimental! This feature is part of an experimental API preview. interface rocfft_field_add_brick function rocfft_field_add_brick_(field,brick) bind(c, name="rocfft_field_add_brick") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_field_add_brick_ type(c_ptr),value :: field type(c_ptr),value :: brick end function end interface !> @brief Add a `rocfft_field` to a `rocfft_plan_description` as an input. !> !> The field may be reused or freed immediately after the function returns. !> !> @param[in, out] description - : `rocfft_plan_description` that will pass the field information !> to plan creation !> @param[in] field - : `rocfft_field` struct added as an input field !> !> @warning Experimental! This feature is part of an experimental API preview. interface rocfft_plan_description_add_infield function rocfft_plan_description_add_infield_(description,field) & bind(c, name="rocfft_plan_description_add_infield") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_plan_description_add_infield_ type(c_ptr),value :: description type(c_ptr),value :: field end function end interface !> @brief Add a `rocfft_field` to a `rocfft_plan_description` as an output. !> !> The field may be reused or freed immediately after the function returns. !> !> @param[in, out] description - : `rocfft_plan_description` that will pass the field information !> to plan creation !> @param[in] field - : `rocfft_field` struct added as an output field !> !> @warning Experimental! This feature is part of an experimental API preview. interface rocfft_plan_description_add_outfield function rocfft_plan_description_add_outfield_(description,field) & bind(c, name="rocfft_plan_description_add_outfield") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_plan_description_add_outfield_ type(c_ptr),value :: description type(c_ptr),value :: field end function end interface !> @brief Get work buffer size on current HIP device !> @details Get the work buffer size required for a plan on the current HIP device. !> !> Work memory may be required on any device(s) with input or output !> data for the transform, and also the current device when the plan !> was created. If the FFT plan uses multiple devices then this !> function can be called repeatedly with each of those devices as !> the current HIP device, to know the complete work memory !> requirements for all devices. !> !> @param[in] plan - plan handle !> @param[out] size_in_bytes - size of needed work buffer in bytes interface rocfft_plan_get_work_buffer_size function rocfft_plan_get_work_buffer_size_(plan,size_in_bytes) & bind(c, name="rocfft_plan_get_work_buffer_size") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_plan_get_work_buffer_size_ type(c_ptr),value :: plan integer(c_size_t) :: size_in_bytes end function end interface !> @brief Print all plan information !> @details Prints plan details to stdout, to aid debugging !> @param[in] plan - plan handle interface rocfft_plan_get_print function rocfft_plan_get_print_(plan) bind(c, name="rocfft_plan_get_print") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_plan_get_print_ type(c_ptr),value :: plan end function end interface !> @brief Create plan description !> @details This API creates a plan description with which the user !> can set extra plan properties. The plan description must be freed !> with a call to `rocfft_plan_description_destroy`. !> @param[out] description - plan description handle interface rocfft_plan_description_create function rocfft_plan_description_create_(description) & bind(c, name="rocfft_plan_description_create") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_plan_description_create_ type(c_ptr) :: description end function end interface !> @brief Destroy a plan description !> @details This API frees the plan description. A plan description !> can be freed any time after it is passed to `rocfft_plan_create`. !> @param[in] description - plan description handle interface rocfft_plan_description_destroy function rocfft_plan_description_destroy_(description) & bind(c, name="rocfft_plan_description_destroy") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_plan_description_destroy_ type(c_ptr),value :: description end function end interface !> @brief Create execution info !> @details This API creates an execution info with which the user !> can control plan execution and work buffers. The execution info must be freed !> with a call to `rocfft_execution_info_destroy`. !> @param[out] myInfo - execution info handle interface rocfft_execution_info_create function rocfft_execution_info_create_(myInfo) bind(c, name="rocfft_execution_info_create") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_execution_info_create_ type(c_ptr) :: myInfo end function end interface !> @brief Destroy an execution info !> @details This API frees the execution info. An execution info !> object can be freed any time after it is passed to !> `rocfft_execute`. !> @param[in] myInfo - execution info handle interface rocfft_execution_info_destroy function rocfft_execution_info_destroy_(myInfo) bind(c, name="rocfft_execution_info_destroy") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_execution_info_destroy_ type(c_ptr),value :: myInfo end function end interface !> @brief Set work buffer in execution info for the current HIP device !> !> @details This is one of the execution info functions to specify !> optional additional information to control execution. This API !> provides a work buffer for the transform. It must be called !> before `rocfft_execute`. !> !> Work memory may be required on any device(s) with input or output !> data for the transform, and also the current device when the plan !> was created. If the FFT plan uses multiple devices then this !> function can be called repeatedly with each of those devices as !> the current HIP device, to set work memory for all devices. !> !> When a non-zero value is obtained from !> `rocfft_plan_get_work_buffer_size`, that means the library needs a !> work buffer to compute the transform. In this case, the user !> should allocate the work buffer and pass it to the library via !> this API. !> !> If a work buffer is required for the transform but is not !> specified using this function, `rocfft_execute` will automatically !> allocate the required buffer and free it when execution is !> finished. !> !> Users should allocate their own work buffers if they need precise !> control over the lifetimes of those buffers, or if multiple plans !> need to share the same buffer. !> !> @param[in] myInfo - execution info handle !> @param[in] work_buffer - work buffer !> @param[in] size_in_bytes - size of work buffer in bytes interface rocfft_execution_info_set_work_buffer function rocfft_execution_info_set_work_buffer_(myInfo,work_buffer,size_in_bytes) & bind(c, name="rocfft_execution_info_set_work_buffer") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_execution_info_set_work_buffer_ type(c_ptr),value :: myInfo type(c_ptr),value :: work_buffer integer(c_size_t),value :: size_in_bytes end function end interface !> @brief Set stream in execution info !> @details Associates an existing compute stream to a plan. This !> must be called before the call to `rocfft_execute`. !> !> Once the association is made, execution of the FFT will run the !> computation through the specified stream. !> !> The stream must be of type hipStream_t. It is an error to pass !> the address of a hipStream_t object. !> !> @param[in] myInfo - execution info handle !> @param[in] stream - underlying compute stream interface rocfft_execution_info_set_stream function rocfft_execution_info_set_stream_(myInfo,stream) & bind(c, name="rocfft_execution_info_set_stream") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_execution_info_set_stream_ type(c_ptr),value :: myInfo type(c_ptr),value :: stream end function end interface !> @brief Set a load callback for a plan execution (experimental) !> @details This function specifies a user-defined callback function !> that is run to load input from global memory at the start of the !> transform. Callbacks are an experimental feature in rocFFT. !> !> Callback function pointers/data are given as arrays, with one !> function/data pointer per brick in the input field of the plan. !> Load callbacks require at least one brick in the input field to !> be assigned to the current device used at plan creation. A plan !> with no input field specified is considered to have one brick on !> the current device used at plan creation. !> !> All functions in the array must perform the same logical !> operation. That is, any function in the array must be !> substitutable for any other function in the array if the data !> being loaded were moved to another brick. !> !> The provided function pointers replace any previously-specified !> load callback for this execution info handle. !> !> Load callbacks have the following signature: !> !> @code !> Tdata load_cb(Tdata* data, size_t offset, void* cbdata, void* sharedMem); !> @endcode !> !> 'Tdata' is the type of a single element of the input buffer. It is !> the caller's responsibility to ensure that the function type is !> appropriate for the plan (for example, a single-precision !> real-to-complex transform would load single-precision real !> elements). !> !> A null value for 'cb_functions' may be specified to clear any !> previously registered load callback. 'cb_data' may be null if !> the functions require no additional pointer to be passed to them. !> !> Currently, 'shared_mem_bytes' must be 0. Callbacks are not !> supported on transforms that use planar formats for either input !> or output. !> !> @param[in] myInfo - execution info handle !> @param[in] cb_functions - callback function pointers !> @param[in] cb_data - callback function data, passed to the function pointer when it is called !> @param[in] shared_mem_bytes - amount of shared memory to allocate for the callback function !> to use interface rocfft_execution_info_set_load_callback function rocfft_execution_info_set_load_callback_(myInfo,cb_functions,cb_data, & shared_mem_bytes) & bind(c, name="rocfft_execution_info_set_load_callback") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_execution_info_set_load_callback_ type(c_ptr),value :: myInfo type(c_ptr),value :: cb_functions type(c_ptr),value :: cb_data integer(c_size_t),value :: shared_mem_bytes end function end interface !> @brief Set a store callback for a plan execution (experimental) !> @details This function specifies a user-defined callback function !> that is run to store output to global memory at the end of the !> transform. Callbacks are an experimental feature in rocFFT. !> !> Callback function pointers/data are given as arrays, with one !> function/data pointer per brick in the output field of the plan. !> Store callbacks require at least one brick in the output field to !> be assigned to the current device used at plan creation. A plan !> with no output field specified is considered to have one brick on !> the current device used at plan creation. !> !> All functions in the array must perform the same logical !> operation. That is, any function in the array must be !> substitutable for any other function in the array if the data !> being stored were moved to another brick. !> !> The provided function pointers replace any previously-specified !> store callback for this execution info handle. !> !> Store callbacks have the following signature: !> !> @code !> void store_cb(Tdata* data, size_t offset, Tdata element, void* cbdata, void* sharedMem); !> @endcode !> !> 'Tdata' is the type of a single element of the output buffer. It is !> the caller's responsibility to ensure that the function type is !> appropriate for the plan (for example, a single-precision !> real-to-complex transform would store single-precision complex !> elements). !> !> A null value for 'cb_functions' may be specified to clear any !> previously registered load callback. 'cb_data' may be null if !> the functions require no additional pointer to be passed to them. !> !> Currently, 'shared_mem_bytes' must be 0. Callbacks are not !> supported on transforms that use planar formats for either input !> or output. !> !> @param[in] myInfo - execution info handle !> @param[in] cb_functions - callback function pointers !> @param[in] cb_data - callback function data, passed to the function pointer when it is called !> @param[in] shared_mem_bytes - amount of shared memory to allocate for the callback function !> to use interface rocfft_execution_info_set_store_callback function rocfft_execution_info_set_store_callback_(myInfo,cb_functions,cb_data, & shared_mem_bytes) & bind(c, name="rocfft_execution_info_set_store_callback") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_execution_info_set_store_callback_ type(c_ptr),value :: myInfo type(c_ptr),value :: cb_functions type(c_ptr),value :: cb_data integer(c_size_t),value :: shared_mem_bytes end function end interface !> @brief Serialize compiled kernel cache !> !> @details Serialize rocFFT's cache of compiled kernels into a !> buffer. This buffer is allocated by rocFFT and must be freed !> with a call to `rocfft_cache_buffer_free`. The length of the !> buffer in bytes is written to 'buffer_len_bytes'. interface rocfft_cache_serialize function rocfft_cache_serialize_(buffer,buffer_len_bytes) bind(c, name="rocfft_cache_serialize") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_cache_serialize_ type(c_ptr) :: buffer type(c_ptr),value :: buffer_len_bytes end function end interface !> @brief Free cache serialization buffer !> !> @details Deallocate a buffer allocated by `rocfft_cache_serialize`. interface rocfft_cache_buffer_free function rocfft_cache_buffer_free_(buffer) bind(c, name="rocfft_cache_buffer_free") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_cache_buffer_free_ type(c_ptr),value :: buffer end function end interface !> @brief Deserialize a buffer into the compiled kernel cache. !> !> @details Kernels in the buffer that match already-cached kernels !> will replace those kernels that are in the cache. Already-cached !> kernels that do not match those in the buffer are unmodified by !> this operation. The cache is unmodified if either a null buffer !> pointer or a zero length is passed. interface rocfft_cache_deserialize function rocfft_cache_deserialize_(buffer,buffer_len_bytes) & bind(c, name="rocfft_cache_deserialize") use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_cache_deserialize_ type(c_ptr),value :: buffer integer(c_size_t),value :: buffer_len_bytes end function end interface #ifdef USE_FPOINTER_INTERFACES contains #ifdef USE_ASSUMED_RANK_INTERFACES function rocfft_plan_create_assumed_rank(plan,placement,transform_type,myPrecision,dimensions, & lengths,number_of_transforms,description) use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_plan_create_assumed_rank type(c_ptr) :: plan integer(kind(rocfft_placement_inplace)) :: placement integer(kind(rocfft_transform_type_complex_forward)) :: transform_type integer(kind(rocfft_precision_single)) :: myPrecision integer(c_size_t) :: dimensions integer(c_size_t),target,contiguous,dimension(..) :: lengths integer(c_size_t) :: number_of_transforms type(c_ptr) :: description ! rocfft_plan_create_assumed_rank = rocfft_plan_create_(plan,placement,transform_type, & myPrecision,dimensions,c_loc(lengths),number_of_transforms,description) end function #else function rocfft_plan_create_rank_0(plan,placement,transform_type,myPrecision,dimensions, & lengths,number_of_transforms,description) use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_plan_create_rank_0 type(c_ptr) :: plan integer(kind(rocfft_placement_inplace)) :: placement integer(kind(rocfft_transform_type_complex_forward)) :: transform_type integer(kind(rocfft_precision_single)) :: myPrecision integer(c_size_t) :: dimensions integer(c_size_t),target :: lengths integer(c_size_t) :: number_of_transforms type(c_ptr) :: description ! rocfft_plan_create_rank_0 = rocfft_plan_create_(plan,placement,transform_type,myPrecision, & dimensions,c_loc(lengths),number_of_transforms,description) end function function rocfft_plan_create_rank_1(plan,placement,transform_type,myPrecision,dimensions, & lengths,number_of_transforms,description) use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_plan_create_rank_1 type(c_ptr) :: plan integer(kind(rocfft_placement_inplace)) :: placement integer(kind(rocfft_transform_type_complex_forward)) :: transform_type integer(kind(rocfft_precision_single)) :: myPrecision integer(c_size_t) :: dimensions integer(c_size_t),target,dimension(:) :: lengths integer(c_size_t) :: number_of_transforms type(c_ptr) :: description ! rocfft_plan_create_rank_1 = rocfft_plan_create_(plan,placement,transform_type,myPrecision, & dimensions,c_loc(lengths),number_of_transforms,description) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocfft_plan_description_set_data_layout_assumed_rank(description,in_array_type, & out_array_type,in_offsets,out_offsets,in_strides_size,in_strides,in_distance, & out_strides_size,out_strides,out_distance) use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_plan_description_set_data_layout_assumed_rank type(c_ptr) :: description integer(kind(rocfft_array_type_complex_interleaved)) :: in_array_type integer(kind(rocfft_array_type_complex_interleaved)) :: out_array_type integer(c_size_t),target,contiguous,dimension(..) :: in_offsets integer(c_size_t),target,contiguous,dimension(..) :: out_offsets integer(c_size_t) :: in_strides_size integer(c_size_t),target,contiguous,dimension(..) :: in_strides integer(c_size_t) :: in_distance integer(c_size_t) :: out_strides_size integer(c_size_t),target,contiguous,dimension(..) :: out_strides integer(c_size_t) :: out_distance ! rocfft_plan_description_set_data_layout_assumed_rank = & rocfft_plan_description_set_data_layout_(description,in_array_type,out_array_type, & c_loc(in_offsets),c_loc(out_offsets),in_strides_size,c_loc(in_strides),in_distance, & out_strides_size,c_loc(out_strides),out_distance) end function #else function rocfft_plan_description_set_data_layout_rank_0(description,in_array_type, & out_array_type,in_offsets,out_offsets,in_strides_size,in_strides,in_distance, & out_strides_size,out_strides,out_distance) use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_plan_description_set_data_layout_rank_0 type(c_ptr) :: description integer(kind(rocfft_array_type_complex_interleaved)) :: in_array_type integer(kind(rocfft_array_type_complex_interleaved)) :: out_array_type integer(c_size_t),target :: in_offsets integer(c_size_t),target :: out_offsets integer(c_size_t) :: in_strides_size integer(c_size_t),target :: in_strides integer(c_size_t) :: in_distance integer(c_size_t) :: out_strides_size integer(c_size_t),target :: out_strides integer(c_size_t) :: out_distance ! rocfft_plan_description_set_data_layout_rank_0 = rocfft_plan_description_set_data_layout_( & description,in_array_type,out_array_type,c_loc(in_offsets),c_loc(out_offsets), & in_strides_size,c_loc(in_strides),in_distance,out_strides_size,c_loc(out_strides), & out_distance) end function function rocfft_plan_description_set_data_layout_rank_1(description,in_array_type, & out_array_type,in_offsets,out_offsets,in_strides_size,in_strides,in_distance, & out_strides_size,out_strides,out_distance) use iso_c_binding use hipfort_rocfft_enums implicit none integer(kind(rocfft_status_success)) :: rocfft_plan_description_set_data_layout_rank_1 type(c_ptr) :: description integer(kind(rocfft_array_type_complex_interleaved)) :: in_array_type integer(kind(rocfft_array_type_complex_interleaved)) :: out_array_type integer(c_size_t),target,dimension(:) :: in_offsets integer(c_size_t),target,dimension(:) :: out_offsets integer(c_size_t) :: in_strides_size integer(c_size_t),target,dimension(:) :: in_strides integer(c_size_t) :: in_distance integer(c_size_t) :: out_strides_size integer(c_size_t),target,dimension(:) :: out_strides integer(c_size_t) :: out_distance ! rocfft_plan_description_set_data_layout_rank_1 = rocfft_plan_description_set_data_layout_( & description,in_array_type,out_array_type,c_loc(in_offsets),c_loc(out_offsets), & in_strides_size,c_loc(in_strides),in_distance,out_strides_size,c_loc(out_strides), & out_distance) end function #endif #endif end module hipfort_rocfft hipfort-rocm-10.0.0/lib/hipfort/hipfort_rocfft_enums.F90000066400000000000000000000062601524740623400231420ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_rocfft_enums implicit none ! rocfft_status_e enum, bind(c) enumerator :: rocfft_status_success = 0 enumerator :: rocfft_status_failure = 1 enumerator :: rocfft_status_invalid_arg_value = 2 enumerator :: rocfft_status_invalid_dimensions = 3 enumerator :: rocfft_status_invalid_array_type = 4 enumerator :: rocfft_status_invalid_strides = 5 enumerator :: rocfft_status_invalid_distance = 6 enumerator :: rocfft_status_invalid_offset = 7 enumerator :: rocfft_status_invalid_work_buffer = 8 end enum ! rocfft_transform_type_e enum, bind(c) enumerator :: rocfft_transform_type_complex_forward = 0 enumerator :: rocfft_transform_type_complex_inverse = 1 enumerator :: rocfft_transform_type_real_forward = 2 enumerator :: rocfft_transform_type_real_inverse = 3 end enum ! rocfft_precision_e enum, bind(c) enumerator :: rocfft_precision_single = 0 enumerator :: rocfft_precision_double = 1 enumerator :: rocfft_precision_half = 2 end enum ! rocfft_result_placement_e enum, bind(c) enumerator :: rocfft_placement_inplace = 0 enumerator :: rocfft_placement_notinplace = 1 end enum ! rocfft_array_type_e enum, bind(c) enumerator :: rocfft_array_type_complex_interleaved = 0 enumerator :: rocfft_array_type_complex_planar = 1 enumerator :: rocfft_array_type_real = 2 enumerator :: rocfft_array_type_hermitian_interleaved = 3 enumerator :: rocfft_array_type_hermitian_planar = 4 enumerator :: rocfft_array_type_unset = 5 end enum ! rocfft_comm_type_e enum, bind(c) enumerator :: rocfft_comm_none = 0 enumerator :: rocfft_comm_mpi = 1 end enum end module hipfort_rocfft_enums hipfort-rocm-10.0.0/lib/hipfort/hipfort_rocrand.F90000066400000000000000000001640451524740623400221060ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_rocrand use hipfort_rocrand_enums use hipfort_rocrand_types implicit none !> \brief Creates a new random number generator. !> !> Creates a new pseudo random number generator of type \p rng_type !> and returns it in \p generator. !> !> Values for \p rng_type are: !> - ROCRAND_RNG_PSEUDO_XORWOW !> - ROCRAND_RNG_PSEUDO_MRG31K3P !> - ROCRAND_RNG_PSEUDO_MRG32K3A !> - ROCRAND_RNG_PSEUDO_MTGP32 !> - ROCRAND_RNG_PSEUDO_PHILOX4_32_10 !> - ROCRAND_RNG_PSEUDO_LFSR113 !> - ROCRAND_RNG_PSEUDO_THREEFRY2_32_20 !> - ROCRAND_RNG_PSEUDO_THREEFRY2_64_20 !> - ROCRAND_RNG_PSEUDO_THREEFRY4_32_20 !> - ROCRAND_RNG_PSEUDO_THREEFRY4_64_20 !> - ROCRAND_RNG_QUASI_SOBOL32 !> - ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL32 !> - ROCRAND_RNG_QUASI_SOBOL64 !> - ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL64 !> !> \param generator - Pointer to generator !> \param rng_type - Type of generator to create !> !> \return !> - ROCRAND_STATUS_ALLOCATION_FAILED, if memory could not be allocated !> - ROCRAND_STATUS_VERSION_MISMATCH if the header file version does not match the !> dynamically linked library version !> - ROCRAND_STATUS_TYPE_ERROR if the value for \p rng_type is invalid !> - ROCRAND_STATUS_SUCCESS if generator was created successfully interface rocrand_create_generator function rocrand_create_generator_(generator,rng_type) bind(c, name="rocrand_create_generator") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_create_generator_ type(c_ptr) :: generator integer(kind(ROCRAND_RNG_PSEUDO_DEFAULT)),value :: rng_type end function end interface !> \brief Creates a new host random number generator. !> !> Creates a new pseudo random number generator of type \p rng_type !> and returns it in \p generator. This generator is executed on the host rather than !> on a device, and it is enqueued on the stream associated with the generator. !> !> All generators are supported. !> !> \param generator - Pointer to generator !> \param rng_type - Type of generator to create !> !> \return !> - ROCRAND_STATUS_ALLOCATION_FAILED, if memory could not be allocated !> - ROCRAND_STATUS_VERSION_MISMATCH if the header file version does not match the !> dynamically linked library version !> - ROCRAND_STATUS_TYPE_ERROR if the value for \p rng_type is invalid !> - ROCRAND_STATUS_SUCCESS if generator was created successfully interface rocrand_create_generator_host function rocrand_create_generator_host_(generator,rng_type) & bind(c, name="rocrand_create_generator_host") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_create_generator_host_ type(c_ptr) :: generator integer(kind(ROCRAND_RNG_PSEUDO_DEFAULT)),value :: rng_type end function end interface !> \brief Creates a new host random number generator, similar to `rocrand_create_generator_host`. !> The exception is that, instead of enqueuing the host function in the stream, !> execution happens synchronously with respect to the calling thread and the stream is !> ignored. interface rocrand_create_generator_host_blocking function rocrand_create_generator_host_blocking_(generator,rng_type) & bind(c, name="rocrand_create_generator_host_blocking") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_create_generator_host_blocking_ type(c_ptr) :: generator integer(kind(ROCRAND_RNG_PSEUDO_DEFAULT)),value :: rng_type end function end interface !> \brief Destroys random number generator. !> !> Destroys random number generator and frees related memory. !> !> \param generator - Generator to be destroyed !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_SUCCESS if generator was destroyed successfully interface rocrand_destroy_generator function rocrand_destroy_generator_(generator) bind(c, name="rocrand_destroy_generator") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_destroy_generator_ type(c_ptr),value :: generator end function end interface !> \brief Generates uniformly distributed 32-bit unsigned integers. !> !> Generates \p n uniformly distributed 32-bit unsigned integers and !> saves them to \p output_data. !> !> Generated numbers are between \p 0 and \p 2^32, including \p 0 and !> excluding \p 2^32. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of 32-bit unsigned integers to generate !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed !> - ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not a multiple of the dimension !> of used quasi-random generator !> - ROCRAND_STATUS_SUCCESS if random numbers were successfully generated interface rocrand_generate function rocrand_generate_(generator,output_data,n) bind(c, name="rocrand_generate") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocrand_generate_assumed_rank #else module procedure & rocrand_generate_rank_0,& rocrand_generate_rank_1 #endif #endif end interface !> \brief Generates uniformly distributed 64-bit unsigned integers. !> !> Generates \p n uniformly distributed 64-bit unsigned integers and !> saves them to \p output_data. !> !> Generated numbers are between \p 0 and \p 2^64, including \p 0 and !> excluding \p 2^64. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of 64-bit unsigned integers to generate !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed !> - ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not a multiple of the dimension !> of used quasi-random generator !> - ROCRAND_TYPE_ERROR if the generator can't natively generate 64-bit random numbers !> - ROCRAND_STATUS_SUCCESS if random numbers were successfully generated interface rocrand_generate_long_long function rocrand_generate_long_long_(generator,output_data,n) & bind(c, name="rocrand_generate_long_long") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_long_long_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocrand_generate_long_long_assumed_rank #else module procedure & rocrand_generate_long_long_rank_0,& rocrand_generate_long_long_rank_1 #endif #endif end interface !> \brief Generates uniformly distributed 8-bit unsigned integers. !> !> Generates \p n uniformly distributed 8-bit unsigned integers and !> saves them to \p output_data. !> !> Generated numbers are between \p 0 and \p 2^8, including \p 0 and !> excluding \p 2^8. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of 8-bit unsigned integers to generate !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed !> - ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not a multiple of the dimension !> of used quasi-random generator !> - ROCRAND_STATUS_SUCCESS if random numbers were successfully generated interface rocrand_generate_char function rocrand_generate_char_(generator,output_data,n) bind(c, name="rocrand_generate_char") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_char_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n end function end interface !> \brief Generates uniformly distributed 16-bit unsigned integers. !> !> Generates \p n uniformly distributed 16-bit unsigned integers and !> saves them to \p output_data. !> !> Generated numbers are between \p 0 and \p 2^16, including \p 0 and !> excluding \p 2^16. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of 16-bit unsigned integers to generate !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed !> - ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not a multiple of the dimension !> of used quasi-random generator !> - ROCRAND_STATUS_SUCCESS if random numbers were successfully generated interface rocrand_generate_short function rocrand_generate_short_(generator,output_data,n) bind(c, name="rocrand_generate_short") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_short_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n end function end interface !> \brief Generates uniformly distributed \p float values. !> !> Generates \p n uniformly distributed 32-bit floating-point values !> and saves them to \p output_data. !> !> Generated numbers are between \p 0.0f and \p 1.0f, excluding \p 0.0f and !> including \p 1.0f. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of floats to generate !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed !> - ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not a multiple of the dimension !> of used quasi-random generator !> - ROCRAND_STATUS_SUCCESS if random numbers were successfully generated interface rocrand_generate_uniform function rocrand_generate_uniform_(generator,output_data,n) & bind(c, name="rocrand_generate_uniform") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_uniform_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocrand_generate_uniform_assumed_rank #else module procedure & rocrand_generate_uniform_rank_0,& rocrand_generate_uniform_rank_1 #endif #endif end interface !> \brief Generates uniformly distributed double-precision floating-point values. !> !> Generates \p n uniformly distributed 64-bit double-precision floating-point !> values and saves them to \p output_data. !> !> Generated numbers are between \p 0.0 and \p 1.0, excluding \p 0.0 and !> including \p 1.0. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of doubles to generate !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed !> - ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not a multiple of the dimension !> of used quasi-random generator !> - ROCRAND_STATUS_SUCCESS if random numbers were successfully generated interface rocrand_generate_uniform_double function rocrand_generate_uniform_double_(generator,output_data,n) & bind(c, name="rocrand_generate_uniform_double") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_uniform_double_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocrand_generate_uniform_double_assumed_rank #else module procedure & rocrand_generate_uniform_double_rank_0,& rocrand_generate_uniform_double_rank_1 #endif #endif end interface !> \brief Generates uniformly distributed half-precision floating-point values. !> !> Generates \p n uniformly distributed 16-bit half-precision floating-point !> values and saves them to \p output_data. !> !> Generated numbers are between \p 0.0 and \p 1.0, excluding \p 0.0 and !> including \p 1.0. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of halfs to generate !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed !> - ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not a multiple of the dimension !> of used quasi-random generator !> - ROCRAND_STATUS_SUCCESS if random numbers were successfully generated interface rocrand_generate_uniform_half function rocrand_generate_uniform_half_(generator,output_data,n) & bind(c, name="rocrand_generate_uniform_half") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_uniform_half_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n end function end interface !> \brief Generates normally distributed \p float values. !> !> Generates \p n normally distributed distributed 32-bit floating-point !> values and saves them to \p output_data. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of floats to generate !> \param mean - Mean value of normal distribution !> \param stddev - Standard deviation value of normal distribution !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed !> - ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not a multiple of the dimension !> of used quasi-random generator !> - ROCRAND_STATUS_SUCCESS if random numbers were successfully generated interface rocrand_generate_normal function rocrand_generate_normal_(generator,output_data,n,mean,stddev) & bind(c, name="rocrand_generate_normal") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_normal_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n real(c_float),value :: mean real(c_float),value :: stddev end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocrand_generate_normal_assumed_rank #else module procedure & rocrand_generate_normal_rank_0,& rocrand_generate_normal_rank_1 #endif #endif end interface !> \brief Generates normally distributed \p double values. !> !> Generates \p n normally distributed 64-bit double-precision floating-point !> numbers and saves them to \p output_data. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of doubles to generate !> \param mean - Mean value of normal distribution !> \param stddev - Standard deviation value of normal distribution !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed !> - ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not a multiple of the dimension !> of used quasi-random generator !> - ROCRAND_STATUS_SUCCESS if random numbers were successfully generated interface rocrand_generate_normal_double function rocrand_generate_normal_double_(generator,output_data,n,mean,stddev) & bind(c, name="rocrand_generate_normal_double") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_normal_double_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n real(c_double),value :: mean real(c_double),value :: stddev end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocrand_generate_normal_double_assumed_rank #else module procedure & rocrand_generate_normal_double_rank_0,& rocrand_generate_normal_double_rank_1 #endif #endif end interface !> \brief Generates normally distributed \p half values. !> !> Generates \p n normally distributed 16-bit half-precision floating-point !> numbers and saves them to \p output_data. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of halfs to generate !> \param mean - Mean value of normal distribution !> \param stddev - Standard deviation value of normal distribution !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed !> - ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not a multiple of the dimension !> of used quasi-random generator !> - ROCRAND_STATUS_SUCCESS if random numbers were successfully generated interface rocrand_generate_normal_half function rocrand_generate_normal_half_(generator,output_data,n,mean,stddev) & bind(c, name="rocrand_generate_normal_half") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_normal_half_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n integer(c_short),value :: mean integer(c_short),value :: stddev end function end interface !> \brief Generates log-normally distributed \p float values. !> !> Generates \p n log-normally distributed 32-bit floating-point values !> and saves them to \p output_data. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of floats to generate !> \param mean - Mean value of log normal distribution !> \param stddev - Standard deviation value of log normal distribution !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed !> - ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not a multiple of the dimension !> of used quasi-random generator !> - ROCRAND_STATUS_SUCCESS if random numbers were successfully generated interface rocrand_generate_log_normal function rocrand_generate_log_normal_(generator,output_data,n,mean,stddev) & bind(c, name="rocrand_generate_log_normal") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_log_normal_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n real(c_float),value :: mean real(c_float),value :: stddev end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocrand_generate_log_normal_assumed_rank #else module procedure & rocrand_generate_log_normal_rank_0,& rocrand_generate_log_normal_rank_1 #endif #endif end interface !> \brief Generates log-normally distributed \p double values. !> !> Generates \p n log-normally distributed 64-bit double-precision floating-point !> values and saves them to \p output_data. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of doubles to generate !> \param mean - Mean value of log normal distribution !> \param stddev - Standard deviation value of log normal distribution !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed !> - ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not a multiple of the dimension !> of used quasi-random generator !> - ROCRAND_STATUS_SUCCESS if random numbers were successfully generated interface rocrand_generate_log_normal_double function rocrand_generate_log_normal_double_(generator,output_data,n,mean,stddev) & bind(c, name="rocrand_generate_log_normal_double") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_log_normal_double_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n real(c_double),value :: mean real(c_double),value :: stddev end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocrand_generate_log_normal_double_assumed_rank #else module procedure & rocrand_generate_log_normal_double_rank_0,& rocrand_generate_log_normal_double_rank_1 #endif #endif end interface !> \brief Generates log-normally distributed \p half values. !> !> Generates \p n log-normally distributed 16-bit half-precision floating-point !> values and saves them to \p output_data. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of halfs to generate !> \param mean - Mean value of log normal distribution !> \param stddev - Standard deviation value of log normal distribution !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed !> - ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not a multiple of the dimension !> of used quasi-random generator !> - ROCRAND_STATUS_SUCCESS if random numbers were successfully generated interface rocrand_generate_log_normal_half function rocrand_generate_log_normal_half_(generator,output_data,n,mean,stddev) & bind(c, name="rocrand_generate_log_normal_half") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_log_normal_half_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n integer(c_short),value :: mean integer(c_short),value :: stddev end function end interface !> \brief Generates Poisson-distributed 32-bit unsigned integers. !> !> Generates \p n Poisson-distributed 32-bit unsigned integers and !> saves them to \p output_data. !> !> \param generator - Generator to use !> \param output_data - Pointer to memory to store generated numbers !> \param n - Number of 32-bit unsigned integers to generate !> \param lambda - lambda for the Poisson distribution !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed !> - ROCRAND_STATUS_OUT_OF_RANGE if lambda is non-positive !> - ROCRAND_STATUS_LENGTH_NOT_MULTIPLE if \p n is not a multiple of the dimension !> of used quasi-random generator !> - ROCRAND_STATUS_SUCCESS if random numbers were successfully generated interface rocrand_generate_poisson function rocrand_generate_poisson_(generator,output_data,n,lambda) & bind(c, name="rocrand_generate_poisson") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_poisson_ type(c_ptr),value :: generator type(c_ptr),value :: output_data integer(c_size_t),value :: n real(c_double),value :: lambda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocrand_generate_poisson_assumed_rank #else module procedure & rocrand_generate_poisson_rank_0,& rocrand_generate_poisson_rank_1 #endif #endif end interface !> \brief Initializes the generator's state on GPU or host. !> !> Initializes the generator's state on GPU or host. User it not !> required to call this function before using a generator. !> !> If rocrand_initialize() was not called for a generator, it will be !> automatically called by functions which generates random numbers like !> rocrand_generate(), rocrand_generate_uniform() etc. !> !> \param generator - Generator to initialize !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_LAUNCH_FAILURE if a HIP kernel launch failed !> - ROCRAND_STATUS_SUCCESS if the seeds were generated successfully interface rocrand_initialize_generator function rocrand_initialize_generator_(generator) bind(c, name="rocrand_initialize_generator") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_initialize_generator_ type(c_ptr),value :: generator end function end interface !> \brief Sets the current stream for kernel launches. !> !> Sets the current stream for all kernel launches of the generator. !> All functions will use this stream. !> !> \param generator - Generator to modify !> \param stream - Stream to use or NULL for default stream !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_SUCCESS if stream was set successfully interface rocrand_set_stream function rocrand_set_stream_(generator,stream) bind(c, name="rocrand_set_stream") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_set_stream_ type(c_ptr),value :: generator type(c_ptr),value :: stream end function end interface !> \brief Sets the seed of a pseudo-random number generator. !> !> Sets the seed of the pseudo-random number generator. !> !> - This operation resets the generator's internal state. !> - This operation does not change the generator's offset. !> !> For an MRG32K3a or MRG31K3p generator the seed value can't be zero. If \p seed is !> equal to zero and generator's type is ROCRAND_RNG_PSEUDO_MRG32K3A or !> ROCRAND_RNG_PSEUDO_MRG31K3P, !> value \p 12345 is used as seed instead. !> !> For a LFSR113 generator seed values must be larger than 1, 7, 15, !> 127. The \p seed upper and lower 32 bits used as first and !> second seed value. If those values smaller than 2 and/or 8, those !> are increased with 1 and/or 7. !> !> \param generator - Pseudo-random number generator !> \param seed - New seed value !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_TYPE_ERROR if the generator is a quasi-random number generator !> - ROCRAND_STATUS_SUCCESS if seed was set successfully interface rocrand_set_seed function rocrand_set_seed_(generator,seed) bind(c, name="rocrand_set_seed") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_set_seed_ type(c_ptr),value :: generator integer(c_int64_t),value :: seed end function end interface !> \brief Sets the seeds of a pseudo-random number generator. !> !> Sets the seed of the pseudo-random number generator. Currently only for LFSR113 !> !> - This operation resets the generator's internal state. !> - This operation does not change the generator's offset. !> !> Only usable for LFSR113. !> !> For a LFSR113 generator seed values must be bigger than 1, 7, 15, !> 127. If those values smaller, than the requested minimum values [2, 8, 16, 128], then !> it will be increased with the minimum values minus 1 [1, 7, 15, 127]. !> !> \param generator - Pseudo-random number generator !> \param seed - New seed value !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_TYPE_ERROR if the generator is a quasi-random number generator !> - ROCRAND_STATUS_SUCCESS if seed was set successfully interface rocrand_set_seed_uint4 function rocrand_set_seed_uint4_(generator,seed) bind(c, name="rocrand_set_seed_uint4") use iso_c_binding use hipfort_rocrand_enums use hipfort_rocrand_types implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_set_seed_uint4_ type(c_ptr),value :: generator type(uint4),value :: seed end function end interface !> \brief Sets the offset of a random number generator. !> !> Sets the absolute offset of the random number generator. !> !> - This operation resets the generator's internal state. !> - This operation does not change the generator's seed. !> !> Absolute offset cannot be set if generator's type is ROCRAND_RNG_PSEUDO_MTGP32 or !> ROCRAND_RNG_PSEUDO_LFSR113. !> !> \param generator - Random number generator !> \param offset - New absolute offset !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_SUCCESS if offset was successfully set !> - ROCRAND_STATUS_TYPE_ERROR if generator's type is ROCRAND_RNG_PSEUDO_MTGP32 or !> ROCRAND_RNG_PSEUDO_LFSR113 interface rocrand_set_offset function rocrand_set_offset_(generator,offset) bind(c, name="rocrand_set_offset") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_set_offset_ type(c_ptr),value :: generator integer(c_int64_t),value :: offset end function end interface !> \brief Sets the ordering of a random number generator. !> !> Sets the ordering of the results of a random number generator. !> !> - This operation resets the generator's internal state. !> - This operation does not change the generator's seed. !> !> \param generator - Random number generator !> \param order - New ordering of results !> !> The ordering choices for pseudorandom sequences are the following. !> Note that not all generators support all orderings. For details, see !> the Programmer's Guide in the documentation. !> - ROCRAND_ORDERING_PSEUDO_DEFAULT !> - ROCRAND_ORDERING_PSEUDO_LEGACY !> - ROCRAND_ORDERING_PSEUDO_BEST !> - ROCRAND_ORDERING_PSEUDO_SEEDED !> - ROCRAND_ORDERING_PSEUDO_DYNAMIC !> !> For quasirandom sequences there is only one ordering, ROCRAND_ORDERING_QUASI_DEFAULT. !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_OUT_OF_RANGE if the ordering is not valid !> - ROCRAND_STATUS_SUCCESS if the ordering was successfully set !> - ROCRAND_STATUS_TYPE_ERROR if generator's type is not valid interface rocrand_set_ordering function rocrand_set_ordering_(generator,order) bind(c, name="rocrand_set_ordering") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_set_ordering_ type(c_ptr),value :: generator integer(kind(ROCRAND_ORDERING_PSEUDO_BEST)),value :: order end function end interface !> \brief Set the number of dimensions of a quasi-random number generator. !> !> Set the number of dimensions of a quasi-random number generator. !> Supported values of \p dimensions are 1 to 20000. !> !> - This operation resets the generator's internal state. !> - This operation does not change the generator's offset. !> !> \param generator - Quasi-random number generator !> \param dimensions - Number of dimensions !> !> \return !> - ROCRAND_STATUS_NOT_CREATED if the generator wasn't created !> - ROCRAND_STATUS_TYPE_ERROR if the generator is not a quasi-random number generator !> - ROCRAND_STATUS_OUT_OF_RANGE if \p dimensions is out of range !> - ROCRAND_STATUS_SUCCESS if the number of dimensions was set successfully interface rocrand_set_quasi_random_generator_dimensions function rocrand_set_quasi_random_generator_dimensions_(generator,dimensions) & bind(c, name="rocrand_set_quasi_random_generator_dimensions") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_set_quasi_random_generator_dimensions_ type(c_ptr),value :: generator integer(c_int),value :: dimensions end function end interface !> \brief Returns the version number of the library. !> !> Returns in \p version the version number of the dynamically linked !> rocRAND library. !> !> \param version - Version of the library !> !> \return !> - ROCRAND_STATUS_OUT_OF_RANGE if \p version is NULL !> - ROCRAND_STATUS_SUCCESS if the version number was successfully returned interface rocrand_get_version function rocrand_get_version_(version) bind(c, name="rocrand_get_version") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_get_version_ integer(c_int) :: version end function end interface !> \brief Construct the histogram for a Poisson distribution. !> !> Construct the histogram for the Poisson distribution with lambda \p lambda. !> !> \param lambda - lambda for the Poisson distribution !> \param discrete_distribution - pointer to the histogram in device memory !> !> \return !> - ROCRAND_STATUS_ALLOCATION_FAILED if memory could not be allocated !> - ROCRAND_STATUS_OUT_OF_RANGE if \p discrete_distribution pointer was null !> - ROCRAND_STATUS_OUT_OF_RANGE if lambda is non-positive !> - ROCRAND_STATUS_SUCCESS if the histogram was constructed successfully interface rocrand_create_poisson_distribution function rocrand_create_poisson_distribution_(lambda,discrete_distribution) & bind(c, name="rocrand_create_poisson_distribution") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_create_poisson_distribution_ real(c_double),value :: lambda type(c_ptr) :: discrete_distribution end function end interface !> \brief Construct the histogram for a custom discrete distribution. !> !> Construct the histogram for the discrete distribution of \p size !> 32-bit unsigned integers from the range [\p offset, \p offset + \p size) !> using \p probabilities as probabilities. !> !> \param probabilities - probabilities of the the distribution in host memory !> \param mySize - size of \p probabilities !> \param offset - offset of values !> \param discrete_distribution - pointer to the histogram in device memory !> !> \return !> - ROCRAND_STATUS_ALLOCATION_FAILED if memory could not be allocated !> - ROCRAND_STATUS_OUT_OF_RANGE if \p discrete_distribution pointer was null !> - ROCRAND_STATUS_OUT_OF_RANGE if \p size was zero !> - ROCRAND_STATUS_SUCCESS if the histogram was constructed successfully interface rocrand_create_discrete_distribution function rocrand_create_discrete_distribution_(probabilities,mySize,offset, & discrete_distribution) & bind(c, name="rocrand_create_discrete_distribution") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_create_discrete_distribution_ type(c_ptr),value :: probabilities integer(c_int),value :: mySize integer(c_int),value :: offset type(c_ptr) :: discrete_distribution end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocrand_create_discrete_distribution_assumed_rank #else module procedure & rocrand_create_discrete_distribution_rank_0,& rocrand_create_discrete_distribution_rank_1 #endif #endif end interface !> \brief Destroy the histogram array for a discrete distribution. !> !> Destroy the histogram array for a discrete distribution created by !> rocrand_create_poisson_distribution. !> !> \param discrete_distribution - pointer to the histogram in device memory !> !> \return !> - ROCRAND_STATUS_OUT_OF_RANGE if \p discrete_distribution was null !> - ROCRAND_STATUS_SUCCESS if the histogram was destroyed successfully interface rocrand_destroy_discrete_distribution function rocrand_destroy_discrete_distribution_(discrete_distribution) & bind(c, name="rocrand_destroy_discrete_distribution") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_destroy_discrete_distribution_ type(c_ptr),value :: discrete_distribution end function end interface !> \brief Get the vector for 32-bit (scrambled-)sobol generation. !> !> \param vectors - location where to write the vector pointer to !> !> \param set - which direction vector set to use !> !> \return !> - ROCRAND_STATUS_OUT_OF_RANGE if \p set was invalid for this method !> - ROCRAND_STATUS_SUCCESS if the pointer was set succesfully interface rocrand_get_direction_vectors32 function rocrand_get_direction_vectors32_(vectors,set) & bind(c, name="rocrand_get_direction_vectors32") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_get_direction_vectors32_ type(c_ptr) :: vectors integer(kind(ROCRAND_DIRECTION_VECTORS_32_JOEKUO6)),value :: set end function end interface !> \brief Get the vector for 64-bit (scrambled-)sobol generation. !> !> \param vectors - location where to write the vector pointer to !> !> \param set - which direction vector set to use !> !> \return !> - ROCRAND_STATUS_OUT_OF_RANGE if \p set was invalid for this method !> - ROCRAND_STATUS_SUCCESS if the pointer was set succesfully interface rocrand_get_direction_vectors64 function rocrand_get_direction_vectors64_(vectors,set) & bind(c, name="rocrand_get_direction_vectors64") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_get_direction_vectors64_ type(c_ptr) :: vectors integer(kind(ROCRAND_DIRECTION_VECTORS_32_JOEKUO6)),value :: set end function end interface !> \brief Get the scramble constants for 32-bit scrambled sobol generation. !> !> \param constants - location where to write the constants pointer to !> !> \return !> - ROCRAND_STATUS_SUCCESS if the pointer was set succesfully interface rocrand_get_scramble_constants32 function rocrand_get_scramble_constants32_(constants) & bind(c, name="rocrand_get_scramble_constants32") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_get_scramble_constants32_ type(c_ptr) :: constants end function end interface !> \brief Get the scramble constants for 64-bit scrambled sobol generation. !> !> \param constants - location where to write the constants pointer to !> !> \return !> - ROCRAND_STATUS_SUCCESS if the pointer was set succesfully interface rocrand_get_scramble_constants64 function rocrand_get_scramble_constants64_(constants) & bind(c, name="rocrand_get_scramble_constants64") use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_get_scramble_constants64_ type(c_ptr) :: constants end function end interface #ifdef USE_FPOINTER_INTERFACES contains #ifdef USE_ASSUMED_RANK_INTERFACES function rocrand_generate_assumed_rank(generator,output_data,n) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_assumed_rank type(c_ptr) :: generator integer(c_int),target,contiguous,dimension(..) :: output_data integer(c_size_t) :: n ! rocrand_generate_assumed_rank = rocrand_generate_(generator,c_loc(output_data),n) end function #else function rocrand_generate_rank_0(generator,output_data,n) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_rank_0 type(c_ptr) :: generator integer(c_int),target :: output_data integer(c_size_t) :: n ! rocrand_generate_rank_0 = rocrand_generate_(generator,c_loc(output_data),n) end function function rocrand_generate_rank_1(generator,output_data,n) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_rank_1 type(c_ptr) :: generator integer(c_int),target,dimension(:) :: output_data integer(c_size_t) :: n ! rocrand_generate_rank_1 = rocrand_generate_(generator,c_loc(output_data),n) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocrand_generate_long_long_assumed_rank(generator,output_data,n) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_long_long_assumed_rank type(c_ptr) :: generator integer(c_int64_t),target,contiguous,dimension(..) :: output_data integer(c_size_t) :: n ! rocrand_generate_long_long_assumed_rank = rocrand_generate_long_long_(generator, & c_loc(output_data),n) end function #else function rocrand_generate_long_long_rank_0(generator,output_data,n) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_long_long_rank_0 type(c_ptr) :: generator integer(c_int64_t),target :: output_data integer(c_size_t) :: n ! rocrand_generate_long_long_rank_0 = rocrand_generate_long_long_(generator, & c_loc(output_data),n) end function function rocrand_generate_long_long_rank_1(generator,output_data,n) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_long_long_rank_1 type(c_ptr) :: generator integer(c_int64_t),target,dimension(:) :: output_data integer(c_size_t) :: n ! rocrand_generate_long_long_rank_1 = rocrand_generate_long_long_(generator, & c_loc(output_data),n) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocrand_generate_uniform_assumed_rank(generator,output_data,n) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_uniform_assumed_rank type(c_ptr) :: generator real(c_float),target,contiguous,dimension(..) :: output_data integer(c_size_t) :: n ! rocrand_generate_uniform_assumed_rank = rocrand_generate_uniform_(generator, & c_loc(output_data),n) end function #else function rocrand_generate_uniform_rank_0(generator,output_data,n) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_uniform_rank_0 type(c_ptr) :: generator real(c_float),target :: output_data integer(c_size_t) :: n ! rocrand_generate_uniform_rank_0 = rocrand_generate_uniform_(generator,c_loc(output_data),n) end function function rocrand_generate_uniform_rank_1(generator,output_data,n) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_uniform_rank_1 type(c_ptr) :: generator real(c_float),target,dimension(:) :: output_data integer(c_size_t) :: n ! rocrand_generate_uniform_rank_1 = rocrand_generate_uniform_(generator,c_loc(output_data),n) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocrand_generate_uniform_double_assumed_rank(generator,output_data,n) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_uniform_double_assumed_rank type(c_ptr) :: generator real(c_double),target,contiguous,dimension(..) :: output_data integer(c_size_t) :: n ! rocrand_generate_uniform_double_assumed_rank = rocrand_generate_uniform_double_(generator, & c_loc(output_data),n) end function #else function rocrand_generate_uniform_double_rank_0(generator,output_data,n) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_uniform_double_rank_0 type(c_ptr) :: generator real(c_double),target :: output_data integer(c_size_t) :: n ! rocrand_generate_uniform_double_rank_0 = rocrand_generate_uniform_double_(generator, & c_loc(output_data),n) end function function rocrand_generate_uniform_double_rank_1(generator,output_data,n) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_uniform_double_rank_1 type(c_ptr) :: generator real(c_double),target,dimension(:) :: output_data integer(c_size_t) :: n ! rocrand_generate_uniform_double_rank_1 = rocrand_generate_uniform_double_(generator, & c_loc(output_data),n) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocrand_generate_normal_assumed_rank(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_normal_assumed_rank type(c_ptr) :: generator real(c_float),target,contiguous,dimension(..) :: output_data integer(c_size_t) :: n real(c_float) :: mean real(c_float) :: stddev ! rocrand_generate_normal_assumed_rank = rocrand_generate_normal_(generator, & c_loc(output_data),n,mean,stddev) end function #else function rocrand_generate_normal_rank_0(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_normal_rank_0 type(c_ptr) :: generator real(c_float),target :: output_data integer(c_size_t) :: n real(c_float) :: mean real(c_float) :: stddev ! rocrand_generate_normal_rank_0 = rocrand_generate_normal_(generator,c_loc(output_data),n, & mean,stddev) end function function rocrand_generate_normal_rank_1(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_normal_rank_1 type(c_ptr) :: generator real(c_float),target,dimension(:) :: output_data integer(c_size_t) :: n real(c_float) :: mean real(c_float) :: stddev ! rocrand_generate_normal_rank_1 = rocrand_generate_normal_(generator,c_loc(output_data),n, & mean,stddev) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocrand_generate_normal_double_assumed_rank(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_normal_double_assumed_rank type(c_ptr) :: generator real(c_double),target,contiguous,dimension(..) :: output_data integer(c_size_t) :: n real(c_double) :: mean real(c_double) :: stddev ! rocrand_generate_normal_double_assumed_rank = rocrand_generate_normal_double_(generator, & c_loc(output_data),n,mean,stddev) end function #else function rocrand_generate_normal_double_rank_0(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_normal_double_rank_0 type(c_ptr) :: generator real(c_double),target :: output_data integer(c_size_t) :: n real(c_double) :: mean real(c_double) :: stddev ! rocrand_generate_normal_double_rank_0 = rocrand_generate_normal_double_(generator, & c_loc(output_data),n,mean,stddev) end function function rocrand_generate_normal_double_rank_1(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_normal_double_rank_1 type(c_ptr) :: generator real(c_double),target,dimension(:) :: output_data integer(c_size_t) :: n real(c_double) :: mean real(c_double) :: stddev ! rocrand_generate_normal_double_rank_1 = rocrand_generate_normal_double_(generator, & c_loc(output_data),n,mean,stddev) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocrand_generate_log_normal_assumed_rank(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_log_normal_assumed_rank type(c_ptr) :: generator real(c_float),target,contiguous,dimension(..) :: output_data integer(c_size_t) :: n real(c_float) :: mean real(c_float) :: stddev ! rocrand_generate_log_normal_assumed_rank = rocrand_generate_log_normal_(generator, & c_loc(output_data),n,mean,stddev) end function #else function rocrand_generate_log_normal_rank_0(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_log_normal_rank_0 type(c_ptr) :: generator real(c_float),target :: output_data integer(c_size_t) :: n real(c_float) :: mean real(c_float) :: stddev ! rocrand_generate_log_normal_rank_0 = rocrand_generate_log_normal_(generator, & c_loc(output_data),n,mean,stddev) end function function rocrand_generate_log_normal_rank_1(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_log_normal_rank_1 type(c_ptr) :: generator real(c_float),target,dimension(:) :: output_data integer(c_size_t) :: n real(c_float) :: mean real(c_float) :: stddev ! rocrand_generate_log_normal_rank_1 = rocrand_generate_log_normal_(generator, & c_loc(output_data),n,mean,stddev) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocrand_generate_log_normal_double_assumed_rank(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_log_normal_double_assumed_rank type(c_ptr) :: generator real(c_double),target,contiguous,dimension(..) :: output_data integer(c_size_t) :: n real(c_double) :: mean real(c_double) :: stddev ! rocrand_generate_log_normal_double_assumed_rank = rocrand_generate_log_normal_double_( & generator,c_loc(output_data),n,mean,stddev) end function #else function rocrand_generate_log_normal_double_rank_0(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_log_normal_double_rank_0 type(c_ptr) :: generator real(c_double),target :: output_data integer(c_size_t) :: n real(c_double) :: mean real(c_double) :: stddev ! rocrand_generate_log_normal_double_rank_0 = rocrand_generate_log_normal_double_(generator, & c_loc(output_data),n,mean,stddev) end function function rocrand_generate_log_normal_double_rank_1(generator,output_data,n,mean,stddev) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_log_normal_double_rank_1 type(c_ptr) :: generator real(c_double),target,dimension(:) :: output_data integer(c_size_t) :: n real(c_double) :: mean real(c_double) :: stddev ! rocrand_generate_log_normal_double_rank_1 = rocrand_generate_log_normal_double_(generator, & c_loc(output_data),n,mean,stddev) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocrand_generate_poisson_assumed_rank(generator,output_data,n,lambda) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_poisson_assumed_rank type(c_ptr) :: generator integer(c_int),target,contiguous,dimension(..) :: output_data integer(c_size_t) :: n real(c_double) :: lambda ! rocrand_generate_poisson_assumed_rank = rocrand_generate_poisson_(generator, & c_loc(output_data),n,lambda) end function #else function rocrand_generate_poisson_rank_0(generator,output_data,n,lambda) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_poisson_rank_0 type(c_ptr) :: generator integer(c_int),target :: output_data integer(c_size_t) :: n real(c_double) :: lambda ! rocrand_generate_poisson_rank_0 = rocrand_generate_poisson_(generator,c_loc(output_data),n, & lambda) end function function rocrand_generate_poisson_rank_1(generator,output_data,n,lambda) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_generate_poisson_rank_1 type(c_ptr) :: generator integer(c_int),target,dimension(:) :: output_data integer(c_size_t) :: n real(c_double) :: lambda ! rocrand_generate_poisson_rank_1 = rocrand_generate_poisson_(generator,c_loc(output_data),n, & lambda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocrand_create_discrete_distribution_assumed_rank(probabilities,mySize,offset, & discrete_distribution) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_create_discrete_distribution_assumed_rank real(c_double),target,contiguous,dimension(..) :: probabilities integer(c_int) :: mySize integer(c_int) :: offset type(c_ptr) :: discrete_distribution ! rocrand_create_discrete_distribution_assumed_rank = rocrand_create_discrete_distribution_( & c_loc(probabilities),mySize,offset,discrete_distribution) end function #else function rocrand_create_discrete_distribution_rank_0(probabilities,mySize,offset, & discrete_distribution) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_create_discrete_distribution_rank_0 real(c_double),target :: probabilities integer(c_int) :: mySize integer(c_int) :: offset type(c_ptr) :: discrete_distribution ! rocrand_create_discrete_distribution_rank_0 = rocrand_create_discrete_distribution_(c_loc( & probabilities),mySize,offset,discrete_distribution) end function function rocrand_create_discrete_distribution_rank_1(probabilities,mySize,offset, & discrete_distribution) use iso_c_binding use hipfort_rocrand_enums implicit none integer(kind(ROCRAND_STATUS_SUCCESS)) :: rocrand_create_discrete_distribution_rank_1 real(c_double),target,dimension(:) :: probabilities integer(c_int) :: mySize integer(c_int) :: offset type(c_ptr) :: discrete_distribution ! rocrand_create_discrete_distribution_rank_1 = rocrand_create_discrete_distribution_(c_loc( & probabilities),mySize,offset,discrete_distribution) end function #endif #endif end module hipfort_rocrand hipfort-rocm-10.0.0/lib/hipfort/hipfort_rocrand_enums.F90000066400000000000000000000076671524740623400233230ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_rocrand_enums use, intrinsic :: iso_c_binding implicit none ! rocrand_status enum, bind(c) enumerator :: ROCRAND_STATUS_SUCCESS = 0 enumerator :: ROCRAND_STATUS_VERSION_MISMATCH = 100 enumerator :: ROCRAND_STATUS_NOT_CREATED = 101 enumerator :: ROCRAND_STATUS_ALLOCATION_FAILED = 102 enumerator :: ROCRAND_STATUS_TYPE_ERROR = 103 enumerator :: ROCRAND_STATUS_OUT_OF_RANGE = 104 enumerator :: ROCRAND_STATUS_LENGTH_NOT_MULTIPLE = 105 enumerator :: ROCRAND_STATUS_DOUBLE_PRECISION_REQUIRED = 106 enumerator :: ROCRAND_STATUS_LAUNCH_FAILURE = 107 enumerator :: ROCRAND_STATUS_INTERNAL_ERROR = 108 end enum ! rocrand_rng_type enum, bind(c) enumerator :: ROCRAND_RNG_PSEUDO_DEFAULT = 400 enumerator :: ROCRAND_RNG_PSEUDO_XORWOW = 401 enumerator :: ROCRAND_RNG_PSEUDO_MRG32K3A = 402 enumerator :: ROCRAND_RNG_PSEUDO_MTGP32 = 403 enumerator :: ROCRAND_RNG_PSEUDO_PHILOX4_32_10 = 404 enumerator :: ROCRAND_RNG_PSEUDO_MRG31K3P = 405 enumerator :: ROCRAND_RNG_PSEUDO_LFSR113 = 406 enumerator :: ROCRAND_RNG_PSEUDO_MT19937 = 407 enumerator :: ROCRAND_RNG_PSEUDO_THREEFRY2_32_20 = 408 enumerator :: ROCRAND_RNG_PSEUDO_THREEFRY2_64_20 = 409 enumerator :: ROCRAND_RNG_PSEUDO_THREEFRY4_32_20 = 410 enumerator :: ROCRAND_RNG_PSEUDO_THREEFRY4_64_20 = 411 enumerator :: ROCRAND_RNG_QUASI_DEFAULT = 500 enumerator :: ROCRAND_RNG_QUASI_SOBOL32 = 501 enumerator :: ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL32 = 502 enumerator :: ROCRAND_RNG_QUASI_SOBOL64 = 504 enumerator :: ROCRAND_RNG_QUASI_SCRAMBLED_SOBOL64 = 505 end enum ! rocrand_ordering enum, bind(c) enumerator :: ROCRAND_ORDERING_PSEUDO_BEST = 100 enumerator :: ROCRAND_ORDERING_PSEUDO_DEFAULT = 101 enumerator :: ROCRAND_ORDERING_PSEUDO_SEEDED = 102 enumerator :: ROCRAND_ORDERING_PSEUDO_LEGACY = 103 enumerator :: ROCRAND_ORDERING_PSEUDO_DYNAMIC = 104 enumerator :: ROCRAND_ORDERING_QUASI_DEFAULT = 201 end enum ! rocrand_direction_vector_set enum, bind(c) enumerator :: ROCRAND_DIRECTION_VECTORS_32_JOEKUO6 = 101 enumerator :: ROCRAND_SCRAMBLED_DIRECTION_VECTORS_32_JOEKUO6 = 102 enumerator :: ROCRAND_DIRECTION_VECTORS_64_JOEKUO6 = 103 enumerator :: ROCRAND_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6 = 104 end enum integer(c_int), parameter :: ROCRAND_VERSION = 400500 integer(c_int), parameter :: ROCRAND_DEFAULT_MAX_BLOCK_SIZE = 256 end module hipfort_rocrand_enums hipfort-rocm-10.0.0/lib/hipfort/hipfort_rocrand_types.F90000066400000000000000000000041741524740623400233260ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_rocrand_types use, intrinsic :: iso_c_binding implicit none type, bind(c) :: uint4 integer(c_int) :: x integer(c_int) :: y integer(c_int) :: z integer(c_int) :: w end type uint4 type, bind(c) :: rocrand_discrete_distribution_st integer(c_int) :: size !< Number of entries in the probability table integer(c_int) :: offset !< The distribution can be offset type(c_ptr) :: alias !< Alias table type(c_ptr) :: probability !< Probability data for the alias table type(c_ptr) :: cdf !< Cumulative distribution function end type rocrand_discrete_distribution_st end module hipfort_rocrand_types hipfort-rocm-10.0.0/lib/hipfort/hipfort_rocsolver.F90000066400000000000000000152117361524740623400225020ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_rocsolver use hipfort_rocsolver_enums implicit none !> \brief The GET_VERSION_STRING function queries the library version. !> !> \details !> @param[out] buf - A buffer that the version string will be written into. !> @param[in] len - The size of the given buffer in bytes. interface rocsolver_get_version_string function rocsolver_get_version_string_(buf,len) bind(c, name="rocsolver_get_version_string") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_get_version_string_ type(c_ptr),value :: buf integer(c_size_t),value :: len end function end interface !> \brief The GET_VERSION_STRING_SIZE function queries the minimum buffer size for a !> successful call to `rocsolver_get_version_string`. !> !> \details !> @param[out] len - pointer to size_t. !> The minimum length of buffer to pass to !> `rocsolver_get_version_string`. interface rocsolver_get_version_string_size function rocsolver_get_version_string_size_(len) & bind(c, name="rocsolver_get_version_string_size") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_get_version_string_size_ integer(c_size_t) :: len end function end interface !> \brief The LOG_BEGIN function initiates a rocSOLVER multi-level logging session. !> !> \details !> Initializes the rocSOLVER logging environment with default values (no !> logging and one level depth). Default mode can be overridden by using the !> environment variables ``ROCSOLVER_LAYER`` and ``ROCSOLVER_LEVELS``. !> !> This function also sets the streams for the log results output. !> The default is ``STDERR`` for all modes. This default can be overridden !> using the environment variable ``ROCSOLVER_LOG_PATH``, or, more specifically, !> ``ROCSOLVER_LOG_TRACE_PATH``, ``ROCSOLVER_LOG_BENCH_PATH``, and !> ``ROCSOLVER_LOG_PROFILE_PATH``. interface rocsolver_log_begin function rocsolver_log_begin_() bind(c, name="rocsolver_log_begin") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_log_begin_ end function end interface !> \brief The LOG_END function ends the multi-level rocSOLVER logging session. !> !> \details !> If applicable, this function also prints the profile logging results !> before cleaning the logging environment. interface rocsolver_log_end function rocsolver_log_end_() bind(c, name="rocsolver_log_end") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_log_end_ end function end interface !> \brief The LOG_SET_LAYER_MODE function sets the logging mode for the rocSOLVER multi-level !> logging environment. !> !> \details !> @param[in] layer_mode - rocblas_layer_mode_flags. !> Specifies the logging mode. interface rocsolver_log_set_layer_mode function rocsolver_log_set_layer_mode_(layer_mode) bind(c, name="rocsolver_log_set_layer_mode") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_log_set_layer_mode_ integer(c_int),value :: layer_mode end function end interface !> \brief The LOG_SET_MAX_LEVELS function sets the maximum trace log depth for the rocSOLVER !> multi-level logging environment. !> !> \details !> @param[in] max_levels - rocblas_int. max_levels >= 1. !> Specifies the maximum depth for which nested function calls !> will appear in the trace and profile logs. interface rocsolver_log_set_max_levels function rocsolver_log_set_max_levels_(max_levels) bind(c, name="rocsolver_log_set_max_levels") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_log_set_max_levels_ integer(c_int),value :: max_levels end function end interface !> \brief The LOG_RESTORE_DEFAULTS function restores the default values of the rocSOLVER !> multi-level logging environment. !> !> \details !> This function sets the logging mode and maximum trace log depth to their !> default values (no logging and one level depth). interface rocsolver_log_restore_defaults function rocsolver_log_restore_defaults_() bind(c, name="rocsolver_log_restore_defaults") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_log_restore_defaults_ end function end interface !> \brief The LOG_WRITE_PROFILE function prints the profile logging results. interface rocsolver_log_write_profile function rocsolver_log_write_profile_() bind(c, name="rocsolver_log_write_profile") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_log_write_profile_ end function end interface !> \brief The LOG_FLUSH_PROFILE function prints the profile logging results and clears the !> profile record. interface rocsolver_log_flush_profile function rocsolver_log_flush_profile_() bind(c, name="rocsolver_log_flush_profile") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_log_flush_profile_ end function end interface !> \brief The SET_ALG_MODE function sets the algorithm mode to be used by the specified function. !> !> @param[in] handle - rocblas_handle. !> @param[in] func - `rocsolver_function`. !> The function that will use the selected algorithm mode. !> @param[in] mode - `rocsolver_alg_mode`. !> The algorithm mode that will be used by the specified function. !> rocsolver_alg_mode_mixed is not supported. interface rocsolver_set_alg_mode function rocsolver_set_alg_mode_(handle,func,mode) bind(c, name="rocsolver_set_alg_mode") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_set_alg_mode_ type(c_ptr),value :: handle integer(kind(rocsolver_function_bdsqr)),value :: func integer(kind(rocsolver_alg_mode_gpu)),value :: mode end function end interface !> \brief The GET_ALG_MODE function gets the algorithm mode being used by the specified function. !> !> @param[in] handle - rocblas_handle. !> @param[in] func - `rocsolver_function`. !> The specified function. !> @param[out] mode - pointer to `rocsolver_alg_mode`. !> On exit, the value is overwritten by the algorithm mode used !> by the specified function. interface rocsolver_get_alg_mode function rocsolver_get_alg_mode_(handle,func,mode) bind(c, name="rocsolver_get_alg_mode") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_get_alg_mode_ type(c_ptr),value :: handle integer(kind(rocsolver_function_bdsqr)),value :: func type(c_ptr),value :: mode end function end interface !> \brief The LACGV functions conjugate the complex vector ``x``. !> !> \details !> Conjugates the ``n`` entries of a complex vector ``x`` with increment ``incx``. !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The dimension of vector x. !> @param[inout] x - pointer to type. Array on the GPU of size at least n (size depends on the !> value of incx). !> On entry, the vector x. !> On exit, each entry is overwritten with its conjugate value. !> @param[in] incx - rocblas_int. incx != 0. !> The distance between two consecutive elements of x. !> If incx is negative, the elements of x are indexed in !> reverse order. interface rocsolver_clacgv function rocsolver_clacgv_(handle,n,x,incx) bind(c, name="rocsolver_clacgv") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clacgv_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_clacgv_assumed_rank #else module procedure & rocsolver_clacgv_rank_0,& rocsolver_clacgv_rank_1 #endif #endif end interface interface rocsolver_zlacgv function rocsolver_zlacgv_(handle,n,x,incx) bind(c, name="rocsolver_zlacgv") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlacgv_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zlacgv_assumed_rank #else module procedure & rocsolver_zlacgv_rank_0,& rocsolver_zlacgv_rank_1 #endif #endif end interface interface rocsolver_clacgv_64 function rocsolver_clacgv_64_(handle,n,x,incx) bind(c, name="rocsolver_clacgv_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clacgv_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface interface rocsolver_zlacgv_64 function rocsolver_zlacgv_64_(handle,n,x,incx) bind(c, name="rocsolver_zlacgv_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlacgv_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx end function end interface !> \brief The LANGE functions compute the norm of a general ``m``-by-``n`` matrix ``A``. !> !> \details !> The norm computed is specified by ``norm_type`` as follows: !> !> - ``rocsolver_norm_type_one``: the 1-norm (maximum column sum), !> - ``rocsolver_norm_type_frobenius``: the Frobenius norm (square root of sum of squares), !> - ``rocsolver_norm_type_infinity``: the infinity-norm (maximum row sum), or !> - ``rocsolver_norm_type_max``: the maximum absolute value of any element. !> !> @param[in] handle - rocblas_handle. !> @param[in] norm_type - rocsolver_norm_type. !> Specifies the type of norm to compute. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix A. !> @param[in] A - pointer to type. Array on the GPU of dimension lda*n. !> The m-by-n matrix A. !> @param[in] lda - rocblas_int. lda >= m. !> The leading dimension of A. !> @param[out] norm - pointer to real type. Scalar on the GPU. !> The computed norm of the matrix A. interface rocsolver_slange function rocsolver_slange_(handle,norm_type,m,n,A,lda,norm) bind(c, name="rocsolver_slange") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slange_ type(c_ptr),value :: handle integer(kind(rocsolver_norm_type_one)),value :: norm_type integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: norm end function end interface interface rocsolver_dlange function rocsolver_dlange_(handle,norm_type,m,n,A,lda,norm) bind(c, name="rocsolver_dlange") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlange_ type(c_ptr),value :: handle integer(kind(rocsolver_norm_type_one)),value :: norm_type integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: norm end function end interface interface rocsolver_clange function rocsolver_clange_(handle,norm_type,m,n,A,lda,norm) bind(c, name="rocsolver_clange") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clange_ type(c_ptr),value :: handle integer(kind(rocsolver_norm_type_one)),value :: norm_type integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: norm end function end interface interface rocsolver_zlange function rocsolver_zlange_(handle,norm_type,m,n,A,lda,norm) bind(c, name="rocsolver_zlange") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlange_ type(c_ptr),value :: handle integer(kind(rocsolver_norm_type_one)),value :: norm_type integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: norm end function end interface interface rocsolver_slange_64 function rocsolver_slange_64_(handle,norm_type,m,n,A,lda,norm) & bind(c, name="rocsolver_slange_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slange_64_ type(c_ptr),value :: handle integer(kind(rocsolver_norm_type_one)),value :: norm_type integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: norm end function end interface interface rocsolver_dlange_64 function rocsolver_dlange_64_(handle,norm_type,m,n,A,lda,norm) & bind(c, name="rocsolver_dlange_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlange_64_ type(c_ptr),value :: handle integer(kind(rocsolver_norm_type_one)),value :: norm_type integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: norm end function end interface interface rocsolver_clange_64 function rocsolver_clange_64_(handle,norm_type,m,n,A,lda,norm) & bind(c, name="rocsolver_clange_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clange_64_ type(c_ptr),value :: handle integer(kind(rocsolver_norm_type_one)),value :: norm_type integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: norm end function end interface interface rocsolver_zlange_64 function rocsolver_zlange_64_(handle,norm_type,m,n,A,lda,norm) & bind(c, name="rocsolver_zlange_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlange_64_ type(c_ptr),value :: handle integer(kind(rocsolver_norm_type_one)),value :: norm_type integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: norm end function end interface !> \brief GECON estimates the reciprocal of the condition number of a general n-by-n matrix A !> in the 1-norm or infinity-norm. !> !> \details !> The reciprocal condition number is computed as !> !> \f[ !> \text{rcond} = \frac{1}{\|A\| \cdot \|A^{-1}\|} !> \f] !> !> where A is the matrix in its factorized form as returned by \ref rocsolver_sgetrf "GETRF", !> and the !> norm can be the 1-norm or the infinity-norm. !> !> The computed rcond will be a lower bound on the actual rcond. When rcond is close to zero, !> the matrix !> A is poorly conditioned (nearly singular). When rcond is close to 1, the matrix A is well !> conditioned. !> !> @param[in] handle - rocblas_handle. !> @param[in] norm_type - rocsolver_norm_type. !> Specifies the norm to be used. The 1-norm and the infinity-norm !> are supported, specified by values of rocsolver_norm_type_one and !> rocsolver_norm_type_infinity. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrix A. !> @param[in] A - pointer to type. Array on the GPU of dimension lda*n. !> The factors L and U of the factorization \f$A = PLU\f$ as returned by \ref !> rocsolver_sgetrf "GETRF". !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A. !> @param[in] anorm - pointer to real type. Scalar on the GPU. !> The norm of the original matrix A (before factorization) as returned by \ref !> rocsolver_slange "LANGE". !> @param[out] rcond - pointer to real type. Scalar on the GPU. !> The reciprocal condition number estimate. interface rocsolver_sgecon function rocsolver_sgecon_(handle,norm_type,n,A,lda,anorm,rcond) & bind(c, name="rocsolver_sgecon") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgecon_ type(c_ptr),value :: handle integer(kind(rocsolver_norm_type_one)),value :: norm_type integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: anorm type(c_ptr),value :: rcond end function end interface interface rocsolver_dgecon function rocsolver_dgecon_(handle,norm_type,n,A,lda,anorm,rcond) & bind(c, name="rocsolver_dgecon") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgecon_ type(c_ptr),value :: handle integer(kind(rocsolver_norm_type_one)),value :: norm_type integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: anorm type(c_ptr),value :: rcond end function end interface interface rocsolver_cgecon function rocsolver_cgecon_(handle,norm_type,n,A,lda,anorm,rcond) & bind(c, name="rocsolver_cgecon") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgecon_ type(c_ptr),value :: handle integer(kind(rocsolver_norm_type_one)),value :: norm_type integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: anorm type(c_ptr),value :: rcond end function end interface interface rocsolver_zgecon function rocsolver_zgecon_(handle,norm_type,n,A,lda,anorm,rcond) & bind(c, name="rocsolver_zgecon") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgecon_ type(c_ptr),value :: handle integer(kind(rocsolver_norm_type_one)),value :: norm_type integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: anorm type(c_ptr),value :: rcond end function end interface interface rocsolver_sgecon_64 function rocsolver_sgecon_64_(handle,norm_type,n,A,lda,anorm,rcond) & bind(c, name="rocsolver_sgecon_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgecon_64_ type(c_ptr),value :: handle integer(kind(rocsolver_norm_type_one)),value :: norm_type integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: anorm type(c_ptr),value :: rcond end function end interface interface rocsolver_dgecon_64 function rocsolver_dgecon_64_(handle,norm_type,n,A,lda,anorm,rcond) & bind(c, name="rocsolver_dgecon_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgecon_64_ type(c_ptr),value :: handle integer(kind(rocsolver_norm_type_one)),value :: norm_type integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: anorm type(c_ptr),value :: rcond end function end interface interface rocsolver_cgecon_64 function rocsolver_cgecon_64_(handle,norm_type,n,A,lda,anorm,rcond) & bind(c, name="rocsolver_cgecon_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgecon_64_ type(c_ptr),value :: handle integer(kind(rocsolver_norm_type_one)),value :: norm_type integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: anorm type(c_ptr),value :: rcond end function end interface interface rocsolver_zgecon_64 function rocsolver_zgecon_64_(handle,norm_type,n,A,lda,anorm,rcond) & bind(c, name="rocsolver_zgecon_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgecon_64_ type(c_ptr),value :: handle integer(kind(rocsolver_norm_type_one)),value :: norm_type integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: anorm type(c_ptr),value :: rcond end function end interface !> \brief The LASWP functions perform a series of row interchanges on the matrix ``A``. !> !> \details !> Row interchanges are done one by one. If \f$\text{ipiv}[k_1 + (j - k_1) \cdot !> \text{abs}(\text{incx})] = r\f$, then the j-th row of ``A`` !> will be interchanged with the r-th row of ``A``, for \f$j = k_1,k_1+1,\dots,k_2\f$. Indices !> \f$k_1\f$ and \f$k_2\f$ are 1-based indices. !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix to which the row !> interchanges will be applied. On exit, the resulting permuted matrix. !> @param[in] lda - rocblas_int. lda > 0. !> The leading dimension of the array A. !> @param[in] k1 - rocblas_int. k1 > 0. !> The k_1 index. This is the first element of ipiv for which a row interchange !> will !> be done. This is a 1-based index. !> @param[in] k2 - rocblas_int. k2 > k1 > 0. !> The k_2 index. k_2 - k_1 + 1 is the number of elements of ipiv for which a row !> interchange will be done. This is a 1-based index. !> @param[in] ipiv - pointer to rocblas_int. Array on the GPU of dimension at least \f$k_1 + !> (k_2 - k_1)\cdot \text{abs}(\text{incx})\f$. !> The vector of pivot indices. Only the elements in positions !> \f$k_1\f$ through \f$k_1 + (k_2 - k_1)\cdot \text{abs}(\text{incx})\f$ of this !> vector are accessed. !> Elements of ipiv are considered 1-based. !> @param[in] incx - rocblas_int. incx != 0. !> The distance between successive values of ipiv. If incx !> is negative, the pivots are applied in reverse order. interface rocsolver_slaswp function rocsolver_slaswp_(handle,n,A,lda,k1,k2,ipiv,incx) bind(c, name="rocsolver_slaswp") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slaswp_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: k1 integer(c_int),value :: k2 type(c_ptr),value :: ipiv integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_slaswp_assumed_rank #else module procedure & rocsolver_slaswp_rank_0,& rocsolver_slaswp_rank_1,& rocsolver_slaswp_full_rank #endif #endif end interface interface rocsolver_dlaswp function rocsolver_dlaswp_(handle,n,A,lda,k1,k2,ipiv,incx) bind(c, name="rocsolver_dlaswp") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlaswp_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: k1 integer(c_int),value :: k2 type(c_ptr),value :: ipiv integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dlaswp_assumed_rank #else module procedure & rocsolver_dlaswp_rank_0,& rocsolver_dlaswp_rank_1,& rocsolver_dlaswp_full_rank #endif #endif end interface interface rocsolver_claswp function rocsolver_claswp_(handle,n,A,lda,k1,k2,ipiv,incx) bind(c, name="rocsolver_claswp") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_claswp_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: k1 integer(c_int),value :: k2 type(c_ptr),value :: ipiv integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_claswp_assumed_rank #else module procedure & rocsolver_claswp_rank_0,& rocsolver_claswp_rank_1,& rocsolver_claswp_full_rank #endif #endif end interface interface rocsolver_zlaswp function rocsolver_zlaswp_(handle,n,A,lda,k1,k2,ipiv,incx) bind(c, name="rocsolver_zlaswp") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlaswp_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: k1 integer(c_int),value :: k2 type(c_ptr),value :: ipiv integer(c_int),value :: incx end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zlaswp_assumed_rank #else module procedure & rocsolver_zlaswp_rank_0,& rocsolver_zlaswp_rank_1,& rocsolver_zlaswp_full_rank #endif #endif end interface !> \brief The LARFG functions generate a Householder reflector H of order ``n``. !> !> \details !> The reflector H is such that: !> !> \f[ !> H^H\left[\begin{array}{c} !> \text{alpha}\\% !> x !> \end{array}\right]=\left[\begin{array}{c} !> \text{beta}\\% !> 0 !> \end{array}\right] !> \f] !> !> where ``x`` is an ``n``-1 vector and ``alpha`` and ``beta`` are scalars. Matrix H can be !> generated as !> !> \f[ !> H = I - \text{tau}\left[\begin{array}{c} !> 1\\% !> v !> \end{array}\right]\left[\begin{array}{cc} !> 1 & v^H \end{array}\right] !> \f] !> !> where v is an ``n`` -1 vector, and ``tau`` is a scalar known as the Householder scalar. The !> vector !> !> \f[ !> \bar{v}=\left[\begin{array}{c} !> 1\\% !> v !> \end{array}\right] !> \f] !> !> is the Householder vector associated with the reflection. !> !> \note !> The matrix H is orthogonal/unitary (that is, \f$H^H H=H H^H=I\f$). It is symmetric when !> real (that is, \f$H^T=H\f$), but not Hermitian when complex !> (that is, \f$H^H≠ H\f$ in general). !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The order (size) of reflector H. !> @param[inout] alpha - pointer to type. A scalar on the GPU. !> On entry, the scalar alpha. !> On exit, it is overwritten with beta. !> @param[inout] x - pointer to type. Array on the GPU of size at least n-1 (size depends on !> the value of incx). !> On entry, the vector x, !> On exit, it is overwritten with vector v. !> @param[in] incx - rocblas_int. incx > 0. !> The distance between two consecutive elements of x. !> @param[out] tau - pointer to type. A scalar on the GPU. !> The Householder scalar tau. interface rocsolver_slarfg function rocsolver_slarfg_(handle,n,alpha,x,incx,tau) bind(c, name="rocsolver_slarfg") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarfg_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: tau end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_slarfg_assumed_rank #else module procedure & rocsolver_slarfg_rank_0,& rocsolver_slarfg_rank_1 #endif #endif end interface interface rocsolver_dlarfg function rocsolver_dlarfg_(handle,n,alpha,x,incx,tau) bind(c, name="rocsolver_dlarfg") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarfg_ type(c_ptr),value :: handle integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: tau end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dlarfg_assumed_rank #else module procedure & rocsolver_dlarfg_rank_0,& rocsolver_dlarfg_rank_1 #endif #endif end interface interface rocsolver_clarfg function rocsolver_clarfg_(handle,n,alpha,x,incx,tau) bind(c, name="rocsolver_clarfg") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarfg_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: tau end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_clarfg_assumed_rank #else module procedure & rocsolver_clarfg_rank_0,& rocsolver_clarfg_rank_1 #endif #endif end interface interface rocsolver_zlarfg function rocsolver_zlarfg_(handle,n,alpha,x,incx,tau) bind(c, name="rocsolver_zlarfg") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarfg_ type(c_ptr),value :: handle integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: tau end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zlarfg_assumed_rank #else module procedure & rocsolver_zlarfg_rank_0,& rocsolver_zlarfg_rank_1 #endif #endif end interface interface rocsolver_slarfg_64 function rocsolver_slarfg_64_(handle,n,alpha,x,incx,tau) bind(c, name="rocsolver_slarfg_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarfg_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_float) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: tau end function end interface interface rocsolver_dlarfg_64 function rocsolver_dlarfg_64_(handle,n,alpha,x,incx,tau) bind(c, name="rocsolver_dlarfg_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarfg_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n real(c_double) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: tau end function end interface interface rocsolver_clarfg_64 function rocsolver_clarfg_64_(handle,n,alpha,x,incx,tau) bind(c, name="rocsolver_clarfg_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarfg_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: tau end function end interface interface rocsolver_zlarfg_64 function rocsolver_zlarfg_64_(handle,n,alpha,x,incx,tau) bind(c, name="rocsolver_zlarfg_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarfg_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: tau end function end interface !> \brief The LARFT functions generate the triangular factor ``T`` of a block reflector H of !> order ``n``. !> !> \details !> The block reflector H is defined as the product of ``k`` Householder matrices: !> !> \f[ !> \begin{array}{cl} !> H = H(1)H(2)\cdots H(k) & \: \text{if direct indicates forward direction, or} \\% !> H = H(k)\cdots H(2)H(1) & \: \text{if direct indicates backward direction} !> \end{array} !> \f] !> !> The triangular factor ``T`` is upper triangular in the forward direction and lower !> triangular in the backward direction. !> If ``storev`` is column-wise, then !> !> \f[ !> H = I - VTV^H !> \f] !> !> where the \f$j\f$th column of matrix ``V`` contains the Householder vector associated with !> \f$H(j)\f$. If ``storev`` is row-wise, then !> !> \f[ !> H = I - V^H T V !> \f] !> !> where the \f$i\f$th row of matrix ``V`` contains the Householder vector associated with !> \f$H(i)\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] myDirect - `rocblas_direct`. !> Specifies the direction in which the Householder matrices are applied. !> @param[in] storev - `rocblas_storev`. !> Specifies how the Householder vectors are stored in matrix V. !> @param[in] n - rocblas_int. n >= 0. !> The order (size) of the block reflector. !> @param[in] k - rocblas_int. k >= 1. !> The number of Householder matrices forming H. !> @param[in] V - pointer to type. Array on the GPU of size ldv*k if column-wise or ldv*n if !> row-wise. !> The matrix of Householder vectors. !> @param[in] ldv - rocblas_int. ldv >= n if column-wise or ldv >= k if row-wise. !> The leading dimension of V. !> @param[in] tau - pointer to type. Array of k scalars on the GPU. !> The vector of all the Householder scalars. !> @param[out] T - pointer to type. Array on the GPU of dimension ldt*k. !> The triangular factor. T is upper triangular if direct indicates forward !> direction. Otherwise, it is !> lower triangular. The rest of the array is not used. !> @param[in] ldt - rocblas_int. ldt >= k. !> The leading dimension of T. interface rocsolver_slarft function rocsolver_slarft_(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) & bind(c, name="rocsolver_slarft") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarft_ type(c_ptr),value :: handle integer(kind(rocblas_forward_direction)),value :: myDirect integer(kind(rocblas_column_wise)),value :: storev integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: tau type(c_ptr),value :: T integer(c_int),value :: ldt end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_slarft_assumed_rank #else module procedure & rocsolver_slarft_rank_0,& rocsolver_slarft_rank_1,& rocsolver_slarft_full_rank #endif #endif end interface interface rocsolver_dlarft function rocsolver_dlarft_(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) & bind(c, name="rocsolver_dlarft") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarft_ type(c_ptr),value :: handle integer(kind(rocblas_forward_direction)),value :: myDirect integer(kind(rocblas_column_wise)),value :: storev integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: tau type(c_ptr),value :: T integer(c_int),value :: ldt end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dlarft_assumed_rank #else module procedure & rocsolver_dlarft_rank_0,& rocsolver_dlarft_rank_1,& rocsolver_dlarft_full_rank #endif #endif end interface interface rocsolver_clarft function rocsolver_clarft_(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) & bind(c, name="rocsolver_clarft") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarft_ type(c_ptr),value :: handle integer(kind(rocblas_forward_direction)),value :: myDirect integer(kind(rocblas_column_wise)),value :: storev integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: tau type(c_ptr),value :: T integer(c_int),value :: ldt end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_clarft_assumed_rank #else module procedure & rocsolver_clarft_rank_0,& rocsolver_clarft_rank_1,& rocsolver_clarft_full_rank #endif #endif end interface interface rocsolver_zlarft function rocsolver_zlarft_(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) & bind(c, name="rocsolver_zlarft") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarft_ type(c_ptr),value :: handle integer(kind(rocblas_forward_direction)),value :: myDirect integer(kind(rocblas_column_wise)),value :: storev integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: tau type(c_ptr),value :: T integer(c_int),value :: ldt end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zlarft_assumed_rank #else module procedure & rocsolver_zlarft_rank_0,& rocsolver_zlarft_rank_1,& rocsolver_zlarft_full_rank #endif #endif end interface !> \brief The LARF functions apply a Householder reflector H to a general matrix ``A``. !> !> \details !> The Householder reflector H, of order ``m`` or ``n``, is applied to an ``m`` -by-``n`` !> matrix ``A`` !> from the left or the right, depending on the value of ``side``. H is given by !> !> \f[ !> H = I - \text{alpha}\cdot xx^H !> \f] !> !> where ``alpha`` is the Householder scalar and ``x`` is a Householder vector. H is never !> actually computed. !> !> @param[in] handle - rocblas_handle. !> @param[in] side - rocblas_side. !> Determines whether H is applied from the left or the right. !> @param[in] m - rocblas_int. m >= 0. !> Number of rows of A. !> @param[in] n - rocblas_int. n >= 0. !> Number of columns of A. !> @param[in] x - pointer to type. Array on the GPU of size at least 1 + (m-1)*abs(incx) if !> left side, or !> at least 1 + (n-1)*abs(incx) if right side. !> The Householder vector x. !> @param[in] incx - rocblas_int. incx != 0. !> Distance between two consecutive elements of x. !> If incx < 0, the elements of x are indexed in reverse order. !> @param[in] alpha - pointer to type. A scalar on the GPU. !> The Householder scalar. If \f$\alpha = 0\f$, then \f$H = I\f$ (A will remain !> the same, and x is never used). !> @param[inout] A - pointer to type. Array on the GPU of size lda*n. !> On entry, the matrix A. On exit, it is overwritten with !> \f$HA\f$ (or \f$AH\f$). !> @param[in] lda - rocblas_int. lda >= m. !> Leading dimension of A. interface rocsolver_slarf function rocsolver_slarf_(handle,side,m,n,x,incx,alpha,A,lda) bind(c, name="rocsolver_slarf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarf_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_slarf_assumed_rank #else module procedure & rocsolver_slarf_rank_0,& rocsolver_slarf_rank_1,& rocsolver_slarf_full_rank #endif #endif end interface interface rocsolver_dlarf function rocsolver_dlarf_(handle,side,m,n,x,incx,alpha,A,lda) bind(c, name="rocsolver_dlarf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarf_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dlarf_assumed_rank #else module procedure & rocsolver_dlarf_rank_0,& rocsolver_dlarf_rank_1,& rocsolver_dlarf_full_rank #endif #endif end interface interface rocsolver_clarf function rocsolver_clarf_(handle,side,m,n,x,incx,alpha,A,lda) bind(c, name="rocsolver_clarf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarf_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_clarf_assumed_rank #else module procedure & rocsolver_clarf_rank_0,& rocsolver_clarf_rank_1,& rocsolver_clarf_full_rank #endif #endif end interface interface rocsolver_zlarf function rocsolver_zlarf_(handle,side,m,n,x,incx,alpha,A,lda) bind(c, name="rocsolver_zlarf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarf_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: x integer(c_int),value :: incx complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zlarf_assumed_rank #else module procedure & rocsolver_zlarf_rank_0,& rocsolver_zlarf_rank_1,& rocsolver_zlarf_full_rank #endif #endif end interface interface rocsolver_slarf_64 function rocsolver_slarf_64_(handle,side,m,n,x,incx,alpha,A,lda) & bind(c, name="rocsolver_slarf_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarf_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_float) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface interface rocsolver_dlarf_64 function rocsolver_dlarf_64_(handle,side,m,n,x,incx,alpha,A,lda) & bind(c, name="rocsolver_dlarf_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarf_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx real(c_double) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface interface rocsolver_clarf_64 function rocsolver_clarf_64_(handle,side,m,n,x,incx,alpha,A,lda) & bind(c, name="rocsolver_clarf_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarf_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface interface rocsolver_zlarf_64 function rocsolver_zlarf_64_(handle,side,m,n,x,incx,alpha,A,lda) & bind(c, name="rocsolver_zlarf_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarf_64_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: x integer(c_int64_t),value :: incx complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int64_t),value :: lda end function end interface !> \brief The LARFB functions apply a block reflector ``H`` to a general ``m`` -by-``n`` !> matrix ``A``. !> !> \details !> The block reflector H is applied in one of the following forms, depending on !> the values of ``side`` and ``trans``: !> !> \f[ !> \begin{array}{cl} !> HA & \: \text{(No transpose from the left),}\\% !> H^H A & \: \text{(Transpose or conjugate transpose from the left),}\\% !> AH & \: \text{(No transpose from the right), or}\\% !> AH^H & \: \text{(Transpose or conjugate transpose from the right).} !> \end{array} !> \f] !> !> The block reflector H is defined as the product of ``k`` Householder matrices as !> !> \f[ !> \begin{array}{cl} !> H = H(1)H(2)\cdots H(k) & \: \text{if direct indicates forward direction, or} \\% !> H = H(k)\cdots H(2)H(1) & \: \text{if direct indicates backward direction} !> \end{array} !> \f] !> !> H is never stored. It is calculated as !> !> \f[ !> H = I - VTV^H !> \f] !> !> where the \f$j\f$th column of matrix ``V`` contains the Householder vector associated with !> \f$H(j)\f$, if ``storev`` is column-wise, or !> !> \f[ !> H = I - V^H T V !> \f] !> !> where the \f$i\f$th row of matrix ``V`` contains the Householder vector associated with !> \f$H(i)\f$, if ``storev`` is row-wise. !> ``T`` is the associated triangular factor as computed by \ref rocsolver_slarft "LARFT". !> !> @param[in] handle - rocblas_handle. !> @param[in] side - rocblas_side. !> Specifies from which side to apply H. !> @param[in] trans - rocblas_operation. !> Specifies whether the block reflector or its transpose/conjugate transpose is !> to be applied. !> @param[in] myDirect - `rocblas_direct`. !> Specifies the direction in which the Householder matrices are to be applied to !> generate H. !> @param[in] storev - `rocblas_storev`. !> Specifies how the Householder vectors are stored in matrix V. !> @param[in] m - rocblas_int. m >= 0. !> Number of rows of matrix A. !> @param[in] n - rocblas_int. n >= 0. !> Number of columns of matrix A. !> @param[in] k - rocblas_int. k >= 1. !> The number of Householder matrices. !> @param[in] V - pointer to type. Array on the GPU of size ldv*k if column-wise, ldv*n if !> row-wise and applying from the right, !> or ldv*m if row-wise and applying from the left. !> The matrix of Householder vectors. !> @param[in] ldv - rocblas_int. ldv >= k if row-wise, ldv >= m if column-wise and applying !> from the left, or ldv >= n if !> column-wise and applying from the right. !> The leading dimension of V. !> @param[in] T - pointer to type. Array on the GPU of dimension ldt*k. !> The triangular factor of the block reflector. !> @param[in] ldt - rocblas_int. ldt >= k. !> The leading dimension of T. !> @param[inout] A - pointer to type. Array on the GPU of size lda*n. !> On entry, the matrix A. On exit, it is overwritten with !> \f$HA\f$, \f$AH\f$, \f$H^H A\f$, or \f$AH^H\f$. !> @param[in] lda - rocblas_int. lda >= m. !> The leading dimension of A. interface rocsolver_slarfb function rocsolver_slarfb_(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) & bind(c, name="rocsolver_slarfb") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarfb_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_forward_direction)),value :: myDirect integer(kind(rocblas_column_wise)),value :: storev integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: T integer(c_int),value :: ldt type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_slarfb_assumed_rank #else module procedure & rocsolver_slarfb_rank_0,& rocsolver_slarfb_rank_1,& rocsolver_slarfb_full_rank #endif #endif end interface interface rocsolver_dlarfb function rocsolver_dlarfb_(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) & bind(c, name="rocsolver_dlarfb") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarfb_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_forward_direction)),value :: myDirect integer(kind(rocblas_column_wise)),value :: storev integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: T integer(c_int),value :: ldt type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dlarfb_assumed_rank #else module procedure & rocsolver_dlarfb_rank_0,& rocsolver_dlarfb_rank_1,& rocsolver_dlarfb_full_rank #endif #endif end interface interface rocsolver_clarfb function rocsolver_clarfb_(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) & bind(c, name="rocsolver_clarfb") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarfb_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_forward_direction)),value :: myDirect integer(kind(rocblas_column_wise)),value :: storev integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: T integer(c_int),value :: ldt type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_clarfb_assumed_rank #else module procedure & rocsolver_clarfb_rank_0,& rocsolver_clarfb_rank_1,& rocsolver_clarfb_full_rank #endif #endif end interface interface rocsolver_zlarfb function rocsolver_zlarfb_(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) & bind(c, name="rocsolver_zlarfb") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarfb_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(kind(rocblas_forward_direction)),value :: myDirect integer(kind(rocblas_column_wise)),value :: storev integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: T integer(c_int),value :: ldt type(c_ptr),value :: A integer(c_int),value :: lda end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zlarfb_assumed_rank #else module procedure & rocsolver_zlarfb_rank_0,& rocsolver_zlarfb_rank_1,& rocsolver_zlarfb_full_rank #endif #endif end interface !> \brief The LASR functions apply a sequence of Givens plane rotations, represented as a !> transformation P, !> to a general ``m``-by-``n`` matrix ``A``. !> !> \details !> The transformation P is applied in one of the following forms, depending on !> the value of ``side``: !> !> \f[ !> \begin{array}{cl} !> PA & \: \text{(No transpose from the left),}\\% !> AP^T & \: \text{(Transpose from the right).} !> \end{array} !> \f] !> !> P is defined as the product of k plane rotations, with k = ``m`` - 1 when applied from the !> left, and !> k = ``n`` - 1 when applied from the right, as follows: !> !> \f[ !> \begin{array}{cl} !> P = P(1)P(2)\cdots P(k) & \: \text{if direct indicates backward direction, or} \\% !> P = P(k)\cdots P(2)P(1) & \: \text{if direct indicates forward direction} !> \end{array} !> \f] !> !> Each P(i) is defined by a Givens rotation !> !> \f[ !> R(i) = \left[\begin{array}{cc} !> c_i & s_i \\% !> -s_i & c_i !> \end{array}\right], !> \f] !> !> where the \f$c_i\f$ and \f$s_i\f$ are the corresponding cosine and sine factors. !> !> The rotations are performed on different planes depending on the value of ``pivot``. If !> ``pivot`` is !> ``variable``, the rotation R(i) is performed on plane (i,i+1), that is, P(i) appears as a !> rank-2 !> modification to the identity matrix in the i-th and (i+1)-th rows and columns. If ``pivot`` !> is !> ``top``, then the modification appears in the first and (i+1)-th rows and columns of P(i), !> and if ``pivot`` is ``bottom``, then the modification appears in the i-th and last rows and !> columns of P(i). !> !> All rotations are applied directly without ever forming P(i) explicitly. !> !> @param[in] handle - rocblas_handle. !> @param[in] side - rocblas_side. !> Specifies from which side to apply P. !> @param[in] pivot - `rocblas_pivot`. !> Specifies the planes on which the rotations are applied. !> @param[in] myDirect - `rocblas_direct`. !> Specifies the direction in which the plane rotations are to be applied to !> generate P. !> @param[in] m - rocblas_int. m >= 0. !> Number of rows of matrix A. !> @param[in] n - rocblas_int. n >= 0. !> Number of columns of matrix A. !> @param[in] C - pointer to real type. Array on the GPU of size n-1 if side is right, or m-1 !> if side is left. !> Contains the series of cosine factors defining the Givens rotations. !> @param[in] S - pointer to real type. Array on the GPU of size n-1 if side is right, or m-1 !> if side is left. !> Contains the series of sine factors defining the Givens rotations. !> @param[inout] A - pointer to type. Array on the GPU of size lda*n. !> On entry, the matrix A. On exit, it is overwritten with !> \f$PA\f$, or \f$AP^T\f$. !> @param[in] lda - rocblas_int. lda >= m. !> The leading dimension of A. interface rocsolver_slasr function rocsolver_slasr_(handle,side,pivot,myDirect,m,n,C,S,A,lda) & bind(c, name="rocsolver_slasr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slasr_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_pivot_variable)),value :: pivot integer(kind(rocblas_forward_direction)),value :: myDirect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: C type(c_ptr),value :: S type(c_ptr),value :: A integer(c_int),value :: lda end function end interface interface rocsolver_dlasr function rocsolver_dlasr_(handle,side,pivot,myDirect,m,n,C,S,A,lda) & bind(c, name="rocsolver_dlasr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlasr_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_pivot_variable)),value :: pivot integer(kind(rocblas_forward_direction)),value :: myDirect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: C type(c_ptr),value :: S type(c_ptr),value :: A integer(c_int),value :: lda end function end interface interface rocsolver_clasr function rocsolver_clasr_(handle,side,pivot,myDirect,m,n,C,S,A,lda) & bind(c, name="rocsolver_clasr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clasr_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_pivot_variable)),value :: pivot integer(kind(rocblas_forward_direction)),value :: myDirect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: C type(c_ptr),value :: S type(c_ptr),value :: A integer(c_int),value :: lda end function end interface interface rocsolver_zlasr function rocsolver_zlasr_(handle,side,pivot,myDirect,m,n,C,S,A,lda) & bind(c, name="rocsolver_zlasr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlasr_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_pivot_variable)),value :: pivot integer(kind(rocblas_forward_direction)),value :: myDirect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: C type(c_ptr),value :: S type(c_ptr),value :: A integer(c_int),value :: lda end function end interface !> \brief The LABRD functions computes the bidiagonal form of the first ``k`` rows and columns !> of !> a general ``m`` -by-``n`` matrix ``A``, as well as the matrices ``X`` and ``Y`` needed to !> reduce !> the remaining part of ``A``. !> !> \details !> The reduced form is given by: !> !> \f[ !> B = Q^H A P !> \f] !> !> where the leading ``k`` -by-``k`` block of B is upper bidiagonal if ``m`` >= ``n``, or !> lower bidiagonal if ``m`` < ``n``. Q and !> P are orthogonal/unitary matrices represented as the product of Householder matrices: !> !> \f[ !> \begin{array}{cl} !> Q = H(1)H(2)\cdots H(k), & \text{and} \\% !> P = G(1)G(2)\cdots G(k). !> \end{array} !> \f] !> !> Each Householder matrix \f$H(i)\f$ and \f$G(i)\f$ is given by !> !> \f[ !> \begin{array}{cl} !> H(i) = I - \text{tauq}[i]\cdot v_i^{}v_i^H, & \text{and} \\% !> G(i) = I - \text{taup}[i]\cdot u_i^{}u_i^H. !> \end{array} !> \f] !> !> If ``m`` >= ``n``, the first \f$i-1\f$ elements of the Householder vector \f$v_i\f$ are !> zero, and \f$v_i[i]=1\f$, !> while the first \f$i\f$ elements of the Householder vector \f$u_i\f$ are zero, and !> \f$u_i[i+1]=1\f$. !> If ``m`` < ``n``, the first \f$i\f$ elements of the Householder vector \f$v_i\f$ are zero, !> and \f$v_i[i+1]=1\f$, !> while the first \f$i-1\f$ elements of the Householder vector \f$u_i\f$ are zero, and !> \f$u_i[i]=1\f$. !> !> The unreduced part of the matrix ``A`` can be updated using the block update !> !> \f[ !> A = A - VY^H - XU^H !> \f] !> !> where V and U are the ``m`` -by-``k`` and ``n`` -by-``k`` matrices formed with the vectors !> \f$v_i\f$ and \f$u_i\f$, respectively. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix A. !> @param[in] k - rocblas_int. min(m,n) >= k >= 0. !> The number of leading rows and columns of matrix A that will be reduced. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the m-by-n matrix to be reduced. !> On exit, the first k elements on the diagonal and superdiagonal (if m >= n) or !> subdiagonal (if m < n) contain the bidiagonal form B. !> - If m >= n, the elements below the diagonal of the first k columns are the !> (possibly non-zero) elements !> of the Householder vectors associated with Q, while the elements above the !> superdiagonal of the first k rows are the n - i - 1 (possibly non-zero) !> elements of the Householder vectors related to P. !> - If m < n, the elements below the subdiagonal of the first k columns are the m !> - i - 1 (possibly non-zero) !> elements of the Householder vectors related to Q, while the elements above the !> diagonal of the first k rows are the n - i (possibly non-zero) elements of the !> vectors associated with P. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[out] D - pointer to real type. Array on the GPU of dimension k. !> The diagonal elements of B. !> @param[out] E - pointer to real type. Array on the GPU of dimension k. !> The off-diagonal elements of B. !> @param[out] tauq - pointer to type. Array on the GPU of dimension k. !> The Householder scalars associated with matrix Q. !> @param[out] taup - pointer to type. Array on the GPU of dimension k. !> The Householder scalars associated with matrix P. !> @param[out] X - pointer to type. Array on the GPU of dimension ldx*k. !> The m-by-k matrix needed to update the unreduced part of A. !> @param[in] ldx - rocblas_int. ldx >= m. !> The leading dimension of X. !> @param[out] Y - pointer to type. Array on the GPU of dimension ldy*k. !> The n-by-k matrix needed to update the unreduced part of A. !> @param[in] ldy - rocblas_int. ldy >= n. !> The leading dimension of Y. interface rocsolver_slabrd function rocsolver_slabrd_(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) & bind(c, name="rocsolver_slabrd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slabrd_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup type(c_ptr),value :: X integer(c_int),value :: ldx type(c_ptr),value :: Y integer(c_int),value :: ldy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_slabrd_assumed_rank #else module procedure & rocsolver_slabrd_rank_0,& rocsolver_slabrd_rank_1,& rocsolver_slabrd_full_rank #endif #endif end interface interface rocsolver_dlabrd function rocsolver_dlabrd_(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) & bind(c, name="rocsolver_dlabrd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlabrd_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup type(c_ptr),value :: X integer(c_int),value :: ldx type(c_ptr),value :: Y integer(c_int),value :: ldy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dlabrd_assumed_rank #else module procedure & rocsolver_dlabrd_rank_0,& rocsolver_dlabrd_rank_1,& rocsolver_dlabrd_full_rank #endif #endif end interface interface rocsolver_clabrd function rocsolver_clabrd_(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) & bind(c, name="rocsolver_clabrd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clabrd_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup type(c_ptr),value :: X integer(c_int),value :: ldx type(c_ptr),value :: Y integer(c_int),value :: ldy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_clabrd_assumed_rank #else module procedure & rocsolver_clabrd_rank_0,& rocsolver_clabrd_rank_1,& rocsolver_clabrd_full_rank #endif #endif end interface interface rocsolver_zlabrd function rocsolver_zlabrd_(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) & bind(c, name="rocsolver_zlabrd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlabrd_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup type(c_ptr),value :: X integer(c_int),value :: ldx type(c_ptr),value :: Y integer(c_int),value :: ldy end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zlabrd_assumed_rank #else module procedure & rocsolver_zlabrd_rank_0,& rocsolver_zlabrd_rank_1,& rocsolver_zlabrd_full_rank #endif #endif end interface !> \brief LATRD computes the tridiagonal form of k rows and columns of !> a symmetric/hermitian matrix A, as well as the matrix W needed to update !> the remaining part of A. !> !> \details !> The reduced form is given by: !> !> \f[ !> T = Q^H A Q !> \f] !> !> If uplo is lower, the first k rows and columns of T form the tridiagonal block. If uplo is !> upper, then the last !> k rows and columns of T form the tridiagonal block. Q is an orthogonal/unitary matrix !> represented as the !> product of Householder matrices !> !> \f[ !> \begin{array}{cl} !> Q = H(1)H(2)\cdots H(k) & \text{if uplo indicates lower, or}\\% !> Q = H(n)H(n-1)\cdots H(n-k+1) & \text{if uplo is upper}. !> \end{array} !> \f] !> !> Each Householder matrix \f$H(i)\f$ is given by !> !> \f[ !> H(i) = I - \text{tau}[i]\cdot v_i^{}v_i^H !> \f] !> !> where tau[\f$i\f$] is the corresponding Householder scalar. When uplo indicates lower, the !> first \f$i\f$ !> elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i+1] = 1\f$. If uplo is !> upper, !> the last n-\f$i\f$ elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = !> 1\f$. !> !> The unreduced part of the matrix A can be updated using a rank update of the form: !> !> \f[ !> A = A - VW^H - WV^H !> \f] !> !> where V is the n-by-k matrix formed by the vectors \f$v_i\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrix A. !> @param[in] k - rocblas_int. 0 <= k <= n. !> The number of rows and columns of the matrix A to be reduced. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the n-by-n matrix to be reduced. !> On exit, if uplo is lower, the first k columns have been reduced to tridiagonal !> form !> (given in the diagonal elements of A and the array E), the elements below the !> diagonal !> contain the possibly non-zero entries of the Householder vectors associated !> with Q, stored as columns. !> If uplo is upper, the last k columns have been reduced to tridiagonal form !> (given in the diagonal elements of A and the array E), the elements above the !> diagonal !> contain the possibly non-zero entries of the Householder vectors associated !> with Q, stored as columns. !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A. !> @param[out] E - pointer to real type. Array on the GPU of dimension n-1. !> If upper (lower), the last (first) k elements of E are the off-diagonal !> elements of the !> computed tridiagonal block. !> @param[out] tau - pointer to type. Array on the GPU of dimension n-1. !> If upper (lower), the last (first) k elements of tau are the Householder !> scalars related to Q. !> @param[out] W - pointer to type. Array on the GPU of dimension ldw*k. !> The n-by-k matrix needed to update the unreduced part of A. !> @param[in] ldw - rocblas_int. ldw >= n. !> The leading dimension of W. interface rocsolver_slatrd function rocsolver_slatrd_(handle,uplo,n,k,A,lda,E,tau,W,ldw) bind(c, name="rocsolver_slatrd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slatrd_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: E type(c_ptr),value :: tau type(c_ptr),value :: W integer(c_int),value :: ldw end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_slatrd_assumed_rank #else module procedure & rocsolver_slatrd_rank_0,& rocsolver_slatrd_rank_1,& rocsolver_slatrd_full_rank #endif #endif end interface interface rocsolver_dlatrd function rocsolver_dlatrd_(handle,uplo,n,k,A,lda,E,tau,W,ldw) bind(c, name="rocsolver_dlatrd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlatrd_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: E type(c_ptr),value :: tau type(c_ptr),value :: W integer(c_int),value :: ldw end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dlatrd_assumed_rank #else module procedure & rocsolver_dlatrd_rank_0,& rocsolver_dlatrd_rank_1,& rocsolver_dlatrd_full_rank #endif #endif end interface interface rocsolver_clatrd function rocsolver_clatrd_(handle,uplo,n,k,A,lda,E,tau,W,ldw) bind(c, name="rocsolver_clatrd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clatrd_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: E type(c_ptr),value :: tau type(c_ptr),value :: W integer(c_int),value :: ldw end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_clatrd_assumed_rank #else module procedure & rocsolver_clatrd_rank_0,& rocsolver_clatrd_rank_1,& rocsolver_clatrd_full_rank #endif #endif end interface interface rocsolver_zlatrd function rocsolver_zlatrd_(handle,uplo,n,k,A,lda,E,tau,W,ldw) bind(c, name="rocsolver_zlatrd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlatrd_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: E type(c_ptr),value :: tau type(c_ptr),value :: W integer(c_int),value :: ldw end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zlatrd_assumed_rank #else module procedure & rocsolver_zlatrd_rank_0,& rocsolver_zlatrd_rank_1,& rocsolver_zlatrd_full_rank #endif #endif end interface !> \brief The LASYF functions compute a partial factorization of a symmetric matrix \f$A\f$ !> using Bunch-Kaufman diagonal pivoting. !> !> \details !> The partial factorization has the form !> !> \f[ !> A = \left[ \begin{array}{cc} !> I & U_{12} \\% !> 0 & U_{22} !> \end{array} \right] \left[ \begin{array}{cc} !> A_{11} & 0 \\% !> 0 & D !> \end{array} \right] \left[ \begin{array}{cc} !> I & 0 \\% !> U_{12}^T & U_{22}^T !> \end{array} \right] !> \f] !> !> or !> !> \f[ !> A = \left[ \begin{array}{cc} !> L_{11} & 0 \\% !> L_{21} & I !> \end{array} \right] \left[ \begin{array}{cc} !> D & 0 \\% !> 0 & A_{22} !> \end{array} \right] \left[ \begin{array}{cc} !> L_{11}^T & L_{21}^T \\% !> 0 & I !> \end{array} \right] !> \f] !> !> depending on the value of ``uplo``. The order of the block diagonal matrix \f$D\f$ !> is either \f$nb\f$ or \f$nb-1\f$ and is returned in the argument \f$kb\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrix A. !> @param[in] nb - rocblas_int. 2 <= nb <= n. !> The number of columns of A to be factored. !> @param[out] kb - pointer to a rocblas_int on the GPU. !> The number of columns of A that were actually factored (either nb or !> nb-1). !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the symmetric matrix A to be factored. !> On exit, the partially factored matrix. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] ipiv - pointer to rocblas_int. Array on the GPU of dimension n. !> The vector of pivot indices. Elements of ipiv are 1-based indices. !> - If uplo is upper, then only the last kb elements of ipiv will be !> set. For n - kb < k <= n, if ipiv[k] > 0, then rows and columns k !> and ipiv[k] were interchanged and D[k,k] is a 1-by-1 diagonal block. !> If, instead, ipiv[k] = ipiv[k-1] < 0, then rows and columns k-1 !> and -ipiv[k] were interchanged and D[k-1,k-1] to D[k,k] is a 2-by-2 !> diagonal block. !> - If uplo is lower, then only the first kb elements of ipiv will be !> set. For 1 <= k <= kb, if ipiv[k] > 0, then rows and columns k !> and ipiv[k] were interchanged and D[k,k] is a 1-by-1 diagonal block. !> If, instead, ipiv[k] = ipiv[k+1] < 0, then rows and columns k+1 !> and -ipiv[k] were interchanged and D[k,k] to D[k+1,k+1] is a 2-by-2 !> diagonal block. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, D is singular. D[i,i] is the first diagonal zero. interface rocsolver_slasyf function rocsolver_slasyf_(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) & bind(c, name="rocsolver_slasyf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slasyf_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: nb type(c_ptr),value :: kb type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_slasyf_assumed_rank #else module procedure & rocsolver_slasyf_rank_0,& rocsolver_slasyf_rank_1,& rocsolver_slasyf_full_rank #endif #endif end interface interface rocsolver_dlasyf function rocsolver_dlasyf_(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) & bind(c, name="rocsolver_dlasyf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlasyf_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: nb type(c_ptr),value :: kb type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dlasyf_assumed_rank #else module procedure & rocsolver_dlasyf_rank_0,& rocsolver_dlasyf_rank_1,& rocsolver_dlasyf_full_rank #endif #endif end interface interface rocsolver_clasyf function rocsolver_clasyf_(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) & bind(c, name="rocsolver_clasyf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clasyf_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: nb type(c_ptr),value :: kb type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_clasyf_assumed_rank #else module procedure & rocsolver_clasyf_rank_0,& rocsolver_clasyf_rank_1,& rocsolver_clasyf_full_rank #endif #endif end interface interface rocsolver_zlasyf function rocsolver_zlasyf_(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) & bind(c, name="rocsolver_zlasyf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlasyf_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: nb type(c_ptr),value :: kb type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zlasyf_assumed_rank #else module procedure & rocsolver_zlasyf_rank_0,& rocsolver_zlasyf_rank_1,& rocsolver_zlasyf_full_rank #endif #endif end interface !> \brief The LAUUM functions compute the product of the upper (or lower) triangular part U !> (or L) of a !> symmetric/Hemitian matrix ``A`` with its transpose. !> !> \details !> If ``uplo`` indicates upper, then \f$U U^H\f$ is computed. If ``uplo`` indicates lower, !> then \f$L^H L\f$ is computed instead. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower triangular part of A will be used. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A is not referenced. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns and rows of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, it contains the upper (or lower) part of the symmetric/Hermitian !> matrix. !> On exit, the upper (or lower) part is overwritten with the result of \f$U !> U^H\f$ (or \f$L^H L\f$). !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of the array A. interface rocsolver_slauum function rocsolver_slauum_(handle,uplo,n,A,lda) bind(c, name="rocsolver_slauum") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slauum_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda end function end interface interface rocsolver_dlauum function rocsolver_dlauum_(handle,uplo,n,A,lda) bind(c, name="rocsolver_dlauum") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlauum_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda end function end interface interface rocsolver_clauum function rocsolver_clauum_(handle,uplo,n,A,lda) bind(c, name="rocsolver_clauum") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clauum_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda end function end interface interface rocsolver_zlauum function rocsolver_zlauum_(handle,uplo,n,A,lda) bind(c, name="rocsolver_zlauum") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlauum_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda end function end interface !> \brief The ORG2R functions generate an ``m``-by-``n`` Matrix Q with orthonormal columns. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The matrix Q is defined as the first ``n`` columns of the product of ``k`` Householder !> reflectors of order ``m`` !> !> \f[ !> Q = H(1)H(2)\cdots H(k). !> \f] !> !> The Householder matrices \f$H(i)\f$ are never stored. They are computed from the !> corresponding !> Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref !> rocsolver_sgeqrf "GEQRF". !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix Q. !> @param[in] n - rocblas_int. 0 <= n <= m. !> The number of columns of the matrix Q. !> @param[in] k - rocblas_int. 0 <= k <= n. !> The number of Householder reflectors. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GEQRF", with the !> Householder vectors in the first k columns. !> On exit, the computed matrix Q. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgeqrf "GEQRF". interface rocsolver_sorg2r function rocsolver_sorg2r_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_sorg2r") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorg2r_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sorg2r_assumed_rank #else module procedure & rocsolver_sorg2r_rank_0,& rocsolver_sorg2r_rank_1,& rocsolver_sorg2r_full_rank #endif #endif end interface interface rocsolver_dorg2r function rocsolver_dorg2r_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_dorg2r") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorg2r_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dorg2r_assumed_rank #else module procedure & rocsolver_dorg2r_rank_0,& rocsolver_dorg2r_rank_1,& rocsolver_dorg2r_full_rank #endif #endif end interface !> \brief The UNG2R functions generate an ``m`` -by-``n`` complex matrix Q with orthonormal !> columns. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The matrix Q is defined as the first ``n`` columns of the product of ``k`` Householder !> reflectors of order ``m`` !> !> \f[ !> Q = H(1)H(2)\cdots H(k) !> \f] !> !> The Householder matrices \f$H(i)\f$ are never stored. They are computed from the !> corresponding !> Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref !> rocsolver_sgeqrf "GEQRF". !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix Q. !> @param[in] n - rocblas_int. 0 <= n <= m. !> The number of columns of the matrix Q. !> @param[in] k - rocblas_int. 0 <= k <= n. !> The number of Householder reflectors. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GEQRF", with the !> Householder vectors in the first k columns. !> On exit, the computed matrix Q. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgeqrf "GEQRF". interface rocsolver_cung2r function rocsolver_cung2r_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_cung2r") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cung2r_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cung2r_assumed_rank #else module procedure & rocsolver_cung2r_rank_0,& rocsolver_cung2r_rank_1,& rocsolver_cung2r_full_rank #endif #endif end interface interface rocsolver_zung2r function rocsolver_zung2r_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_zung2r") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zung2r_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zung2r_assumed_rank #else module procedure & rocsolver_zung2r_rank_0,& rocsolver_zung2r_rank_1,& rocsolver_zung2r_full_rank #endif #endif end interface !> \brief The ORGQR functions generate an ``m``-by-``n`` Matrix Q with orthonormal columns. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The matrix Q is defined as the first ``n`` columns of the product of ``k`` Householder !> reflectors of order ``m`` !> !> \f[ !> Q = H(1)H(2)\cdots H(k) !> \f] !> !> The Householder matrices \f$H(i)\f$ are never stored. They are computed from the !> corresponding !> Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref !> rocsolver_sgeqrf "GEQRF". !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix Q. !> @param[in] n - rocblas_int. 0 <= n <= m. !> The number of columns of the matrix Q. !> @param[in] k - rocblas_int. 0 <= k <= n. !> The number of Householder reflectors. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GEQRF", with the !> Householder vectors in the first k columns. !> On exit, the computed matrix Q. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgeqrf "GEQRF". interface rocsolver_sorgqr function rocsolver_sorgqr_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_sorgqr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgqr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sorgqr_assumed_rank #else module procedure & rocsolver_sorgqr_rank_0,& rocsolver_sorgqr_rank_1,& rocsolver_sorgqr_full_rank #endif #endif end interface interface rocsolver_dorgqr function rocsolver_dorgqr_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_dorgqr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgqr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dorgqr_assumed_rank #else module procedure & rocsolver_dorgqr_rank_0,& rocsolver_dorgqr_rank_1,& rocsolver_dorgqr_full_rank #endif #endif end interface !> \brief The UNGQR functions generate an ``m`` -by-``n`` complex matrix Q with orthonormal !> columns. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The matrix Q is defined as the first ``n`` columns of the product of ``k`` Householder !> reflectors of order ``m`` !> !> \f[ !> Q = H(1)H(2)\cdots H(k) !> \f] !> !> Householder matrices \f$H(i)\f$ are never stored. They are computed from the corresponding !> Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref !> rocsolver_sgeqrf "GEQRF". !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix Q. !> @param[in] n - rocblas_int. 0 <= n <= m. !> The number of columns of the matrix Q. !> @param[in] k - rocblas_int. 0 <= k <= n. !> The number of Householder reflectors. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GEQRF", with the !> Householder vectors in the first k columns. !> On exit, the computed matrix Q. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgeqrf "GEQRF". interface rocsolver_cungqr function rocsolver_cungqr_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_cungqr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungqr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cungqr_assumed_rank #else module procedure & rocsolver_cungqr_rank_0,& rocsolver_cungqr_rank_1,& rocsolver_cungqr_full_rank #endif #endif end interface interface rocsolver_zungqr function rocsolver_zungqr_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_zungqr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungqr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zungqr_assumed_rank #else module procedure & rocsolver_zungqr_rank_0,& rocsolver_zungqr_rank_1,& rocsolver_zungqr_full_rank #endif #endif end interface !> \brief The ORGL2 functions generate an ``m``-by-``n`` Matrix Q with orthonormal rows. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The matrix Q is defined as the first ``m`` rows of the product of ``k`` Householder !> reflectors of order ``n`` !> !> \f[ !> Q = H(k)H(k-1)\cdots H(1) !> \f] !> !> The Householder matrices \f$H(i)\f$ are never stored. They are computed from its !> corresponding !> Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref !> rocsolver_sgelqf "GELQF". !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. 0 <= m <= n. !> The number of rows of the matrix Q. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix Q. !> @param[in] k - rocblas_int. 0 <= k <= m. !> The number of Householder reflectors. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GELQF", with the !> Householder vectors in the first k rows. !> On exit, the computed matrix Q. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU, of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgelqf "GELQF". interface rocsolver_sorgl2 function rocsolver_sorgl2_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_sorgl2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgl2_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sorgl2_assumed_rank #else module procedure & rocsolver_sorgl2_rank_0,& rocsolver_sorgl2_rank_1,& rocsolver_sorgl2_full_rank #endif #endif end interface interface rocsolver_dorgl2 function rocsolver_dorgl2_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_dorgl2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgl2_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dorgl2_assumed_rank #else module procedure & rocsolver_dorgl2_rank_0,& rocsolver_dorgl2_rank_1,& rocsolver_dorgl2_full_rank #endif #endif end interface !> \brief The UNGL2 functions generate an ``m`` -by-``n`` complex matrix Q with orthonormal !> rows. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The matrix Q is defined as the first ``m`` rows of the product of ``k`` Householder !> reflectors of order ``n`` !> !> \f[ !> Q = H(k)^H H(k-1)^H\cdots H(1)^H !> \f] !> !> The Householder matrices \f$H(i)\f$ are never stored. They are computed from the !> corresponding !> Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref !> rocsolver_sgelqf "GELQF". !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. 0 <= m <= n. !> The number of rows of the matrix Q. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix Q. !> @param[in] k - rocblas_int. 0 <= k <= m. !> The number of Householder reflectors. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GELQF", with the !> Householder vectors in the first k rows. !> On exit, the computed matrix Q. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgelqf "GELQF". interface rocsolver_cungl2 function rocsolver_cungl2_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_cungl2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungl2_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cungl2_assumed_rank #else module procedure & rocsolver_cungl2_rank_0,& rocsolver_cungl2_rank_1,& rocsolver_cungl2_full_rank #endif #endif end interface interface rocsolver_zungl2 function rocsolver_zungl2_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_zungl2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungl2_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zungl2_assumed_rank #else module procedure & rocsolver_zungl2_rank_0,& rocsolver_zungl2_rank_1,& rocsolver_zungl2_full_rank #endif #endif end interface !> \brief The ORGLQ functions generate an ``m``-by-``n`` Matrix Q with orthonormal rows. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The matrix Q is defined as the first ``m`` rows of the product of ``k`` Householder !> reflectors of order ``n`` !> !> \f[ !> Q = H(k)H(k-1)\cdots H(1) !> \f] !> !> The Householder matrices \f$H(i)\f$ are never stored. They are computed from the !> corresponding !> Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref !> rocsolver_sgelqf "GELQF". !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. 0 <= m <= n. !> The number of rows of the matrix Q. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix Q. !> @param[in] k - rocblas_int. 0 <= k <= m. !> The number of Householder reflectors. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GELQF", with the !> Householder vectors in the first k rows. !> On exit, the computed matrix Q. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgelqf "GELQF". interface rocsolver_sorglq function rocsolver_sorglq_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_sorglq") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorglq_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sorglq_assumed_rank #else module procedure & rocsolver_sorglq_rank_0,& rocsolver_sorglq_rank_1,& rocsolver_sorglq_full_rank #endif #endif end interface interface rocsolver_dorglq function rocsolver_dorglq_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_dorglq") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorglq_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dorglq_assumed_rank #else module procedure & rocsolver_dorglq_rank_0,& rocsolver_dorglq_rank_1,& rocsolver_dorglq_full_rank #endif #endif end interface !> \brief The UNGLQ functions generate an ``m`` -by-``n`` complex matrix Q with orthonormal !> rows. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The matrix Q is defined as the first ``m`` rows of the product of ``k`` Householder !> reflectors of order ``n`` !> !> \f[ !> Q = H(k)^H H(k-1)^H\cdots H(1)^H !> \f] !> !> The Householder matrices \f$H(i)\f$ are never stored. They are computed from the !> corresponding !> Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref !> rocsolver_sgelqf "GELQF". !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. 0 <= m <= n. !> The number of rows of the matrix Q. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix Q. !> @param[in] k - rocblas_int. 0 <= k <= m. !> The number of Householder reflectors. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GELQF", with the !> Householder vectors in the first k rows. !> On exit, the computed matrix Q. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgelqf "GELQF". interface rocsolver_cunglq function rocsolver_cunglq_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_cunglq") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunglq_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cunglq_assumed_rank #else module procedure & rocsolver_cunglq_rank_0,& rocsolver_cunglq_rank_1,& rocsolver_cunglq_full_rank #endif #endif end interface interface rocsolver_zunglq function rocsolver_zunglq_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_zunglq") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunglq_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zunglq_assumed_rank #else module procedure & rocsolver_zunglq_rank_0,& rocsolver_zunglq_rank_1,& rocsolver_zunglq_full_rank #endif #endif end interface !> \brief The ORG2L functions generate an ``m``-by-``n`` Matrix Q with orthonormal columns. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The matrix Q is defined as the last ``n`` columns of the product of ``k`` !> Householder reflectors of order ``m`` !> !> \f[ !> Q = H(k)H(k-1)\cdots H(1) !> \f] !> !> The Householder matrices \f$H(i)\f$ are never stored. They are computed from the !> corresponding Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned !> by \ref rocsolver_sgeqlf "GEQLF". !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix Q. !> @param[in] n - rocblas_int. 0 <= n <= m. !> The number of columns of the matrix Q. !> @param[in] k - rocblas_int. 0 <= k <= n. !> The number of Householder reflectors. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GEQLF", with the !> Householder vectors in the last k columns. !> On exit, the computed matrix Q. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgeqlf "GEQLF". interface rocsolver_sorg2l function rocsolver_sorg2l_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_sorg2l") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorg2l_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sorg2l_assumed_rank #else module procedure & rocsolver_sorg2l_rank_0,& rocsolver_sorg2l_rank_1,& rocsolver_sorg2l_full_rank #endif #endif end interface interface rocsolver_dorg2l function rocsolver_dorg2l_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_dorg2l") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorg2l_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dorg2l_assumed_rank #else module procedure & rocsolver_dorg2l_rank_0,& rocsolver_dorg2l_rank_1,& rocsolver_dorg2l_full_rank #endif #endif end interface !> \brief The UNG2L functions generate an ``m`` -by-``n`` complex matrix Q with orthonormal !> columns. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The matrix Q is defined as the last ``n`` columns of the product of ``k`` !> Householder reflectors of order ``m`` !> !> \f[ !> Q = H(k)H(k-1)\cdots H(1) !> \f] !> !> The Householder matrices \f$H(i)\f$ are never stored. They are computed from the !> corresponding Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned !> by \ref rocsolver_sgeqlf "GEQLF". !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix Q. !> @param[in] n - rocblas_int. 0 <= n <= m. !> The number of columns of the matrix Q. !> @param[in] k - rocblas_int. 0 <= k <= n. !> The number of Householder reflectors. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GEQLF", with the !> Householder vectors in the last k columns. !> On exit, the computed matrix Q. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgeqlf "GEQLF". interface rocsolver_cung2l function rocsolver_cung2l_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_cung2l") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cung2l_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cung2l_assumed_rank #else module procedure & rocsolver_cung2l_rank_0,& rocsolver_cung2l_rank_1,& rocsolver_cung2l_full_rank #endif #endif end interface interface rocsolver_zung2l function rocsolver_zung2l_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_zung2l") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zung2l_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zung2l_assumed_rank #else module procedure & rocsolver_zung2l_rank_0,& rocsolver_zung2l_rank_1,& rocsolver_zung2l_full_rank #endif #endif end interface !> \brief The ORGQL functions generate an ``m``-by-``n`` Matrix Q with orthonormal columns. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The matrix Q is defined as the last ``n`` column of the product of ``k`` Householder !> reflectors of order ``m`` !> !> \f[ !> Q = H(k)H(k-1)\cdots H(1) !> \f] !> !> The Householder matrices \f$H(i)\f$ are never stored. They are computed from the !> corresponding Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned !> by \ref rocsolver_sgeqlf "GEQLF". !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix Q. !> @param[in] n - rocblas_int. 0 <= n <= m. !> The number of columns of the matrix Q. !> @param[in] k - rocblas_int. 0 <= k <= n. !> The number of Householder reflectors. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GEQLF", with the !> Householder vectors in the last k columns. !> On exit, the computed matrix Q. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgeqlf "GEQLF". interface rocsolver_sorgql function rocsolver_sorgql_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_sorgql") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgql_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sorgql_assumed_rank #else module procedure & rocsolver_sorgql_rank_0,& rocsolver_sorgql_rank_1,& rocsolver_sorgql_full_rank #endif #endif end interface interface rocsolver_dorgql function rocsolver_dorgql_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_dorgql") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgql_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dorgql_assumed_rank #else module procedure & rocsolver_dorgql_rank_0,& rocsolver_dorgql_rank_1,& rocsolver_dorgql_full_rank #endif #endif end interface !> \brief The UNGQL functions generate an ``m`` -by-``n`` complex matrix Q with orthonormal !> columns. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The matrix Q is defined as the last ``n`` columns of the product of ``k`` !> Householder reflectors of order ``m`` !> !> \f[ !> Q = H(k)H(k-1)\cdots H(1) !> \f] !> !> The Householder matrices \f$H(i)\f$ are never stored. They are computed from the !> corresponding Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned !> by \ref rocsolver_sgeqlf "GEQLF". !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix Q. !> @param[in] n - rocblas_int. 0 <= n <= m. !> The number of columns of the matrix Q. !> @param[in] k - rocblas_int. 0 <= k <= n. !> The number of Householder reflectors. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A as returned by \ref rocsolver_sgeqrf "GEQLF", with the !> Householder vectors in the last k columns. !> On exit, the computed matrix Q. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgeqlf "GEQLF". interface rocsolver_cungql function rocsolver_cungql_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_cungql") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungql_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cungql_assumed_rank #else module procedure & rocsolver_cungql_rank_0,& rocsolver_cungql_rank_1,& rocsolver_cungql_full_rank #endif #endif end interface interface rocsolver_zungql function rocsolver_zungql_(handle,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_zungql") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungql_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zungql_assumed_rank #else module procedure & rocsolver_zungql_rank_0,& rocsolver_zungql_rank_1,& rocsolver_zungql_full_rank #endif #endif end interface !> \brief The ORGBR functions generate an ``m`` -by-``n`` Matrix Q with orthonormal rows or !> columns. !> !> \details !> If ``storev`` is column-wise, then the matrix Q has orthonormal columns. If ``m`` >= ``k``, !> Q is defined as the first !> ``n`` columns of the product of ``k`` Householder reflectors of order ``m`` !> !> \f[ !> Q = H(1)H(2)\cdots H(k) !> \f] !> !> If ``m`` < ``k``, Q is defined as the product of Householder reflectors of order ``m`` !> !> \f[ !> Q = H(1)H(2)\cdots H(m-1) !> \f] !> !> However, if ``storev`` is row-wise, then the matrix Q has orthonormal rows. If ``n`` > !> ``k``, Q is defined as the !> first ``m`` rows of the product of ``k`` Householder reflectors of order ``n`` !> !> \f[ !> Q = H(k)H(k-1)\cdots H(1) !> \f] !> !> If ``n`` <= ``k``, Q is defined as the product of Householder reflectors of order ``n`` !> !> \f[ !> Q = H(n-1)H(n-2)\cdots H(1) !> \f] !> !> The Householder matrices \f$H(i)\f$ are never stored. They are computed from the !> corresponding !> Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref !> rocsolver_sgebrd "GEBRD" in its arguments ``A`` and tauq or taup. !> !> @param[in] handle - rocblas_handle. !> @param[in] storev - `rocblas_storev`. !> Specifies whether to work column-wise or row-wise. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix Q. !> If row-wise, then min(n,k) <= m <= n. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix Q. !> If column-wise, then min(m,k) <= n <= m. !> @param[in] k - rocblas_int. k >= 0. !> The number of columns (if storev is column-wise) or rows (if row-wise) of the !> original matrix reduced by \ref rocsolver_sgebrd "GEBRD". !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the Householder vectors as returned by \ref rocsolver_sgebrd "GEBRD". !> On exit, the computed matrix Q. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension min(m,k) if column-wise, !> or min(n,k) if row-wise. !> The Householder scalars as returned by \ref rocsolver_sgebrd "GEBRD". interface rocsolver_sorgbr function rocsolver_sorgbr_(handle,storev,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_sorgbr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgbr_ type(c_ptr),value :: handle integer(kind(rocblas_column_wise)),value :: storev integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sorgbr_assumed_rank #else module procedure & rocsolver_sorgbr_rank_0,& rocsolver_sorgbr_rank_1,& rocsolver_sorgbr_full_rank #endif #endif end interface interface rocsolver_dorgbr function rocsolver_dorgbr_(handle,storev,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_dorgbr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgbr_ type(c_ptr),value :: handle integer(kind(rocblas_column_wise)),value :: storev integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dorgbr_assumed_rank #else module procedure & rocsolver_dorgbr_rank_0,& rocsolver_dorgbr_rank_1,& rocsolver_dorgbr_full_rank #endif #endif end interface !> \brief The UNGBR functions generate an ``m`` -by-``n`` complex matrix Q with orthonormal !> rows or !> columns. !> !> \details !> If ``storev`` is column-wise, then the matrix Q has orthonormal columns. If ``m`` >= ``k``, !> Q is defined as the first !> ``n`` columns of the product of ``k`` Householder reflectors of order ``m`` !> !> \f[ !> Q = H(1)H(2)\cdots H(k) !> \f] !> !> If ``m`` < ``k``, Q is defined as the product of Householder reflectors of order ``m`` !> !> \f[ !> Q = H(1)H(2)\cdots H(m-1) !> \f] !> !> However, if ``storev`` is row-wise, then the matrix Q has orthonormal rows. If ``n`` > !> ``k``, Q is defined as the !> first ``m`` rows of the product of ``k`` Householder reflectors of order ``n`` !> !> \f[ !> Q = H(k)H(k-1)\cdots H(1) !> \f] !> !> If ``n`` <= ``k``, Q is defined as the product of Householder reflectors of order ``n`` !> !> \f[ !> Q = H(n-1)H(n-2)\cdots H(1) !> \f] !> !> The Householder matrices \f$H(i)\f$ are never stored. They are computed from the !> corresponding !> Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned by \ref !> rocsolver_sgebrd "GEBRD" in its arguments ``A`` and tauq or taup. !> !> @param[in] handle - rocblas_handle. !> @param[in] storev - `rocblas_storev`. !> Specifies whether to work column-wise or row-wise. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix Q. !> If row-wise, then min(n,k) <= m <= n. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix Q. !> If column-wise, then min(m,k) <= n <= m. !> @param[in] k - rocblas_int. k >= 0. !> The number of columns (if storev is column-wise) or rows (if row-wise) of the !> original matrix reduced by \ref rocsolver_sgebrd "GEBRD". !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the Householder vectors as returned by \ref rocsolver_sgebrd "GEBRD". !> On exit, the computed matrix Q. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension min(m,k) if column-wise or !> min(n,k) if row-wise. !> The Householder scalars as returned by \ref rocsolver_sgebrd "GEBRD". interface rocsolver_cungbr function rocsolver_cungbr_(handle,storev,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_cungbr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungbr_ type(c_ptr),value :: handle integer(kind(rocblas_column_wise)),value :: storev integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cungbr_assumed_rank #else module procedure & rocsolver_cungbr_rank_0,& rocsolver_cungbr_rank_1,& rocsolver_cungbr_full_rank #endif #endif end interface interface rocsolver_zungbr function rocsolver_zungbr_(handle,storev,m,n,k,A,lda,ipiv) bind(c, name="rocsolver_zungbr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungbr_ type(c_ptr),value :: handle integer(kind(rocblas_column_wise)),value :: storev integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zungbr_assumed_rank #else module procedure & rocsolver_zungbr_rank_0,& rocsolver_zungbr_rank_1,& rocsolver_zungbr_full_rank #endif #endif end interface !> \brief The ORGTR functions generate an ``n``-by-``n`` orthogonal Matrix Q. !> !> \details !> Q is defined as the product of ``n``-1 Householder reflectors of order ``n``. If !> ``uplo`` indicates ``upper``, then Q has the form !> !> \f[ !> Q = H(n-1)H(n-2)\cdots H(1) !> \f] !> !> However, if ``uplo`` indicates ``lower``, then Q has the form !> !> \f[ !> Q = H(1)H(2)\cdots H(n-1) !> \f] !> !> The Householder matrices \f$H(i)\f$ are never stored. They are computed from the !> corresponding Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned !> by !> \ref rocsolver_ssytrd "SYTRD" in its arguments ``A`` and tau. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the \ref rocsolver_ssytrd "SYTRD" factorization was upper or !> lower !> triangular. If uplo indicates lower (or upper), then the upper (or lower) !> part of A is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrix Q. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the Householder vectors as returned !> by \ref rocsolver_ssytrd "SYTRD". On exit, the computed matrix Q. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension n-1. !> The Householder scalars as returned by \ref rocsolver_ssytrd "SYTRD". interface rocsolver_sorgtr function rocsolver_sorgtr_(handle,uplo,n,A,lda,ipiv) bind(c, name="rocsolver_sorgtr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgtr_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sorgtr_assumed_rank #else module procedure & rocsolver_sorgtr_rank_0,& rocsolver_sorgtr_rank_1,& rocsolver_sorgtr_full_rank #endif #endif end interface interface rocsolver_dorgtr function rocsolver_dorgtr_(handle,uplo,n,A,lda,ipiv) bind(c, name="rocsolver_dorgtr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgtr_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dorgtr_assumed_rank #else module procedure & rocsolver_dorgtr_rank_0,& rocsolver_dorgtr_rank_1,& rocsolver_dorgtr_full_rank #endif #endif end interface !> \brief The UNGTR functions generate an ``n``-by-``n`` unitary matrix Q. !> !> \details !> Q is defined as the product of ``n``-1 Householder reflectors of order ``n``. If !> ``uplo`` indicates ``upper``, then Q has the form !> !> \f[ !> Q = H(n-1)H(n-2)\cdots H(1) !> \f] !> !> However, if ``uplo`` indicates ``lower``, then Q has the form !> !> \f[ !> Q = H(1)H(2)\cdots H(n-1) !> \f] !> !> The Householder matrices \f$H(i)\f$ are never stored. They are computed from their !> corresponding Householder vectors \f$v_i\f$ and scalars \f$\text{ipiv}[i]\f$, as returned !> by !> \ref rocsolver_chetrd "HETRD" in its arguments ``A`` and tau. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the \ref rocsolver_chetrd "HETRD" factorization was upper or !> lower !> triangular. If uplo indicates lower (or upper), then the upper (or lower) !> part of A is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrix Q. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the Householder vectors as returned !> by \ref rocsolver_chetrd "HETRD". On exit, the computed matrix Q. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension n-1. !> The Householder scalars as returned by \ref rocsolver_chetrd "HETRD". interface rocsolver_cungtr function rocsolver_cungtr_(handle,uplo,n,A,lda,ipiv) bind(c, name="rocsolver_cungtr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungtr_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cungtr_assumed_rank #else module procedure & rocsolver_cungtr_rank_0,& rocsolver_cungtr_rank_1,& rocsolver_cungtr_full_rank #endif #endif end interface interface rocsolver_zungtr function rocsolver_zungtr_(handle,uplo,n,A,lda,ipiv) bind(c, name="rocsolver_zungtr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungtr_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zungtr_assumed_rank #else module procedure & rocsolver_zungtr_rank_0,& rocsolver_zungtr_rank_1,& rocsolver_zungtr_full_rank #endif #endif end interface !> \brief The ORM2R functions multiply a matrix Q with orthonormal columns by a general ``m`` !> -by-``n`` !> matrix ``C``. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The matrix Q is applied in one of the following forms, depending on !> the values of ``side`` and ``trans``: !> !> \f[ !> \begin{array}{cl} !> QC & \: \text{No transpose from the left,}\\% !> Q^TC & \: \text{Transpose from the left,}\\% !> CQ & \: \text{No transpose from the right, and}\\% !> CQ^T & \: \text{Transpose from the right.} !> \end{array} !> \f] !> !> Q is defined as the product of ``k`` Householder reflectors !> !> \f[ !> Q = H(1)H(2) \cdots H(k) !> \f] !> !> of order ``m`` if applying from the left, or ``n`` if applying from the right. Q is never !> stored. It is !> calculated from the Householder vectors and scalars returned by the QR factorization \ref !> rocsolver_sgeqrf "GEQRF". !> !> @param[in] handle - rocblas_handle. !> @param[in] side - rocblas_side. !> Specifies from which side to apply Q. !> @param[in] trans - rocblas_operation. !> Specifies whether the matrix Q or its transpose is to be applied. !> @param[in] m - rocblas_int. m >= 0. !> Number of rows of matrix C. !> @param[in] n - rocblas_int. n >= 0. !> Number of columns of matrix C. !> @param[in] k - rocblas_int. k >= 0. k <= m if side is left, and k <= n if side is right. !> The number of Householder reflectors that form Q. !> @param[in] A - pointer to type. Array on the GPU of size lda*k. !> The Householder vectors as returned by \ref rocsolver_sgeqrf "GEQRF" !> in the first k columns of its argument A. !> @param[in] lda - rocblas_int. lda >= m if side is left, or lda >= n if side is right. !> Leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgeqrf "GEQRF". !> @param[inout] C - pointer to type. Array on the GPU of size ldc*n. !> On entry, the matrix C. On exit, it is overwritten with !> \f$QC\f$, \f$CQ\f$, \f$Q^TC\f$, or \f$CQ^T\f$. !> @param[in] ldc - rocblas_int. ldc >= m. !> Leading dimension of C. interface rocsolver_sorm2r function rocsolver_sorm2r_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_sorm2r") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorm2r_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sorm2r_assumed_rank #else module procedure & rocsolver_sorm2r_rank_0,& rocsolver_sorm2r_rank_1,& rocsolver_sorm2r_full_rank #endif #endif end interface interface rocsolver_dorm2r function rocsolver_dorm2r_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_dorm2r") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorm2r_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dorm2r_assumed_rank #else module procedure & rocsolver_dorm2r_rank_0,& rocsolver_dorm2r_rank_1,& rocsolver_dorm2r_full_rank #endif #endif end interface !> \brief The UNM2R functions multiply a complex matrix Q with orthonormal columns by a !> general ``m``-by-``n`` matrix ``C``. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The matrix Q is applied in one of the following forms, depending on !> the values of ``side`` and ``trans``: !> !> \f[ !> \begin{array}{cl} !> QC & \: \text{No transpose from the left,}\\% !> Q^H C & \: \text{Conjugate transpose from the left,}\\% !> CQ & \: \text{No transpose from the right, and}\\% !> CQ^H & \: \text{Conjugate transpose from the right.} !> \end{array} !> \f] !> !> Q is defined as the product of ``k`` Householder reflectors !> !> \f[ !> Q = H(1)H(2)\cdots H(k) !> \f] !> !> of order ``m`` if applying from the left, or ``n`` if applying from the right. Q is never !> stored. It is !> calculated from the Householder vectors and scalars returned by the QR factorization \ref !> rocsolver_sgeqrf "GEQRF". !> !> @param[in] handle - rocblas_handle. !> @param[in] side - rocblas_side. !> Specifies from which side to apply Q. !> @param[in] trans - rocblas_operation. !> Specifies whether the matrix Q or its conjugate transpose is to be applied. !> @param[in] m - rocblas_int. m >= 0. !> Number of rows of matrix C. !> @param[in] n - rocblas_int. n >= 0. !> Number of columns of matrix C. !> @param[in] k - rocblas_int. k >= 0. k <= m if side is left, and k <= n if side is right. !> The number of Householder reflectors that form Q. !> @param[in] A - pointer to type. Array on the GPU of size lda*k. !> The Householder vectors as returned by \ref rocsolver_sgeqrf "GEQRF" !> in the first k columns of its argument A. !> @param[in] lda - rocblas_int. lda >= m if side is left, or lda >= n if side is right. !> Leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgeqrf "GEQRF". !> @param[inout] C - pointer to type. Array on the GPU of size ldc*n. !> On entry, the matrix C. On exit, it is overwritten with !> \f$QC\f$, \f$CQ\f$, \f$Q^H C\f$, or \f$CQ^H\f$. !> @param[in] ldc - rocblas_int. ldc >= m. !> Leading dimension of C. interface rocsolver_cunm2r function rocsolver_cunm2r_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_cunm2r") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunm2r_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cunm2r_assumed_rank #else module procedure & rocsolver_cunm2r_rank_0,& rocsolver_cunm2r_rank_1,& rocsolver_cunm2r_full_rank #endif #endif end interface interface rocsolver_zunm2r function rocsolver_zunm2r_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_zunm2r") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunm2r_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zunm2r_assumed_rank #else module procedure & rocsolver_zunm2r_rank_0,& rocsolver_zunm2r_rank_1,& rocsolver_zunm2r_full_rank #endif #endif end interface !> \brief The ORMQR functions multiply a matrix Q with orthonormal columns by a general ``m`` !> -by-``n`` !> matrix ``C``. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The matrix Q is applied in one of the following forms, depending on !> the values of side and trans: !> !> \f[ !> \begin{array}{cl} !> QC & \: \text{No transpose from the left,}\\% !> Q^TC & \: \text{Transpose from the left,}\\% !> CQ & \: \text{No transpose from the right, and}\\% !> CQ^T & \: \text{Transpose from the right.} !> \end{array} !> \f] !> !> Q is defined as the product of ``k`` Householder reflectors !> !> \f[ !> Q = H(1)H(2)\cdots H(k) !> \f] !> !> of order ``m`` if applying from the left, or ``n`` if applying from the right. Q is never !> stored. It is !> calculated from the Householder vectors and scalars returned by the QR factorization \ref !> rocsolver_sgeqrf "GEQRF". !> !> @param[in] handle - rocblas_handle. !> @param[in] side - rocblas_side. !> Specifies from which side to apply Q. !> @param[in] trans - rocblas_operation. !> Specifies whether the matrix Q or its transpose is to be applied. !> @param[in] m - rocblas_int. m >= 0. !> Number of rows of matrix C. !> @param[in] n - rocblas_int. n >= 0. !> Number of columns of matrix C. !> @param[in] k - rocblas_int. k >= 0. k <= m if side is left, and k <= n if side is right. !> The number of Householder reflectors that form Q. !> @param[in] A - pointer to type. Array on the GPU of size lda*k. !> The Householder vectors as returned by \ref rocsolver_sgeqrf "GEQRF" !> in the first k columns of its argument A. !> @param[in] lda - rocblas_int. lda >= m if side is left, or lda >= n if side is right. !> Leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgeqrf "GEQRF". !> @param[inout] C - pointer to type. Array on the GPU of size ldc*n. !> On entry, the matrix C. On exit, it is overwritten with !> \f$QC\f$, \f$CQ\f$, \f$Q^TC\f$, or \f$CQ^T\f$. !> @param[in] ldc - rocblas_int. ldc >= m. !> Leading dimension of C. interface rocsolver_sormqr function rocsolver_sormqr_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_sormqr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormqr_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sormqr_assumed_rank #else module procedure & rocsolver_sormqr_rank_0,& rocsolver_sormqr_rank_1,& rocsolver_sormqr_full_rank #endif #endif end interface interface rocsolver_dormqr function rocsolver_dormqr_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_dormqr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormqr_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dormqr_assumed_rank #else module procedure & rocsolver_dormqr_rank_0,& rocsolver_dormqr_rank_1,& rocsolver_dormqr_full_rank #endif #endif end interface !> \brief The UNMQR functions multiply a complex matrix Q with orthonormal columns by a !> general ``m``-by-``n`` matrix ``C``. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The matrix Q is applied in one of the following forms, depending on !> the values of ``side`` and ``trans``: !> !> \f[ !> \begin{array}{cl} !> QC & \: \text{No transpose from the left,}\\% !> Q^H C & \: \text{Conjugate transpose from the left,}\\% !> CQ & \: \text{No transpose from the right, and}\\% !> CQ^H & \: \text{Conjugate transpose from the right.} !> \end{array} !> \f] !> !> Q is defined as the product of ``k`` Householder reflectors !> !> \f[ !> Q = H(1)H(2)\cdots H(k) !> \f] !> !> of order ``m`` if applying from the left or ``n`` if applying from the right. Q is never !> stored. It is !> calculated from the Householder vectors and scalars returned by the QR factorization \ref !> rocsolver_sgeqrf "GEQRF". !> !> @param[in] handle - rocblas_handle. !> @param[in] side - rocblas_side. !> Specifies from which side to apply Q. !> @param[in] trans - rocblas_operation. !> Specifies whether the matrix Q or its conjugate transpose is to be applied. !> @param[in] m - rocblas_int. m >= 0. !> Number of rows of matrix C. !> @param[in] n - rocblas_int. n >= 0. !> Number of columns of matrix C. !> @param[in] k - rocblas_int. k >= 0. k <= m if side is left, and k <= n if side is right. !> The number of Householder reflectors that form Q. !> @param[in] A - pointer to type. Array on the GPU of size lda*k. !> The Householder vectors as returned by \ref rocsolver_sgeqrf "GEQRF" !> in the first k columns of its argument A. !> @param[in] lda - rocblas_int. lda >= m if side is left, or lda >= n if side is right. !> Leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgeqrf "GEQRF". !> @param[inout] C - pointer to type. Array on the GPU of size ldc*n. !> On entry, the matrix C. On exit, it is overwritten with !> \f$QC\f$, \f$CQ\f$, \f$Q^H C\f$, or \f$CQ^H\f$. !> @param[in] ldc - rocblas_int. ldc >= m. !> Leading dimension of C. interface rocsolver_cunmqr function rocsolver_cunmqr_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_cunmqr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmqr_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cunmqr_assumed_rank #else module procedure & rocsolver_cunmqr_rank_0,& rocsolver_cunmqr_rank_1,& rocsolver_cunmqr_full_rank #endif #endif end interface interface rocsolver_zunmqr function rocsolver_zunmqr_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_zunmqr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmqr_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zunmqr_assumed_rank #else module procedure & rocsolver_zunmqr_rank_0,& rocsolver_zunmqr_rank_1,& rocsolver_zunmqr_full_rank #endif #endif end interface !> \brief The ORML2 functions multiply a matrix Q with orthonormal rows by a general ``m`` !> -by-``n`` !> matrix ``C``. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The matrix Q is applied in one of the following forms, depending on !> the values of ``side`` and ``trans``: !> !> \f[ !> \begin{array}{cl} !> QC & \: \text{No transpose from the left,}\\% !> Q^TC & \: \text{Transpose from the left,}\\% !> CQ & \: \text{No transpose from the right, and}\\% !> CQ^T & \: \text{Transpose from the right.} !> \end{array} !> \f] !> !> Q is defined as the product of ``k`` Householder reflectors !> !> \f[ !> Q = H(k)H(k-1)\cdots H(1) !> \f] !> !> of order ``m`` if applying from the left, or ``n`` if applying from the right. Q is never !> stored. It is !> calculated from the Householder vectors and scalars returned by the LQ factorization \ref !> rocsolver_sgelqf "GELQF". !> !> @param[in] handle - rocblas_handle. !> @param[in] side - rocblas_side. !> Specifies from which side to apply Q. !> @param[in] trans - rocblas_operation. !> Specifies whether the matrix Q or its transpose is to be applied. !> @param[in] m - rocblas_int. m >= 0. !> Number of rows of matrix C. !> @param[in] n - rocblas_int. n >= 0. !> Number of columns of matrix C. !> @param[in] k - rocblas_int. k >= 0. k <= m if side is left, and k <= n if side is right. !> The number of Householder reflectors that form Q. !> @param[in] A - pointer to type. Array on the GPU of size lda*m if side is left, or lda*n if !> side is right. !> The Householder vectors as returned by \ref rocsolver_sgelqf "GELQF" !> in the first k rows of its argument A. !> @param[in] lda - rocblas_int. lda >= k. !> Leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgelqf "GELQF". !> @param[inout] C - pointer to type. Array on the GPU of size ldc*n. !> On entry, the matrix C. On exit, it is overwritten with !> \f$QC\f$, \f$CQ\f$, \f$Q^TC\f$, or \f$CQ^T\f$. !> @param[in] ldc - rocblas_int. ldc >= m. !> Leading dimension of C. interface rocsolver_sorml2 function rocsolver_sorml2_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_sorml2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorml2_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sorml2_assumed_rank #else module procedure & rocsolver_sorml2_rank_0,& rocsolver_sorml2_rank_1,& rocsolver_sorml2_full_rank #endif #endif end interface interface rocsolver_dorml2 function rocsolver_dorml2_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_dorml2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorml2_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dorml2_assumed_rank #else module procedure & rocsolver_dorml2_rank_0,& rocsolver_dorml2_rank_1,& rocsolver_dorml2_full_rank #endif #endif end interface !> \brief The UNML2 functions multiply a complex matrix Q with orthonormal rows by a general !> ``m``-by-``n`` matrix ``C``. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The matrix Q is applied in one of the following forms, depending on !> the values of ``side`` and ``trans``: !> !> \f[ !> \begin{array}{cl} !> QC & \: \text{No transpose from the left,}\\% !> Q^H C & \: \text{Conjugate transpose from the left,}\\% !> CQ & \: \text{No transpose from the right, and}\\% !> CQ^H & \: \text{Conjugate transpose from the right.} !> \end{array} !> \f] !> !> Q is defined as the product of ``k`` Householder reflectors !> !> \f[ !> Q = H(k)^H H(k-1)^H\cdots H(1)^H !> \f] !> !> of order ``m`` if applying from the left, or ``n`` if applying from the right. Q is never !> stored. It is !> calculated from the Householder vectors and scalars returned by the LQ factorization \ref !> rocsolver_sgelqf "GELQF". !> !> @param[in] handle - rocblas_handle. !> @param[in] side - rocblas_side. !> Specifies from which side to apply Q. !> @param[in] trans - rocblas_operation. !> Specifies whether the matrix Q or its conjugate transpose is to be applied. !> @param[in] m - rocblas_int. m >= 0. !> Number of rows of matrix C. !> @param[in] n - rocblas_int. n >= 0. !> Number of columns of matrix C. !> @param[in] k - rocblas_int. k >= 0. k <= m if side is left, and k <= n if side is right. !> The number of Householder reflectors that form Q. !> @param[in] A - pointer to type. Array on the GPU of size lda*m if side is left or lda*n if !> side is right. !> The Householder vectors as returned by \ref rocsolver_sgelqf "GELQF" !> in the first k rows of its argument A. !> @param[in] lda - rocblas_int. lda >= k. !> Leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgelqf "GELQF". !> @param[inout] C - pointer to type. Array on the GPU of size ldc*n. !> On entry, the matrix C. On exit, it is overwritten with !> \f$QC\f$, \f$CQ\f$, \f$Q^H C\f$, or \f$CQ^H\f$. !> @param[in] ldc - rocblas_int. ldc >= m. !> Leading dimension of C. interface rocsolver_cunml2 function rocsolver_cunml2_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_cunml2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunml2_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cunml2_assumed_rank #else module procedure & rocsolver_cunml2_rank_0,& rocsolver_cunml2_rank_1,& rocsolver_cunml2_full_rank #endif #endif end interface interface rocsolver_zunml2 function rocsolver_zunml2_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_zunml2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunml2_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zunml2_assumed_rank #else module procedure & rocsolver_zunml2_rank_0,& rocsolver_zunml2_rank_1,& rocsolver_zunml2_full_rank #endif #endif end interface !> \brief The ORMLQ functions multiply a matrix Q with orthonormal rows by a general ``m`` !> -by-``n`` !> matrix ``C``. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The matrix Q is applied in one of the following forms, depending on !> the values of ``side`` and ``trans``: !> !> \f[ !> \begin{array}{cl} !> QC & \: \text{No transpose from the left,}\\% !> Q^TC & \: \text{Transpose from the left,}\\% !> CQ & \: \text{No transpose from the right, and}\\% !> CQ^T & \: \text{Transpose from the right.} !> \end{array} !> \f] !> !> Q is defined as the product of ``k`` Householder reflectors !> !> \f[ !> Q = H(k)H(k-1)\cdots H(1) !> \f] !> !> of order ``m`` if applying from the left, or ``n`` if applying from the right. Q is never !> stored. It is !> calculated from the Householder vectors and scalars returned by the LQ factorization \ref !> rocsolver_sgelqf "GELQF". !> !> @param[in] handle - rocblas_handle. !> @param[in] side - rocblas_side. !> Specifies from which side to apply Q. !> @param[in] trans - rocblas_operation. !> Specifies whether the matrix Q or its transpose is to be applied. !> @param[in] m - rocblas_int. m >= 0. !> Number of rows of matrix C. !> @param[in] n - rocblas_int. n >= 0. !> Number of columns of matrix C. !> @param[in] k - rocblas_int. k >= 0. k <= m if side is left, and k <= n if side is right. !> The number of Householder reflectors that form Q. !> @param[in] A - pointer to type. Array on the GPU of size lda*m if side is left, or lda*n if !> side is right. !> The Householder vectors as returned by \ref rocsolver_sgelqf "GELQF" !> in the first k rows of its argument A. !> @param[in] lda - rocblas_int. lda >= k. !> Leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgelqf "GELQF". !> @param[inout] C - pointer to type. Array on the GPU of size ldc*n. !> On entry, the matrix C. On exit, it is overwritten with !> \f$QC\f$, \f$CQ\f$, \f$Q^TC\f$, or \f$CQ^T\f$. !> @param[in] ldc - rocblas_int. ldc >= m. !> Leading dimension of C. interface rocsolver_sormlq function rocsolver_sormlq_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_sormlq") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormlq_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sormlq_assumed_rank #else module procedure & rocsolver_sormlq_rank_0,& rocsolver_sormlq_rank_1,& rocsolver_sormlq_full_rank #endif #endif end interface interface rocsolver_dormlq function rocsolver_dormlq_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_dormlq") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormlq_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dormlq_assumed_rank #else module procedure & rocsolver_dormlq_rank_0,& rocsolver_dormlq_rank_1,& rocsolver_dormlq_full_rank #endif #endif end interface !> \brief The UNMLQ functions multiply a complex matrix Q with orthonormal rows by a general !> ``m``-by-``n`` matrix ``C``. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The matrix Q is applied in one of the following forms, depending on !> the values of ``side`` and ``trans``: !> !> \f[ !> \begin{array}{cl} !> QC & \: \text{No transpose from the left,}\\% !> Q^H C & \: \text{Conjugate transpose from the left,}\\% !> CQ & \: \text{No transpose from the right, and}\\% !> CQ^H & \: \text{Conjugate transpose from the right.} !> \end{array} !> \f] !> !> Q is defined as the product of ``k`` Householder reflectors !> !> \f[ !> Q = H(k)^H H(k-1)^H\cdots H(1)^H !> \f] !> !> of order ``m`` if applying from the left, or ``n`` if applying from the right. Q is never !> stored. It is !> calculated from the Householder vectors and scalars returned by the LQ factorization \ref !> rocsolver_sgelqf "GELQF". !> !> @param[in] handle - rocblas_handle. !> @param[in] side - rocblas_side. !> Specifies from which side to apply Q. !> @param[in] trans - rocblas_operation. !> Specifies whether the matrix Q or its conjugate transpose is to be applied. !> @param[in] m - rocblas_int. m >= 0. !> Number of rows of matrix C. !> @param[in] n - rocblas_int. n >= 0. !> Number of columns of matrix C. !> @param[in] k - rocblas_int. k >= 0. k <= m if side is left, and k <= n if side is right. !> The number of Householder reflectors that form Q. !> @param[in] A - pointer to type. Array on the GPU of size lda*m if side is left or lda*n if !> side is right. !> The Householder vectors as returned by \ref rocsolver_sgelqf "GELQF" !> in the first k rows of its argument A. !> @param[in] lda - rocblas_int. lda >= k. !> Leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by \ref rocsolver_sgelqf "GELQF". !> @param[inout] C - pointer to type. Array on the GPU of size ldc*n. !> On entry, the matrix C. On exit, it is overwritten with !> \f$QC\f$, \f$CQ\f$, \f$Q^H C\f$, or \f$CQ^H\f$. !> @param[in] ldc - rocblas_int. ldc >= m. !> Leading dimension of C. interface rocsolver_cunmlq function rocsolver_cunmlq_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_cunmlq") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmlq_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cunmlq_assumed_rank #else module procedure & rocsolver_cunmlq_rank_0,& rocsolver_cunmlq_rank_1,& rocsolver_cunmlq_full_rank #endif #endif end interface interface rocsolver_zunmlq function rocsolver_zunmlq_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_zunmlq") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmlq_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zunmlq_assumed_rank #else module procedure & rocsolver_zunmlq_rank_0,& rocsolver_zunmlq_rank_1,& rocsolver_zunmlq_full_rank #endif #endif end interface !> \brief The ORM2L functions multiply a matrix Q with orthonormal columns by a general ``m`` !> -by-``n`` !> matrix ``C``. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The matrix Q is applied in one of the following forms, depending on !> the values of ``side`` and ``trans``: !> !> \f[ !> \begin{array}{cl} !> QC & \: \text{No transpose from the left,}\\% !> Q^TC & \: \text{Transpose from the left,}\\% !> CQ & \: \text{No transpose from the right, and}\\% !> CQ^T & \: \text{Transpose from the right.} !> \end{array} !> \f] !> !> Q is defined as the product of ``k`` Householder reflectors !> !> \f[ !> Q = H(k)H(k-1)\cdots H(1) !> \f] !> !> of order ``m`` if applying from the left, or ``n`` if applying from the right. Q is !> never stored. It is calculated from the Householder vectors and scalars !> returned by the QL factorization \ref rocsolver_sgeqlf "GEQLF". !> !> @param[in] handle - rocblas_handle. !> @param[in] side - rocblas_side. !> Specifies from which side to apply Q. !> @param[in] trans - rocblas_operation. !> Specifies whether the matrix Q or its transpose is to be !> applied. !> @param[in] m - rocblas_int. m >= 0. !> Number of rows of matrix C. !> @param[in] n - rocblas_int. n >= 0. !> Number of columns of matrix C. !> @param[in] k - rocblas_int. k >= 0. k <= m if side is left, and k <= n if side is right. !> The number of Householder reflectors that form Q. !> @param[in] A - pointer to type. Array on the GPU of size lda*k. !> The Householder vectors as returned by \ref rocsolver_sgeqlf "GEQLF" in the !> last k columns of its !> argument A. !> @param[in] lda - rocblas_int. lda >= m if side is left, and lda >= n if side is right. !> Leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by !> \ref rocsolver_sgeqlf "GEQLF". !> @param[inout] C - pointer to type. Array on the GPU of size ldc*n. !> On entry, the matrix C. On exit, it is overwritten with !> \f$QC\f$, \f$CQ\f$, \f$Q^TC\f$, or \f$CQ^T\f$. !> @param[in] ldc - rocblas_int. ldc >= m. !> Leading dimension of C. interface rocsolver_sorm2l function rocsolver_sorm2l_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_sorm2l") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorm2l_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sorm2l_assumed_rank #else module procedure & rocsolver_sorm2l_rank_0,& rocsolver_sorm2l_rank_1,& rocsolver_sorm2l_full_rank #endif #endif end interface interface rocsolver_dorm2l function rocsolver_dorm2l_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_dorm2l") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorm2l_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dorm2l_assumed_rank #else module procedure & rocsolver_dorm2l_rank_0,& rocsolver_dorm2l_rank_1,& rocsolver_dorm2l_full_rank #endif #endif end interface !> \brief The UNM2L functions multiply a complex matrix Q with orthonormal columns by a !> general ``m``-by-``n`` matrix ``C``. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The matrix Q is applied in one of the following forms, depending on !> the values of ``side`` and ``trans``: !> !> \f[ !> \begin{array}{cl} !> QC & \: \text{No transpose from the left,}\\% !> Q^H C & \: \text{Conjugate transpose from the left,}\\% !> CQ & \: \text{No transpose from the right, and}\\% !> CQ^H & \: \text{Conjugate transpose from the right.} !> \end{array} !> \f] !> !> Q is defined as the product of ``k`` Householder reflectors !> !> \f[ !> Q = H(k)H(k-1)\cdots H(1) !> \f] !> !> of order ``m`` if applying from the left, or ``n`` if applying from the right. Q is !> never stored. It is calculated from the Householder vectors and scalars !> returned by the QL factorization \ref rocsolver_sgeqlf "GEQLF". !> !> @param[in] handle - rocblas_handle. !> @param[in] side - rocblas_side. !> Specifies from which side to apply Q. !> @param[in] trans - rocblas_operation. !> Specifies whether the matrix Q or its conjugate !> transpose is to be applied. !> @param[in] m - rocblas_int. m >= 0. !> Number of rows of matrix C. !> @param[in] n - rocblas_int. n >= 0. !> Number of columns of matrix C. !> @param[in] k - rocblas_int. k >= 0. k <= m if side is left, and k <= n if side is right. !> The number of Householder reflectors that form Q. !> @param[in] A - pointer to type. Array on the GPU of size lda*k. !> The Householder vectors as returned by \ref rocsolver_sgeqlf "GEQLF" in the !> last k columns of its !> argument A. !> @param[in] lda - rocblas_int. lda >= m if side is left, and lda >= n if side is right. !> Leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by !> \ref rocsolver_sgeqlf "GEQLF". !> @param[inout] C - pointer to type. Array on the GPU of size ldc*n. !> On entry, the matrix C. On exit, it is overwritten with !> \f$QC\f$, \f$CQ\f$, \f$Q^HC\f$, or \f$CQ^H\f$. !> @param[in] ldc - rocblas_int. ldc >= m. !> Leading dimension of C. interface rocsolver_cunm2l function rocsolver_cunm2l_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_cunm2l") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunm2l_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cunm2l_assumed_rank #else module procedure & rocsolver_cunm2l_rank_0,& rocsolver_cunm2l_rank_1,& rocsolver_cunm2l_full_rank #endif #endif end interface interface rocsolver_zunm2l function rocsolver_zunm2l_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_zunm2l") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunm2l_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zunm2l_assumed_rank #else module procedure & rocsolver_zunm2l_rank_0,& rocsolver_zunm2l_rank_1,& rocsolver_zunm2l_full_rank #endif #endif end interface !> \brief The ORMQL functions multiply a matrix Q with orthonormal columns by a general ``m`` !> -by-``n`` !> matrix ``C``. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The matrix Q is applied in one of the following forms, depending on !> the values of ``side`` and ``trans``: !> !> \f[ !> \begin{array}{cl} !> QC & \: \text{No transpose from the left,}\\% !> Q^TC & \: \text{Transpose from the left,}\\% !> CQ & \: \text{No transpose from the right, and}\\% !> CQ^T & \: \text{Transpose from the right.} !> \end{array} !> \f] !> !> Q is defined as the product of ``k`` Householder reflectors !> !> \f[ !> Q = H(k)H(k-1)\cdots H(1) !> \f] !> !> of order ``m`` if applying from the left, or ``n`` if applying from the right. Q is !> never stored. It is calculated from the Householder vectors and scalars !> returned by the QL factorization \ref rocsolver_sgeqlf "GEQLF". !> !> @param[in] handle - rocblas_handle. !> @param[in] side - rocblas_side. !> Specifies from which side to apply Q. !> @param[in] trans - rocblas_operation. !> Specifies whether the matrix Q or its transpose is to be !> applied. !> @param[in] m - rocblas_int. m >= 0. !> Number of rows of matrix C. !> @param[in] n - rocblas_int. n >= 0. !> Number of columns of matrix C. !> @param[in] k - rocblas_int. k >= 0. k <= m if side is left, and k <= n if side is right. !> The number of Householder reflectors that form Q. !> @param[in] A - pointer to type. Array on the GPU of size lda*k. !> The Householder vectors as returned by \ref rocsolver_sgeqlf "GEQLF" in the !> last k columns of its !> argument A. !> @param[in] lda - rocblas_int. lda >= m if side is left, and lda >= n if side is right. !> Leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by !> \ref rocsolver_sgeqlf "GEQLF". !> @param[inout] C - pointer to type. Array on the GPU of size ldc*n. !> On entry, the matrix C. On exit, it is overwritten with !> \f$QC\f$, \f$CQ\f$, \f$Q^TC\f$, or \f$CQ^T\f$. !> @param[in] ldc - rocblas_int. ldc >= m. !> Leading dimension of C. interface rocsolver_sormql function rocsolver_sormql_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_sormql") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormql_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sormql_assumed_rank #else module procedure & rocsolver_sormql_rank_0,& rocsolver_sormql_rank_1,& rocsolver_sormql_full_rank #endif #endif end interface interface rocsolver_dormql function rocsolver_dormql_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_dormql") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormql_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dormql_assumed_rank #else module procedure & rocsolver_dormql_rank_0,& rocsolver_dormql_rank_1,& rocsolver_dormql_full_rank #endif #endif end interface !> \brief The UNMQL functions multiply a complex matrix Q with orthonormal columns by a !> general ``m``-by-``n`` matrix ``C``. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The matrix Q is applied in one of the following forms, depending on !> the values of ``side`` and ``trans``: !> !> \f[ !> \begin{array}{cl} !> QC & \: \text{No transpose from the left,}\\% !> Q^H C & \: \text{Conjugate transpose from the left,}\\% !> CQ & \: \text{No transpose from the right, and}\\% !> CQ^H & \: \text{Conjugate transpose from the right.} !> \end{array} !> \f] !> !> Q is defined as the product of ``k`` Householder reflectors !> !> \f[ !> Q = H(k)H(k-1)\cdots H(1) !> \f] !> !> of order ``m`` if applying from the left, or ``n`` if applying from the right. Q is !> never stored. It is calculated from the Householder vectors and scalars !> returned by the QL factorization \ref rocsolver_sgeqlf "GEQLF". !> !> @param[in] handle - rocblas_handle. !> @param[in] side - rocblas_side. !> Specifies from which side to apply Q. !> @param[in] trans - rocblas_operation. !> Specifies whether the matrix Q or its conjugate !> transpose is to be applied. !> @param[in] m - rocblas_int. m >= 0. !> Number of rows of matrix C. !> @param[in] n - rocblas_int. n >= 0. !> Number of columns of matrix C. !> @param[in] k - rocblas_int. k >= 0. k <= m if side is left, and k <= n if side is right. !> The number of Householder reflectors that form Q. !> @param[in] A - pointer to type. Array on the GPU of size lda*k. !> The Householder vectors as returned by \ref rocsolver_sgeqlf "GEQLF" in the !> last k columns of its !> argument A. !> @param[in] lda - rocblas_int. lda >= m if side is left, and lda >= n if side is right. !> Leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least k. !> The Householder scalars as returned by !> \ref rocsolver_sgeqlf "GEQLF". !> @param[inout] C - pointer to type. Array on the GPU of size ldc*n. !> On entry, the matrix C. On exit, it is overwritten with !> \f$QC\f$, \f$CQ\f$, \f$Q^HC\f$, or \f$CQ^H\f$. !> @param[in] ldc - rocblas_int. ldc >= m. !> Leading dimension of C. interface rocsolver_cunmql function rocsolver_cunmql_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_cunmql") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmql_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cunmql_assumed_rank #else module procedure & rocsolver_cunmql_rank_0,& rocsolver_cunmql_rank_1,& rocsolver_cunmql_full_rank #endif #endif end interface interface rocsolver_zunmql function rocsolver_zunmql_(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_zunmql") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmql_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zunmql_assumed_rank #else module procedure & rocsolver_zunmql_rank_0,& rocsolver_zunmql_rank_1,& rocsolver_zunmql_full_rank #endif #endif end interface !> \brief The ORMBR functions multiply a matrix Q with orthonormal rows or columns by a !> general ``m``-by-``n`` matrix ``C``. !> !> \details !> If ``storev`` is column-wise, then the matrix Q has orthonormal columns. !> If ``storev`` is row-wise, then the matrix Q has orthonormal rows. !> The matrix Q is applied in one of the following forms, depending on !> the values of ``side`` and ``trans``: !> !> \f[ !> \begin{array}{cl} !> QC & \: \text{No transpose from the left,}\\% !> Q^TC & \: \text{Transpose from the left,}\\% !> CQ & \: \text{No transpose from the right, and}\\% !> CQ^T & \: \text{Transpose from the right.} !> \end{array} !> \f] !> !> The order q of the orthogonal matrix Q is q = ``m`` if applying from the left or q = ``n`` !> if applying from the right. !> !> When ``storev`` is column-wise, if q >= ``k``, then Q is defined as the product of ``k`` !> Householder reflectors !> !> \f[ !> Q = H(1)H(2)\cdots H(k), !> \f] !> !> and if q < ``k``, then Q is defined as the product !> !> \f[ !> Q = H(1)H(2)\cdots H(q-1). !> \f] !> !> When ``storev`` is row-wise, if q > ``k``, then Q is defined as the product of ``k`` !> Householder reflectors !> !> \f[ !> Q = H(1)H(2)\cdots H(k), !> \f] !> !> and if q <= ``k``, Q is defined as the product !> !> \f[ !> Q = H(1)H(2)\cdots H(q-1). !> \f] !> !> The Householder matrices \f$H(i)\f$ are never stored. They are computed from its !> corresponding !> Householder vectors and scalars as returned by \ref rocsolver_sgebrd "GEBRD" in its !> arguments ``A`` and tauq or taup. !> !> @param[in] handle - rocblas_handle. !> @param[in] storev - `rocblas_storev`. !> Specifies whether to work column-wise or row-wise. !> @param[in] side - rocblas_side. !> Specifies from which side to apply Q. !> @param[in] trans - rocblas_operation. !> Specifies whether the matrix Q or its transpose is to be applied. !> @param[in] m - rocblas_int. m >= 0. !> Number of rows of matrix C. !> @param[in] n - rocblas_int. n >= 0. !> Number of columns of matrix C. !> @param[in] k - rocblas_int. k >= 0. !> The number of columns (if storev is column-wise) or rows (if row-wise) of the !> original matrix reduced by \ref rocsolver_sgebrd "GEBRD". !> @param[in] A - pointer to type. Array on the GPU of size lda*min(q,k) if column-wise, or !> lda*q if row-wise. !> The Householder vectors as returned by \ref rocsolver_sgebrd "GEBRD". !> @param[in] lda - rocblas_int. lda >= q if column-wise, or lda >= min(q,k) if row-wise. !> Leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least min(q,k). !> The Householder scalars as returned by \ref rocsolver_sgebrd "GEBRD". !> @param[inout] C - pointer to type. Array on the GPU of size ldc*n. !> On entry, the matrix C. On exit, it is overwritten with !> \f$QC\f$, \f$CQ\f$, \f$Q^TC\f$, or \f$CQ^T\f$. !> @param[in] ldc - rocblas_int. ldc >= m. !> Leading dimension of C. interface rocsolver_sormbr function rocsolver_sormbr_(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_sormbr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormbr_ type(c_ptr),value :: handle integer(kind(rocblas_column_wise)),value :: storev integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sormbr_assumed_rank #else module procedure & rocsolver_sormbr_rank_0,& rocsolver_sormbr_rank_1,& rocsolver_sormbr_full_rank #endif #endif end interface interface rocsolver_dormbr function rocsolver_dormbr_(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_dormbr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormbr_ type(c_ptr),value :: handle integer(kind(rocblas_column_wise)),value :: storev integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dormbr_assumed_rank #else module procedure & rocsolver_dormbr_rank_0,& rocsolver_dormbr_rank_1,& rocsolver_dormbr_full_rank #endif #endif end interface !> \brief The UNMBR functions multiply a complex matrix Q with orthonormal rows or columns by !> a general ``m``-by-``n`` matrix ``C``. !> !> \details !> If storev is column-wise, then the matrix Q has orthonormal columns. !> If storev is row-wise, then the matrix Q has orthonormal rows. !> The matrix Q is applied in one of the following forms, depending on !> the values of ``side`` and ``trans``: !> !> \f[ !> \begin{array}{cl} !> QC & \: \text{No transpose from the left,}\\% !> Q^H C & \: \text{Conjugate transpose from the left,}\\% !> CQ & \: \text{No transpose from the right, and}\\% !> CQ^H & \: \text{Conjugate transpose from the right.} !> \end{array} !> \f] !> !> The order q of the unitary matrix Q is q = ``m`` if applying from the left, or q = ``n`` if !> applying from the right. !> !> When storev is column-wise, if q >= ``k``, then Q is defined as the product of ``k`` !> Householder reflectors !> !> \f[ !> Q = H(1)H(2)\cdots H(k), !> \f] !> !> and if q < ``k``, then Q is defined as the product !> !> \f[ !> Q = H(1)H(2)\cdots H(q-1). !> \f] !> !> When storev is row-wise, if q > ``k``, then Q is defined as the product of ``k`` !> Householder reflectors !> !> \f[ !> Q = H(1)H(2)\cdots H(k), !> \f] !> !> and if q <= ``k``, Q is defined as the product !> !> \f[ !> Q = H(1)H(2)\cdots H(q-1). !> \f] !> !> The Householder matrices \f$H(i)\f$ are never stored. They are computed from their !> corresponding !> Householder vectors and scalars as returned by \ref rocsolver_sgebrd "GEBRD" in its !> arguments ``A`` and tauq or taup. !> !> @param[in] handle - rocblas_handle. !> @param[in] storev - `rocblas_storev`. !> Specifies whether to work column-wise or row-wise. !> @param[in] side - rocblas_side. !> Specifies from which side to apply Q. !> @param[in] trans - rocblas_operation. !> Specifies whether the matrix Q or its conjugate transpose is to be applied. !> @param[in] m - rocblas_int. m >= 0. !> Number of rows of matrix C. !> @param[in] n - rocblas_int. n >= 0. !> Number of columns of matrix C. !> @param[in] k - rocblas_int. k >= 0. !> The number of columns (if storev is column-wise) or rows (if row-wise) of the !> original matrix reduced by \ref rocsolver_sgebrd "GEBRD". !> @param[in] A - pointer to type. Array on the GPU of size lda*min(q,k) if column-wise, or !> lda*q if row-wise. !> The Householder vectors as returned by \ref rocsolver_sgebrd "GEBRD". !> @param[in] lda - rocblas_int. lda >= q if column-wise, or lda >= min(q,k) if row-wise. !> Leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least min(q,k). !> The Householder scalars as returned by \ref rocsolver_sgebrd "GEBRD". !> @param[inout] C - pointer to type. Array on the GPU of size ldc*n. !> On entry, the matrix C. On exit, it is overwritten with !> \f$QC\f$, \f$CQ\f$, \f$Q^H C\f$, or \f$CQ^H\f$. !> @param[in] ldc - rocblas_int. ldc >= m. !> Leading dimension of C. interface rocsolver_cunmbr function rocsolver_cunmbr_(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_cunmbr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmbr_ type(c_ptr),value :: handle integer(kind(rocblas_column_wise)),value :: storev integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cunmbr_assumed_rank #else module procedure & rocsolver_cunmbr_rank_0,& rocsolver_cunmbr_rank_1,& rocsolver_cunmbr_full_rank #endif #endif end interface interface rocsolver_zunmbr function rocsolver_zunmbr_(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_zunmbr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmbr_ type(c_ptr),value :: handle integer(kind(rocblas_column_wise)),value :: storev integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zunmbr_assumed_rank #else module procedure & rocsolver_zunmbr_rank_0,& rocsolver_zunmbr_rank_1,& rocsolver_zunmbr_full_rank #endif #endif end interface !> \brief The ORMTR functions multiply an orthogonal matrix Q by a general ``m`` -by-``n`` !> matrix ``C``. !> !> \details !> The matrix Q is applied in one of the following forms, depending on !> the values of ``side`` and ``trans``: !> !> \f[ !> \begin{array}{cl} !> QC & \: \text{No transpose from the left,}\\% !> Q^TC & \: \text{Transpose from the left,}\\% !> CQ & \: \text{No transpose from the right, and}\\% !> CQ^T & \: \text{Transpose from the right.} !> \end{array} !> \f] !> !> The order q of the orthogonal matrix Q is q = ``m`` if applying from the left, or !> q = ``n`` if applying from the right. !> !> Q is defined as a product of q-1 Householder reflectors. If !> ``uplo`` indicates ``upper``, then Q has the form !> !> \f[ !> Q = H(q-1)H(q-2)\cdots H(1). !> \f] !> !> However, if ``uplo`` indicates ``lower``, then Q has the form !> !> \f[ !> Q = H(1)H(2)\cdots H(q-1) !> \f] !> !> The Householder matrices \f$H(i)\f$ are never stored. They are computed from their !> corresponding Householder vectors and scalars as returned by !> \ref rocsolver_ssytrd "SYTRD" in its arguments ``A`` and tau. !> !> @param[in] handle - rocblas_handle. !> @param[in] side - rocblas_side. !> Specifies from which side to apply Q. !> @param[in] uplo - rocblas_fill. !> Specifies whether the \ref rocsolver_ssytrd "SYTRD" factorization was upper or !> lower triangular. If uplo indicates lower (or upper), then the upper (or !> lower) part of A is not used. !> @param[in] trans - rocblas_operation. !> Specifies whether the matrix Q or its transpose is to be !> applied. !> @param[in] m - rocblas_int. m >= 0. !> Number of rows of matrix C. !> @param[in] n - rocblas_int. n >= 0. !> Number of columns of matrix C. !> @param[in] A - pointer to type. Array on the GPU of size lda*q. !> On entry, the Householder vectors as !> returned by \ref rocsolver_ssytrd "SYTRD". !> @param[in] lda - rocblas_int. lda >= q. !> Leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least q-1. !> The Householder scalars as returned by !> \ref rocsolver_ssytrd "SYTRD". !> @param[inout] C - pointer to type. Array on the GPU of size ldc*n. !> On entry, the matrix C. On exit, it is overwritten with !> \f$QC\f$, \f$CQ\f$, \f$Q^TC\f$, or \f$CQ^T\f$. !> @param[in] ldc - rocblas_int. ldc >= m. !> Leading dimension of C. interface rocsolver_sormtr function rocsolver_sormtr_(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_sormtr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormtr_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sormtr_assumed_rank #else module procedure & rocsolver_sormtr_rank_0,& rocsolver_sormtr_rank_1,& rocsolver_sormtr_full_rank #endif #endif end interface interface rocsolver_dormtr function rocsolver_dormtr_(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_dormtr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormtr_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dormtr_assumed_rank #else module procedure & rocsolver_dormtr_rank_0,& rocsolver_dormtr_rank_1,& rocsolver_dormtr_full_rank #endif #endif end interface !> \brief The UNMTR functions multiply a unitary matrix Q by a general ``m`` -by-``n`` matrix !> ``C``. !> !> \details !> The matrix Q is applied in one of the following forms, depending on !> the values of ``side`` and ``trans``: !> !> \f[ !> \begin{array}{cl} !> QC & \: \text{No transpose from the left,}\\% !> Q^H C & \: \text{Conjugate transpose from the left,}\\% !> CQ & \: \text{No transpose from the right, and}\\% !> CQ^H & \: \text{Conjugate transpose from the right.} !> \end{array} !> \f] !> !> The order q of the unitary matrix Q is q = ``m`` if applying from the left, or !> q = ``n`` if applying from the right. !> !> Q is defined as a product of q-1 Householder reflectors. If !> ``uplo`` indicates ``upper``, then Q has the form !> !> \f[ !> Q = H(q-1)H(q-2)\cdots H(1). !> \f] !> !> However, if ``uplo`` indicates ``lower``, then Q has the form !> !> \f[ !> Q = H(1)H(2)\cdots H(q-1) !> \f] !> !> The Householder matrices \f$H(i)\f$ are never stored. They are computed from their !> corresponding Householder vectors and scalars as returned by !> \ref rocsolver_chetrd "HETRD" in its arguments ``A`` and tau. !> !> @param[in] handle - rocblas_handle. !> @param[in] side - rocblas_side. !> Specifies from which side to apply Q. !> @param[in] uplo - rocblas_fill. !> Specifies whether the \ref rocsolver_chetrd "HETRD" factorization was upper or !> lower triangular. If uplo indicates lower (or upper), then the upper (or !> lower) part of A is not used. !> @param[in] trans - rocblas_operation. !> Specifies whether the matrix Q or its conjugate !> transpose is to be applied. !> @param[in] m - rocblas_int. m >= 0. !> Number of rows of matrix C. !> @param[in] n - rocblas_int. n >= 0. !> Number of columns of matrix C. !> @param[in] A - pointer to type. Array on the GPU of size lda*q. !> On entry, the Householder vectors as !> returned by \ref rocsolver_chetrd "HETRD". !> @param[in] lda - rocblas_int. lda >= q. !> Leading dimension of A. !> @param[in] ipiv - pointer to type. Array on the GPU of dimension at least q-1. !> The Householder scalars as returned by !> \ref rocsolver_chetrd "HETRD". !> @param[inout] C - pointer to type. Array on the GPU of size ldc*n. !> On entry, the matrix C. On exit, it is overwritten with !> \f$QC\f$, \f$CQ\f$, \f$Q^HC\f$, or \f$CQ^H\f$. !> @param[in] ldc - rocblas_int. ldc >= m. !> Leading dimension of C. interface rocsolver_cunmtr function rocsolver_cunmtr_(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_cunmtr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmtr_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cunmtr_assumed_rank #else module procedure & rocsolver_cunmtr_rank_0,& rocsolver_cunmtr_rank_1,& rocsolver_cunmtr_full_rank #endif #endif end interface interface rocsolver_zunmtr function rocsolver_zunmtr_(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) & bind(c, name="rocsolver_zunmtr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmtr_ type(c_ptr),value :: handle integer(kind(rocblas_side_left)),value :: side integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zunmtr_assumed_rank #else module procedure & rocsolver_zunmtr_rank_0,& rocsolver_zunmtr_rank_1,& rocsolver_zunmtr_full_rank #endif #endif end interface !> \brief The BDSQR functions compute the singular value decomposition (SVD) of an !> ``n``-by-``n`` bidiagonal matrix B, using the implicit QR algorithm. !> !> \details !> The SVD of B has the form: !> !> \f[ !> B = QSP^H !> \f] !> !> where S is the ``n`` -by-``n`` diagonal matrix of singular values of B, the columns of Q !> are the left !> singular vectors of B, and the columns of P are its right singular vectors. !> !> The computation of the singular vectors is optional. This function accepts input matrices !> ``U`` (of size ``nu`` -by-``n``) and ``V`` (of size ``n`` -by-``nv``) that are overwritten !> with \f$UQ\f$ and \f$P^H V\f$. If ``nu`` = 0, !> no left vectors are computed. If ``nv`` = 0, no right vectors are computed. !> !> Optionally, this function can also compute \f$Q^H C\f$ for a given ``n`` -by-``nc`` input !> matrix ``C``. !> !> \note !> In order to carry out calculations, this method could potentially synchronize the stream !> contained within the !> ``rocblas_handle``. !> !> \note !> A hybrid (CPU+GPU) approach is available for BDSQR, primarily intended for homogeneous !> architectures. !> Use \ref rocsolver_set_alg_mode to enable it. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether B is upper or lower bidiagonal. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of matrix B. !> @param[in] nv - rocblas_int. nv >= 0. !> The number of columns of matrix V. !> @param[in] nu - rocblas_int. nu >= 0. !> The number of rows of matrix U. !> @param[in] nc - rocblas_int. nc >= 0. !> The number of columns of matrix C. !> @param[inout] D - pointer to real type. Array on the GPU of dimension n. !> On entry, the diagonal elements of B. On exit, if info = 0, !> the singular values of B in decreasing order, and if info > 0, !> the diagonal elements of a bidiagonal matrix !> orthogonally equivalent to B. !> @param[inout] E - pointer to real type. Array on the GPU of dimension n-1. !> On entry, the off-diagonal elements of B. On exit, if info > 0, !> the off-diagonal elements of a bidiagonal matrix !> orthogonally equivalent to B (if info = 0 this matrix converges to zero). !> @param[inout] V - pointer to type. Array on the GPU of dimension ldv*nv. !> On entry, the matrix V. On exit, it is overwritten with \f$P^H V\f$. !> (Not referenced if nv = 0.) !> @param[in] ldv - rocblas_int. ldv >= n if nv > 0, or ldv >=1 if nv = 0. !> The leading dimension of V. !> @param[inout] U - pointer to type. Array on the GPU of dimension ldu*n. !> On entry, the matrix U. On exit, it is overwritten with \f$UQ\f$. !> (Not referenced if nu = 0.) !> @param[in] ldu - rocblas_int. ldu >= nu. !> The leading dimension of U. !> @param[inout] C - pointer to type. Array on the GPU of dimension ldc*nc. !> On entry, the matrix C. On exit, it is overwritten with \f$Q^H C\f$. !> (Not referenced if nc = 0.) !> @param[in] ldc - rocblas_int. ldc >= n if nc > 0, or ldc >=1 if nc = 0. !> The leading dimension of C. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, i elements of E have not converged to zero. interface rocsolver_sbdsqr function rocsolver_sbdsqr_(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) & bind(c, name="rocsolver_sbdsqr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sbdsqr_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: nv integer(c_int),value :: nu integer(c_int),value :: nc type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sbdsqr_assumed_rank #else module procedure & rocsolver_sbdsqr_rank_0,& rocsolver_sbdsqr_rank_1,& rocsolver_sbdsqr_full_rank #endif #endif end interface interface rocsolver_dbdsqr function rocsolver_dbdsqr_(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) & bind(c, name="rocsolver_dbdsqr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dbdsqr_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: nv integer(c_int),value :: nu integer(c_int),value :: nc type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dbdsqr_assumed_rank #else module procedure & rocsolver_dbdsqr_rank_0,& rocsolver_dbdsqr_rank_1,& rocsolver_dbdsqr_full_rank #endif #endif end interface interface rocsolver_cbdsqr function rocsolver_cbdsqr_(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) & bind(c, name="rocsolver_cbdsqr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cbdsqr_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: nv integer(c_int),value :: nu integer(c_int),value :: nc type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cbdsqr_assumed_rank #else module procedure & rocsolver_cbdsqr_rank_0,& rocsolver_cbdsqr_rank_1,& rocsolver_cbdsqr_full_rank #endif #endif end interface interface rocsolver_zbdsqr function rocsolver_zbdsqr_(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) & bind(c, name="rocsolver_zbdsqr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zbdsqr_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: nv integer(c_int),value :: nu integer(c_int),value :: nc type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zbdsqr_assumed_rank #else module procedure & rocsolver_zbdsqr_rank_0,& rocsolver_zbdsqr_rank_1,& rocsolver_zbdsqr_full_rank #endif #endif end interface !> \brief The STERF functions compute the eigenvalues of a symmetric tridiagonal matrix. !> !> \details !> The eigenvalues of the symmetric tridiagonal matrix are computed by the !> Pal-Walker-Kahan variant of the QL/QR algorithm and returned in !> increasing order. !> !> The matrix is not represented explicitly, but rather as the array of !> diagonal elements D and the array of symmetric off-diagonal elements E. !> !> \note !> A hybrid (CPU+GPU) approach is available for STERF, primarily intended for !> homogeneous architectures. Use \ref rocsolver_set_alg_mode to enable it. !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the tridiagonal matrix. !> @param[inout] D - pointer to real type. Array on the GPU of dimension n. !> On entry, the diagonal elements of the tridiagonal matrix. !> On exit, if info = 0, the eigenvalues in increasing order. !> If info > 0, the diagonal elements of a tridiagonal matrix !> that is similar to the original matrix (that is, it has the same !> eigenvalues). !> @param[inout] E - pointer to real type. Array on the GPU of dimension n-1. !> On entry, the off-diagonal elements of the tridiagonal matrix. !> On exit, if info = 0, this array converges to zero. !> If info > 0, the off-diagonal elements of a tridiagonal matrix !> that is similar to the original matrix (that is, it has the same !> eigenvalues). !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, STERF did not converge. i elements of E did not !> converge to zero. interface rocsolver_ssterf function rocsolver_ssterf_(handle,n,D,E,myInfo) bind(c, name="rocsolver_ssterf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssterf_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssterf_assumed_rank #else module procedure & rocsolver_ssterf_rank_0,& rocsolver_ssterf_rank_1 #endif #endif end interface interface rocsolver_dsterf function rocsolver_dsterf_(handle,n,D,E,myInfo) bind(c, name="rocsolver_dsterf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsterf_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsterf_assumed_rank #else module procedure & rocsolver_dsterf_rank_0,& rocsolver_dsterf_rank_1 #endif #endif end interface !> \brief The STEQR functions compute the eigenvalues and (optionally) eigenvectors of !> a symmetric tridiagonal matrix. !> !> \details !> The eigenvalues of the symmetric tridiagonal matrix are computed by the !> implicit QL/QR algorithm and returned in increasing order. !> !> The matrix is not represented explicitly, but rather as the array of !> diagonal elements ``D`` and the array of symmetric off-diagonal elements ``E``. !> When ``D`` and ``E`` correspond to the tridiagonal form of a full symmetric/Hermitian !> matrix, as returned by, for example, !> \ref rocsolver_ssytrd "SYTRD" or \ref rocsolver_chetrd "HETRD", the eigenvectors of the !> original matrix can also !> be computed, depending on the value of ``evect``. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies how the eigenvectors are computed. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the tridiagonal matrix. !> @param[inout] D - pointer to real type. Array on the GPU of dimension n. !> On entry, the diagonal elements of the tridiagonal matrix. !> On exit, if info = 0, the eigenvalues in increasing order. !> If info > 0, the diagonal elements of a tridiagonal matrix !> that is similar to the original matrix (that is, it has the same !> eigenvalues). !> @param[inout] E - pointer to real type. Array on the GPU of dimension n-1. !> On entry, the off-diagonal elements of the tridiagonal matrix. !> On exit, if info = 0, this array converges to zero. !> If info > 0, the off-diagonal elements of a tridiagonal matrix !> that is similar to the original matrix (that is, it has the same !> eigenvalues). !> @param[inout] C - pointer to type. Array on the GPU of dimension ldc*n. !> On entry, if evect is original, the orthogonal/unitary matrix !> used for the reduction to tridiagonal form as returned by, for example, !> \ref rocsolver_sorgtr "ORGTR" or \ref rocsolver_cungtr "UNGTR". !> On exit, it is overwritten with the eigenvectors of the original !> symmetric/Hermitian matrix (if evect is original) or the !> eigenvectors of the tridiagonal matrix (if evect is tridiagonal). !> (Not referenced if evect is none.) !> @param[in] ldc - rocblas_int. ldc >= n if evect is original or tridiagonal. !> Specifies the leading dimension of C. !> (Not referenced if evect is none.) !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, STEQR did not converge. i elements of E did not !> converge to zero. interface rocsolver_ssteqr function rocsolver_ssteqr_(handle,evect,n,D,E,C,ldc,myInfo) bind(c, name="rocsolver_ssteqr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssteqr_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(c_int),value :: n type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssteqr_assumed_rank #else module procedure & rocsolver_ssteqr_rank_0,& rocsolver_ssteqr_rank_1,& rocsolver_ssteqr_full_rank #endif #endif end interface interface rocsolver_dsteqr function rocsolver_dsteqr_(handle,evect,n,D,E,C,ldc,myInfo) bind(c, name="rocsolver_dsteqr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsteqr_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(c_int),value :: n type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsteqr_assumed_rank #else module procedure & rocsolver_dsteqr_rank_0,& rocsolver_dsteqr_rank_1,& rocsolver_dsteqr_full_rank #endif #endif end interface interface rocsolver_csteqr function rocsolver_csteqr_(handle,evect,n,D,E,C,ldc,myInfo) bind(c, name="rocsolver_csteqr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csteqr_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(c_int),value :: n type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_csteqr_assumed_rank #else module procedure & rocsolver_csteqr_rank_0,& rocsolver_csteqr_rank_1,& rocsolver_csteqr_full_rank #endif #endif end interface interface rocsolver_zsteqr function rocsolver_zsteqr_(handle,evect,n,D,E,C,ldc,myInfo) bind(c, name="rocsolver_zsteqr") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsteqr_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(c_int),value :: n type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zsteqr_assumed_rank #else module procedure & rocsolver_zsteqr_rank_0,& rocsolver_zsteqr_rank_1,& rocsolver_zsteqr_full_rank #endif #endif end interface !> \brief The STEDC functions compute the eigenvalues and (optionally) eigenvectors of !> a symmetric tridiagonal matrix. !> !> \details !> This function uses the divide-and-conquer method to compute the eigenvectors. !> The eigenvalues are returned in increasing order. !> !> The matrix is not represented explicitly, but rather as the array of !> diagonal elements ``D`` and the array of symmetric off-diagonal elements ``E``. !> When ``D`` and ``E`` correspond to the tridiagonal form of a full symmetric/Hermitian !> matrix, as returned by, for example, !> \ref rocsolver_ssytrd "SYTRD" or \ref rocsolver_chetrd "HETRD", the eigenvectors of the !> original matrix can also !> be computed, depending on the value of ``evect``. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies how the eigenvectors are computed. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the tridiagonal matrix. !> @param[inout] D - pointer to real type. Array on the GPU of dimension n. !> On entry, the diagonal elements of the tridiagonal matrix. !> On exit, if info = 0, the eigenvalues in increasing order. !> @param[inout] E - pointer to real type. Array on the GPU of dimension n-1. !> On entry, the off-diagonal elements of the tridiagonal matrix. !> On exit, if info = 0, the values of this array are destroyed. !> @param[inout] C - pointer to type. Array on the GPU of dimension ldc*n. !> On entry, if evect is original, the orthogonal/unitary matrix !> used for the reduction to tridiagonal form as returned by, for example, !> \ref rocsolver_sorgtr "ORGTR" or \ref rocsolver_cungtr "UNGTR". !> On exit, if info = 0, it is overwritten with the eigenvectors of the original !> symmetric/Hermitian matrix (if evect is original) or the !> eigenvectors of the tridiagonal matrix (if evect is tridiagonal). !> (Not referenced if evect is none.) !> @param[in] ldc - rocblas_int. ldc >= n if evect is original or tridiagonal. !> Specifies the leading dimension of C. (Not referenced if evect is none.) !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, STEDC failed to compute an eigenvalue on the sub-matrix formed !> by !> the rows and columns info/(n+1) through mod(info,n+1). interface rocsolver_sstedc function rocsolver_sstedc_(handle,evect,n,D,E,C,ldc,myInfo) bind(c, name="rocsolver_sstedc") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sstedc_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(c_int),value :: n type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sstedc_assumed_rank #else module procedure & rocsolver_sstedc_rank_0,& rocsolver_sstedc_rank_1,& rocsolver_sstedc_full_rank #endif #endif end interface interface rocsolver_dstedc function rocsolver_dstedc_(handle,evect,n,D,E,C,ldc,myInfo) bind(c, name="rocsolver_dstedc") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dstedc_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(c_int),value :: n type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dstedc_assumed_rank #else module procedure & rocsolver_dstedc_rank_0,& rocsolver_dstedc_rank_1,& rocsolver_dstedc_full_rank #endif #endif end interface interface rocsolver_cstedc function rocsolver_cstedc_(handle,evect,n,D,E,C,ldc,myInfo) bind(c, name="rocsolver_cstedc") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cstedc_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(c_int),value :: n type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cstedc_assumed_rank #else module procedure & rocsolver_cstedc_rank_0,& rocsolver_cstedc_rank_1,& rocsolver_cstedc_full_rank #endif #endif end interface interface rocsolver_zstedc function rocsolver_zstedc_(handle,evect,n,D,E,C,ldc,myInfo) bind(c, name="rocsolver_zstedc") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zstedc_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(c_int),value :: n type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zstedc_assumed_rank #else module procedure & rocsolver_zstedc_rank_0,& rocsolver_zstedc_rank_1,& rocsolver_zstedc_full_rank #endif #endif end interface !> \brief The STEBZ functions compute a set of eigenvalues of a symmetric tridiagonal matrix !> T. !> !> \details !> This function computes all the eigenvalues of T, all the eigenvalues in the half-open !> interval (``vl``, ``vu`` ], !> or the ``il``-th through ``iu``-th eigenvalues, depending on the value of ``erange``. !> !> The eigenvalues are returned in increasing order either for the entire matrix or grouped by !> independent !> diagonal blocks (if they exist), depending on the value of ``eorder``. !> !> @param[in] handle - rocblas_handle. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] eorder - `rocblas_eorder`. !> Specifies whether the computed eigenvalues will be ordered by their position in !> the !> entire spectrum or grouped by independent diagonal (split off) blocks. !> @param[in] n - rocblas_int. n >= 0. !> The order of the tridiagonal matrix T. !> @param[in] vl - real type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if erange indicates to !> look !> for all the eigenvalues of T or the eigenvalues within a set of indices. !> @param[in] vu - real type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if erange indicates to !> look !> for all the eigenvalues of T or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if erange !> indicates to look !> for all the eigenvalues of T or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if erange indicates !> to look !> for all the eigenvalues of T or the eigenvalues in a half-open interval. !> @param[in] abstol - real type. !> The absolute tolerance. An eigenvalue is considered to be located if it lies !> in an interval whose width is <= abstol. If abstol is negative, then !> machine-epsilon times !> the 1-norm of the tridiagonal form of A will be used as the tolerance. If !> abstol=0, then the tolerance will be set !> to twice the underflow threshold. This is the tolerance that could get the most !> accurate results. !> @param[in] D - pointer to real type. Array on the GPU of dimension n. !> The diagonal elements of the tridiagonal matrix. !> @param[in] E - pointer to real type. Array on the GPU of dimension n-1. !> The off-diagonal elements of the tridiagonal matrix. !> @param[out] nev - pointer to a rocblas_int on the GPU. !> The total number of eigenvalues found. !> @param[out] nsplit - pointer to a rocblas_int on the GPU. !> The number of split off blocks in the matrix. !> @param[out] W - pointer to real type. Array on the GPU of dimension n. !> The first nev elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[out] iblock - pointer to rocblas_int. Array on the GPU of dimension n. !> The block indices corresponding to each eigenvalue. When matrix T has !> split off blocks (nsplit > 1), then if iblock[i] = k, the !> eigenvalue W[i] belongs to the k-th diagonal block from the top. !> @param[out] isplit - pointer to rocblas_int. Array on the GPU of dimension n. !> The splitting indices that divide the tridiagonal matrix into !> diagonal blocks. The k-th block stretches from the end of the (k-1)-th !> block (or the top left corner of the tridiagonal matrix, !> in the case of the 1st block) to the isplit[k]-th row/column. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = 1, the bisection did not converge for some eigenvalues, that is, the !> returned !> values are not as accurate as the given tolerance. The non-converged !> eigenvalues !> are flagged by negative entries in iblock. interface rocsolver_sstebz function rocsolver_sstebz_(handle,erange,eorder,n,vl,vu,il,iu,abstol,D,E,nev,nsplit,W,iblock, & isplit,myInfo) & bind(c, name="rocsolver_sstebz") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sstebz_ type(c_ptr),value :: handle integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_eorder_blocks)),value :: eorder integer(c_int),value :: n real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_float),value :: abstol type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: nev type(c_ptr),value :: nsplit type(c_ptr),value :: W type(c_ptr),value :: iblock type(c_ptr),value :: isplit type(c_ptr),value :: myInfo end function end interface interface rocsolver_dstebz function rocsolver_dstebz_(handle,erange,eorder,n,vl,vu,il,iu,abstol,D,E,nev,nsplit,W,iblock, & isplit,myInfo) & bind(c, name="rocsolver_dstebz") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dstebz_ type(c_ptr),value :: handle integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_eorder_blocks)),value :: eorder integer(c_int),value :: n real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_double),value :: abstol type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: nev type(c_ptr),value :: nsplit type(c_ptr),value :: W type(c_ptr),value :: iblock type(c_ptr),value :: isplit type(c_ptr),value :: myInfo end function end interface !> \brief The STEIN functions compute the eigenvectors associated with a set of !> provided eigenvalues of a symmetric tridiagonal matrix. !> !> \details !> The eigenvectors of the symmetric tridiagonal matrix are computed using !> inverse iteration. !> !> The matrix is not represented explicitly, but rather as the array of !> diagonal elements ``D`` and the array of symmetric off-diagonal elements ``E``. !> The eigenvalues must be provided in the array ``W``, as returned by \ref rocsolver_sstebz !> "STEBZ". !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the tridiagonal matrix. !> @param[in] D - pointer to real type. Array on the GPU of dimension n. !> The diagonal elements of the tridiagonal matrix. !> @param[in] E - pointer to real type. Array on the GPU of dimension n-1. !> The off-diagonal elements of the tridiagonal matrix. !> @param[in] nev - pointer to a rocblas_int on the GPU. 0 <= nev <= n. !> The number of provided eigenvalues and the number of eigenvectors !> to be computed. !> @param[in] W - pointer to real type. Array on the GPU of dimension >= nev. !> A subset of nev eigenvalues of the tridiagonal matrix, as returned !> by \ref rocsolver_sstebz "STEBZ". !> @param[in] iblock - pointer to rocblas_int. Array on the GPU of dimension n. !> The block indices corresponding to each eigenvalue, as !> returned by \ref rocsolver_sstebz "STEBZ". If iblock[i] = k, !> then eigenvalue W[i] belongs to the k-th block from the top. !> @param[in] isplit - pointer to rocblas_int. Array on the GPU of dimension n. !> The splitting indices that divide the tridiagonal matrix into !> diagonal blocks, as returned by \ref rocsolver_sstebz "STEBZ". !> The k-th block stretches from the end of the (k-1)-th !> block (or the top left corner of the tridiagonal matrix, !> in the case of the 1st block) to the isplit[k]-th row/column. !> @param[out] Z - pointer to type. Array on the GPU of dimension ldz*nev. !> On exit, contains the eigenvectors of the tridiagonal matrix !> corresponding to the provided eigenvalues, stored by columns. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of Z. !> @param[out] ifail - pointer to rocblas_int. Array on the GPU of dimension n. !> If info = 0, the first nev elements of ifail are zero. !> Otherwise, contains the indices of those eigenvectors that failed !> to converge. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, i eigenvectors did not converge. Their indices are stored in !> ifail. interface rocsolver_sstein function rocsolver_sstein_(handle,n,D,E,nev,W,iblock,isplit,Z,ldz,ifail,myInfo) & bind(c, name="rocsolver_sstein") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sstein_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: iblock type(c_ptr),value :: isplit type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail type(c_ptr),value :: myInfo end function end interface interface rocsolver_dstein function rocsolver_dstein_(handle,n,D,E,nev,W,iblock,isplit,Z,ldz,ifail,myInfo) & bind(c, name="rocsolver_dstein") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dstein_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: iblock type(c_ptr),value :: isplit type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail type(c_ptr),value :: myInfo end function end interface interface rocsolver_cstein function rocsolver_cstein_(handle,n,D,E,nev,W,iblock,isplit,Z,ldz,ifail,myInfo) & bind(c, name="rocsolver_cstein") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cstein_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: iblock type(c_ptr),value :: isplit type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail type(c_ptr),value :: myInfo end function end interface interface rocsolver_zstein function rocsolver_zstein_(handle,n,D,E,nev,W,iblock,isplit,Z,ldz,ifail,myInfo) & bind(c, name="rocsolver_zstein") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zstein_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: iblock type(c_ptr),value :: isplit type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail type(c_ptr),value :: myInfo end function end interface !> \brief The BDSVDX functions compute a set of singular values of a bidiagonal matrix B. !> !> \details !> This function computes all the singular values of B, all the singular values in the !> half-open interval !> \f$[vl, vu)\f$, or the ``il`` -th through ``iu`` -th singular values, depending on the !> value of ``srange``. !> !> Depending on the value of ``svect``, the corresponding singular vectors will be computed !> and stored as blocks !> in the output matrix ``Z``. That is, !> !> \f[ !> Z = \left[\begin{array}{c} !> U\\% !> V !> \end{array}\right] !> \f] !> !> where U contains the corresponding left singular vectors of B and V contains the !> corresponding right !> singular vectors. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether B is upper or lower bidiagonal. !> @param[in] svect - `rocblas_svect`. !> Specifies how the singular vectors are computed. Only rocblas_svect_none and !> rocblas_svect_singular are accepted. !> @param[in] srange - `rocblas_srange`. !> Specifies the type of range or interval of the singular values to be computed. !> @param[in] n - rocblas_int. n >= 0. !> The order of the bidiagonal matrix B. !> @param[in] D - pointer to real type. Array on the GPU of dimension n. !> The diagonal elements of the bidiagonal matrix. !> @param[in] E - pointer to real type. Array on the GPU of dimension n-1. !> The off-diagonal elements of the bidiagonal matrix. !> @param[in] vl - real type. 0 <= vl < vu. !> The lower bound of the search interval [vl, vu). Ignored if srange indicates to !> look !> for all the singular values of B or the singular values within a set of !> indices. !> @param[in] vu - real type. 0 <= vl < vu. !> The upper bound of the search interval [vl, vu). Ignored if srange indicates to !> look !> for all the singular values of B or the singular values within a set of !> indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest singular value to be computed. Ignored if srange !> indicates to look !> for all the singular values of B or the singular values in a half-open !> interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest singular value to be computed. Ignored if srange !> indicates to look !> for all the singular values of B or the singular values in a half-open !> interval. !> @param[out] nsv - pointer to a rocblas_int on the GPU. !> The total number of singular values found. If srange is rocblas_srange_all, nsv !> = n. !> If srange is rocblas_srange_index, nsv = iu - il + 1. Otherwise, 0 <= nsv <= n. !> @param[out] S - pointer to real type. Array on the GPU of dimension nsv. !> The first nsv elements contain the computed singular values in descending !> order. !> - Note: If srange is rocblas_srange_value, then the value of nsv is not known !> in advance. !> In this case, the user should ensure that S is large enough to hold n values. !> @param[out] Z - pointer to real type. Array on the GPU of dimension ldz*nsv. !> If info = 0, the first nsv columns contain the computed singular vectors !> corresponding to the !> singular values in S. The first n rows of Z contain the matrix U, and the next !> n rows contain !> the matrix V. Not referenced if svect is rocblas_svect_none. !> - Note: If srange is rocblas_srange_value, then the value of nsv is not known !> in advance. !> In this case, the user should ensure that Z is large enough to hold n columns. !> @param[in] ldz - rocblas_int. ldz >= 2*n if svect is rocblas_svect_singular and ldz >= 1 !> otherwise. !> Specifies the leading dimension of Z. !> @param[out] ifail - pointer to rocblas_int. Array on the GPU of dimension n. !> If info = 0, the first nsv elements of ifail are zero. !> Otherwise, contains the indices of those eigenvectors that failed !> to converge, as returned by \ref rocsolver_sstein "STEIN". !> Not referenced if svect is rocblas_svect_none. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, i eigenvectors did not converge in \ref rocsolver_sstein !> "STEIN". Their !> indices are stored in ifail. interface rocsolver_sbdsvdx function rocsolver_sbdsvdx_(handle,uplo,svect,srange,n,D,E,vl,vu,il,iu,nsv,S,Z,ldz,ifail, & myInfo) & bind(c, name="rocsolver_sbdsvdx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sbdsvdx_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_svect_all)),value :: svect integer(kind(rocblas_srange_all)),value :: srange integer(c_int),value :: n type(c_ptr),value :: D type(c_ptr),value :: E real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nsv type(c_ptr),value :: S type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail type(c_ptr),value :: myInfo end function end interface interface rocsolver_dbdsvdx function rocsolver_dbdsvdx_(handle,uplo,svect,srange,n,D,E,vl,vu,il,iu,nsv,S,Z,ldz,ifail, & myInfo) & bind(c, name="rocsolver_dbdsvdx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dbdsvdx_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_svect_all)),value :: svect integer(kind(rocblas_srange_all)),value :: srange integer(c_int),value :: n type(c_ptr),value :: D type(c_ptr),value :: E real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nsv type(c_ptr),value :: S type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail type(c_ptr),value :: myInfo end function end interface !> \brief The GETF2_NPVT functions compute the LU factorization of a general ``m`` -by-``n`` !> matrix ``A`` !> without partial pivoting. !> !> \details !> (This is the unblocked Level-2-BLAS version of the algorithm. An optimized internal !> implementation without rocBLAS calls !> could be executed with small and mid-size matrices if optimizations are enabled (default !> option). For more details, see the !> "rocSOLVER performance tuning" guide.) !> !> The factorization has the form !> !> \f[ !> A = LU !> \f] !> !> where L is lower triangular with unit !> diagonal elements (lower trapezoidal if ``m`` > ``n``), and U is upper !> triangular (upper trapezoidal if ``m`` < ``n``). !> !> \note !> Although this routine can offer better performance, Gaussian elimination without pivoting !> is not backward stable. !> If numerical accuracy is compromised, use the legacy-LAPACK API \ref rocsolver_sgetf2 !> "GETF2" routines instead. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the m-by-n matrix A to be factored. !> On exit, the factors L and U from the factorization. !> The unit diagonal elements of L are not stored. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, U is singular. U[i,i] is the first zero element in the !> diagonal. The factorization from !> this point might be incomplete. interface rocsolver_sgetf2_npvt function rocsolver_sgetf2_npvt_(handle,m,n,A,lda,myInfo) bind(c, name="rocsolver_sgetf2_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_ 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 type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetf2_npvt_assumed_rank #else module procedure & rocsolver_sgetf2_npvt_rank_0,& rocsolver_sgetf2_npvt_rank_1,& rocsolver_sgetf2_npvt_full_rank #endif #endif end interface interface rocsolver_dgetf2_npvt function rocsolver_dgetf2_npvt_(handle,m,n,A,lda,myInfo) bind(c, name="rocsolver_dgetf2_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_ 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 type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetf2_npvt_assumed_rank #else module procedure & rocsolver_dgetf2_npvt_rank_0,& rocsolver_dgetf2_npvt_rank_1,& rocsolver_dgetf2_npvt_full_rank #endif #endif end interface interface rocsolver_cgetf2_npvt function rocsolver_cgetf2_npvt_(handle,m,n,A,lda,myInfo) bind(c, name="rocsolver_cgetf2_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_ 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 type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetf2_npvt_assumed_rank #else module procedure & rocsolver_cgetf2_npvt_rank_0,& rocsolver_cgetf2_npvt_rank_1,& rocsolver_cgetf2_npvt_full_rank #endif #endif end interface interface rocsolver_zgetf2_npvt function rocsolver_zgetf2_npvt_(handle,m,n,A,lda,myInfo) bind(c, name="rocsolver_zgetf2_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_ 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 type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetf2_npvt_assumed_rank #else module procedure & rocsolver_zgetf2_npvt_rank_0,& rocsolver_zgetf2_npvt_rank_1,& rocsolver_zgetf2_npvt_full_rank #endif #endif end interface interface rocsolver_sgetf2_npvt_64 function rocsolver_sgetf2_npvt_64_(handle,m,n,A,lda,myInfo) & bind(c, name="rocsolver_sgetf2_npvt_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo end function end interface interface rocsolver_dgetf2_npvt_64 function rocsolver_dgetf2_npvt_64_(handle,m,n,A,lda,myInfo) & bind(c, name="rocsolver_dgetf2_npvt_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo end function end interface interface rocsolver_cgetf2_npvt_64 function rocsolver_cgetf2_npvt_64_(handle,m,n,A,lda,myInfo) & bind(c, name="rocsolver_cgetf2_npvt_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo end function end interface interface rocsolver_zgetf2_npvt_64 function rocsolver_zgetf2_npvt_64_(handle,m,n,A,lda,myInfo) & bind(c, name="rocsolver_zgetf2_npvt_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo end function end interface !> \brief The GETF2_NPVT_BATCHED functions compute the LU factorization of a batch of !> general ``m``-by-``n`` matrices without partial pivoting. !> !> \details !> (This is the unblocked Level-2-BLAS version of the algorithm. An optimized internal !> implementation without rocBLAS calls !> could be executed with small and mid-size matrices if optimizations are enabled (default !> option). For more details, see the !> "rocSOLVER performance tuning" guide.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = L_l U_l !> \f] !> !> where \f$L_l\f$ is lower triangular with unit !> diagonal elements (lower trapezoidal if ``m`` > ``n``), and \f$U_l\f$ is upper !> triangular (upper trapezoidal if ``m`` < ``n``). !> !> \note !> Although this routine can offer better performance, Gaussian elimination without pivoting !> is not backward stable. !> If numerical accuracy is compromised, use the legacy-LAPACK API \ref !> rocsolver_sgetf2_batched "GETF2_BATCHED" routines instead. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all matrices A_l in the batch. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the factors L_l and U_l from the factorizations. !> The unit diagonal elements of L_l are not stored. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for factorization of A_l. !> If info[l] = i > 0, U_l is singular. U_l[i,i] is the first zero element in the !> diagonal. The factorization from !> this point might be incomplete. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgetf2_npvt_batched function rocsolver_sgetf2_npvt_batched_(handle,m,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_sgetf2_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_batched_ 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 type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dgetf2_npvt_batched function rocsolver_dgetf2_npvt_batched_(handle,m,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_dgetf2_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_batched_ 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 type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_cgetf2_npvt_batched function rocsolver_cgetf2_npvt_batched_(handle,m,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_cgetf2_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_batched_ 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 type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zgetf2_npvt_batched function rocsolver_zgetf2_npvt_batched_(handle,m,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_zgetf2_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_batched_ 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 type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_sgetf2_npvt_batched_64 function rocsolver_sgetf2_npvt_batched_64_(handle,m,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_sgetf2_npvt_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dgetf2_npvt_batched_64 function rocsolver_dgetf2_npvt_batched_64_(handle,m,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_dgetf2_npvt_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cgetf2_npvt_batched_64 function rocsolver_cgetf2_npvt_batched_64_(handle,m,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_cgetf2_npvt_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zgetf2_npvt_batched_64 function rocsolver_zgetf2_npvt_batched_64_(handle,m,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_zgetf2_npvt_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The GETF2_NPVT_STRIDED_BATCHED functions compute the LU factorization of a batch !> of general ``m``-by-``n`` matrices without partial pivoting. !> !> \details !> (This is the unblocked Level-2-BLAS version of the algorithm. An optimized internal !> implementation without rocBLAS calls !> could be executed with small and mid-size matrices if optimizations are enabled (default !> option). For more details, see the !> "rocSOLVER performance tuning" guide.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = L_l U_l !> \f] !> !> where \f$L_l\f$ is lower triangular with unit !> diagonal elements (lower trapezoidal if ``m`` > ``n``), and \f$U_l\f$ is upper !> triangular (upper trapezoidal if ``m`` < ``n``). !> !> \note !> Although this routine can offer better performance, Gaussian elimination without pivoting !> is not backward stable. !> If numerical accuracy is compromised, use \ref rocsolver_sgetf2_strided_batched !> "GETF2_STRIDED_BATCHED" routines instead. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the factors L_l and U_l from the factorization. !> The unit diagonal elements of L_l are not stored. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for factorization of A_l. !> If info[l] = i > 0, U_l is singular. U_l[i,i] is the first zero element in the !> diagonal. The factorization from !> this point might be incomplete. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgetf2_npvt_strided_batched function rocsolver_sgetf2_npvt_strided_batched_(handle,m,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_sgetf2_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetf2_npvt_strided_batched_assumed_rank #else module procedure & rocsolver_sgetf2_npvt_strided_batched_rank_0,& rocsolver_sgetf2_npvt_strided_batched_rank_1,& rocsolver_sgetf2_npvt_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgetf2_npvt_strided_batched function rocsolver_dgetf2_npvt_strided_batched_(handle,m,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_dgetf2_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetf2_npvt_strided_batched_assumed_rank #else module procedure & rocsolver_dgetf2_npvt_strided_batched_rank_0,& rocsolver_dgetf2_npvt_strided_batched_rank_1,& rocsolver_dgetf2_npvt_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgetf2_npvt_strided_batched function rocsolver_cgetf2_npvt_strided_batched_(handle,m,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_cgetf2_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetf2_npvt_strided_batched_assumed_rank #else module procedure & rocsolver_cgetf2_npvt_strided_batched_rank_0,& rocsolver_cgetf2_npvt_strided_batched_rank_1,& rocsolver_cgetf2_npvt_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgetf2_npvt_strided_batched function rocsolver_zgetf2_npvt_strided_batched_(handle,m,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_zgetf2_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetf2_npvt_strided_batched_assumed_rank #else module procedure & rocsolver_zgetf2_npvt_strided_batched_rank_0,& rocsolver_zgetf2_npvt_strided_batched_rank_1,& rocsolver_zgetf2_npvt_strided_batched_full_rank #endif #endif end interface interface rocsolver_sgetf2_npvt_strided_batched_64 function rocsolver_sgetf2_npvt_strided_batched_64_(handle,m,n,A,lda,strideA,myInfo, & batch_count) & bind(c, name="rocsolver_sgetf2_npvt_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dgetf2_npvt_strided_batched_64 function rocsolver_dgetf2_npvt_strided_batched_64_(handle,m,n,A,lda,strideA,myInfo, & batch_count) & bind(c, name="rocsolver_dgetf2_npvt_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cgetf2_npvt_strided_batched_64 function rocsolver_cgetf2_npvt_strided_batched_64_(handle,m,n,A,lda,strideA,myInfo, & batch_count) & bind(c, name="rocsolver_cgetf2_npvt_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zgetf2_npvt_strided_batched_64 function rocsolver_zgetf2_npvt_strided_batched_64_(handle,m,n,A,lda,strideA,myInfo, & batch_count) & bind(c, name="rocsolver_zgetf2_npvt_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The GETRF_NPVT functions compute the LU factorization of a general ``m`` -by-``n`` !> matrix ``A`` !> without partial pivoting. !> !> \details !> (This is the blocked Level-3-BLAS version of the algorithm. An optimized internal !> implementation without rocBLAS calls !> could be executed with mid-size matrices if optimizations are enabled (default option). For !> more details, see the !> "rocSOLVER performance tuning" guide.) !> !> The factorization has the form !> !> \f[ !> A = LU !> \f] !> !> where L is lower triangular with unit !> diagonal elements (lower trapezoidal if ``m`` > ``n``), and U is upper !> triangular (upper trapezoidal if ``m`` < ``n``). !> !> \note !> Although this routine can offer better performance than GETRF, Gaussian elimination without !> pivoting is not backward stable. !> If numerical accuracy is compromised, use \ref rocsolver_sgetrf "GETRF" routines instead. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the m-by-n matrix A to be factored. !> On exit, the factors L and U from the factorization. !> The unit diagonal elements of L are not stored. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, U is singular. U[i,i] is the first zero element in the !> diagonal. The factorization from !> this point might be incomplete. interface rocsolver_sgetrf_npvt function rocsolver_sgetrf_npvt_(handle,m,n,A,lda,myInfo) bind(c, name="rocsolver_sgetrf_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_ 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 type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetrf_npvt_assumed_rank #else module procedure & rocsolver_sgetrf_npvt_rank_0,& rocsolver_sgetrf_npvt_rank_1,& rocsolver_sgetrf_npvt_full_rank #endif #endif end interface interface rocsolver_dgetrf_npvt function rocsolver_dgetrf_npvt_(handle,m,n,A,lda,myInfo) bind(c, name="rocsolver_dgetrf_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_ 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 type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetrf_npvt_assumed_rank #else module procedure & rocsolver_dgetrf_npvt_rank_0,& rocsolver_dgetrf_npvt_rank_1,& rocsolver_dgetrf_npvt_full_rank #endif #endif end interface interface rocsolver_cgetrf_npvt function rocsolver_cgetrf_npvt_(handle,m,n,A,lda,myInfo) bind(c, name="rocsolver_cgetrf_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_ 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 type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetrf_npvt_assumed_rank #else module procedure & rocsolver_cgetrf_npvt_rank_0,& rocsolver_cgetrf_npvt_rank_1,& rocsolver_cgetrf_npvt_full_rank #endif #endif end interface interface rocsolver_zgetrf_npvt function rocsolver_zgetrf_npvt_(handle,m,n,A,lda,myInfo) bind(c, name="rocsolver_zgetrf_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_ 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 type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetrf_npvt_assumed_rank #else module procedure & rocsolver_zgetrf_npvt_rank_0,& rocsolver_zgetrf_npvt_rank_1,& rocsolver_zgetrf_npvt_full_rank #endif #endif end interface interface rocsolver_sgetrf_npvt_64 function rocsolver_sgetrf_npvt_64_(handle,m,n,A,lda,myInfo) & bind(c, name="rocsolver_sgetrf_npvt_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo end function end interface interface rocsolver_dgetrf_npvt_64 function rocsolver_dgetrf_npvt_64_(handle,m,n,A,lda,myInfo) & bind(c, name="rocsolver_dgetrf_npvt_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo end function end interface interface rocsolver_cgetrf_npvt_64 function rocsolver_cgetrf_npvt_64_(handle,m,n,A,lda,myInfo) & bind(c, name="rocsolver_cgetrf_npvt_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo end function end interface interface rocsolver_zgetrf_npvt_64 function rocsolver_zgetrf_npvt_64_(handle,m,n,A,lda,myInfo) & bind(c, name="rocsolver_zgetrf_npvt_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo end function end interface !> \brief The GETRF_NPVT_BATCHED functions compute the LU factorization of a batch of !> general ``m``-by-``n`` matrices without partial pivoting. !> !> \details !> (This is the blocked Level-3-BLAS version of the algorithm. An optimized internal !> implementation without rocBLAS calls !> could be executed with mid-size matrices if optimizations are enabled (default option). For !> more details, see the !> "rocSOLVER performance tuning" guide.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = L_l U_l !> \f] !> !> where \f$L_l\f$ is lower triangular with unit !> diagonal elements (lower trapezoidal if ``m`` > ``n``), and \f$U_l\f$ is upper !> triangular (upper trapezoidal if ``m`` < ``n``). !> !> \note !> Although this routine can offer better performance, Gaussian elimination without pivoting !> is not backward stable. !> If numerical accuracy is compromised, use \ref rocsolver_sgetrf_batched "GETRF_BATCHED" !> routines instead. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all matrices A_l in the batch. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the factors L_l and U_l from the factorizations. !> The unit diagonal elements of L_l are not stored. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for factorization of A_l. !> If info[l] = i > 0, U_l is singular. U_l[i,i] is the first zero element in the !> diagonal. The factorization from !> this point might be incomplete. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgetrf_npvt_batched function rocsolver_sgetrf_npvt_batched_(handle,m,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_sgetrf_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_batched_ 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 type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dgetrf_npvt_batched function rocsolver_dgetrf_npvt_batched_(handle,m,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_dgetrf_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_batched_ 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 type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_cgetrf_npvt_batched function rocsolver_cgetrf_npvt_batched_(handle,m,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_cgetrf_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_batched_ 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 type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zgetrf_npvt_batched function rocsolver_zgetrf_npvt_batched_(handle,m,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_zgetrf_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_batched_ 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 type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_sgetrf_npvt_batched_64 function rocsolver_sgetrf_npvt_batched_64_(handle,m,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_sgetrf_npvt_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dgetrf_npvt_batched_64 function rocsolver_dgetrf_npvt_batched_64_(handle,m,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_dgetrf_npvt_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cgetrf_npvt_batched_64 function rocsolver_cgetrf_npvt_batched_64_(handle,m,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_cgetrf_npvt_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zgetrf_npvt_batched_64 function rocsolver_zgetrf_npvt_batched_64_(handle,m,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_zgetrf_npvt_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The GETRF_NPVT_STRIDED_BATCHED functions compute the LU factorization of a batch !> of general ``m``-by-``n`` matrices without partial pivoting. !> !> \details !> (This is the blocked Level-3-BLAS version of the algorithm. An optimized internal !> implementation without rocBLAS calls !> could be executed with mid-size matrices if optimizations are enabled (default option). For !> more details, see the !> "rocSOLVER performance tuning" guide.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = L_l U_l !> \f] !> !> where \f$L_l\f$ is lower triangular with unit !> diagonal elements (lower trapezoidal if ``m`` > ``n``), and \f$U_l\f$ is upper !> triangular (upper trapezoidal if ``m`` < ``n``). !> !> \note !> Although this routine can offer better performance, Gaussian elimination without pivoting !> is not backward stable. !> If numerical accuracy is compromised, use \ref rocsolver_sgetrf_strided_batched !> "GETRF_STRIDED_BATCHED" routines instead. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the factors L_l and U_l from the factorization. !> The unit diagonal elements of L_l are not stored. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for factorization of A_l. !> If info[l] = i > 0, U_l is singular. U_l[i,i] is the first zero element in the !> diagonal. The factorization from !> this point might be incomplete. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgetrf_npvt_strided_batched function rocsolver_sgetrf_npvt_strided_batched_(handle,m,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_sgetrf_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetrf_npvt_strided_batched_assumed_rank #else module procedure & rocsolver_sgetrf_npvt_strided_batched_rank_0,& rocsolver_sgetrf_npvt_strided_batched_rank_1,& rocsolver_sgetrf_npvt_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgetrf_npvt_strided_batched function rocsolver_dgetrf_npvt_strided_batched_(handle,m,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_dgetrf_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetrf_npvt_strided_batched_assumed_rank #else module procedure & rocsolver_dgetrf_npvt_strided_batched_rank_0,& rocsolver_dgetrf_npvt_strided_batched_rank_1,& rocsolver_dgetrf_npvt_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgetrf_npvt_strided_batched function rocsolver_cgetrf_npvt_strided_batched_(handle,m,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_cgetrf_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetrf_npvt_strided_batched_assumed_rank #else module procedure & rocsolver_cgetrf_npvt_strided_batched_rank_0,& rocsolver_cgetrf_npvt_strided_batched_rank_1,& rocsolver_cgetrf_npvt_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgetrf_npvt_strided_batched function rocsolver_zgetrf_npvt_strided_batched_(handle,m,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_zgetrf_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetrf_npvt_strided_batched_assumed_rank #else module procedure & rocsolver_zgetrf_npvt_strided_batched_rank_0,& rocsolver_zgetrf_npvt_strided_batched_rank_1,& rocsolver_zgetrf_npvt_strided_batched_full_rank #endif #endif end interface interface rocsolver_sgetrf_npvt_strided_batched_64 function rocsolver_sgetrf_npvt_strided_batched_64_(handle,m,n,A,lda,strideA,myInfo, & batch_count) & bind(c, name="rocsolver_sgetrf_npvt_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dgetrf_npvt_strided_batched_64 function rocsolver_dgetrf_npvt_strided_batched_64_(handle,m,n,A,lda,strideA,myInfo, & batch_count) & bind(c, name="rocsolver_dgetrf_npvt_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cgetrf_npvt_strided_batched_64 function rocsolver_cgetrf_npvt_strided_batched_64_(handle,m,n,A,lda,strideA,myInfo, & batch_count) & bind(c, name="rocsolver_cgetrf_npvt_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zgetrf_npvt_strided_batched_64 function rocsolver_zgetrf_npvt_strided_batched_64_(handle,m,n,A,lda,strideA,myInfo, & batch_count) & bind(c, name="rocsolver_zgetrf_npvt_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The GETF2 functions compute the LU factorization of a general ``m`` -by-``n`` matrix !> ``A`` !> using partial pivoting with row interchanges. !> !> \details !> (This is the unblocked Level-2-BLAS version of the algorithm. An optimized internal !> implementation without rocBLAS calls !> could be executed with small and mid-size matrices if optimizations are enabled (default !> option). For more details, see the !> "rocSOLVER performance tuning" guide.) !> !> The factorization has the form !> !> \f[ !> A = PLU !> \f] !> !> where P is a permutation matrix, L is lower triangular with unit !> diagonal elements (lower trapezoidal if ``m`` > ``n``), and U is upper !> triangular (upper trapezoidal if ``m`` < ``n``). !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the m-by-n matrix A to be factored. !> On exit, the factors L and U from the factorization. !> The unit diagonal elements of L are not stored. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[out] ipiv - pointer to rocblas_int. Array on the GPU of dimension min(m,n). !> The vector of pivot indices. Elements of ipiv are 1-based indices. !> For 1 <= i <= min(m,n), row i of the !> matrix was interchanged with row ipiv[i]. !> Matrix P of the factorization can be derived from ipiv. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, U is singular. U[i,i] is the first zero pivot. interface rocsolver_sgetf2 function rocsolver_sgetf2_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_sgetf2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_ 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 type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetf2_assumed_rank #else module procedure & rocsolver_sgetf2_rank_0,& rocsolver_sgetf2_rank_1,& rocsolver_sgetf2_full_rank #endif #endif end interface interface rocsolver_dgetf2 function rocsolver_dgetf2_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_dgetf2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_ 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 type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetf2_assumed_rank #else module procedure & rocsolver_dgetf2_rank_0,& rocsolver_dgetf2_rank_1,& rocsolver_dgetf2_full_rank #endif #endif end interface interface rocsolver_cgetf2 function rocsolver_cgetf2_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_cgetf2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_ 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 type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetf2_assumed_rank #else module procedure & rocsolver_cgetf2_rank_0,& rocsolver_cgetf2_rank_1,& rocsolver_cgetf2_full_rank #endif #endif end interface interface rocsolver_zgetf2 function rocsolver_zgetf2_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_zgetf2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_ 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 type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetf2_assumed_rank #else module procedure & rocsolver_zgetf2_rank_0,& rocsolver_zgetf2_rank_1,& rocsolver_zgetf2_full_rank #endif #endif end interface interface rocsolver_sgetf2_64 function rocsolver_sgetf2_64_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_sgetf2_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function end interface interface rocsolver_dgetf2_64 function rocsolver_dgetf2_64_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_dgetf2_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function end interface interface rocsolver_cgetf2_64 function rocsolver_cgetf2_64_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_cgetf2_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function end interface interface rocsolver_zgetf2_64 function rocsolver_zgetf2_64_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_zgetf2_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function end interface !> \brief The GETF2_BATCHED functions compute the LU factorization of a batch of general !> ``m``-by-``n`` matrices using partial pivoting with row interchanges. !> !> \details !> (This is the unblocked Level-2-BLAS version of the algorithm. An optimized internal !> implementation without rocBLAS calls !> could be executed with small and mid-size matrices if optimizations are enabled (default !> option). For more details, see the !> "rocSOLVER performance tuning" guide.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = P_l L_l U_l !> \f] !> !> where \f$P_l\f$ is a permutation matrix, \f$L_l\f$ is lower triangular with unit !> diagonal elements (lower trapezoidal if ``m`` > ``n``), and \f$U_l\f$ is upper !> triangular (upper trapezoidal if ``m`` < ``n``). !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all matrices A_l in the batch. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the factors L_l and U_l from the factorizations. !> The unit diagonal elements of L_l are not stored. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[out] ipiv - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideP). !> Contains the vectors of pivot indices ipiv_l (corresponding to A_l). !> Dimension of ipiv_l is min(m,n). !> Elements of ipiv_l are 1-based indices. !> For each instance A_l in the batch and for 1 <= i <= min(m,n), row i of the !> matrix A_l was interchanged with row ipiv_l[i]. !> Matrix P_l of the factorization can be derived from ipiv_l. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value of strideP. The normal use case is !> strideP >= min(m,n). !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for factorization of A_l. !> If info[l] = i > 0, U_l is singular. U_l[i,i] is the first zero pivot. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgetf2_batched function rocsolver_sgetf2_batched_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_sgetf2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetf2_batched_assumed_rank #else module procedure & rocsolver_sgetf2_batched_rank_0,& rocsolver_sgetf2_batched_rank_1 #endif #endif end interface interface rocsolver_dgetf2_batched function rocsolver_dgetf2_batched_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_dgetf2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetf2_batched_assumed_rank #else module procedure & rocsolver_dgetf2_batched_rank_0,& rocsolver_dgetf2_batched_rank_1 #endif #endif end interface interface rocsolver_cgetf2_batched function rocsolver_cgetf2_batched_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_cgetf2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetf2_batched_assumed_rank #else module procedure & rocsolver_cgetf2_batched_rank_0,& rocsolver_cgetf2_batched_rank_1 #endif #endif end interface interface rocsolver_zgetf2_batched function rocsolver_zgetf2_batched_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_zgetf2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetf2_batched_assumed_rank #else module procedure & rocsolver_zgetf2_batched_rank_0,& rocsolver_zgetf2_batched_rank_1 #endif #endif end interface interface rocsolver_sgetf2_batched_64 function rocsolver_sgetf2_batched_64_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_sgetf2_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dgetf2_batched_64 function rocsolver_dgetf2_batched_64_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_dgetf2_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cgetf2_batched_64 function rocsolver_cgetf2_batched_64_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_cgetf2_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zgetf2_batched_64 function rocsolver_zgetf2_batched_64_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_zgetf2_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The GETF2_STRIDED_BATCHED functions compute the LU factorization of a batch of !> general ``m``-by-``n`` matrices using partial pivoting with row interchanges. !> !> \details !> (This is the unblocked Level-2-BLAS version of the algorithm. An optimized internal !> implementation without rocBLAS calls !> could be executed with small and mid-size matrices if optimizations are enabled (default !> option). For more details, see the !> "rocSOLVER performance tuning" guide.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = P_l L_l U_l !> \f] !> !> where \f$P_l\f$ is a permutation matrix, \f$L_l\f$ is lower triangular with unit !> diagonal elements (lower trapezoidal if ``m`` > ``n``), and \f$U_l\f$ is upper !> triangular (upper trapezoidal if ``m`` < ``n``). !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the factors L_l and U_l from the factorization. !> The unit diagonal elements of L_l are not stored. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] ipiv - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideP). !> Contains the vectors of pivots indices ipiv_l (corresponding to A_l). !> Dimension of ipiv_l is min(m,n). !> Elements of ipiv_l are 1-based indices. !> For each instance A_l in the batch and for 1 <= i <= min(m,n), row i of the !> matrix A_l was interchanged with row ipiv_l[i]. !> Matrix P_l of the factorization can be derived from ipiv_l. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value of strideP. The normal use case is !> strideP >= min(m,n). !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for factorization of A_l. !> If info[l] = i > 0, U_l is singular. U_l[i,i] is the first zero pivot. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgetf2_strided_batched function rocsolver_sgetf2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_sgetf2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetf2_strided_batched_assumed_rank #else module procedure & rocsolver_sgetf2_strided_batched_rank_0,& rocsolver_sgetf2_strided_batched_rank_1,& rocsolver_sgetf2_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgetf2_strided_batched function rocsolver_dgetf2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_dgetf2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetf2_strided_batched_assumed_rank #else module procedure & rocsolver_dgetf2_strided_batched_rank_0,& rocsolver_dgetf2_strided_batched_rank_1,& rocsolver_dgetf2_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgetf2_strided_batched function rocsolver_cgetf2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_cgetf2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetf2_strided_batched_assumed_rank #else module procedure & rocsolver_cgetf2_strided_batched_rank_0,& rocsolver_cgetf2_strided_batched_rank_1,& rocsolver_cgetf2_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgetf2_strided_batched function rocsolver_zgetf2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_zgetf2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetf2_strided_batched_assumed_rank #else module procedure & rocsolver_zgetf2_strided_batched_rank_0,& rocsolver_zgetf2_strided_batched_rank_1,& rocsolver_zgetf2_strided_batched_full_rank #endif #endif end interface interface rocsolver_sgetf2_strided_batched_64 function rocsolver_sgetf2_strided_batched_64_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_sgetf2_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dgetf2_strided_batched_64 function rocsolver_dgetf2_strided_batched_64_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_dgetf2_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cgetf2_strided_batched_64 function rocsolver_cgetf2_strided_batched_64_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_cgetf2_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zgetf2_strided_batched_64 function rocsolver_zgetf2_strided_batched_64_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_zgetf2_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The GETRF functions compute the LU factorization of a general ``m`` -by-``n`` matrix !> ``A`` !> using partial pivoting with row interchanges. !> !> \details !> (This is the blocked Level-3-BLAS version of the algorithm. An optimized internal !> implementation without rocBLAS calls !> could be executed with mid-size matrices if optimizations are enabled (default option). For !> more details, see the !> "rocSOLVER performance tuning" guide.) !> !> The factorization has the form !> !> \f[ !> A = PLU !> \f] !> !> where P is a permutation matrix, L is lower triangular with unit !> diagonal elements (lower trapezoidal if ``m`` > ``n``), and U is upper !> triangular (upper trapezoidal if ``m`` < ``n``). !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the m-by-n matrix A to be factored. !> On exit, the factors L and U from the factorization. !> The unit diagonal elements of L are not stored. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[out] ipiv - pointer to rocblas_int. Array on the GPU of dimension min(m,n). !> The vector of pivot indices. Elements of ipiv are 1-based indices. !> For 1 <= i <= min(m,n), row i of the !> matrix was interchanged with row ipiv[i]. !> Matrix P of the factorization can be derived from ipiv. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, U is singular. U[i,i] is the first zero pivot. interface rocsolver_sgetrf function rocsolver_sgetrf_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_sgetrf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_ 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 type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetrf_assumed_rank #else module procedure & rocsolver_sgetrf_rank_0,& rocsolver_sgetrf_rank_1,& rocsolver_sgetrf_full_rank #endif #endif end interface interface rocsolver_dgetrf function rocsolver_dgetrf_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_dgetrf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_ 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 type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetrf_assumed_rank #else module procedure & rocsolver_dgetrf_rank_0,& rocsolver_dgetrf_rank_1,& rocsolver_dgetrf_full_rank #endif #endif end interface interface rocsolver_cgetrf function rocsolver_cgetrf_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_cgetrf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_ 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 type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetrf_assumed_rank #else module procedure & rocsolver_cgetrf_rank_0,& rocsolver_cgetrf_rank_1,& rocsolver_cgetrf_full_rank #endif #endif end interface interface rocsolver_zgetrf function rocsolver_zgetrf_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_zgetrf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_ 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 type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetrf_assumed_rank #else module procedure & rocsolver_zgetrf_rank_0,& rocsolver_zgetrf_rank_1,& rocsolver_zgetrf_full_rank #endif #endif end interface interface rocsolver_sgetrf_64 function rocsolver_sgetrf_64_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_sgetrf_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function end interface interface rocsolver_dgetrf_64 function rocsolver_dgetrf_64_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_dgetrf_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function end interface interface rocsolver_cgetrf_64 function rocsolver_cgetrf_64_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_cgetrf_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function end interface interface rocsolver_zgetrf_64 function rocsolver_zgetrf_64_(handle,m,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_zgetrf_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function end interface !> \brief The GETRF_BATCHED functions compute the LU factorization of a batch of general !> ``m``-by-``n`` matrices using partial pivoting with row interchanges. !> !> \details !> (This is the blocked Level-3-BLAS version of the algorithm. An optimized internal !> implementation without rocBLAS calls !> could be executed with mid-size matrices if optimizations are enabled (default option). For !> more details, see the !> "rocSOLVER performance tuning" guide.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = P_l L_l U_l !> \f] !> !> where \f$P_l\f$ is a permutation matrix, \f$L_l\f$ is lower triangular with unit !> diagonal elements (lower trapezoidal if ``m`` > ``n``), and \f$U_l\f$ is upper !> triangular (upper trapezoidal if ``m`` < ``n``). !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all matrices A_l in the batch. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the factors L_l and U_l from the factorizations. !> The unit diagonal elements of L_l are not stored. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[out] ipiv - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideP). !> Contains the vectors of pivot indices ipiv_l (corresponding to A_l). !> Dimension of ipiv_l is min(m,n). !> Elements of ipiv_l are 1-based indices. !> For each instance A_l in the batch and for 1 <= i <= min(m,n), row i of the !> matrix A_l was interchanged with row ipiv_l[i]. !> Matrix P_l of the factorization can be derived from ipiv_l. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value of strideP. The normal use case is !> strideP >= min(m,n). !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for factorization of A_l. !> If info[l] = i > 0, U_l is singular. U_l[i,i] is the first zero pivot. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgetrf_batched function rocsolver_sgetrf_batched_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_sgetrf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetrf_batched_assumed_rank #else module procedure & rocsolver_sgetrf_batched_rank_0,& rocsolver_sgetrf_batched_rank_1 #endif #endif end interface interface rocsolver_dgetrf_batched function rocsolver_dgetrf_batched_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_dgetrf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetrf_batched_assumed_rank #else module procedure & rocsolver_dgetrf_batched_rank_0,& rocsolver_dgetrf_batched_rank_1 #endif #endif end interface interface rocsolver_cgetrf_batched function rocsolver_cgetrf_batched_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_cgetrf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetrf_batched_assumed_rank #else module procedure & rocsolver_cgetrf_batched_rank_0,& rocsolver_cgetrf_batched_rank_1 #endif #endif end interface interface rocsolver_zgetrf_batched function rocsolver_zgetrf_batched_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_zgetrf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetrf_batched_assumed_rank #else module procedure & rocsolver_zgetrf_batched_rank_0,& rocsolver_zgetrf_batched_rank_1 #endif #endif end interface interface rocsolver_sgetrf_batched_64 function rocsolver_sgetrf_batched_64_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_sgetrf_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dgetrf_batched_64 function rocsolver_dgetrf_batched_64_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_dgetrf_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cgetrf_batched_64 function rocsolver_cgetrf_batched_64_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_cgetrf_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zgetrf_batched_64 function rocsolver_zgetrf_batched_64_(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_zgetrf_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The GETRF_STRIDED_BATCHED functions compute the LU factorization of a batch of !> general ``m``-by-``n`` matrices using partial pivoting with row interchanges. !> !> \details !> (This is the blocked Level-3-BLAS version of the algorithm. An optimized internal !> implementation without rocBLAS calls !> could be executed with mid-size matrices if optimizations are enabled (default option). For !> more details, see the !> "rocSOLVER performance tuning" guide.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = P_l L_l U_l !> \f] !> !> where \f$P_l\f$ is a permutation matrix, \f$L_l\f$ is lower triangular with unit !> diagonal elements (lower trapezoidal if ``m`` > ``n``), and \f$U_l\f$ is upper !> triangular (upper trapezoidal if ``m`` < ``n``). !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the factors L_l and U_l from the factorization. !> The unit diagonal elements of L_l are not stored. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] ipiv - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideP). !> Contains the vectors of pivots indices ipiv_l (corresponding to A_l). !> Dimension of ipiv_l is min(m,n). !> Elements of ipiv_l are 1-based indices. !> For each instance A_l in the batch and for 1 <= i <= min(m,n), row i of the !> matrix A_l was interchanged with row ipiv_l[i]. !> Matrix P_l of the factorization can be derived from ipiv_l. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value of strideP. The normal use case is !> strideP >= min(m,n). !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for factorization of A_l. !> If info[l] = i > 0, U_l is singular. U_l[i,i] is the first zero pivot. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgetrf_strided_batched function rocsolver_sgetrf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_sgetrf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetrf_strided_batched_assumed_rank #else module procedure & rocsolver_sgetrf_strided_batched_rank_0,& rocsolver_sgetrf_strided_batched_rank_1,& rocsolver_sgetrf_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgetrf_strided_batched function rocsolver_dgetrf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_dgetrf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetrf_strided_batched_assumed_rank #else module procedure & rocsolver_dgetrf_strided_batched_rank_0,& rocsolver_dgetrf_strided_batched_rank_1,& rocsolver_dgetrf_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgetrf_strided_batched function rocsolver_cgetrf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_cgetrf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetrf_strided_batched_assumed_rank #else module procedure & rocsolver_cgetrf_strided_batched_rank_0,& rocsolver_cgetrf_strided_batched_rank_1,& rocsolver_cgetrf_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgetrf_strided_batched function rocsolver_zgetrf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_zgetrf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetrf_strided_batched_assumed_rank #else module procedure & rocsolver_zgetrf_strided_batched_rank_0,& rocsolver_zgetrf_strided_batched_rank_1,& rocsolver_zgetrf_strided_batched_full_rank #endif #endif end interface interface rocsolver_sgetrf_strided_batched_64 function rocsolver_sgetrf_strided_batched_64_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_sgetrf_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dgetrf_strided_batched_64 function rocsolver_dgetrf_strided_batched_64_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_dgetrf_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cgetrf_strided_batched_64 function rocsolver_cgetrf_strided_batched_64_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_cgetrf_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zgetrf_strided_batched_64 function rocsolver_zgetrf_strided_batched_64_(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_zgetrf_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The GEQR2 functions compute a QR factorization of a general ``m`` -by-``n`` matrix !> ``A``. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The factorization has the form !> !> \f[ !> A = Q\left[\begin{array}{c} !> R\\% !> 0 !> \end{array}\right] !> \f] !> !> where R is upper triangular (upper trapezoidal if ``m`` < ``n``), and Q is !> an ``m`` -by-``m`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q = H(1)H(2)\cdots H(k), \quad \text{with} \: k = \text{min}(m,n) !> \f] !> !> Each Householder matrix \f$H(i)\f$ is given by !> !> \f[ !> H(i) = I - \text{ipiv}[i] \cdot v_i^{} v_i^H !> \f] !> !> where the first i-1 elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = !> 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the m-by-n matrix to be factored. !> On exit, the elements on and above the diagonal contain the !> factor R, and the elements below the diagonal are the last m - i elements !> of Householder vector v_i. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[out] ipiv - pointer to type. Array on the GPU of dimension min(m,n). !> The Householder scalars. interface rocsolver_sgeqr2 function rocsolver_sgeqr2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_sgeqr2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgeqr2_assumed_rank #else module procedure & rocsolver_sgeqr2_rank_0,& rocsolver_sgeqr2_rank_1,& rocsolver_sgeqr2_full_rank #endif #endif end interface interface rocsolver_dgeqr2 function rocsolver_dgeqr2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_dgeqr2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgeqr2_assumed_rank #else module procedure & rocsolver_dgeqr2_rank_0,& rocsolver_dgeqr2_rank_1,& rocsolver_dgeqr2_full_rank #endif #endif end interface interface rocsolver_cgeqr2 function rocsolver_cgeqr2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_cgeqr2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgeqr2_assumed_rank #else module procedure & rocsolver_cgeqr2_rank_0,& rocsolver_cgeqr2_rank_1,& rocsolver_cgeqr2_full_rank #endif #endif end interface interface rocsolver_zgeqr2 function rocsolver_zgeqr2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_zgeqr2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgeqr2_assumed_rank #else module procedure & rocsolver_zgeqr2_rank_0,& rocsolver_zgeqr2_rank_1,& rocsolver_zgeqr2_full_rank #endif #endif end interface interface rocsolver_sgeqr2_64 function rocsolver_sgeqr2_64_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_sgeqr2_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv end function end interface interface rocsolver_dgeqr2_64 function rocsolver_dgeqr2_64_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_dgeqr2_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv end function end interface interface rocsolver_cgeqr2_64 function rocsolver_cgeqr2_64_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_cgeqr2_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv end function end interface interface rocsolver_zgeqr2_64 function rocsolver_zgeqr2_64_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_zgeqr2_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv end function end interface !> \brief The GEQR2_BATCHED functions compute the QR factorization of a batch of general !> ``m``-by-``n`` matrices. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = Q_l\left[\begin{array}{c} !> R_l\\% !> 0 !> \end{array}\right] !> \f] !> !> where \f$R_l\f$ is upper triangular (upper trapezoidal if ``m`` < ``n``), and \f$Q_l\f$ is !> an ``m`` -by-``m`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q_l = H_l(1)H_l(2)\cdots H_l(k), \quad \text{with} \: k = \text{min}(m,n) !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{ipiv}_l^{}[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where the first i-1 elements of Householder vector \f$v_{l_i}\f$ are zero, and !> \f$v_{l_i}[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on and above the diagonal contain the !> factor R_l. The elements below the diagonal are the last m - i elements !> of Householder vector v_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[out] ipiv - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors ipiv_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgeqr2_batched function rocsolver_sgeqr2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_sgeqr2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgeqr2_batched_assumed_rank #else module procedure & rocsolver_sgeqr2_batched_rank_0,& rocsolver_sgeqr2_batched_rank_1 #endif #endif end interface interface rocsolver_dgeqr2_batched function rocsolver_dgeqr2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_dgeqr2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgeqr2_batched_assumed_rank #else module procedure & rocsolver_dgeqr2_batched_rank_0,& rocsolver_dgeqr2_batched_rank_1 #endif #endif end interface interface rocsolver_cgeqr2_batched function rocsolver_cgeqr2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_cgeqr2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgeqr2_batched_assumed_rank #else module procedure & rocsolver_cgeqr2_batched_rank_0,& rocsolver_cgeqr2_batched_rank_1 #endif #endif end interface interface rocsolver_zgeqr2_batched function rocsolver_zgeqr2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_zgeqr2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgeqr2_batched_assumed_rank #else module procedure & rocsolver_zgeqr2_batched_rank_0,& rocsolver_zgeqr2_batched_rank_1 #endif #endif end interface interface rocsolver_sgeqr2_batched_64 function rocsolver_sgeqr2_batched_64_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_sgeqr2_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dgeqr2_batched_64 function rocsolver_dgeqr2_batched_64_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_dgeqr2_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cgeqr2_batched_64 function rocsolver_cgeqr2_batched_64_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_cgeqr2_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zgeqr2_batched_64 function rocsolver_zgeqr2_batched_64_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_zgeqr2_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int64_t),value :: batch_count end function end interface !> \brief The GEQR2_STRIDED_BATCHED functions computes the QR factorization of a batch of !> general ``m``-by-``n`` matrices. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = Q_l\left[\begin{array}{c} !> R_l\\% !> 0 !> \end{array}\right] !> \f] !> !> where \f$R_l\f$ is upper triangular (upper trapezoidal if ``m`` < ``n``), and \f$Q_l\f$ is !> an ``m`` -by-``m`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q_l = H_l(1)H_l(2)\cdots H_l(k), \quad \text{with} \: k = \text{min}(m,n) !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{ipiv}_l^{}[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where the first i-1 elements of Householder vector \f$v_{l_i}\f$ are zero, and !> \f$v_{l_i}[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on and above the diagonal contain the !> factor R_l. The elements below the diagonal are the last m - i elements !> of Householder vector v_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] ipiv - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors ipiv_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgeqr2_strided_batched function rocsolver_sgeqr2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_sgeqr2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgeqr2_strided_batched_assumed_rank #else module procedure & rocsolver_sgeqr2_strided_batched_rank_0,& rocsolver_sgeqr2_strided_batched_rank_1,& rocsolver_sgeqr2_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgeqr2_strided_batched function rocsolver_dgeqr2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_dgeqr2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgeqr2_strided_batched_assumed_rank #else module procedure & rocsolver_dgeqr2_strided_batched_rank_0,& rocsolver_dgeqr2_strided_batched_rank_1,& rocsolver_dgeqr2_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgeqr2_strided_batched function rocsolver_cgeqr2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_cgeqr2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgeqr2_strided_batched_assumed_rank #else module procedure & rocsolver_cgeqr2_strided_batched_rank_0,& rocsolver_cgeqr2_strided_batched_rank_1,& rocsolver_cgeqr2_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgeqr2_strided_batched function rocsolver_zgeqr2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_zgeqr2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgeqr2_strided_batched_assumed_rank #else module procedure & rocsolver_zgeqr2_strided_batched_rank_0,& rocsolver_zgeqr2_strided_batched_rank_1,& rocsolver_zgeqr2_strided_batched_full_rank #endif #endif end interface interface rocsolver_sgeqr2_strided_batched_64 function rocsolver_sgeqr2_strided_batched_64_(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) & bind(c, name="rocsolver_sgeqr2_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dgeqr2_strided_batched_64 function rocsolver_dgeqr2_strided_batched_64_(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) & bind(c, name="rocsolver_dgeqr2_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cgeqr2_strided_batched_64 function rocsolver_cgeqr2_strided_batched_64_(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) & bind(c, name="rocsolver_cgeqr2_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zgeqr2_strided_batched_64 function rocsolver_zgeqr2_strided_batched_64_(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) & bind(c, name="rocsolver_zgeqr2_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int64_t),value :: batch_count end function end interface !> \brief The GERQ2 functions compute a RQ factorization of a general ``m`` -by-``n`` matrix !> ``A``. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The factorization has the form !> !> \f[ !> A = \left[\begin{array}{cc} !> 0 & R !> \end{array}\right] Q !> \f] !> !> where R is upper triangular (upper trapezoidal if ``m`` > ``n``), and Q is !> an ``n`` -by-``n`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q = H(1)'H(2)' \cdots H(k)', \quad \text{with} \: k = \text{min}(m,n). !> \f] !> !> Each Householder matrix \f$H(i)\f$ is given by !> !> \f[ !> H(i) = I - \text{ipiv}[i] \cdot v_i^{} v_i^H !> \f] !> !> where the last n-i elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = !> 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the m-by-n matrix to be factored. !> On exit, the elements on and above the (m-n)-th subdiagonal (when !> m >= n) or the (n-m)-th superdiagonal (when n > m) contain the !> factor R, and the elements below the sub/superdiagonal are the first i - 1 !> elements of Householder vector v_i. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[out] ipiv - pointer to type. Array on the GPU of dimension min(m,n). !> The Householder scalars. interface rocsolver_sgerq2 function rocsolver_sgerq2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_sgerq2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgerq2_assumed_rank #else module procedure & rocsolver_sgerq2_rank_0,& rocsolver_sgerq2_rank_1,& rocsolver_sgerq2_full_rank #endif #endif end interface interface rocsolver_dgerq2 function rocsolver_dgerq2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_dgerq2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgerq2_assumed_rank #else module procedure & rocsolver_dgerq2_rank_0,& rocsolver_dgerq2_rank_1,& rocsolver_dgerq2_full_rank #endif #endif end interface interface rocsolver_cgerq2 function rocsolver_cgerq2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_cgerq2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgerq2_assumed_rank #else module procedure & rocsolver_cgerq2_rank_0,& rocsolver_cgerq2_rank_1,& rocsolver_cgerq2_full_rank #endif #endif end interface interface rocsolver_zgerq2 function rocsolver_zgerq2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_zgerq2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgerq2_assumed_rank #else module procedure & rocsolver_zgerq2_rank_0,& rocsolver_zgerq2_rank_1,& rocsolver_zgerq2_full_rank #endif #endif end interface !> \brief The GERQ2_BATCHED functions compute the RQ factorization of a batch of general !> ``m``-by-``n`` matrices. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = \left[\begin{array}{cc} !> 0 & R_l !> \end{array}\right] Q_l !> \f] !> !> where \f$R_l\f$ is upper triangular (upper trapezoidal if ``m`` > ``n``), and \f$Q_l\f$ is !> an ``n`` -by-``n`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q_l = H_l(1)'H_l(2)' \cdots H_l(k)', \quad \text{with} \: k = \text{min}(m,n). !> \f] !> !> Each Householder matrices \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{ipiv}_l^{}[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where the last n-i elements of Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i] !> = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on and above the (m-n)-th subdiagonal (when !> m >= n) or the (n-m)-th superdiagonal (when n > m) contain the !> factor R_l, and the elements below the sub/superdiagonal are the first i - 1 !> elements of Householder vector v_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[out] ipiv - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors ipiv_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgerq2_batched function rocsolver_sgerq2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_sgerq2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgerq2_batched_assumed_rank #else module procedure & rocsolver_sgerq2_batched_rank_0,& rocsolver_sgerq2_batched_rank_1 #endif #endif end interface interface rocsolver_dgerq2_batched function rocsolver_dgerq2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_dgerq2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgerq2_batched_assumed_rank #else module procedure & rocsolver_dgerq2_batched_rank_0,& rocsolver_dgerq2_batched_rank_1 #endif #endif end interface interface rocsolver_cgerq2_batched function rocsolver_cgerq2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_cgerq2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgerq2_batched_assumed_rank #else module procedure & rocsolver_cgerq2_batched_rank_0,& rocsolver_cgerq2_batched_rank_1 #endif #endif end interface interface rocsolver_zgerq2_batched function rocsolver_zgerq2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_zgerq2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgerq2_batched_assumed_rank #else module procedure & rocsolver_zgerq2_batched_rank_0,& rocsolver_zgerq2_batched_rank_1 #endif #endif end interface !> \brief The GERQ2_STRIDED_BATCHED functions compute the RQ factorization of a batch of !> general ``m``-by-``n`` matrices. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = \left[\begin{array}{cc} !> 0 & R_l !> \end{array}\right] Q_l !> \f] !> !> where \f$R_l\f$ is upper triangular (upper trapezoidal if ``m`` > ``n``), and \f$Q_l\f$ is !> an ``n`` -by-``n`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q_l = H_l(1)'H_l(2)' \cdots H_l(k)', \quad \text{with} \: k = \text{min}(m,n). !> \f] !> !> Each Householder matrices \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{ipiv}_l^{}[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where the last n-i elements of Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i] !> = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on and above the (m-n)-th subdiagonal (when !> m >= n) or the (n-m)-th superdiagonal (when n > m) contain the !> factor R_l, and the elements below the sub/superdiagonal are the first i - 1 !> elements of Householder vector v_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] ipiv - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors ipiv_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgerq2_strided_batched function rocsolver_sgerq2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_sgerq2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgerq2_strided_batched_assumed_rank #else module procedure & rocsolver_sgerq2_strided_batched_rank_0,& rocsolver_sgerq2_strided_batched_rank_1,& rocsolver_sgerq2_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgerq2_strided_batched function rocsolver_dgerq2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_dgerq2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgerq2_strided_batched_assumed_rank #else module procedure & rocsolver_dgerq2_strided_batched_rank_0,& rocsolver_dgerq2_strided_batched_rank_1,& rocsolver_dgerq2_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgerq2_strided_batched function rocsolver_cgerq2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_cgerq2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgerq2_strided_batched_assumed_rank #else module procedure & rocsolver_cgerq2_strided_batched_rank_0,& rocsolver_cgerq2_strided_batched_rank_1,& rocsolver_cgerq2_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgerq2_strided_batched function rocsolver_zgerq2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_zgerq2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgerq2_strided_batched_assumed_rank #else module procedure & rocsolver_zgerq2_strided_batched_rank_0,& rocsolver_zgerq2_strided_batched_rank_1,& rocsolver_zgerq2_strided_batched_full_rank #endif #endif end interface !> \brief The GEQL2 functions compute a QL factorization of a general ``m`` -by-``n`` matrix !> ``A``. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The factorization has the form !> !> \f[ !> A = Q\left[\begin{array}{c} !> 0\\% !> L !> \end{array}\right] !> \f] !> !> where L is lower triangular (lower trapezoidal if ``m`` < ``n``), and Q is !> an ``m`` -by-``m`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q = H(k)H(k-1)\cdots H(1), \quad \text{with} \: k = \text{min}(m,n) !> \f] !> !> Each Householder matrix \f$H(i)\f$ is given by !> !> \f[ !> H(i) = I - \text{ipiv}[i] \cdot v_i^{} v_i^H !> \f] !> !> where the last m-i elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = !> 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the m-by-n matrix to be factored. !> On exit, the elements on and below the (m-n)-th subdiagonal (when !> m >= n) or the (n-m)-th superdiagonal (when n > m) contain the !> factor L, and the elements above the sub/superdiagonal are the first i - 1 !> elements of Householder vector v_i. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[out] ipiv - pointer to type. Array on the GPU of dimension min(m,n). !> The Householder scalars. interface rocsolver_sgeql2 function rocsolver_sgeql2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_sgeql2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgeql2_assumed_rank #else module procedure & rocsolver_sgeql2_rank_0,& rocsolver_sgeql2_rank_1,& rocsolver_sgeql2_full_rank #endif #endif end interface interface rocsolver_dgeql2 function rocsolver_dgeql2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_dgeql2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgeql2_assumed_rank #else module procedure & rocsolver_dgeql2_rank_0,& rocsolver_dgeql2_rank_1,& rocsolver_dgeql2_full_rank #endif #endif end interface interface rocsolver_cgeql2 function rocsolver_cgeql2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_cgeql2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgeql2_assumed_rank #else module procedure & rocsolver_cgeql2_rank_0,& rocsolver_cgeql2_rank_1,& rocsolver_cgeql2_full_rank #endif #endif end interface interface rocsolver_zgeql2 function rocsolver_zgeql2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_zgeql2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgeql2_assumed_rank #else module procedure & rocsolver_zgeql2_rank_0,& rocsolver_zgeql2_rank_1,& rocsolver_zgeql2_full_rank #endif #endif end interface !> \brief The GEQL2_BATCHED functions compute the QL factorization of a batch of general !> ``m``-by-``n`` matrices. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = Q_l\left[\begin{array}{c} !> 0\\% !> L_l !> \end{array}\right] !> \f] !> !> where \f$L_l\f$ is lower triangular (lower trapezoidal if ``m`` < ``n``), and \f$Q_l\f$ is !> an ``m`` -by-``m`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q_l = H_l(k)H_l(k-1)\cdots H_l(1), \quad \text{with} \: k = \text{min}(m,n) !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{ipiv}_l^{}[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where the last m-i elements of the Householder vector \f$v_{l_i}\f$ are zero, and !> \f$v_{l_i}[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on and below the (m-n)-th subdiagonal (when !> m >= n) or the (n-m)-th superdiagonal (when n > m) contain the !> factor L_l, and the elements above the sub/superdiagonal are the first i - 1 !> elements of Householder vector v_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[out] ipiv - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors ipiv_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value !> of strideP. The normal use is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgeql2_batched function rocsolver_sgeql2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_sgeql2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgeql2_batched_assumed_rank #else module procedure & rocsolver_sgeql2_batched_rank_0,& rocsolver_sgeql2_batched_rank_1 #endif #endif end interface interface rocsolver_dgeql2_batched function rocsolver_dgeql2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_dgeql2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgeql2_batched_assumed_rank #else module procedure & rocsolver_dgeql2_batched_rank_0,& rocsolver_dgeql2_batched_rank_1 #endif #endif end interface interface rocsolver_cgeql2_batched function rocsolver_cgeql2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_cgeql2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgeql2_batched_assumed_rank #else module procedure & rocsolver_cgeql2_batched_rank_0,& rocsolver_cgeql2_batched_rank_1 #endif #endif end interface interface rocsolver_zgeql2_batched function rocsolver_zgeql2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_zgeql2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgeql2_batched_assumed_rank #else module procedure & rocsolver_zgeql2_batched_rank_0,& rocsolver_zgeql2_batched_rank_1 #endif #endif end interface !> \brief The GEQL2_STRIDED_BATCHED functions compute the QL factorization of a batch of !> general ``m``-by-``n`` matrices. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = Q_l\left[\begin{array}{c} !> 0\\% !> L_l !> \end{array}\right] !> \f] !> !> where \f$L_l\f$ is lower triangular (lower trapezoidal if ``m`` < ``n``), and \f$Q_l\f$ is !> an ``m`` -by-``m`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q_l = H_l(k)H_l(k-1)\cdots H_l(1), \quad \text{with} \: k = \text{min}(m,n) !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{ipiv}_l^{}[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where the last m-i elements of the Householder vector \f$v_{l_i}\f$ are zero, and !> \f$v_{l_i}[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on and below the (m-n)-th subdiagonal (when !> m >= n) or the (n-m)-th superdiagonal (when n > m) contain the !> factor L_l, and the elements above the sub/superdiagonal are the first i - 1 !> elements of Householder vector v_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] ipiv - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors ipiv_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgeql2_strided_batched function rocsolver_sgeql2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_sgeql2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgeql2_strided_batched_assumed_rank #else module procedure & rocsolver_sgeql2_strided_batched_rank_0,& rocsolver_sgeql2_strided_batched_rank_1,& rocsolver_sgeql2_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgeql2_strided_batched function rocsolver_dgeql2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_dgeql2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgeql2_strided_batched_assumed_rank #else module procedure & rocsolver_dgeql2_strided_batched_rank_0,& rocsolver_dgeql2_strided_batched_rank_1,& rocsolver_dgeql2_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgeql2_strided_batched function rocsolver_cgeql2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_cgeql2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgeql2_strided_batched_assumed_rank #else module procedure & rocsolver_cgeql2_strided_batched_rank_0,& rocsolver_cgeql2_strided_batched_rank_1,& rocsolver_cgeql2_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgeql2_strided_batched function rocsolver_zgeql2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_zgeql2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgeql2_strided_batched_assumed_rank #else module procedure & rocsolver_zgeql2_strided_batched_rank_0,& rocsolver_zgeql2_strided_batched_rank_1,& rocsolver_zgeql2_strided_batched_full_rank #endif #endif end interface !> \brief The GELQ2 functions compute a LQ factorization of a general ``m`` -by-``n`` matrix !> ``A``. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The factorization has the form !> !> \f[ !> A = \left[\begin{array}{cc} !> L & 0 !> \end{array}\right] Q !> \f] !> !> where L is lower triangular (lower trapezoidal if ``m`` > ``n``), and Q is !> an ``n`` -by-``n`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q = H(k)'H(k-1)' \cdots H(1)', \quad \text{with} \: k = \text{min}(m,n). !> \f] !> !> Each Householder matrix \f$H(i)\f$ is given by !> !> \f[ !> H(i) = I - \text{ipiv}[i] \cdot v_i^H v_i^{} !> \f] !> !> where the first i-1 elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = !> 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the m-by-n matrix to be factored. !> On exit, the elements on and below the diagonal contain the !> factor L, and the elements above the diagonal are the last n - i elements !> of Householder vector v_i. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[out] ipiv - pointer to type. Array on the GPU of dimension min(m,n). !> The Householder scalars. interface rocsolver_sgelq2 function rocsolver_sgelq2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_sgelq2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgelq2_assumed_rank #else module procedure & rocsolver_sgelq2_rank_0,& rocsolver_sgelq2_rank_1,& rocsolver_sgelq2_full_rank #endif #endif end interface interface rocsolver_dgelq2 function rocsolver_dgelq2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_dgelq2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgelq2_assumed_rank #else module procedure & rocsolver_dgelq2_rank_0,& rocsolver_dgelq2_rank_1,& rocsolver_dgelq2_full_rank #endif #endif end interface interface rocsolver_cgelq2 function rocsolver_cgelq2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_cgelq2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgelq2_assumed_rank #else module procedure & rocsolver_cgelq2_rank_0,& rocsolver_cgelq2_rank_1,& rocsolver_cgelq2_full_rank #endif #endif end interface interface rocsolver_zgelq2 function rocsolver_zgelq2_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_zgelq2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgelq2_assumed_rank #else module procedure & rocsolver_zgelq2_rank_0,& rocsolver_zgelq2_rank_1,& rocsolver_zgelq2_full_rank #endif #endif end interface !> \brief The GELQ2_BATCHED functions compute the LQ factorization of a batch of general !> ``m``-by-``n`` matrices. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = \left[\begin{array}{cc} !> L_l & 0 !> \end{array}\right] Q_l !> \f] !> !> where \f$L_l\f$ is lower triangular (lower trapezoidal if ``m`` > ``n``), and \f$Q_l\f$ is !> an ``n`` -by-``n`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q_l = H_l(k)'H_l(k-1)' \cdots H_l(1)', \quad \text{with} \: k = \text{min}(m,n). !> \f] !> !> Each Householder matrices \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{ipiv}_l^{}[i] \cdot v_{l_i}^H v_{l_i}^{} !> \f] !> !> where the first i-1 elements of Householder vector \f$v_{l_i}\f$ are zero, and !> \f$v_{l_i}[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on and below the diagonal contain the !> factor L_l. The elements above the diagonal are the last n - i elements !> of Householder vector v_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[out] ipiv - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors ipiv_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgelq2_batched function rocsolver_sgelq2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_sgelq2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgelq2_batched_assumed_rank #else module procedure & rocsolver_sgelq2_batched_rank_0,& rocsolver_sgelq2_batched_rank_1 #endif #endif end interface interface rocsolver_dgelq2_batched function rocsolver_dgelq2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_dgelq2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgelq2_batched_assumed_rank #else module procedure & rocsolver_dgelq2_batched_rank_0,& rocsolver_dgelq2_batched_rank_1 #endif #endif end interface interface rocsolver_cgelq2_batched function rocsolver_cgelq2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_cgelq2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgelq2_batched_assumed_rank #else module procedure & rocsolver_cgelq2_batched_rank_0,& rocsolver_cgelq2_batched_rank_1 #endif #endif end interface interface rocsolver_zgelq2_batched function rocsolver_zgelq2_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_zgelq2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgelq2_batched_assumed_rank #else module procedure & rocsolver_zgelq2_batched_rank_0,& rocsolver_zgelq2_batched_rank_1 #endif #endif end interface !> \brief The GELQ2_STRIDED_BATCHED functions compute the LQ factorization of a batch of !> general ``m``-by-``n`` matrices. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = \left[\begin{array}{cc} !> L_l & 0 !> \end{array}\right] Q_l !> \f] !> !> where \f$L_l\f$ is lower triangular (lower trapezoidal if ``m`` > ``n``), and \f$Q_l\f$ is !> an ``n`` -by-``n`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q_l = H_l(k)'H_l(k-1)' \cdots H_l(1)', \quad \text{with} \: k = \text{min}(m,n). !> \f] !> !> Each Householder matrices \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{ipiv}_l^{}[i] \cdot v_{l_i}^H v_{l_i}^{} !> \f] !> !> where the first i-1 elements of Householder vector \f$v_{l_i}\f$ are zero, and !> \f$v_{l_i}[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on and below the diagonal contain the !> factor L_l. The elements above the diagonal are the last n - i elements !> of Householder vector v_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] ipiv - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors ipiv_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgelq2_strided_batched function rocsolver_sgelq2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_sgelq2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgelq2_strided_batched_assumed_rank #else module procedure & rocsolver_sgelq2_strided_batched_rank_0,& rocsolver_sgelq2_strided_batched_rank_1,& rocsolver_sgelq2_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgelq2_strided_batched function rocsolver_dgelq2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_dgelq2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgelq2_strided_batched_assumed_rank #else module procedure & rocsolver_dgelq2_strided_batched_rank_0,& rocsolver_dgelq2_strided_batched_rank_1,& rocsolver_dgelq2_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgelq2_strided_batched function rocsolver_cgelq2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_cgelq2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgelq2_strided_batched_assumed_rank #else module procedure & rocsolver_cgelq2_strided_batched_rank_0,& rocsolver_cgelq2_strided_batched_rank_1,& rocsolver_cgelq2_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgelq2_strided_batched function rocsolver_zgelq2_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_zgelq2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgelq2_strided_batched_assumed_rank #else module procedure & rocsolver_zgelq2_strided_batched_rank_0,& rocsolver_zgelq2_strided_batched_rank_1,& rocsolver_zgelq2_strided_batched_full_rank #endif #endif end interface !> \brief The GEQRF functions compute a QR factorization of a general ``m`` -by-``n`` matrix !> ``A``. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The factorization has the form !> !> \f[ !> A = Q\left[\begin{array}{c} !> R\\% !> 0 !> \end{array}\right] !> \f] !> !> where R is upper triangular (upper trapezoidal if ``m`` < ``n``), and Q is !> an ``m`` -by-``m`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q = H(1)H(2)\cdots H(k), \quad \text{with} \: k = \text{min}(m,n) !> \f] !> !> Each Householder matrix \f$H(i)\f$ is given by !> !> \f[ !> H(i) = I - \text{ipiv}[i] \cdot v_i^{} v_i^H !> \f] !> !> where the first i-1 elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = !> 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the m-by-n matrix to be factored. !> On exit, the elements on and above the diagonal contain the !> factor R, and the elements below the diagonal are the last m - i elements !> of Householder vector v_i. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[out] ipiv - pointer to type. Array on the GPU of dimension min(m,n). !> The Householder scalars. interface rocsolver_sgeqrf function rocsolver_sgeqrf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_sgeqrf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgeqrf_assumed_rank #else module procedure & rocsolver_sgeqrf_rank_0,& rocsolver_sgeqrf_rank_1,& rocsolver_sgeqrf_full_rank #endif #endif end interface interface rocsolver_dgeqrf function rocsolver_dgeqrf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_dgeqrf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgeqrf_assumed_rank #else module procedure & rocsolver_dgeqrf_rank_0,& rocsolver_dgeqrf_rank_1,& rocsolver_dgeqrf_full_rank #endif #endif end interface interface rocsolver_cgeqrf function rocsolver_cgeqrf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_cgeqrf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgeqrf_assumed_rank #else module procedure & rocsolver_cgeqrf_rank_0,& rocsolver_cgeqrf_rank_1,& rocsolver_cgeqrf_full_rank #endif #endif end interface interface rocsolver_zgeqrf function rocsolver_zgeqrf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_zgeqrf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgeqrf_assumed_rank #else module procedure & rocsolver_zgeqrf_rank_0,& rocsolver_zgeqrf_rank_1,& rocsolver_zgeqrf_full_rank #endif #endif end interface interface rocsolver_sgeqrf_64 function rocsolver_sgeqrf_64_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_sgeqrf_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv end function end interface interface rocsolver_dgeqrf_64 function rocsolver_dgeqrf_64_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_dgeqrf_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv end function end interface interface rocsolver_cgeqrf_64 function rocsolver_cgeqrf_64_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_cgeqrf_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv end function end interface interface rocsolver_zgeqrf_64 function rocsolver_zgeqrf_64_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_zgeqrf_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv end function end interface !> \brief The GEQRF_BATCHED functions compute the QR factorization of a batch of general !> ``m``-by-``n`` matrices. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = Q_l\left[\begin{array}{c} !> R_l\\% !> 0 !> \end{array}\right] !> \f] !> !> where \f$R_l\f$ is upper triangular (upper trapezoidal if ``m`` < ``n``), and \f$Q_l\f$ is !> an ``m`` -by-``m`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q_l = H_l(1)H_l(2)\cdots H_l(k), \quad \text{with} \: k = \text{min}(m,n) !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{ipiv}_l^{}[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where the first i-1 elements of Householder vector \f$v_{l_i}\f$ are zero, and !> \f$v_{l_i}[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on and above the diagonal contain the !> factor R_l. The elements below the diagonal are the last m - i elements !> of Householder vector v_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[out] ipiv - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors ipiv_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgeqrf_batched function rocsolver_sgeqrf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_sgeqrf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgeqrf_batched_assumed_rank #else module procedure & rocsolver_sgeqrf_batched_rank_0,& rocsolver_sgeqrf_batched_rank_1 #endif #endif end interface interface rocsolver_dgeqrf_batched function rocsolver_dgeqrf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_dgeqrf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgeqrf_batched_assumed_rank #else module procedure & rocsolver_dgeqrf_batched_rank_0,& rocsolver_dgeqrf_batched_rank_1 #endif #endif end interface interface rocsolver_cgeqrf_batched function rocsolver_cgeqrf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_cgeqrf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgeqrf_batched_assumed_rank #else module procedure & rocsolver_cgeqrf_batched_rank_0,& rocsolver_cgeqrf_batched_rank_1 #endif #endif end interface interface rocsolver_zgeqrf_batched function rocsolver_zgeqrf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_zgeqrf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgeqrf_batched_assumed_rank #else module procedure & rocsolver_zgeqrf_batched_rank_0,& rocsolver_zgeqrf_batched_rank_1 #endif #endif end interface interface rocsolver_sgeqrf_batched_64 function rocsolver_sgeqrf_batched_64_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_sgeqrf_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dgeqrf_batched_64 function rocsolver_dgeqrf_batched_64_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_dgeqrf_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cgeqrf_batched_64 function rocsolver_cgeqrf_batched_64_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_cgeqrf_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zgeqrf_batched_64 function rocsolver_zgeqrf_batched_64_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_zgeqrf_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int64_t),value :: batch_count end function end interface !> \brief The GEQRF_STRIDED_BATCHED functions compute the QR factorization of a batch of !> general m-by-n matrices. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = Q_l\left[\begin{array}{c} !> R_l\\% !> 0 !> \end{array}\right] !> \f] !> !> where \f$R_l\f$ is upper triangular (upper trapezoidal if ``m`` < ``n``), and \f$Q_l\f$ is !> an ``m`` -by-``m`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q_l = H_l(1)H_l(2)\cdots H_l(k), \quad \text{with} \: k = \text{min}(m,n) !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{ipiv}_l^{}[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where the first i-1 elements of Householder vector \f$v_{l_i}\f$ are zero, and !> \f$v_{l_i}[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on and above the diagonal contain the !> factor R_l. The elements below the diagonal are the last m - i elements !> of Householder vector v_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] ipiv - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors ipiv_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgeqrf_strided_batched function rocsolver_sgeqrf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_sgeqrf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgeqrf_strided_batched_assumed_rank #else module procedure & rocsolver_sgeqrf_strided_batched_rank_0,& rocsolver_sgeqrf_strided_batched_rank_1,& rocsolver_sgeqrf_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgeqrf_strided_batched function rocsolver_dgeqrf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_dgeqrf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgeqrf_strided_batched_assumed_rank #else module procedure & rocsolver_dgeqrf_strided_batched_rank_0,& rocsolver_dgeqrf_strided_batched_rank_1,& rocsolver_dgeqrf_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgeqrf_strided_batched function rocsolver_cgeqrf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_cgeqrf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgeqrf_strided_batched_assumed_rank #else module procedure & rocsolver_cgeqrf_strided_batched_rank_0,& rocsolver_cgeqrf_strided_batched_rank_1,& rocsolver_cgeqrf_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgeqrf_strided_batched function rocsolver_zgeqrf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_zgeqrf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgeqrf_strided_batched_assumed_rank #else module procedure & rocsolver_zgeqrf_strided_batched_rank_0,& rocsolver_zgeqrf_strided_batched_rank_1,& rocsolver_zgeqrf_strided_batched_full_rank #endif #endif end interface interface rocsolver_sgeqrf_strided_batched_64 function rocsolver_sgeqrf_strided_batched_64_(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) & bind(c, name="rocsolver_sgeqrf_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dgeqrf_strided_batched_64 function rocsolver_dgeqrf_strided_batched_64_(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) & bind(c, name="rocsolver_dgeqrf_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cgeqrf_strided_batched_64 function rocsolver_cgeqrf_strided_batched_64_(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) & bind(c, name="rocsolver_cgeqrf_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zgeqrf_strided_batched_64 function rocsolver_zgeqrf_strided_batched_64_(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) & bind(c, name="rocsolver_zgeqrf_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_strided_batched_64_ type(c_ptr),value :: handle integer(c_int64_t),value :: m integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int64_t),value :: batch_count end function end interface !> \brief The GERQF functions compute a RQ factorization of a general ``m`` -by-``n`` matrix !> ``A``. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The factorization has the form !> !> \f[ !> A = \left[\begin{array}{cc} !> 0 & R !> \end{array}\right] Q !> \f] !> !> where R is upper triangular (upper trapezoidal if ``m`` > ``n``), and Q is !> an ``n`` -by-``n`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q = H(1)'H(2)' \cdots H(k)', \quad \text{with} \: k = \text{min}(m,n). !> \f] !> !> Each Householder matrix \f$H(i)\f$ is given by !> !> \f[ !> H(i) = I - \text{ipiv}[i] \cdot v_i^{} v_i^H !> \f] !> !> where the last n-i elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = !> 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the m-by-n matrix to be factored. !> On exit, the elements on and above the (m-n)-th subdiagonal (when !> m >= n) or the (n-m)-th superdiagonal (when n > m) contain the !> factor R, and the elements below the sub/superdiagonal are the first i - 1 !> elements of Householder vector v_i. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[out] ipiv - pointer to type. Array on the GPU of dimension min(m,n). !> The Householder scalars. interface rocsolver_sgerqf function rocsolver_sgerqf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_sgerqf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgerqf_assumed_rank #else module procedure & rocsolver_sgerqf_rank_0,& rocsolver_sgerqf_rank_1,& rocsolver_sgerqf_full_rank #endif #endif end interface interface rocsolver_dgerqf function rocsolver_dgerqf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_dgerqf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgerqf_assumed_rank #else module procedure & rocsolver_dgerqf_rank_0,& rocsolver_dgerqf_rank_1,& rocsolver_dgerqf_full_rank #endif #endif end interface interface rocsolver_cgerqf function rocsolver_cgerqf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_cgerqf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgerqf_assumed_rank #else module procedure & rocsolver_cgerqf_rank_0,& rocsolver_cgerqf_rank_1,& rocsolver_cgerqf_full_rank #endif #endif end interface interface rocsolver_zgerqf function rocsolver_zgerqf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_zgerqf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgerqf_assumed_rank #else module procedure & rocsolver_zgerqf_rank_0,& rocsolver_zgerqf_rank_1,& rocsolver_zgerqf_full_rank #endif #endif end interface !> \brief The GERQF_BATCHED functions compute the RQ factorization of a batch of general !> ``m``-by-``n`` matrices. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = \left[\begin{array}{cc} !> 0 & R_l !> \end{array}\right] Q_l !> \f] !> !> where \f$R_l\f$ is upper triangular (upper trapezoidal if ``m`` > ``n``), and \f$Q_l\f$ is !> an ``n`` -by-``n`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q_l = H_l(1)'H_l(2)' \cdots H_l(k)', \quad \text{with} \: k = \text{min}(m,n). !> \f] !> !> Each Householder matrices \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{ipiv}_l^{}[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where the last n-i elements of Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i] !> = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on and above the (m-n)-th subdiagonal (when !> m >= n) or the (n-m)-th superdiagonal (when n > m) contain the !> factor R_l, and the elements below the sub/superdiagonal are the first i - 1 !> elements of Householder vector v_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[out] ipiv - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors ipiv_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgerqf_batched function rocsolver_sgerqf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_sgerqf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgerqf_batched_assumed_rank #else module procedure & rocsolver_sgerqf_batched_rank_0,& rocsolver_sgerqf_batched_rank_1 #endif #endif end interface interface rocsolver_dgerqf_batched function rocsolver_dgerqf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_dgerqf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgerqf_batched_assumed_rank #else module procedure & rocsolver_dgerqf_batched_rank_0,& rocsolver_dgerqf_batched_rank_1 #endif #endif end interface interface rocsolver_cgerqf_batched function rocsolver_cgerqf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_cgerqf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgerqf_batched_assumed_rank #else module procedure & rocsolver_cgerqf_batched_rank_0,& rocsolver_cgerqf_batched_rank_1 #endif #endif end interface interface rocsolver_zgerqf_batched function rocsolver_zgerqf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_zgerqf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgerqf_batched_assumed_rank #else module procedure & rocsolver_zgerqf_batched_rank_0,& rocsolver_zgerqf_batched_rank_1 #endif #endif end interface !> \brief The GERQF_STRIDED_BATCHED functions compute the RQ factorization of a batch of !> general ``m``-by-``n`` matrices. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = \left[\begin{array}{cc} !> 0 & R_l !> \end{array}\right] Q_l !> \f] !> !> where \f$R_l\f$ is upper triangular (upper trapezoidal if ``m`` > ``n``), and \f$Q_l\f$ is !> an ``n`` -by-``n`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q_l = H_l(1)'H_l(2)' \cdots H_l(k)', \quad \text{with} \: k = \text{min}(m,n). !> \f] !> !> Each Householder matrices \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{ipiv}_l^{}[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where the last n-i elements of Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i] !> = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on and above the (m-n)-th subdiagonal (when !> m >= n) or the (n-m)-th superdiagonal (when n > m) contain the !> factor R_l, and the elements below the sub/superdiagonal are the first i - 1 !> elements of Householder vector v_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] ipiv - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors ipiv_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgerqf_strided_batched function rocsolver_sgerqf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_sgerqf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgerqf_strided_batched_assumed_rank #else module procedure & rocsolver_sgerqf_strided_batched_rank_0,& rocsolver_sgerqf_strided_batched_rank_1,& rocsolver_sgerqf_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgerqf_strided_batched function rocsolver_dgerqf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_dgerqf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgerqf_strided_batched_assumed_rank #else module procedure & rocsolver_dgerqf_strided_batched_rank_0,& rocsolver_dgerqf_strided_batched_rank_1,& rocsolver_dgerqf_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgerqf_strided_batched function rocsolver_cgerqf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_cgerqf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgerqf_strided_batched_assumed_rank #else module procedure & rocsolver_cgerqf_strided_batched_rank_0,& rocsolver_cgerqf_strided_batched_rank_1,& rocsolver_cgerqf_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgerqf_strided_batched function rocsolver_zgerqf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_zgerqf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgerqf_strided_batched_assumed_rank #else module procedure & rocsolver_zgerqf_strided_batched_rank_0,& rocsolver_zgerqf_strided_batched_rank_1,& rocsolver_zgerqf_strided_batched_full_rank #endif #endif end interface !> \brief The GEQLF functions compute a QL factorization of a general ``m`` -by-``n`` matrix !> ``A``. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The factorization has the form !> !> \f[ !> A = Q\left[\begin{array}{c} !> 0\\% !> L !> \end{array}\right] !> \f] !> !> where L is lower triangular (lower trapezoidal if ``m`` < ``n``), and Q is !> an ``m`` -by-``m`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q = H(k)H(k-1)\cdots H(1), \quad \text{with} \: k = \text{min}(m,n) !> \f] !> !> Each Householder matrix \f$H(i)\f$ is given by !> !> \f[ !> H(i) = I - \text{ipiv}[i] \cdot v_i^{} v_i^H !> \f] !> !> where the last m-i elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = !> 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the m-by-n matrix to be factored. !> On exit, the elements on and below the (m-n)-th subdiagonal (when !> m >= n) or the (n-m)-th superdiagonal (when n > m) contain the !> factor L, and the elements above the sub/superdiagonal are the first i - 1 !> elements of Householder vector v_i. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[out] ipiv - pointer to type. Array on the GPU of dimension min(m,n). !> The Householder scalars. interface rocsolver_sgeqlf function rocsolver_sgeqlf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_sgeqlf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgeqlf_assumed_rank #else module procedure & rocsolver_sgeqlf_rank_0,& rocsolver_sgeqlf_rank_1,& rocsolver_sgeqlf_full_rank #endif #endif end interface interface rocsolver_dgeqlf function rocsolver_dgeqlf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_dgeqlf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgeqlf_assumed_rank #else module procedure & rocsolver_dgeqlf_rank_0,& rocsolver_dgeqlf_rank_1,& rocsolver_dgeqlf_full_rank #endif #endif end interface interface rocsolver_cgeqlf function rocsolver_cgeqlf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_cgeqlf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgeqlf_assumed_rank #else module procedure & rocsolver_cgeqlf_rank_0,& rocsolver_cgeqlf_rank_1,& rocsolver_cgeqlf_full_rank #endif #endif end interface interface rocsolver_zgeqlf function rocsolver_zgeqlf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_zgeqlf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgeqlf_assumed_rank #else module procedure & rocsolver_zgeqlf_rank_0,& rocsolver_zgeqlf_rank_1,& rocsolver_zgeqlf_full_rank #endif #endif end interface !> \brief The GEQLF_BATCHED functions compute the QL factorization of a batch of general !> ``m``-by-``n`` matrices. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = Q_l\left[\begin{array}{c} !> 0\\% !> L_l !> \end{array}\right] !> \f] !> !> where \f$L_l\f$ is lower triangular (lower trapezoidal if ``m`` < ``n``), and \f$Q_l\f$ is !> an ``m`` -by-``m`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q_l = H_l(k)H_l(k-1)\cdots H_l(1), \quad \text{with} \: k = \text{min}(m,n) !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{ipiv}_l^{}[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where the last m-i elements of the Householder vector \f$v_{l_i}\f$ are zero, and !> \f$v_{l_i}[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on and below the (m-n)-th subdiagonal (when !> m >= n) or the (n-m)-th superdiagonal (when n > m) contain the !> factor L_l, and the elements above the sub/superdiagonal are the first i - 1 !> elements of Householder vector v_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[out] ipiv - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors ipiv_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgeqlf_batched function rocsolver_sgeqlf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_sgeqlf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgeqlf_batched_assumed_rank #else module procedure & rocsolver_sgeqlf_batched_rank_0,& rocsolver_sgeqlf_batched_rank_1 #endif #endif end interface interface rocsolver_dgeqlf_batched function rocsolver_dgeqlf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_dgeqlf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgeqlf_batched_assumed_rank #else module procedure & rocsolver_dgeqlf_batched_rank_0,& rocsolver_dgeqlf_batched_rank_1 #endif #endif end interface interface rocsolver_cgeqlf_batched function rocsolver_cgeqlf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_cgeqlf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgeqlf_batched_assumed_rank #else module procedure & rocsolver_cgeqlf_batched_rank_0,& rocsolver_cgeqlf_batched_rank_1 #endif #endif end interface interface rocsolver_zgeqlf_batched function rocsolver_zgeqlf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_zgeqlf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgeqlf_batched_assumed_rank #else module procedure & rocsolver_zgeqlf_batched_rank_0,& rocsolver_zgeqlf_batched_rank_1 #endif #endif end interface !> \brief The GEQLF_STRIDED_BATCHED functions compute the QL factorization of a batch of !> general ``m``-by-``n`` matrices. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = Q_l\left[\begin{array}{c} !> 0\\% !> L_l !> \end{array}\right] !> \f] !> !> where \f$L_l\f$ is lower triangular (lower trapezoidal if ``m`` < ``n``), and \f$Q_l\f$ is !> an ``m`` -by-``m`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q_l = H_l(k)H_l(k-1)\cdots H_l(1), \quad \text{with} \: k = \text{min}(m,n) !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{ipiv}_l^{}[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where the last m-i elements of the Householder vector \f$v_{l_i}\f$ are zero, and !> \f$v_{l_i}[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on and below the (m-n)-th subdiagonal (when !> m >= n) or the (n-m)-th superdiagonal (when n > m) contain the !> factor L_l, and the elements above the sub/superdiagonal are the first i - 1 !> elements of Householder vector v_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] ipiv - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors ipiv_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgeqlf_strided_batched function rocsolver_sgeqlf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_sgeqlf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgeqlf_strided_batched_assumed_rank #else module procedure & rocsolver_sgeqlf_strided_batched_rank_0,& rocsolver_sgeqlf_strided_batched_rank_1,& rocsolver_sgeqlf_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgeqlf_strided_batched function rocsolver_dgeqlf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_dgeqlf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgeqlf_strided_batched_assumed_rank #else module procedure & rocsolver_dgeqlf_strided_batched_rank_0,& rocsolver_dgeqlf_strided_batched_rank_1,& rocsolver_dgeqlf_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgeqlf_strided_batched function rocsolver_cgeqlf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_cgeqlf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgeqlf_strided_batched_assumed_rank #else module procedure & rocsolver_cgeqlf_strided_batched_rank_0,& rocsolver_cgeqlf_strided_batched_rank_1,& rocsolver_cgeqlf_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgeqlf_strided_batched function rocsolver_zgeqlf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_zgeqlf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgeqlf_strided_batched_assumed_rank #else module procedure & rocsolver_zgeqlf_strided_batched_rank_0,& rocsolver_zgeqlf_strided_batched_rank_1,& rocsolver_zgeqlf_strided_batched_full_rank #endif #endif end interface !> \brief The GELQF functions compute an LQ factorization of a general ``m`` -by-``n`` matrix !> ``A``. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The factorization has the form !> !> \f[ !> A = \left[\begin{array}{cc} !> L & 0 !> \end{array}\right] Q !> \f] !> !> where L is lower triangular (lower trapezoidal if ``m`` > ``n``), and Q is !> an ``n`` -by-``n`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q = H(k)'H(k-1)' \cdots H(1)', \quad \text{with} \: k = \text{min}(m,n). !> \f] !> !> Each Householder matrix \f$H(i)\f$ is given by !> !> \f[ !> H(i) = I - \text{ipiv}[i] \cdot v_i^H v_i^{} !> \f] !> !> where the first i-1 elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = !> 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the m-by-n matrix to be factored. !> On exit, the elements on and below the diagonal contain the !> factor L, and the elements above the diagonal are the last n - i elements !> of Householder vector v_i. !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of A. !> @param[out] ipiv - pointer to type. Array on the GPU of dimension min(m,n). !> The Householder scalars. interface rocsolver_sgelqf function rocsolver_sgelqf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_sgelqf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgelqf_assumed_rank #else module procedure & rocsolver_sgelqf_rank_0,& rocsolver_sgelqf_rank_1,& rocsolver_sgelqf_full_rank #endif #endif end interface interface rocsolver_dgelqf function rocsolver_dgelqf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_dgelqf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgelqf_assumed_rank #else module procedure & rocsolver_dgelqf_rank_0,& rocsolver_dgelqf_rank_1,& rocsolver_dgelqf_full_rank #endif #endif end interface interface rocsolver_cgelqf function rocsolver_cgelqf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_cgelqf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgelqf_assumed_rank #else module procedure & rocsolver_cgelqf_rank_0,& rocsolver_cgelqf_rank_1,& rocsolver_cgelqf_full_rank #endif #endif end interface interface rocsolver_zgelqf function rocsolver_zgelqf_(handle,m,n,A,lda,ipiv) bind(c, name="rocsolver_zgelqf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_ 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 type(c_ptr),value :: ipiv end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgelqf_assumed_rank #else module procedure & rocsolver_zgelqf_rank_0,& rocsolver_zgelqf_rank_1,& rocsolver_zgelqf_full_rank #endif #endif end interface !> \brief The GELQF_BATCHED functions compute the LQ factorization of a batch of general !> ``m``-by-``n`` matrices. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = \left[\begin{array}{cc} !> L_l & 0 !> \end{array}\right] Q_l !> \f] !> !> where \f$L_l\f$ is lower triangular (lower trapezoidal if ``m`` > ``n``), and \f$Q_l\f$ is !> an ``n`` -by-``n`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q_l = H_l(k)'H_l(k-1)' \cdots H_l(1)', \quad \text{with} \: k = \text{min}(m,n). !> \f] !> !> Each Householder matrices \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{ipiv}_l^{}[i] \cdot v_{l_i}^H v_{l_i}^{} !> \f] !> !> where the first i-1 elements of Householder vector \f$v_{l_i}\f$ are zero, and !> \f$v_{l_i}[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on and below the diagonal contain the !> factor L_l. The elements above the diagonal are the last n - i elements !> of Householder vector v_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[out] ipiv - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors ipiv_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgelqf_batched function rocsolver_sgelqf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_sgelqf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgelqf_batched_assumed_rank #else module procedure & rocsolver_sgelqf_batched_rank_0,& rocsolver_sgelqf_batched_rank_1 #endif #endif end interface interface rocsolver_dgelqf_batched function rocsolver_dgelqf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_dgelqf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgelqf_batched_assumed_rank #else module procedure & rocsolver_dgelqf_batched_rank_0,& rocsolver_dgelqf_batched_rank_1 #endif #endif end interface interface rocsolver_cgelqf_batched function rocsolver_cgelqf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_cgelqf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgelqf_batched_assumed_rank #else module procedure & rocsolver_cgelqf_batched_rank_0,& rocsolver_cgelqf_batched_rank_1 #endif #endif end interface interface rocsolver_zgelqf_batched function rocsolver_zgelqf_batched_(handle,m,n,A,lda,ipiv,strideP,batch_count) & bind(c, name="rocsolver_zgelqf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_batched_ 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 type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgelqf_batched_assumed_rank #else module procedure & rocsolver_zgelqf_batched_rank_0,& rocsolver_zgelqf_batched_rank_1 #endif #endif end interface !> \brief The GELQF_STRIDED_BATCHED functions compute the LQ factorization of a batch of !> general ``m``-by-``n`` matrices. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form !> !> \f[ !> A_l = \left[\begin{array}{cc} !> L_l & 0 !> \end{array}\right] Q_l !> \f] !> !> where \f$L_l\f$ is lower triangular (lower trapezoidal if ``m`` > ``n``), and \f$Q_l\f$ is !> an ``n`` -by-``n`` orthogonal/unitary matrix represented as the product of Householder !> matrices !> !> \f[ !> Q_l = H_l(k)'H_l(k-1)' \cdots H_l(1)', \quad \text{with} \: k = \text{min}(m,n). !> \f] !> !> Each Householder matrices \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{ipiv}_l^{}[i] \cdot v_{l_i}^H v_{l_i}^{} !> \f] !> !> where the first i-1 elements of Householder vector \f$v_{l_i}\f$ are zero, and !> \f$v_{l_i}[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on and below the diagonal contain the !> factor L_l. The elements above the diagonal are the last n - i elements !> of Householder vector v_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] ipiv - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors ipiv_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgelqf_strided_batched function rocsolver_sgelqf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_sgelqf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgelqf_strided_batched_assumed_rank #else module procedure & rocsolver_sgelqf_strided_batched_rank_0,& rocsolver_sgelqf_strided_batched_rank_1,& rocsolver_sgelqf_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgelqf_strided_batched function rocsolver_dgelqf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_dgelqf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgelqf_strided_batched_assumed_rank #else module procedure & rocsolver_dgelqf_strided_batched_rank_0,& rocsolver_dgelqf_strided_batched_rank_1,& rocsolver_dgelqf_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgelqf_strided_batched function rocsolver_cgelqf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_cgelqf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgelqf_strided_batched_assumed_rank #else module procedure & rocsolver_cgelqf_strided_batched_rank_0,& rocsolver_cgelqf_strided_batched_rank_1,& rocsolver_cgelqf_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgelqf_strided_batched function rocsolver_zgelqf_strided_batched_(handle,m,n,A,lda,strideA,ipiv,strideP,batch_count) & bind(c, name="rocsolver_zgelqf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgelqf_strided_batched_assumed_rank #else module procedure & rocsolver_zgelqf_strided_batched_rank_0,& rocsolver_zgelqf_strided_batched_rank_1,& rocsolver_zgelqf_strided_batched_full_rank #endif #endif end interface !> \brief The GEBD2 functions compute the bidiagonal form of a general ``m`` -by-``n`` matrix !> ``A``. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The bidiagonal form is given by: !> !> \f[ !> B = Q^H A P !> \f] !> !> where B is upper bidiagonal if ``m`` >= ``n`` and lower bidiagonal if ``m`` < ``n``, and Q !> and !> P are orthogonal/unitary matrices represented as the product of Householder matrices !> !> \f[ !> \begin{array}{cl} !> Q = H(1)H(2)\cdots H(n)\: \text{and} \: P = G(1)G(2)\cdots G(n-1), & \: \text{if}\: m !> >= n, \:\text{or}\\% !> Q = H(1)H(2)\cdots H(m-1)\: \text{and} \: P = G(1)G(2)\cdots G(m), & \: \text{if}\: m < !> n. !> \end{array} !> \f] !> !> Each Householder matrix \f$H(i)\f$ and \f$G(i)\f$ is given by !> !> \f[ !> \begin{array}{cl} !> H(i) = I - \text{tauq}[i] \cdot v_i^{} v_i^H, & \: \text{and}\\% !> G(i) = I - \text{taup}[i] \cdot u_i^H u_i^{}. !> \end{array} !> \f] !> !> If ``m`` >= ``n``, the first i-1 elements of the Householder vector \f$v_i\f$ are zero, and !> \f$v_i[i] = 1\f$, !> while the first i elements of the Householder vector \f$u_i\f$ are zero, and \f$u_i[i+1] = !> 1\f$. !> If ``m`` < ``n``, the first i elements of the Householder vector \f$v_i\f$ are zero, and !> \f$v_i[i+1] = 1\f$, !> while the first i-1 elements of the Householder vector \f$u_i\f$ are zero, and \f$u_i[i] = !> 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the m-by-n matrix to be factored. !> On exit, the elements on the diagonal and superdiagonal (if m >= n), or !> subdiagonal (if m < n) contain the bidiagonal form B. !> If m >= n, the elements below the diagonal are the last m - i elements !> of Householder vector v_i, and the elements above the !> superdiagonal are the last n - i - 1 elements of Householder vector u_i. !> If m < n, the elements below the subdiagonal are the last m - i - 1 !> elements of Householder vector v_i, and the elements above the !> diagonal are the last n - i elements of Householder vector u_i. !> @param[in] lda - rocblas_int. lda >= m. !> specifies the leading dimension of A. !> @param[out] D - pointer to real type. Array on the GPU of dimension min(m,n). !> The diagonal elements of B. !> @param[out] E - pointer to real type. Array on the GPU of dimension min(m,n)-1. !> The off-diagonal elements of B. !> @param[out] tauq - pointer to type. Array on the GPU of dimension min(m,n). !> The Householder scalars associated with matrix Q. !> @param[out] taup - pointer to type. Array on the GPU of dimension min(m,n). !> The Householder scalars associated with matrix P. interface rocsolver_sgebd2 function rocsolver_sgebd2_(handle,m,n,A,lda,D,E,tauq,taup) bind(c, name="rocsolver_sgebd2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_ 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 type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgebd2_assumed_rank #else module procedure & rocsolver_sgebd2_rank_0,& rocsolver_sgebd2_rank_1,& rocsolver_sgebd2_full_rank #endif #endif end interface interface rocsolver_dgebd2 function rocsolver_dgebd2_(handle,m,n,A,lda,D,E,tauq,taup) bind(c, name="rocsolver_dgebd2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_ 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 type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgebd2_assumed_rank #else module procedure & rocsolver_dgebd2_rank_0,& rocsolver_dgebd2_rank_1,& rocsolver_dgebd2_full_rank #endif #endif end interface interface rocsolver_cgebd2 function rocsolver_cgebd2_(handle,m,n,A,lda,D,E,tauq,taup) bind(c, name="rocsolver_cgebd2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_ 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 type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgebd2_assumed_rank #else module procedure & rocsolver_cgebd2_rank_0,& rocsolver_cgebd2_rank_1,& rocsolver_cgebd2_full_rank #endif #endif end interface interface rocsolver_zgebd2 function rocsolver_zgebd2_(handle,m,n,A,lda,D,E,tauq,taup) bind(c, name="rocsolver_zgebd2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_ 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 type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgebd2_assumed_rank #else module procedure & rocsolver_zgebd2_rank_0,& rocsolver_zgebd2_rank_1,& rocsolver_zgebd2_full_rank #endif #endif end interface !> \brief The GEBD2_BATCHED functions compute the bidiagonal form of a batch of general !> ``m``-by-``n`` matrices. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> For each instance in the batch, the bidiagonal form is given by: !> !> \f[ !> B_l^{} = Q_l^H A_l^{} P_l^{} !> \f] !> !> where \f$B_l\f$ is upper bidiagonal if ``m`` >= ``n`` and lower bidiagonal if ``m`` < !> ``n``, and \f$Q_l\f$ and !> \f$P_l\f$ are orthogonal/unitary matrices represented as the product of Householder !> matrices !> !> \f[ !> \begin{array}{cl} !> Q_l = H_l(1)H_l(2)\cdots H_l(n)\: \text{and} \: P_l = G_l(1)G_l(2)\cdots G_l(n-1), & \: !> \text{if}\: m >= n, \:\text{or}\\% !> Q_l = H_l(1)H_l(2)\cdots H_l(m-1)\: \text{and} \: P_l = G_l(1)G_l(2)\cdots G_l(m), & \: !> \text{if}\: m < n. !> \end{array} !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ and \f$G_l(i)\f$ is given by !> !> \f[ !> \begin{array}{cl} !> H_l^{}(i) = I - \text{tauq}_l^{}[i] \cdot v_{l_i}^{} v_{l_i}^H, & \: \text{and}\\% !> G_l^{}(i) = I - \text{taup}_l^{}[i] \cdot u_{l_i}^H u_{l_i}^{}. !> \end{array} !> \f] !> !> If ``m`` >= ``n``, the first i-1 elements of the Householder vector \f$v_{l_i}\f$ are zero, !> and \f$v_{l_i}[i] = 1\f$, !> while the first i elements of the Householder vector \f$u_{l_i}\f$ are zero, and !> \f$u_{l_i}[i+1] = 1\f$. !> If ``m`` < ``n``, the first i elements of the Householder vector \f$v_{l_i}\f$ are zero, !> and \f$v_{l_i}[i+1] = 1\f$, !> while the first i-1 elements of the Householder vector \f$u_{l_i}\f$ are zero, and !> \f$u_{l_i}[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on the diagonal and superdiagonal (if m >= n), or !> subdiagonal (if m < n) contain the bidiagonal form B_l. !> If m >= n, the elements below the diagonal are the last m - i elements !> of Householder vector v_(l_i), and the elements above the !> superdiagonal are the last n - i - 1 elements of Householder vector u_(l_i). !> If m < n, the elements below the subdiagonal are the last m - i - 1 !> elements of Householder vector v_(l_i), and the elements above the !> diagonal are the last n - i elements of Householder vector u_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> The diagonal elements of B_l. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= min(m,n). !> @param[out] E - pointer to real type. Array on the GPU (the size depends on the value of !> strideE). !> The off-diagonal elements of B_l. !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= min(m,n)-1. !> @param[out] tauq - pointer to type. Array on the GPU (the size depends on the value of !> strideQ). !> Contains the vectors tauq_l of Householder scalars associated with matrices !> Q_l. !> @param[in] strideQ - rocblas_stride. !> Stride from the start of one vector tauq_l to the next one tauq_(l+1). !> There is no restriction for the value !> of strideQ. Normal usage is strideQ >= min(m,n). !> @param[out] taup - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors taup_l of Householder scalars associated with matrices !> P_l. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector taup_l to the next one taup_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgebd2_batched function rocsolver_sgebd2_batched_(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup, & strideP,batch_count) & bind(c, name="rocsolver_sgebd2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_batched_ 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 type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tauq integer(c_int64_t),value :: strideQ type(c_ptr),value :: taup integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgebd2_batched_assumed_rank #else module procedure & rocsolver_sgebd2_batched_rank_0,& rocsolver_sgebd2_batched_rank_1 #endif #endif end interface interface rocsolver_dgebd2_batched function rocsolver_dgebd2_batched_(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup, & strideP,batch_count) & bind(c, name="rocsolver_dgebd2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_batched_ 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 type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tauq integer(c_int64_t),value :: strideQ type(c_ptr),value :: taup integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgebd2_batched_assumed_rank #else module procedure & rocsolver_dgebd2_batched_rank_0,& rocsolver_dgebd2_batched_rank_1 #endif #endif end interface interface rocsolver_cgebd2_batched function rocsolver_cgebd2_batched_(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup, & strideP,batch_count) & bind(c, name="rocsolver_cgebd2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_batched_ 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 type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tauq integer(c_int64_t),value :: strideQ type(c_ptr),value :: taup integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgebd2_batched_assumed_rank #else module procedure & rocsolver_cgebd2_batched_rank_0,& rocsolver_cgebd2_batched_rank_1 #endif #endif end interface interface rocsolver_zgebd2_batched function rocsolver_zgebd2_batched_(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup, & strideP,batch_count) & bind(c, name="rocsolver_zgebd2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_batched_ 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 type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tauq integer(c_int64_t),value :: strideQ type(c_ptr),value :: taup integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgebd2_batched_assumed_rank #else module procedure & rocsolver_zgebd2_batched_rank_0,& rocsolver_zgebd2_batched_rank_1 #endif #endif end interface !> \brief The GEBD2_STRIDED_BATCHED functions compute the bidiagonal form of a batch of !> general ``m``-by-``n`` matrices. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> For each instance in the batch, the bidiagonal form is given by: !> !> \f[ !> B_l^{} = Q_l^H A_l^{} P_l^{} !> \f] !> !> where \f$B_l\f$ is upper bidiagonal if ``m`` >= ``n`` and lower bidiagonal if ``m`` < !> ``n``, and \f$Q_l\f$ and !> \f$P_l\f$ are orthogonal/unitary matrices represented as the product of Householder !> matrices !> !> \f[ !> \begin{array}{cl} !> Q_l = H_l(1)H_l(2)\cdots H_l(n)\: \text{and} \: P_1 = G_l(1)G_l(2)\cdots G_l(n-1), & \: !> \text{if}\: m >= n, \:\text{or}\\% !> Q_l = H_l(1)H_l(2)\cdots H_l(m-1)\: \text{and} \: P_1 = G_l(1)G_l(2)\cdots G_l(m), & \: !> \text{if}\: m < n. !> \end{array} !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ and \f$G_l(i)\f$ is given by !> !> \f[ !> \begin{array}{cl} !> H_l^{}(i) = I - \text{tauq}_l^{}[i] \cdot v_{l_i}^{} v_{l_i}^H, & \: \text{and}\\% !> G_l^{}(i) = I - \text{taup}_l^{}[i] \cdot u_{l_i}^H u_{l_i}^{}. !> \end{array} !> \f] !> !> If ``m`` >= ``n``, the first i-1 elements of the Householder vector \f$v_{l_i}\f$ are zero, !> and \f$v_{l_i}[i] = 1\f$, !> while the first i elements of the Householder vector \f$u_{l_i}\f$ are zero, and !> \f$u_{l_i}[i+1] = 1\f$. !> If ``m`` < ``n``, the first i elements of the Householder vector \f$v_{l_i}\f$ are zero, !> and \f$v_{l_i}[i+1] = 1\f$, !> while the first i-1 elements of the Householder vector \f$u_{l_i}\f$ are zero, and !> \f$u_{l_i}[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on the diagonal and superdiagonal (if m >= n), or !> subdiagonal (if m < n) contain the bidiagonal form B_l. !> If m >= n, the elements below the diagonal are the last m - i elements !> of Householder vector v_(l_i), and the elements above the !> superdiagonal are the last n - i - 1 elements of Householder vector u_(l_i). !> If m < n, the elements below the subdiagonal are the last m - i - 1 !> elements of Householder vector v_(l_i), and the elements above the !> diagonal are the last n - i elements of Householder vector u_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> The diagonal elements of B_l. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= min(m,n). !> @param[out] E - pointer to real type. Array on the GPU (the size depends on the value of !> strideE). !> The off-diagonal elements of B_l. !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= min(m,n)-1. !> @param[out] tauq - pointer to type. Array on the GPU (the size depends on the value of !> strideQ). !> Contains the vectors tauq_l of Householder scalars associated with matrices !> Q_l. !> @param[in] strideQ - rocblas_stride. !> Stride from the start of one vector tauq_l to the next one tauq_(l+1). !> There is no restriction for the value !> of strideQ. Normal usage is strideQ >= min(m,n). !> @param[out] taup - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors taup_l of Householder scalars associated with matrices !> P_l. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector taup_l to the next one taup_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgebd2_strided_batched function rocsolver_sgebd2_strided_batched_(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq, & strideQ,taup,strideP,batch_count) & bind(c, name="rocsolver_sgebd2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tauq integer(c_int64_t),value :: strideQ type(c_ptr),value :: taup integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgebd2_strided_batched_assumed_rank #else module procedure & rocsolver_sgebd2_strided_batched_rank_0,& rocsolver_sgebd2_strided_batched_rank_1,& rocsolver_sgebd2_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgebd2_strided_batched function rocsolver_dgebd2_strided_batched_(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq, & strideQ,taup,strideP,batch_count) & bind(c, name="rocsolver_dgebd2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tauq integer(c_int64_t),value :: strideQ type(c_ptr),value :: taup integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgebd2_strided_batched_assumed_rank #else module procedure & rocsolver_dgebd2_strided_batched_rank_0,& rocsolver_dgebd2_strided_batched_rank_1,& rocsolver_dgebd2_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgebd2_strided_batched function rocsolver_cgebd2_strided_batched_(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq, & strideQ,taup,strideP,batch_count) & bind(c, name="rocsolver_cgebd2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tauq integer(c_int64_t),value :: strideQ type(c_ptr),value :: taup integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgebd2_strided_batched_assumed_rank #else module procedure & rocsolver_cgebd2_strided_batched_rank_0,& rocsolver_cgebd2_strided_batched_rank_1,& rocsolver_cgebd2_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgebd2_strided_batched function rocsolver_zgebd2_strided_batched_(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq, & strideQ,taup,strideP,batch_count) & bind(c, name="rocsolver_zgebd2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tauq integer(c_int64_t),value :: strideQ type(c_ptr),value :: taup integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgebd2_strided_batched_assumed_rank #else module procedure & rocsolver_zgebd2_strided_batched_rank_0,& rocsolver_zgebd2_strided_batched_rank_1,& rocsolver_zgebd2_strided_batched_full_rank #endif #endif end interface !> \brief The GEBRD functions compute the bidiagonal form of a general ``m`` -by-``n`` matrix !> ``A``. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The bidiagonal form is given by: !> !> \f[ !> B = Q^H A P !> \f] !> !> where B is upper bidiagonal if ``m`` >= ``n`` and lower bidiagonal if ``m`` < ``n``, and Q !> and !> P are orthogonal/unitary matrices represented as the product of Householder matrices !> !> \f[ !> \begin{array}{cl} !> Q = H(1)H(2)\cdots H(n)\: \text{and} \: P = G(1)G(2)\cdots G(n-1), & \: \text{if}\: m !> >= n, \:\text{or}\\% !> Q = H(1)H(2)\cdots H(m-1)\: \text{and} \: P = G(1)G(2)\cdots G(m), & \: \text{if}\: m < !> n. !> \end{array} !> \f] !> !> Each Householder matrix \f$H(i)\f$ and \f$G(i)\f$ is given by !> !> \f[ !> \begin{array}{cl} !> H(i) = I - \text{tauq}[i] \cdot v_i^{} v_i^H, & \: \text{and}\\% !> G(i) = I - \text{taup}[i] \cdot u_i^H u_i^{}. !> \end{array} !> \f] !> !> If ``m`` >= ``n``, the first i-1 elements of the Householder vector \f$v_i\f$ are zero, and !> \f$v_i[i] = 1\f$, !> while the first i elements of the Householder vector \f$u_i\f$ are zero, and \f$u_i[i+1] = !> 1\f$. !> If ``m`` < ``n``, the first i elements of the Householder vector \f$v_i\f$ are zero, and !> \f$v_i[i+1] = 1\f$, !> while the first i-1 elements of the Householder vector \f$u_i\f$ are zero, and \f$u_i[i] = !> 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of the matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the m-by-n matrix to be factored. !> On exit, the elements on the diagonal and superdiagonal (if m >= n), or !> subdiagonal (if m < n) contain the bidiagonal form B. !> If m >= n, the elements below the diagonal are the last m - i elements !> of Householder vector v_i, and the elements above the !> superdiagonal are the last n - i - 1 elements of Householder vector u_i. !> If m < n, the elements below the subdiagonal are the last m - i - 1 !> elements of Householder vector v_i, and the elements above the !> diagonal are the last n - i elements of Householder vector u_i. !> @param[in] lda - rocblas_int. lda >= m. !> specifies the leading dimension of A. !> @param[out] D - pointer to real type. Array on the GPU of dimension min(m,n). !> The diagonal elements of B. !> @param[out] E - pointer to real type. Array on the GPU of dimension min(m,n)-1. !> The off-diagonal elements of B. !> @param[out] tauq - pointer to type. Array on the GPU of dimension min(m,n). !> The Householder scalars associated with matrix Q. !> @param[out] taup - pointer to type. Array on the GPU of dimension min(m,n). !> The Householder scalars associated with matrix P. interface rocsolver_sgebrd function rocsolver_sgebrd_(handle,m,n,A,lda,D,E,tauq,taup) bind(c, name="rocsolver_sgebrd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_ 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 type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgebrd_assumed_rank #else module procedure & rocsolver_sgebrd_rank_0,& rocsolver_sgebrd_rank_1,& rocsolver_sgebrd_full_rank #endif #endif end interface interface rocsolver_dgebrd function rocsolver_dgebrd_(handle,m,n,A,lda,D,E,tauq,taup) bind(c, name="rocsolver_dgebrd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_ 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 type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgebrd_assumed_rank #else module procedure & rocsolver_dgebrd_rank_0,& rocsolver_dgebrd_rank_1,& rocsolver_dgebrd_full_rank #endif #endif end interface interface rocsolver_cgebrd function rocsolver_cgebrd_(handle,m,n,A,lda,D,E,tauq,taup) bind(c, name="rocsolver_cgebrd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_ 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 type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgebrd_assumed_rank #else module procedure & rocsolver_cgebrd_rank_0,& rocsolver_cgebrd_rank_1,& rocsolver_cgebrd_full_rank #endif #endif end interface interface rocsolver_zgebrd function rocsolver_zgebrd_(handle,m,n,A,lda,D,E,tauq,taup) bind(c, name="rocsolver_zgebrd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_ 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 type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tauq type(c_ptr),value :: taup end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgebrd_assumed_rank #else module procedure & rocsolver_zgebrd_rank_0,& rocsolver_zgebrd_rank_1,& rocsolver_zgebrd_full_rank #endif #endif end interface !> \brief The GEBRD_BATCHED functions compute the bidiagonal form of a batch of general !> ``m``-by-``n`` matrices. !> !> \details !> (This is the blocked version of the algorithm.) !> !> For each instance in the batch, the bidiagonal form is given by: !> !> \f[ !> B_l^{} = Q_l^H A_l^{} P_l^{} !> \f] !> !> where \f$B_l\f$ is upper bidiagonal if m >= n and lower bidiagonal if m < n, and \f$Q_l\f$ !> and !> \f$P_l\f$ are orthogonal/unitary matrices represented as the product of Householder !> matrices !> !> \f[ !> \begin{array}{cl} !> Q_l = H_l(1)H_l(2)\cdots H_l(n)\: \text{and} \: P_l = G_l(1)G_l(2)\cdots G_l(n-1), & \: !> \text{if}\: m >= n, \:\text{or}\\% !> Q_l = H_l(1)H_l(2)\cdots H_l(m-1)\: \text{and} \: P_l = G_l(1)G_l(2)\cdots G_l(m), & \: !> \text{if}\: m < n. !> \end{array} !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ and \f$G_l(i)\f$ is given by !> !> \f[ !> \begin{array}{cl} !> H_l^{}(i) = I - \text{tauq}_l^{}[i] \cdot v_{l_i}^{} v_{l_i}^H, & \: \text{and}\\% !> G_l^{}(i) = I - \text{taup}_l^{}[i] \cdot u_{l_i}^H u_{l_i}^{}. !> \end{array} !> \f] !> !> If ``m`` >= ``n``, the first i-1 elements of the Householder vector \f$v_{l_i}\f$ are zero, !> and \f$v_{l_i}[i] = 1\f$, !> while the first i elements of the Householder vector \f$u_{l_i}\f$ are zero, and !> \f$u_{l_i}[i+1] = 1\f$. !> If ``m`` < ``n``, the first i elements of the Householder vector \f$v_{l_i}\f$ are zero, !> and \f$v_{l_i}[i+1] = 1\f$, !> while the first i-1 elements of the Householder vector \f$u_{l_i}\f$ are zero, and !> \f$u_{l_i}[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on the diagonal and superdiagonal (if m >= n), or !> subdiagonal (if m < n) contain the bidiagonal form B_l. !> If m >= n, the elements below the diagonal are the last m - i elements !> of Householder vector v_(l_i), and the elements above the !> superdiagonal are the last n - i - 1 elements of Householder vector u_(l_i). !> If m < n, the elements below the subdiagonal are the last m - i - 1 !> elements of Householder vector v_(l_i), and the elements above the !> diagonal are the last n - i elements of Householder vector u_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> The diagonal elements of B_l. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= min(m,n). !> @param[out] E - pointer to real type. Array on the GPU (the size depends on the value of !> strideE). !> The off-diagonal elements of B_l. !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= min(m,n)-1. !> @param[out] tauq - pointer to type. Array on the GPU (the size depends on the value of !> strideQ). !> Contains the vectors tauq_l of Householder scalars associated with matrices !> Q_l. !> @param[in] strideQ - rocblas_stride. !> Stride from the start of one vector tauq_l to the next one tauq_(l+1). !> There is no restriction for the value !> of strideQ. Normal usage is strideQ >= min(m,n). !> @param[out] taup - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors taup_l of Householder scalars associated with matrices !> P_l. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector taup_l to the next one taup_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgebrd_batched function rocsolver_sgebrd_batched_(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup, & strideP,batch_count) & bind(c, name="rocsolver_sgebrd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_batched_ 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 type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tauq integer(c_int64_t),value :: strideQ type(c_ptr),value :: taup integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgebrd_batched_assumed_rank #else module procedure & rocsolver_sgebrd_batched_rank_0,& rocsolver_sgebrd_batched_rank_1 #endif #endif end interface interface rocsolver_dgebrd_batched function rocsolver_dgebrd_batched_(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup, & strideP,batch_count) & bind(c, name="rocsolver_dgebrd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_batched_ 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 type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tauq integer(c_int64_t),value :: strideQ type(c_ptr),value :: taup integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgebrd_batched_assumed_rank #else module procedure & rocsolver_dgebrd_batched_rank_0,& rocsolver_dgebrd_batched_rank_1 #endif #endif end interface interface rocsolver_cgebrd_batched function rocsolver_cgebrd_batched_(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup, & strideP,batch_count) & bind(c, name="rocsolver_cgebrd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_batched_ 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 type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tauq integer(c_int64_t),value :: strideQ type(c_ptr),value :: taup integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgebrd_batched_assumed_rank #else module procedure & rocsolver_cgebrd_batched_rank_0,& rocsolver_cgebrd_batched_rank_1 #endif #endif end interface interface rocsolver_zgebrd_batched function rocsolver_zgebrd_batched_(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ,taup, & strideP,batch_count) & bind(c, name="rocsolver_zgebrd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_batched_ 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 type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tauq integer(c_int64_t),value :: strideQ type(c_ptr),value :: taup integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgebrd_batched_assumed_rank #else module procedure & rocsolver_zgebrd_batched_rank_0,& rocsolver_zgebrd_batched_rank_1 #endif #endif end interface !> \brief The GEBRD_STRIDED_BATCHED functions compute the bidiagonal form of a batch of !> general ``m``-by-``n`` matrices. !> !> \details !> (This is the blocked version of the algorithm.) !> !> For each instance in the batch, the bidiagonal form is given by: !> !> \f[ !> B_l^{} = Q_l^H A_l^{} P_l^{} !> \f] !> !> where \f$B_l\f$ is upper bidiagonal if ``m`` >= ``n`` and lower bidiagonal if ``m`` < !> ``n``, and \f$Q_l\f$ and !> \f$P_l\f$ are orthogonal/unitary matrices represented as the product of Householder !> matrices !> !> \f[ !> \begin{array}{cl} !> Q_l = H_l(1)H_l(2)\cdots H_l(n)\: \text{and} \: P_l = G_l(1)G_l(2)\cdots G_l(n-1), & \: !> \text{if}\: m >= n, \:\text{or}\\% !> Q_l = H_l(1)H_l(2)\cdots H_l(m-1)\: \text{and} \: P_l = G_l(1)G_l(2)\cdots G_l(m), & \: !> \text{if}\: m < n. !> \end{array} !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ and \f$G_l(i)\f$ is given by !> !> \f[ !> \begin{array}{cl} !> H_l^{}(i) = I - \text{tauq}_l^{}[i] \cdot v_{l_i}^{} v_{l_i}^H, & \: \text{and}\\% !> G_l^{}(i) = I - \text{taup}_l^{}[i] \cdot u_{l_i}^H u_{l_i}^{}. !> \end{array} !> \f] !> !> If ``m`` >= ``n``, the first i-1 elements of the Householder vector \f$v_{l_i}\f$ are zero, !> and \f$v_{l_i}[i] = 1\f$, !> while the first i elements of the Householder vector \f$u_{l_i}\f$ are zero, and !> \f$u_{l_i}[i+1] = 1\f$. !> If ``m`` < ``n``, the first i elements of the Householder vector \f$v_{l_i}\f$ are zero, !> and \f$v_{l_i}[i+1] = 1\f$, !> while the first i-1 elements of the Householder vector \f$u_{l_i}\f$ are zero, and !> \f$u_{l_i}[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all the matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all the matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the m-by-n matrices A_l to be factored. !> On exit, the elements on the diagonal and superdiagonal (if m >= n), or !> subdiagonal (if m < n) contain the bidiagonal form B_l. !> If m >= n, the elements below the diagonal are the last m - i elements !> of Householder vector v_(l_i), and the elements above the !> superdiagonal are the last n - i - 1 elements of Householder vector u_(l_i). !> If m < n, the elements below the subdiagonal are the last m - i - 1 !> elements of Householder vector v_(l_i), and the elements above the !> diagonal are the last n - i elements of Householder vector u_(l_i). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> The diagonal elements of B_l. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= min(m,n). !> @param[out] E - pointer to real type. Array on the GPU (the size depends on the value of !> strideE). !> The off-diagonal elements of B_l. !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= min(m,n)-1. !> @param[out] tauq - pointer to type. Array on the GPU (the size depends on the value of !> strideQ). !> Contains the vectors tauq_l of Householder scalars associated with matrices !> Q_l. !> @param[in] strideQ - rocblas_stride. !> Stride from the start of one vector tauq_l to the next one tauq_(l+1). !> There is no restriction for the value !> of strideQ. Normal usage is strideQ >= min(m,n). !> @param[out] taup - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors taup_l of Householder scalars associated with matrices !> P_l. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector taup_l to the next one taup_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= min(m,n). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgebrd_strided_batched function rocsolver_sgebrd_strided_batched_(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq, & strideQ,taup,strideP,batch_count) & bind(c, name="rocsolver_sgebrd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tauq integer(c_int64_t),value :: strideQ type(c_ptr),value :: taup integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgebrd_strided_batched_assumed_rank #else module procedure & rocsolver_sgebrd_strided_batched_rank_0,& rocsolver_sgebrd_strided_batched_rank_1,& rocsolver_sgebrd_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgebrd_strided_batched function rocsolver_dgebrd_strided_batched_(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq, & strideQ,taup,strideP,batch_count) & bind(c, name="rocsolver_dgebrd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tauq integer(c_int64_t),value :: strideQ type(c_ptr),value :: taup integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgebrd_strided_batched_assumed_rank #else module procedure & rocsolver_dgebrd_strided_batched_rank_0,& rocsolver_dgebrd_strided_batched_rank_1,& rocsolver_dgebrd_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgebrd_strided_batched function rocsolver_cgebrd_strided_batched_(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq, & strideQ,taup,strideP,batch_count) & bind(c, name="rocsolver_cgebrd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tauq integer(c_int64_t),value :: strideQ type(c_ptr),value :: taup integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgebrd_strided_batched_assumed_rank #else module procedure & rocsolver_cgebrd_strided_batched_rank_0,& rocsolver_cgebrd_strided_batched_rank_1,& rocsolver_cgebrd_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgebrd_strided_batched function rocsolver_zgebrd_strided_batched_(handle,m,n,A,lda,strideA,D,strideD,E,strideE,tauq, & strideQ,taup,strideP,batch_count) & bind(c, name="rocsolver_zgebrd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_strided_batched_ 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_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tauq integer(c_int64_t),value :: strideQ type(c_ptr),value :: taup integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgebrd_strided_batched_assumed_rank #else module procedure & rocsolver_zgebrd_strided_batched_rank_0,& rocsolver_zgebrd_strided_batched_rank_1,& rocsolver_zgebrd_strided_batched_full_rank #endif #endif end interface !> \brief The GETRS functions solve a system of n linear equations on ``n`` variables in its !> factorized form. !> !> \details !> It solves one of the following systems, depending on the value of ``trans``: !> !> \f[ !> \begin{array}{cl} !> A X = B & \: \text{not transposed,}\\% !> A^T X = B & \: \text{transposed, or}\\% !> A^H X = B & \: \text{conjugate transposed.} !> \end{array} !> \f] !> !> Matrix ``A`` is defined by its triangular factors, as returned by \ref rocsolver_sgetrf !> "GETRF". !> !> @param[in] handle - rocblas_handle. !> @param[in] trans - rocblas_operation. !> Specifies the form of the system of equations. !> @param[in] n - rocblas_int. n >= 0. !> The order of the system, that is, the number of columns and rows of A. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of the matrix B. !> @param[in] A - pointer to type. Array on the GPU of dimension lda*n. !> The factors L and U of the factorization \f$A = PLU\f$ returned by \ref !> rocsolver_sgetrf "GETRF". !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A. !> @param[in] ipiv - pointer to rocblas_int. Array on the GPU of dimension n. !> The pivot indices returned by \ref rocsolver_sgetrf "GETRF". !> @param[inout] B - pointer to type. Array on the GPU of dimension ldb*nrhs. !> On entry, the right hand side matrix B. !> On exit, the solution matrix X. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of B. interface rocsolver_sgetrs function rocsolver_sgetrs_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) & bind(c, name="rocsolver_sgetrs") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetrs_assumed_rank #else module procedure & rocsolver_sgetrs_rank_0,& rocsolver_sgetrs_rank_1,& rocsolver_sgetrs_full_rank #endif #endif end interface interface rocsolver_dgetrs function rocsolver_dgetrs_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) & bind(c, name="rocsolver_dgetrs") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetrs_assumed_rank #else module procedure & rocsolver_dgetrs_rank_0,& rocsolver_dgetrs_rank_1,& rocsolver_dgetrs_full_rank #endif #endif end interface interface rocsolver_cgetrs function rocsolver_cgetrs_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) & bind(c, name="rocsolver_cgetrs") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetrs_assumed_rank #else module procedure & rocsolver_cgetrs_rank_0,& rocsolver_cgetrs_rank_1,& rocsolver_cgetrs_full_rank #endif #endif end interface interface rocsolver_zgetrs function rocsolver_zgetrs_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) & bind(c, name="rocsolver_zgetrs") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetrs_assumed_rank #else module procedure & rocsolver_zgetrs_rank_0,& rocsolver_zgetrs_rank_1,& rocsolver_zgetrs_full_rank #endif #endif end interface interface rocsolver_sgetrs_64 function rocsolver_sgetrs_64_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) & bind(c, name="rocsolver_sgetrs_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface interface rocsolver_dgetrs_64 function rocsolver_dgetrs_64_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) & bind(c, name="rocsolver_dgetrs_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface interface rocsolver_cgetrs_64 function rocsolver_cgetrs_64_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) & bind(c, name="rocsolver_cgetrs_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface interface rocsolver_zgetrs_64 function rocsolver_zgetrs_64_(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) & bind(c, name="rocsolver_zgetrs_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface !> \brief The GETRS_BATCHED functions solve a batch of systems of ``n`` linear equations on !> ``n`` !> variables in its factorized forms. !> !> \details !> For each instance l in the batch, it solves one of the following systems, depending on the !> value of ``trans``: !> !> \f[ !> \begin{array}{cl} !> A_l X_l = B_l & \: \text{not transposed,}\\% !> A_l^T X_l^{} = B_l^{} & \: \text{transposed, or}\\% !> A_l^H X_l^{} = B_l^{} & \: \text{conjugate transposed.} !> \end{array} !> \f] !> !> Matrix \f$A_l\f$ is defined by its triangular factors as returned by \ref !> rocsolver_sgetrf_batched "GETRF_BATCHED". !> !> @param[in] handle - rocblas_handle. !> @param[in] trans - rocblas_operation. !> Specifies the form of the system of equations of each instance in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The order of the system, that is, the number of columns and rows of all A_l !> matrices. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of all the matrices B_l. !> @param[in] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> The factors L_l and U_l of the factorization A_l = P_l*L_l*U_l returned by \ref !> rocsolver_sgetrf_batched "GETRF_BATCHED". !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of matrices A_l. !> @param[in] ipiv - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideP). !> Contains the vectors ipiv_l of pivot indices returned by \ref !> rocsolver_sgetrf_batched "GETRF_BATCHED". !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value of strideP. The normal use case is !> strideP >= n. !> @param[inout] B - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*nrhs. !> On entry, the right hand side matrices B_l. !> On exit, the solution matrix X_l of each system in the batch. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of matrices B_l. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of instances (systems) in the batch. interface rocsolver_sgetrs_batched function rocsolver_sgetrs_batched_(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count) & bind(c, name="rocsolver_sgetrs_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetrs_batched_assumed_rank #else module procedure & rocsolver_sgetrs_batched_rank_0,& rocsolver_sgetrs_batched_rank_1 #endif #endif end interface interface rocsolver_dgetrs_batched function rocsolver_dgetrs_batched_(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count) & bind(c, name="rocsolver_dgetrs_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetrs_batched_assumed_rank #else module procedure & rocsolver_dgetrs_batched_rank_0,& rocsolver_dgetrs_batched_rank_1 #endif #endif end interface interface rocsolver_cgetrs_batched function rocsolver_cgetrs_batched_(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count) & bind(c, name="rocsolver_cgetrs_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetrs_batched_assumed_rank #else module procedure & rocsolver_cgetrs_batched_rank_0,& rocsolver_cgetrs_batched_rank_1 #endif #endif end interface interface rocsolver_zgetrs_batched function rocsolver_zgetrs_batched_(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count) & bind(c, name="rocsolver_zgetrs_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetrs_batched_assumed_rank #else module procedure & rocsolver_zgetrs_batched_rank_0,& rocsolver_zgetrs_batched_rank_1 #endif #endif end interface interface rocsolver_sgetrs_batched_64 function rocsolver_sgetrs_batched_64_(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb, & batch_count) & bind(c, name="rocsolver_sgetrs_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dgetrs_batched_64 function rocsolver_dgetrs_batched_64_(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb, & batch_count) & bind(c, name="rocsolver_dgetrs_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cgetrs_batched_64 function rocsolver_cgetrs_batched_64_(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb, & batch_count) & bind(c, name="rocsolver_cgetrs_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zgetrs_batched_64 function rocsolver_zgetrs_batched_64_(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb, & batch_count) & bind(c, name="rocsolver_zgetrs_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface !> \brief The GETRS_STRIDED_BATCHED functions solve a batch of systems of ``n`` linear !> equations !> on ``n`` variables in its factorized forms. !> !> \details !> For each instance l in the batch, it solves one of the following systems, depending on the !> value of ``trans``: !> !> \f[ !> \begin{array}{cl} !> A_l X_l = B_l & \: \text{not transposed,}\\% !> A_l^T X_l^{} = B_l^{} & \: \text{transposed, or}\\% !> A_l^H X_l^{} = B_l^{} & \: \text{conjugate transposed.} !> \end{array} !> \f] !> !> Matrix \f$A_l\f$ is defined by its triangular factors, as returned by \ref !> rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED". !> !> @param[in] handle - rocblas_handle. !> @param[in] trans - rocblas_operation. !> Specifies the form of the system of equations of each instance in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The order of the system, that is, the number of columns and rows of all A_l !> matrices. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of all the matrices B_l. !> @param[in] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> The factors L_l and U_l of the factorization A_l = P_l*L_l*U_l returned by \ref !> rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED". !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[in] ipiv - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideP). !> Contains the vectors ipiv_l of pivot indices returned by \ref !> rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED". !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value of strideP. The normal use case is !> strideP >= n. !> @param[inout] B - pointer to type. Array on the GPU (size depends on the value of strideB). !> On entry, the right hand side matrices B_l. !> On exit, the solution matrix X_l of each system in the batch. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of matrices B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. The normal use case is !> strideB >= ldb*nrhs. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of instances (systems) in the batch. interface rocsolver_sgetrs_strided_batched function rocsolver_sgetrs_strided_batched_(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,batch_count) & bind(c, name="rocsolver_sgetrs_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans 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 :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: strideB integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetrs_strided_batched_assumed_rank #else module procedure & rocsolver_sgetrs_strided_batched_rank_0,& rocsolver_sgetrs_strided_batched_rank_1,& rocsolver_sgetrs_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgetrs_strided_batched function rocsolver_dgetrs_strided_batched_(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,batch_count) & bind(c, name="rocsolver_dgetrs_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans 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 :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: strideB integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetrs_strided_batched_assumed_rank #else module procedure & rocsolver_dgetrs_strided_batched_rank_0,& rocsolver_dgetrs_strided_batched_rank_1,& rocsolver_dgetrs_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgetrs_strided_batched function rocsolver_cgetrs_strided_batched_(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,batch_count) & bind(c, name="rocsolver_cgetrs_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans 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 :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: strideB integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetrs_strided_batched_assumed_rank #else module procedure & rocsolver_cgetrs_strided_batched_rank_0,& rocsolver_cgetrs_strided_batched_rank_1,& rocsolver_cgetrs_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgetrs_strided_batched function rocsolver_zgetrs_strided_batched_(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,batch_count) & bind(c, name="rocsolver_zgetrs_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans 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 :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: strideB integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetrs_strided_batched_assumed_rank #else module procedure & rocsolver_zgetrs_strided_batched_rank_0,& rocsolver_zgetrs_strided_batched_rank_1,& rocsolver_zgetrs_strided_batched_full_rank #endif #endif end interface interface rocsolver_sgetrs_strided_batched_64 function rocsolver_sgetrs_strided_batched_64_(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP, & B,ldb,strideB,batch_count) & bind(c, name="rocsolver_sgetrs_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dgetrs_strided_batched_64 function rocsolver_dgetrs_strided_batched_64_(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP, & B,ldb,strideB,batch_count) & bind(c, name="rocsolver_dgetrs_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cgetrs_strided_batched_64 function rocsolver_cgetrs_strided_batched_64_(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP, & B,ldb,strideB,batch_count) & bind(c, name="rocsolver_cgetrs_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zgetrs_strided_batched_64 function rocsolver_zgetrs_strided_batched_64_(handle,trans,n,nrhs,A,lda,strideA,ipiv,strideP, & B,ldb,strideB,batch_count) & bind(c, name="rocsolver_zgetrs_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batch_count end function end interface !> \brief The SYTRS functions solve a system of ``n`` linear equations on ``n`` variables in !> its factorized form. !> !> \details !> It solves the linear system \f$ A X = B \f$, where the n-by-n matrix A is symmetric and !> maybe indefinite, !> using one of the following factorizations that depends on the value of ``uplo``: !> !> \f[ !> \begin{array}{cl} !> A X = B & \: \text{where} \\% !> A = U D U^T & \: \text{ U is upper triangular or}\\% !> A = L D L^T & \: \text{ L is lower triangular} !> \end{array} !> \f] !> !> Matrix \f$A\f$ is defined by its triangular factors, as returned by \ref rocsolver_ssytrf !> "SYTRF". !> Matrix \f$D\f$ is a symmetric block diagonal matrix with 1-by-1 or 2-by-2 diagonal blocks. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the factorization of matrix \f$ A \f$ is upper or lower !> triangular. !> @param[in] n - rocblas_int. n >= 0. !> The order of the system, that is, the number of columns and rows of A. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of the matrix B. !> @param[in] A - pointer to type. Array on the GPU of dimension lda*n. !> The factors L (or U) and D of the factorization A returned by \ref !> rocsolver_ssytrf "SYTRF". !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A. !> @param[in] ipiv - pointer to rocblas_int. Array on the GPU of dimension n. !> The pivot indices returned by \ref rocsolver_ssytrf "SYTRF". !> @param[inout] B - pointer to type. Array on the GPU of dimension ldb*nrhs. !> On entry, the right hand side matrix B. !> On exit, the solution matrix X. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of B. interface rocsolver_ssytrs function rocsolver_ssytrs_(handle,uplo,n,nrhs,A,lda,ipiv,B,ldb) bind(c, name="rocsolver_ssytrs") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrs_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb end function end interface interface rocsolver_dsytrs function rocsolver_dsytrs_(handle,uplo,n,nrhs,A,lda,ipiv,B,ldb) bind(c, name="rocsolver_dsytrs") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrs_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb end function end interface interface rocsolver_csytrs function rocsolver_csytrs_(handle,uplo,n,nrhs,A,lda,ipiv,B,ldb) bind(c, name="rocsolver_csytrs") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrs_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb end function end interface interface rocsolver_zsytrs function rocsolver_zsytrs_(handle,uplo,n,nrhs,A,lda,ipiv,B,ldb) bind(c, name="rocsolver_zsytrs") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrs_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb end function end interface interface rocsolver_ssytrs_64 function rocsolver_ssytrs_64_(handle,uplo,n,nrhs,A,lda,ipiv,B,ldb) & bind(c, name="rocsolver_ssytrs_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrs_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface interface rocsolver_dsytrs_64 function rocsolver_dsytrs_64_(handle,uplo,n,nrhs,A,lda,ipiv,B,ldb) & bind(c, name="rocsolver_dsytrs_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrs_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface interface rocsolver_csytrs_64 function rocsolver_csytrs_64_(handle,uplo,n,nrhs,A,lda,ipiv,B,ldb) & bind(c, name="rocsolver_csytrs_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrs_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface interface rocsolver_zsytrs_64 function rocsolver_zsytrs_64_(handle,uplo,n,nrhs,A,lda,ipiv,B,ldb) & bind(c, name="rocsolver_zsytrs_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrs_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface !> \brief The SYTRS_BATCHED functions solve a batch of systems of ``n`` linear equations on !> ``n`` !> variables in its factorized forms. !> !> \details !> For each instance \f$ l \f$ in the batch, it solves the linear system \f$ A_l X_l = B_l !> \f$, !> where the n-by-n matrix A is symmetric and maybe indefinite, !> using one of the following factorization, depending on the value of ``uplo``: !> !> \f[ !> \begin{array}{cl} !> A_l X_l = B_l & \: \text{where} \\% !> A_l = U_l D_l U_l^T & \: \text{U is upper triangular, or}\\% !> A_l = L_l D_l L_l^T & \: \text{L is lower triangular } !> \end{array} !> \f] !> !> Matrix \f$A_l\f$ is defined by its triangular factors as returned by !> \ref rocsolver_ssytrf_batched "SYTRF_BATCHED". !> Note matrix \f$ D_l \f$ contains 1-by-1 or 2-by-2 blocks on the main diagonal. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the factorization of matrix \f$ A \f$ is upper or lower !> triangular. !> @param[in] n - rocblas_int. n >= 0. !> The order of the system, that is, the number of columns and rows of all A_l !> matrices. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of all the matrices B_l. !> @param[in] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> The factors L_l (or U_l) and D_l of the factorization A_l returned by \ref !> rocsolver_ssytrf_batched "SYTRF_BATCHED". !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of matrices A_l. !> @param[in] ipiv - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideP). !> Contains the vectors ipiv_l of pivot indices returned by \ref !> rocsolver_ssytrf_batched "SYTRF_BATCHED". !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value of strideP. The normal use case is !> strideP >= n. !> @param[inout] B - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*nrhs. !> On entry, the right hand side matrices B_l. !> On exit, the solution matrix X_l of each system in the batch. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of matrices B_l. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of instances (systems) in the batch. interface rocsolver_ssytrs_batched function rocsolver_ssytrs_batched_(handle,uplo,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count) & bind(c, name="rocsolver_ssytrs_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrs_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function end interface interface rocsolver_dsytrs_batched function rocsolver_dsytrs_batched_(handle,uplo,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count) & bind(c, name="rocsolver_dsytrs_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrs_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function end interface interface rocsolver_csytrs_batched function rocsolver_csytrs_batched_(handle,uplo,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count) & bind(c, name="rocsolver_csytrs_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrs_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function end interface interface rocsolver_zsytrs_batched function rocsolver_zsytrs_batched_(handle,uplo,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count) & bind(c, name="rocsolver_zsytrs_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrs_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function end interface interface rocsolver_ssytrs_batched_64 function rocsolver_ssytrs_batched_64_(handle,uplo,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count) & bind(c, name="rocsolver_ssytrs_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrs_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dsytrs_batched_64 function rocsolver_dsytrs_batched_64_(handle,uplo,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count) & bind(c, name="rocsolver_dsytrs_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrs_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_csytrs_batched_64 function rocsolver_csytrs_batched_64_(handle,uplo,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count) & bind(c, name="rocsolver_csytrs_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrs_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zsytrs_batched_64 function rocsolver_zsytrs_batched_64_(handle,uplo,n,nrhs,A,lda,ipiv,strideP,B,ldb,batch_count) & bind(c, name="rocsolver_zsytrs_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrs_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface !> \brief The SYTRS_STRIDED_BATCHED functions solve a batch of systems of ``n`` linear !> equations !> on ``n`` variables in its factorized forms. !> !> \details !> For each instance \f$ l \f$ in the batch, it solves the linear system \f$ A_l X_l = B_l !> \f$, !> where the n-by-n matrix A is symmetric and maybe indefinite, !> using one of the following factorizations, depending on the value of ``uplo``: !> !> \f[ !> \begin{array}{cl} !> A_l X_l = B_l & \: \text{where} \\% !> A_l = U_l D_l U_l^T & \: \text{U is upper triangular, or}\\% !> A_l = L_l D_l L_l^T & \: \text{L is lower triangular } !> \end{array} !> \f] !> !> Matrix \f$A_l\f$ is defined by its triangular factors as returned by !> \ref rocsolver_ssytrf_strided_batched "SYTRF_STRIDED_BATCHED". !> Note matrix \f$ D_l \f$ contains 1-by-1 or 2-by-2 blocks on the main diagonal. !> !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the factorization of matrix \f$ A \f$ is upper or lower !> triangular. !> @param[in] n - rocblas_int. n >= 0. !> The order of the system, that is, the number of columns and rows of all A_l !> matrices. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of all the matrices B_l. !> @param[in] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> The factors L_l (or U_l) and D_l of the factorization A_l returned by \ref !> rocsolver_ssytrf_strided_batched "SYTRF_STRIDED_BATCHED". !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[in] ipiv - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideP). !> Contains the vectors ipiv_l of pivot indices returned by \ref !> rocsolver_ssytrf_strided_batched "SYTRF_STRIDED_BATCHED". !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value of strideP. The normal use case is !> strideP >= n. !> @param[inout] B - pointer to type. Array on the GPU (size depends on the value of strideB). !> On entry, the right hand side matrices B_l. !> On exit, the solution matrix X_l of each system in the batch. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of matrices B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. The normal use case is !> strideB >= ldb*nrhs. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of instances (systems) in the batch. interface rocsolver_ssytrs_strided_batched function rocsolver_ssytrs_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,batch_count) & bind(c, name="rocsolver_ssytrs_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrs_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: strideB integer(c_int),value :: batch_count end function end interface interface rocsolver_dsytrs_strided_batched function rocsolver_dsytrs_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,batch_count) & bind(c, name="rocsolver_dsytrs_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrs_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: strideB integer(c_int),value :: batch_count end function end interface interface rocsolver_csytrs_strided_batched function rocsolver_csytrs_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,batch_count) & bind(c, name="rocsolver_csytrs_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrs_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: strideB integer(c_int),value :: batch_count end function end interface interface rocsolver_zsytrs_strided_batched function rocsolver_zsytrs_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,batch_count) & bind(c, name="rocsolver_zsytrs_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrs_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: strideB integer(c_int),value :: batch_count end function end interface interface rocsolver_ssytrs_strided_batched_64 function rocsolver_ssytrs_strided_batched_64_(handle,uplo,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,batch_count) & bind(c, name="rocsolver_ssytrs_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrs_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dsytrs_strided_batched_64 function rocsolver_dsytrs_strided_batched_64_(handle,uplo,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,batch_count) & bind(c, name="rocsolver_dsytrs_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrs_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_csytrs_strided_batched_64 function rocsolver_csytrs_strided_batched_64_(handle,uplo,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,batch_count) & bind(c, name="rocsolver_csytrs_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrs_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zsytrs_strided_batched_64 function rocsolver_zsytrs_strided_batched_64_(handle,uplo,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,batch_count) & bind(c, name="rocsolver_zsytrs_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrs_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batch_count end function end interface !> \brief The GESV functions solve a general system of ``n`` linear equations on ``n`` !> variables. !> !> \details !> The linear system is of the form !> !> \f[ !> A X = B !> \f] !> !> where ``A`` is a general ``n`` -by-``n ``matrix. Matrix `` A`` is first factorized in !> triangular factors L and U !> using \ref rocsolver_sgetrf "GETRF", then the solution is computed with \ref !> rocsolver_sgetrs "GETRS". !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The order of the system, that is, the number of columns and rows of A. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of the matrix B. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. !> On exit, if info = 0, the factors L and U of the LU decomposition of A returned !> by !> \ref rocsolver_sgetrf "GETRF". !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A. !> @param[out] ipiv - pointer to rocblas_int. Array on the GPU of dimension n. !> The pivot indices returned by \ref rocsolver_sgetrf "GETRF". !> @param[inout] B - pointer to type. Array on the GPU of dimension ldb*nrhs. !> On entry, the right hand side matrix B. !> On exit, the solution matrix X. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of B. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, U is singular, and the solution could not be computed. !> U[i,i] is the first zero element in the diagonal. interface rocsolver_sgesv function rocsolver_sgesv_(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) bind(c, name="rocsolver_sgesv") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesv_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgesv_assumed_rank #else module procedure & rocsolver_sgesv_rank_0,& rocsolver_sgesv_rank_1,& rocsolver_sgesv_full_rank #endif #endif end interface interface rocsolver_dgesv function rocsolver_dgesv_(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) bind(c, name="rocsolver_dgesv") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesv_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgesv_assumed_rank #else module procedure & rocsolver_dgesv_rank_0,& rocsolver_dgesv_rank_1,& rocsolver_dgesv_full_rank #endif #endif end interface interface rocsolver_cgesv function rocsolver_cgesv_(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) bind(c, name="rocsolver_cgesv") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesv_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgesv_assumed_rank #else module procedure & rocsolver_cgesv_rank_0,& rocsolver_cgesv_rank_1,& rocsolver_cgesv_full_rank #endif #endif end interface interface rocsolver_zgesv function rocsolver_zgesv_(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) bind(c, name="rocsolver_zgesv") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesv_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgesv_assumed_rank #else module procedure & rocsolver_zgesv_rank_0,& rocsolver_zgesv_rank_1,& rocsolver_zgesv_full_rank #endif #endif end interface !> \brief The GESV_BATCHED functions solve a batch of general systems of ``n`` linear !> equations on ``n`` !> variables. !> !> \details !> The linear systems are of the form !> !> \f[ !> A_l X_l = B_l !> \f] !> !> where \f$A_l\f$ is a general ``n`` -by-``n`` matrix. Matrix \f$A_l\f$ is first factorized !> in triangular factors \f$L_l\f$ and \f$U_l\f$ !> using \ref rocsolver_sgetrf_batched "GETRF_BATCHED", then the solutions are computed with !> \ref rocsolver_sgetrs_batched "GETRS_BATCHED". !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The order of the system, that is, the number of columns and rows of all A_l !> matrices. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of all the matrices B_l. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. !> On exit, if info[l] = 0, the factors L_l and U_l of the LU decomposition of A_l !> returned by !> \ref rocsolver_sgetrf_batched "GETRF_BATCHED". !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of matrices A_l. !> @param[out] ipiv - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideP). !> The vectors ipiv_l of pivot indices returned by \ref rocsolver_sgetrf_batched !> "GETRF_BATCHED". !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value of strideP. The normal use case is !> strideP >= n. !> @param[inout] B - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*nrhs. !> On entry, the right hand side matrices B_l. !> On exit, the solution matrix X_l of each system in the batch. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of matrices B_l. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for A_l. !> If info[l] = i > 0, U_l is singular, and the solution could not be computed. !> U_l[i,i] is the first zero element in the diagonal. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of instances (systems) in the batch. interface rocsolver_sgesv_batched function rocsolver_sgesv_batched_(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count) & bind(c, name="rocsolver_sgesv_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesv_batched_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgesv_batched_assumed_rank #else module procedure & rocsolver_sgesv_batched_rank_0,& rocsolver_sgesv_batched_rank_1 #endif #endif end interface interface rocsolver_dgesv_batched function rocsolver_dgesv_batched_(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count) & bind(c, name="rocsolver_dgesv_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesv_batched_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgesv_batched_assumed_rank #else module procedure & rocsolver_dgesv_batched_rank_0,& rocsolver_dgesv_batched_rank_1 #endif #endif end interface interface rocsolver_cgesv_batched function rocsolver_cgesv_batched_(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count) & bind(c, name="rocsolver_cgesv_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesv_batched_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgesv_batched_assumed_rank #else module procedure & rocsolver_cgesv_batched_rank_0,& rocsolver_cgesv_batched_rank_1 #endif #endif end interface interface rocsolver_zgesv_batched function rocsolver_zgesv_batched_(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo,batch_count) & bind(c, name="rocsolver_zgesv_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesv_batched_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgesv_batched_assumed_rank #else module procedure & rocsolver_zgesv_batched_rank_0,& rocsolver_zgesv_batched_rank_1 #endif #endif end interface !> \brief The GESV_STRIDED_BATCHED functions solve a batch of general systems of ``n`` linear !> equations !> on ``n`` variables. !> !> \details !> The linear systems are of the form !> !> \f[ !> A_l X_l = B_l !> \f] !> !> where \f$A_l\f$ is a general ``n`` -by-``n`` matrix. Matrix \f$A_l\f$ is first factorized !> in triangular factors \f$L_l\f$ and \f$U_l\f$ !> using \ref rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED", and then the solutions !> are computed with !> \ref rocsolver_sgetrs_strided_batched "GETRS_STRIDED_BATCHED". !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The order of the system, that is, the number of columns and rows of all A_l !> matrices. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of all the matrices B_l. !> @param[in] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. !> On exit, if info[l] = 0, the factors L_l and U_l of the LU decomposition of A_l !> returned by !> \ref rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED". !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of matrices A_l. !> @param[inout] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] ipiv - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideP). !> The vectors ipiv_l of pivot indices returned by \ref !> rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED". !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value of strideP. The normal use case is !> strideP >= n. !> @param[inout] B - pointer to type. Array on the GPU (size depends on the value of strideB). !> On entry, the right hand side matrices B_l. !> On exit, the solution matrix X_l of each system in the batch. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of matrices B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. The normal use case is !> strideB >= ldb*nrhs. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for A_l. !> If info[l] = i > 0, U_l is singular, and the solution could not be computed. !> U_l[i,i] is the first zero element in the diagonal. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of instances (systems) in the batch. interface rocsolver_sgesv_strided_batched function rocsolver_sgesv_strided_batched_(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb, & strideB,myInfo,batch_count) & bind(c, name="rocsolver_sgesv_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesv_strided_batched_ type(c_ptr),value :: handle 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 :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgesv_strided_batched_assumed_rank #else module procedure & rocsolver_sgesv_strided_batched_rank_0,& rocsolver_sgesv_strided_batched_rank_1,& rocsolver_sgesv_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgesv_strided_batched function rocsolver_dgesv_strided_batched_(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb, & strideB,myInfo,batch_count) & bind(c, name="rocsolver_dgesv_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesv_strided_batched_ type(c_ptr),value :: handle 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 :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgesv_strided_batched_assumed_rank #else module procedure & rocsolver_dgesv_strided_batched_rank_0,& rocsolver_dgesv_strided_batched_rank_1,& rocsolver_dgesv_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgesv_strided_batched function rocsolver_cgesv_strided_batched_(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb, & strideB,myInfo,batch_count) & bind(c, name="rocsolver_cgesv_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesv_strided_batched_ type(c_ptr),value :: handle 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 :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgesv_strided_batched_assumed_rank #else module procedure & rocsolver_cgesv_strided_batched_rank_0,& rocsolver_cgesv_strided_batched_rank_1,& rocsolver_cgesv_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgesv_strided_batched function rocsolver_zgesv_strided_batched_(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B,ldb, & strideB,myInfo,batch_count) & bind(c, name="rocsolver_zgesv_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesv_strided_batched_ type(c_ptr),value :: handle 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 :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgesv_strided_batched_assumed_rank #else module procedure & rocsolver_zgesv_strided_batched_rank_0,& rocsolver_zgesv_strided_batched_rank_1,& rocsolver_zgesv_strided_batched_full_rank #endif #endif end interface !> \brief The GETRS_NPVT functions solve a system of n linear equations on ``n`` variables in !> its factorized form. !> !> \details !> It solves one of the following systems, depending on the value of ``trans``: !> !> \f[ !> \begin{array}{cl} !> A X = B & \: \text{not transposed,}\\% !> A^T X = B & \: \text{transposed, or}\\% !> A^H X = B & \: \text{conjugate transposed.} !> \end{array} !> \f] !> !> Matrix ``A`` is defined by its triangular factors, as returned by \ref !> rocsolver_sgetrf_npvt "GETRF_NPVT". !> !> @param[in] handle - rocblas_handle. !> !> @param[in] trans - rocblas_operation. !> Specifies the form of the system of equations. !> @param[in] n - rocblas_int. n >= 0. !> The order of the system, that is, the number of columns and rows of A. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of the matrix B. !> @param[in] A - pointer to type. Array on the GPU of dimension lda*n. !> The factors L and U of the factorization \f$A = LU\f$ returned by \ref !> rocsolver_sgetrf_npvt "GETRF_NPVT". !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A. !> @param[inout] B - pointer to type. Array on the GPU of dimension ldb*nrhs. !> On entry, the right hand side matrix B. !> On exit, the solution matrix X. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of B. interface rocsolver_sgetrs_npvt function rocsolver_sgetrs_npvt_(handle,trans,n,nrhs,A,lda,B,ldb) & bind(c, name="rocsolver_sgetrs_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_npvt_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans 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 end function end interface interface rocsolver_dgetrs_npvt function rocsolver_dgetrs_npvt_(handle,trans,n,nrhs,A,lda,B,ldb) & bind(c, name="rocsolver_dgetrs_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_npvt_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans 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 end function end interface interface rocsolver_cgetrs_npvt function rocsolver_cgetrs_npvt_(handle,trans,n,nrhs,A,lda,B,ldb) & bind(c, name="rocsolver_cgetrs_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_npvt_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans 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 end function end interface interface rocsolver_zgetrs_npvt function rocsolver_zgetrs_npvt_(handle,trans,n,nrhs,A,lda,B,ldb) & bind(c, name="rocsolver_zgetrs_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_npvt_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans 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 end function end interface interface rocsolver_sgetrs_npvt_64 function rocsolver_sgetrs_npvt_64_(handle,trans,n,nrhs,A,lda,B,ldb) & bind(c, name="rocsolver_sgetrs_npvt_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_npvt_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface interface rocsolver_dgetrs_npvt_64 function rocsolver_dgetrs_npvt_64_(handle,trans,n,nrhs,A,lda,B,ldb) & bind(c, name="rocsolver_dgetrs_npvt_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_npvt_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface interface rocsolver_cgetrs_npvt_64 function rocsolver_cgetrs_npvt_64_(handle,trans,n,nrhs,A,lda,B,ldb) & bind(c, name="rocsolver_cgetrs_npvt_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_npvt_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface interface rocsolver_zgetrs_npvt_64 function rocsolver_zgetrs_npvt_64_(handle,trans,n,nrhs,A,lda,B,ldb) & bind(c, name="rocsolver_zgetrs_npvt_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_npvt_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface !> \brief The GETRS_NPVT_BATCHED functions solve a batch of systems of ``n`` linear equations !> on ``n`` !> variables in its factorized forms. !> !> \details !> For each instance l in the batch, it solves one of the following systems, depending on the !> value of ``trans``: !> !> \f[ !> \begin{array}{cl} !> A_l X_l = B_l & \: \text{not transposed,}\\% !> A_l^T X_l^{} = B_l^{} & \: \text{transposed, or}\\% !> A_l^H X_l^{} = B_l^{} & \: \text{conjugate transposed.} !> \end{array} !> \f] !> !> Matrix \f$A_l\f$ is defined by its triangular factors as returned by \ref !> rocsolver_sgetrf_npvt_batched "GETRF_NPVT_BATCHED". !> !> @param[in] handle - rocblas_handle. !> !> @param[in] trans - rocblas_operation. !> Specifies the form of the system of equations of each instance in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The order of the system, that is, the number of columns and rows of all A_l !> matrices. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of all the matrices B_l. !> @param[in] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> The factors L_l and U_l of the factorization A_l = L_l*U_l returned by \ref !> rocsolver_sgetrf_npvt_batched "GETRF_NPVT_BATCHED". !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of matrices A_l. !> @param[inout] B - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*nrhs. !> On entry, the right hand side matrices B_l. !> On exit, the solution matrix X_l of each system in the batch. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of matrices B_l. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of instances (systems) in the batch. interface rocsolver_sgetrs_npvt_batched function rocsolver_sgetrs_npvt_batched_(handle,trans,n,nrhs,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_sgetrs_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_npvt_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans 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 integer(c_int),value :: batch_count end function end interface interface rocsolver_dgetrs_npvt_batched function rocsolver_dgetrs_npvt_batched_(handle,trans,n,nrhs,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_dgetrs_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_npvt_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans 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 integer(c_int),value :: batch_count end function end interface interface rocsolver_cgetrs_npvt_batched function rocsolver_cgetrs_npvt_batched_(handle,trans,n,nrhs,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_cgetrs_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_npvt_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans 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 integer(c_int),value :: batch_count end function end interface interface rocsolver_zgetrs_npvt_batched function rocsolver_zgetrs_npvt_batched_(handle,trans,n,nrhs,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_zgetrs_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_npvt_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans 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 integer(c_int),value :: batch_count end function end interface interface rocsolver_sgetrs_npvt_batched_64 function rocsolver_sgetrs_npvt_batched_64_(handle,trans,n,nrhs,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_sgetrs_npvt_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_npvt_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dgetrs_npvt_batched_64 function rocsolver_dgetrs_npvt_batched_64_(handle,trans,n,nrhs,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_dgetrs_npvt_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_npvt_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cgetrs_npvt_batched_64 function rocsolver_cgetrs_npvt_batched_64_(handle,trans,n,nrhs,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_cgetrs_npvt_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_npvt_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zgetrs_npvt_batched_64 function rocsolver_zgetrs_npvt_batched_64_(handle,trans,n,nrhs,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_zgetrs_npvt_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_npvt_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface !> \brief The GETRS_NPVT_STRIDED_BATCHED functions solve a batch of systems of ``n`` linear !> equations !> on ``n`` variables in its factorized forms. !> !> \details !> For each instance l in the batch, it solves one of the following systems, depending on the !> value of ``trans``: !> !> \f[ !> \begin{array}{cl} !> A_l X_l = B_l & \: \text{not transposed,}\\% !> A_l^T X_l^{} = B_l^{} & \: \text{transposed, or}\\% !> A_l^H X_l^{} = B_l^{} & \: \text{conjugate transposed.} !> \end{array} !> \f] !> !> Matrix \f$A_l\f$ is defined by its triangular factors, as returned by \ref !> rocsolver_sgetrf_npvt_strided_batched "GETRF_NPVT_STRIDED_BATCHED". !> !> @param[in] handle - rocblas_handle. !> !> @param[in] trans - rocblas_operation. !> Specifies the form of the system of equations of each instance in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The order of the system, that is, the number of columns and rows of all A_l !> matrices. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of all the matrices B_l. !> @param[in] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> The factors L_l and U_l of the factorization A_l = L_l*U_l returned by \ref !> rocsolver_sgetrf_npvt_strided_batched "GETRF_NPVT_STRIDED_BATCHED". !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[inout] B - pointer to type. Array on the GPU (size depends on the value of strideB). !> On entry, the right hand side matrices B_l. !> On exit, the solution matrix X_l of each system in the batch. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of matrices B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. The normal use case is !> strideB >= ldb*nrhs. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of instances (systems) in the batch. interface rocsolver_sgetrs_npvt_strided_batched function rocsolver_sgetrs_npvt_strided_batched_(handle,trans,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) & bind(c, name="rocsolver_sgetrs_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_npvt_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans 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 integer(c_int),value :: batch_count end function end interface interface rocsolver_dgetrs_npvt_strided_batched function rocsolver_dgetrs_npvt_strided_batched_(handle,trans,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) & bind(c, name="rocsolver_dgetrs_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_npvt_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans 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 integer(c_int),value :: batch_count end function end interface interface rocsolver_cgetrs_npvt_strided_batched function rocsolver_cgetrs_npvt_strided_batched_(handle,trans,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) & bind(c, name="rocsolver_cgetrs_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_npvt_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans 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 integer(c_int),value :: batch_count end function end interface interface rocsolver_zgetrs_npvt_strided_batched function rocsolver_zgetrs_npvt_strided_batched_(handle,trans,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) & bind(c, name="rocsolver_zgetrs_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_npvt_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans 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 integer(c_int),value :: batch_count end function end interface interface rocsolver_sgetrs_npvt_strided_batched_64 function rocsolver_sgetrs_npvt_strided_batched_64_(handle,trans,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) & bind(c, name="rocsolver_sgetrs_npvt_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_npvt_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dgetrs_npvt_strided_batched_64 function rocsolver_dgetrs_npvt_strided_batched_64_(handle,trans,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) & bind(c, name="rocsolver_dgetrs_npvt_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_npvt_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cgetrs_npvt_strided_batched_64 function rocsolver_cgetrs_npvt_strided_batched_64_(handle,trans,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) & bind(c, name="rocsolver_cgetrs_npvt_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_npvt_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zgetrs_npvt_strided_batched_64 function rocsolver_zgetrs_npvt_strided_batched_64_(handle,trans,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) & bind(c, name="rocsolver_zgetrs_npvt_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_npvt_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),value :: trans integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batch_count end function end interface !> \brief The GETRI functions invert a general ``n`` -by-``n`` matrix ``A`` using the LU !> factorization !> computed by \ref rocsolver_sgetrf "GETRF". !> !> \details !> The inverse is computed by solving the linear system !> !> \f[ !> A^{-1}L = U^{-1} !> \f] !> !> where L is the lower triangular factor of ``A`` with unit diagonal elements, and U is the !> upper triangular factor. !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the factors L and U of the factorization \f$A = PLU\f$ returned by !> \ref rocsolver_sgetrf "GETRF". !> On exit, the inverse of A if info = 0, and otherwise undefined. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[in] ipiv - pointer to rocblas_int. Array on the GPU of dimension n. !> The pivot indices returned by \ref rocsolver_sgetrf "GETRF". !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, U is singular. U[i,i] is the first zero pivot. interface rocsolver_sgetri function rocsolver_sgetri_(handle,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_sgetri") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_ 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 :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetri_assumed_rank #else module procedure & rocsolver_sgetri_rank_0,& rocsolver_sgetri_rank_1,& rocsolver_sgetri_full_rank #endif #endif end interface interface rocsolver_dgetri function rocsolver_dgetri_(handle,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_dgetri") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_ 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 :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetri_assumed_rank #else module procedure & rocsolver_dgetri_rank_0,& rocsolver_dgetri_rank_1,& rocsolver_dgetri_full_rank #endif #endif end interface interface rocsolver_cgetri function rocsolver_cgetri_(handle,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_cgetri") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_ 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 :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetri_assumed_rank #else module procedure & rocsolver_cgetri_rank_0,& rocsolver_cgetri_rank_1,& rocsolver_cgetri_full_rank #endif #endif end interface interface rocsolver_zgetri function rocsolver_zgetri_(handle,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_zgetri") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_ 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 :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetri_assumed_rank #else module procedure & rocsolver_zgetri_rank_0,& rocsolver_zgetri_rank_1,& rocsolver_zgetri_full_rank #endif #endif end interface !> \brief The GETRI_BATCHED functions invert a batch of general ``n``-by-``n`` matrices using !> the LU factorization computed by \ref rocsolver_sgetrf_batched "GETRF_BATCHED". !> !> \details !> The inverse of matrix \f$A_l\f$ in the batch is computed by solving the linear system !> !> \f[ !> A_l^{-1} L_l^{} = U_l^{-1} !> \f] !> !> where \f$L_l\f$ is the lower triangular factor of \f$A_l\f$ with unit diagonal elements, !> and \f$U_l\f$ is the !> upper triangular factor. !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of all matrices A_l in the batch. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the factors L_l and U_l of the factorization A_l = P_l*L_l*U_l !> returned by !> \ref rocsolver_sgetrf_batched "GETRF_BATCHED". !> On exit, the inverses of A_l if info[l] = 0, and otherwise undefined. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] ipiv - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideP). !> The pivot indices returned by \ref rocsolver_sgetrf_batched "GETRF_BATCHED". !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+j). !> There is no restriction for the value of strideP. The normal use case is !> strideP >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for inversion of A_l. !> If info[l] = i > 0, U_l is singular. U_l[i,i] is the first zero pivot. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgetri_batched function rocsolver_sgetri_batched_(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_sgetri_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_batched_ 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 integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetri_batched_assumed_rank #else module procedure & rocsolver_sgetri_batched_rank_0,& rocsolver_sgetri_batched_rank_1 #endif #endif end interface interface rocsolver_dgetri_batched function rocsolver_dgetri_batched_(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_dgetri_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_batched_ 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 integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetri_batched_assumed_rank #else module procedure & rocsolver_dgetri_batched_rank_0,& rocsolver_dgetri_batched_rank_1 #endif #endif end interface interface rocsolver_cgetri_batched function rocsolver_cgetri_batched_(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_cgetri_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_batched_ 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 integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetri_batched_assumed_rank #else module procedure & rocsolver_cgetri_batched_rank_0,& rocsolver_cgetri_batched_rank_1 #endif #endif end interface interface rocsolver_zgetri_batched function rocsolver_zgetri_batched_(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_zgetri_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_batched_ 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 integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetri_batched_assumed_rank #else module procedure & rocsolver_zgetri_batched_rank_0,& rocsolver_zgetri_batched_rank_1 #endif #endif end interface !> \brief The GETRI_STRIDED_BATCHED functions invert a batch of general ``n`` -by-``n`` !> matrices !> using the LU factorization computed by \ref rocsolver_sgetrf_strided_batched !> "GETRF_STRIDED_BATCHED". !> !> \details !> The inverse of matrix \f$A_l\f$ in the batch is computed by solving the linear system !> !> \f[ !> A_l^{-1} L_l^{} = U_l^{-1} !> \f] !> !> where \f$L_l\f$ is the lower triangular factor of \f$A_l\f$ with unit diagonal elements, !> and \f$U_l\f$ is the !> upper triangular factor. !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of all matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the factors L_l and U_l of the factorization A_l = P_l*L_l*U_l !> returned by !> \ref rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED". !> On exit, the inverses of A_l if info[l] = 0, and otherwise undefined. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[in] ipiv - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideP). !> The pivot indices returned by \ref rocsolver_sgetrf_strided_batched !> "GETRF_STRIDED_BATCHED". !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value of strideP. The normal use case is !> strideP >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for inversion of A_l. !> If info[l] = i > 0, U_l is singular. U_l[i,i] is the first zero pivot. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgetri_strided_batched function rocsolver_sgetri_strided_batched_(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_sgetri_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetri_strided_batched_assumed_rank #else module procedure & rocsolver_sgetri_strided_batched_rank_0,& rocsolver_sgetri_strided_batched_rank_1,& rocsolver_sgetri_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgetri_strided_batched function rocsolver_dgetri_strided_batched_(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_dgetri_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetri_strided_batched_assumed_rank #else module procedure & rocsolver_dgetri_strided_batched_rank_0,& rocsolver_dgetri_strided_batched_rank_1,& rocsolver_dgetri_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgetri_strided_batched function rocsolver_cgetri_strided_batched_(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_cgetri_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetri_strided_batched_assumed_rank #else module procedure & rocsolver_cgetri_strided_batched_rank_0,& rocsolver_cgetri_strided_batched_rank_1,& rocsolver_cgetri_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgetri_strided_batched function rocsolver_zgetri_strided_batched_(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_zgetri_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetri_strided_batched_assumed_rank #else module procedure & rocsolver_zgetri_strided_batched_rank_0,& rocsolver_zgetri_strided_batched_rank_1,& rocsolver_zgetri_strided_batched_full_rank #endif #endif end interface !> \brief The GETRI_NPVT functions invert a general ``n`` -by``-n`` matrix ``A`` using the LU !> factorization !> computed by \ref rocsolver_sgetrf_npvt "GETRF_NPVT". !> !> \details !> The inverse is computed by solving the linear system !> !> \f[ !> A^{-1}L = U^{-1} !> \f] !> !> where L is the lower triangular factor of ``A`` with unit diagonal elements, and U is the !> upper triangular factor. !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the factors L and U of the factorization \f$A = LU\f$ returned by !> \ref rocsolver_sgetrf_npvt "GETRF_NPVT". !> On exit, the inverse of A if info = 0, and otherwise undefined. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, U is singular. U[i,i] is the first zero pivot. interface rocsolver_sgetri_npvt function rocsolver_sgetri_npvt_(handle,n,A,lda,myInfo) bind(c, name="rocsolver_sgetri_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetri_npvt_assumed_rank #else module procedure & rocsolver_sgetri_npvt_rank_0,& rocsolver_sgetri_npvt_rank_1,& rocsolver_sgetri_npvt_full_rank #endif #endif end interface interface rocsolver_dgetri_npvt function rocsolver_dgetri_npvt_(handle,n,A,lda,myInfo) bind(c, name="rocsolver_dgetri_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetri_npvt_assumed_rank #else module procedure & rocsolver_dgetri_npvt_rank_0,& rocsolver_dgetri_npvt_rank_1,& rocsolver_dgetri_npvt_full_rank #endif #endif end interface interface rocsolver_cgetri_npvt function rocsolver_cgetri_npvt_(handle,n,A,lda,myInfo) bind(c, name="rocsolver_cgetri_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetri_npvt_assumed_rank #else module procedure & rocsolver_cgetri_npvt_rank_0,& rocsolver_cgetri_npvt_rank_1,& rocsolver_cgetri_npvt_full_rank #endif #endif end interface interface rocsolver_zgetri_npvt function rocsolver_zgetri_npvt_(handle,n,A,lda,myInfo) bind(c, name="rocsolver_zgetri_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetri_npvt_assumed_rank #else module procedure & rocsolver_zgetri_npvt_rank_0,& rocsolver_zgetri_npvt_rank_1,& rocsolver_zgetri_npvt_full_rank #endif #endif end interface !> \brief The GETRI_NPVT_BATCHED functions invert a batch of general ``n`` -by-``n`` matrices !> using !> the LU factorization computed by \ref rocsolver_sgetrf_npvt_batched "GETRF_NPVT_BATCHED". !> !> \details !> The inverse of matrix \f$A_l\f$ in the batch is computed by solving the linear system !> !> \f[ !> A_l^{-1} L_l^{} = U_l^{-1} !> \f] !> !> where \f$L_l\f$ is the lower triangular factor of \f$A_l\f$ with unit diagonal elements, !> and \f$U_l\f$ is the !> upper triangular factor. !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of all matrices A_l in the batch. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the factors L_l and U_l of the factorization A_l = L_l*U_l returned !> by !> \ref rocsolver_sgetrf_npvt_batched "GETRF_NPVT_BATCHED". !> On exit, the inverses of A_l if info[l] = 0, and otherwise undefined. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for inversion of A_l. !> If info[l] = i > 0, U_l is singular. U_l[i,i] is the first zero pivot. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgetri_npvt_batched function rocsolver_sgetri_npvt_batched_(handle,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_sgetri_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dgetri_npvt_batched function rocsolver_dgetri_npvt_batched_(handle,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_dgetri_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_cgetri_npvt_batched function rocsolver_cgetri_npvt_batched_(handle,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_cgetri_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zgetri_npvt_batched function rocsolver_zgetri_npvt_batched_(handle,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_zgetri_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The GETRI_NPVT_STRIDED_BATCHED functions invert a batch of general ``n`` -by-``n`` !> matrices !> using the LU factorization computed by \ref rocsolver_sgetrf_npvt_strided_batched !> "GETRF_NPVT_STRIDED_BATCHED". !> !> \details !> The inverse of matrix \f$A_l\f$ in the batch is computed by solving the linear system !> !> \f[ !> A_l^{-1} L_l^{} = U_l^{-1} !> \f] !> !> where \f$L_l\f$ is the lower triangular factor of \f$A_l\f$ with unit diagonal elements, !> and \f$U_l\f$ is the !> upper triangular factor. !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of all matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the factors L_l and U_l of the factorization A_l = L_l*U_l returned !> by !> \ref rocsolver_sgetrf_npvt_strided_batched "GETRF_NPVT_STRIDED_BATCHED". !> On exit, the inverses of A_l if info[l] = 0, and otherwise undefined. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for inversion of A_l. !> If info[l] = i > 0, U_l is singular. U_l[i,i] is the first zero pivot. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgetri_npvt_strided_batched function rocsolver_sgetri_npvt_strided_batched_(handle,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_sgetri_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetri_npvt_strided_batched_assumed_rank #else module procedure & rocsolver_sgetri_npvt_strided_batched_rank_0,& rocsolver_sgetri_npvt_strided_batched_rank_1,& rocsolver_sgetri_npvt_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgetri_npvt_strided_batched function rocsolver_dgetri_npvt_strided_batched_(handle,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_dgetri_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetri_npvt_strided_batched_assumed_rank #else module procedure & rocsolver_dgetri_npvt_strided_batched_rank_0,& rocsolver_dgetri_npvt_strided_batched_rank_1,& rocsolver_dgetri_npvt_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgetri_npvt_strided_batched function rocsolver_cgetri_npvt_strided_batched_(handle,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_cgetri_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetri_npvt_strided_batched_assumed_rank #else module procedure & rocsolver_cgetri_npvt_strided_batched_rank_0,& rocsolver_cgetri_npvt_strided_batched_rank_1,& rocsolver_cgetri_npvt_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgetri_npvt_strided_batched function rocsolver_zgetri_npvt_strided_batched_(handle,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_zgetri_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetri_npvt_strided_batched_assumed_rank #else module procedure & rocsolver_zgetri_npvt_strided_batched_rank_0,& rocsolver_zgetri_npvt_strided_batched_rank_1,& rocsolver_zgetri_npvt_strided_batched_full_rank #endif #endif end interface !> \brief The GELS functions solve 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 !> rocsolver_sgeqrf "GEQRF" (or the LQ !> factorization computed by \ref rocsolver_sgelqf "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^H 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^H 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. !> !> @param[in] handle - rocblas_handle. !> @param[in] trans - rocblas_operation. !> Specifies the form of the system of equations. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of matrix A. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of columns of matrices B and X, !> that is, the columns on the right hand side. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. !> On exit, the QR (or LQ) factorization of A as returned by \ref rocsolver_sgeqrf !> "GEQRF" (or \ref rocsolver_sgelqf "GELQF"). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrix A. !> @param[inout] B - pointer to type. Array on the GPU of dimension ldb*nrhs. !> 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 - rocblas_int. ldb >= max(m,n). !> Specifies the leading dimension of matrix B. !> @param[out] myInfo - pointer to rocblas_int on the GPU. !> 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. interface rocsolver_sgels function rocsolver_sgels_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) & bind(c, name="rocsolver_sgels") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgels_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),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 :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgels_assumed_rank #else module procedure & rocsolver_sgels_rank_0,& rocsolver_sgels_rank_1,& rocsolver_sgels_full_rank #endif #endif end interface interface rocsolver_dgels function rocsolver_dgels_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) & bind(c, name="rocsolver_dgels") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgels_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),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 :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgels_assumed_rank #else module procedure & rocsolver_dgels_rank_0,& rocsolver_dgels_rank_1,& rocsolver_dgels_full_rank #endif #endif end interface interface rocsolver_cgels function rocsolver_cgels_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) & bind(c, name="rocsolver_cgels") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgels_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),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 :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgels_assumed_rank #else module procedure & rocsolver_cgels_rank_0,& rocsolver_cgels_rank_1,& rocsolver_cgels_full_rank #endif #endif end interface interface rocsolver_zgels function rocsolver_zgels_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) & bind(c, name="rocsolver_zgels") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgels_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),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 :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgels_assumed_rank #else module procedure & rocsolver_zgels_rank_0,& rocsolver_zgels_rank_1,& rocsolver_zgels_full_rank #endif #endif end interface !> \brief The GELS_BATCHED functions solve a batch of overdetermined (or underdetermined) !> linear systems !> defined by a set of ``m`` -by-``n`` matrices \f$A_l\f$ and corresponding matrices !> \f$B_l\f$, using the !> QR factorizations computed by \ref rocsolver_sgeqrf_batched "GEQRF_BATCHED" (or the LQ !> factorizations computed by \ref rocsolver_sgelqf_batched "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_l X_l = B_l & \: \text{not transposed, or}\\% !> A_l^H X_l^{} = B_l^{} & \: \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_l is found by minimizing !> !> \f[ !> || B_l - A_l X_l || \quad \text{(or} \: || B_l^{} - A_l^H X_l^{} ||\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_l is chosen such that \f$|| X_l ||\f$ is minimal. !> !> @param[in] handle - rocblas_handle. !> @param[in] trans - rocblas_operation. !> Specifies the form of the system of equations. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all matrices A_l in the batch. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of columns of all matrices B_l and X_l in the batch, !> that is, 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. !> On entry, the matrices A_l. !> On exit, the QR (or LQ) factorizations of A_l as returned by \ref !> rocsolver_sgeqrf_batched "GEQRF_BATCHED" !> (or \ref rocsolver_sgelqf_batched "GELQF_BATCHED"). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[inout] B - array of pointer to type. Each pointer points to an array on the GPU of !> dimension ldb*nrhs. !> On entry, the matrices B_l. !> On exit, when info[l] = 0, B_l is overwritten by the solution vectors (and the !> residuals in !> the overdetermined cases) stored as columns. !> @param[in] ldb - rocblas_int. ldb >= max(m,n). !> Specifies the leading dimension of matrices B_l. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for solution of A_l. !> If info[l] = i > 0, the solution of A_l could not be computed because input !> matrix A_l is rank deficient. The i-th diagonal element of its triangular !> factor is zero. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgels_batched function rocsolver_sgels_batched_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count) & bind(c, name="rocsolver_sgels_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgels_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),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 :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dgels_batched function rocsolver_dgels_batched_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count) & bind(c, name="rocsolver_dgels_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgels_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),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 :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_cgels_batched function rocsolver_cgels_batched_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count) & bind(c, name="rocsolver_cgels_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgels_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),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 :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zgels_batched function rocsolver_zgels_batched_(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo,batch_count) & bind(c, name="rocsolver_zgels_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgels_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),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 :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The GELS_STRIDED_BATCHED functions solve a batch of overdetermined (or !> underdetermined) linear !> systems defined by a set of ``m`` -by-``n`` matrices \f$A_l\f$ and corresponding matrices !> \f$B_l\f$, !> using the QR factorizations computed by \ref rocsolver_sgeqrf_strided_batched !> "GEQRF_STRIDED_BATCHED" !> (or the LQ factorizations computed by \ref rocsolver_sgelqf_strided_batched !> "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_l X_l = B_l & \: \text{not transposed, or}\\% !> A_l^H X_l^{} = B_l^{} & \: \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_l is found by minimizing !> !> \f[ !> || B_l - A_l X_l || \quad \text{(or} \: || B_l^{} - A_l^H X_l^{} ||\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_l is chosen such that \f$|| X_l ||\f$ is minimal. !> !> @param[in] handle - rocblas_handle. !> @param[in] trans - rocblas_operation. !> Specifies the form of the system of equations. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all matrices A_l in the batch. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of columns of all matrices B_l and X_l in the batch, !> that is, 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). !> On entry, the matrices A_l. !> On exit, the QR (or LQ) factorizations of A_l as returned by \ref !> rocsolver_sgeqrf_strided_batched "GEQRF_STRIDED_BATCHED" !> (or \ref rocsolver_sgelqf_strided_batched "GELQF_STRIDED_BATCHED"). !> @param[in] lda - rocblas_int. lda >= m. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The 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). !> On entry, the matrices B_l. !> On exit, when info[l] = 0, each B_l is overwritten by the solution vectors (and !> the residuals in !> the overdetermined cases) stored as columns. !> @param[in] ldb - rocblas_int. ldb >= max(m,n). !> Specifies the leading dimension of matrices B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. The normal use case is !> strideB >= ldb*nrhs. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for solution of A_l. !> If info[l] = i > 0, the solution of A_l could not be computed because input !> matrix A_l is rank deficient. The i-th diagonal element of its triangular !> factor is zero. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgels_strided_batched function rocsolver_sgels_strided_batched_(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB, & myInfo,batch_count) & bind(c, name="rocsolver_sgels_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgels_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),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 :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgels_strided_batched_assumed_rank #else module procedure & rocsolver_sgels_strided_batched_rank_0,& rocsolver_sgels_strided_batched_rank_1,& rocsolver_sgels_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgels_strided_batched function rocsolver_dgels_strided_batched_(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB, & myInfo,batch_count) & bind(c, name="rocsolver_dgels_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgels_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),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 :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgels_strided_batched_assumed_rank #else module procedure & rocsolver_dgels_strided_batched_rank_0,& rocsolver_dgels_strided_batched_rank_1,& rocsolver_dgels_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgels_strided_batched function rocsolver_cgels_strided_batched_(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB, & myInfo,batch_count) & bind(c, name="rocsolver_cgels_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgels_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),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 :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgels_strided_batched_assumed_rank #else module procedure & rocsolver_cgels_strided_batched_rank_0,& rocsolver_cgels_strided_batched_rank_1,& rocsolver_cgels_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgels_strided_batched function rocsolver_zgels_strided_batched_(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb,strideB, & myInfo,batch_count) & bind(c, name="rocsolver_zgels_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgels_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_operation_none)),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 :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgels_strided_batched_assumed_rank #else module procedure & rocsolver_zgels_strided_batched_rank_0,& rocsolver_zgels_strided_batched_rank_1,& rocsolver_zgels_strided_batched_full_rank #endif #endif end interface !> \brief The POTF2 functions compute the Cholesky factorization of a real symmetric (complex !> Hermitian) positive definite matrix ``A``. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The factorization has the form: !> !> \f[ !> \begin{array}{cl} !> A = U^H U & \: \text{if uplo is upper, or}\\% !> A = L L^H & \: \text{if uplo is lower.} !> \end{array} !> \f] !> !> U is an upper triangular matrix and L is lower triangular. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the factorization is upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) part of A is not !> used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A to be factored. On exit, the lower or upper triangular !> factor. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful factorization of matrix A. !> If info = i > 0, the leading minor of order i of A is not positive definite. !> The factorization stopped at this point. interface rocsolver_spotf2 function rocsolver_spotf2_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_spotf2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotf2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_spotf2_assumed_rank #else module procedure & rocsolver_spotf2_rank_0,& rocsolver_spotf2_rank_1,& rocsolver_spotf2_full_rank #endif #endif end interface interface rocsolver_dpotf2 function rocsolver_dpotf2_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_dpotf2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dpotf2_assumed_rank #else module procedure & rocsolver_dpotf2_rank_0,& rocsolver_dpotf2_rank_1,& rocsolver_dpotf2_full_rank #endif #endif end interface interface rocsolver_cpotf2 function rocsolver_cpotf2_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_cpotf2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cpotf2_assumed_rank #else module procedure & rocsolver_cpotf2_rank_0,& rocsolver_cpotf2_rank_1,& rocsolver_cpotf2_full_rank #endif #endif end interface interface rocsolver_zpotf2 function rocsolver_zpotf2_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_zpotf2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zpotf2_assumed_rank #else module procedure & rocsolver_zpotf2_rank_0,& rocsolver_zpotf2_rank_1,& rocsolver_zpotf2_full_rank #endif #endif end interface interface rocsolver_spotf2_64 function rocsolver_spotf2_64_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_spotf2_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotf2_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo end function end interface interface rocsolver_dpotf2_64 function rocsolver_dpotf2_64_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_dpotf2_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo end function end interface interface rocsolver_cpotf2_64 function rocsolver_cpotf2_64_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_cpotf2_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo end function end interface interface rocsolver_zpotf2_64 function rocsolver_zpotf2_64_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_zpotf2_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo end function end interface !> \brief The POTF2_BATCHED functions compute the Cholesky factorization of a !> batch of real symmetric (complex Hermitian) positive definite matrices. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form: !> !> \f[ !> \begin{array}{cl} !> A_l^{} = U_l^H U_l^{} & \: \text{if uplo is upper, or}\\% !> A_l^{} = L_l^{}L_l^H & \: \text{if uplo is lower.} !> \end{array} !> \f] !> !> \f$U_l\f$ is an upper triangular matrix and \f$L_l\f$ is lower triangular. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the factorization is upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l is !> not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of matrix A_l. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l to be factored. On exit, the upper or lower !> triangular factors. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful factorization of matrix A_l. !> If info[l] = i > 0, the leading minor of order i of A_l is not positive !> definite. !> The l-th factorization stopped at this point. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_spotf2_batched function rocsolver_spotf2_batched_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_spotf2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotf2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dpotf2_batched function rocsolver_dpotf2_batched_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_dpotf2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_cpotf2_batched function rocsolver_cpotf2_batched_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_cpotf2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zpotf2_batched function rocsolver_zpotf2_batched_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_zpotf2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_spotf2_batched_64 function rocsolver_spotf2_batched_64_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_spotf2_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotf2_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dpotf2_batched_64 function rocsolver_dpotf2_batched_64_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_dpotf2_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cpotf2_batched_64 function rocsolver_cpotf2_batched_64_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_cpotf2_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zpotf2_batched_64 function rocsolver_zpotf2_batched_64_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_zpotf2_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The POTF2_STRIDED_BATCHED functions compute the Cholesky factorization of a !> batch of real symmetric (complex Hermitian) positive definite matrices. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form: !> !> \f[ !> \begin{array}{cl} !> A_l^{} = U_l^H U_l^{} & \: \text{if uplo is upper, or}\\% !> A_l^{} = L_l^{}L_l^H & \: \text{if uplo is lower.} !> \end{array} !> \f] !> !> \f$U_l\f$ is an upper triangular matrix and \f$L_l\f$ is lower triangular. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the factorization is upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l is !> not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of matrix A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l to be factored. On exit, the upper or lower !> triangular factors. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful factorization of matrix A_l. !> If info[l] = i > 0, the leading minor of order i of A_l is not positive !> definite. !> The l-th factorization stopped at this point. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_spotf2_strided_batched function rocsolver_spotf2_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_spotf2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotf2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_spotf2_strided_batched_assumed_rank #else module procedure & rocsolver_spotf2_strided_batched_rank_0,& rocsolver_spotf2_strided_batched_rank_1,& rocsolver_spotf2_strided_batched_full_rank #endif #endif end interface interface rocsolver_dpotf2_strided_batched function rocsolver_dpotf2_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_dpotf2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dpotf2_strided_batched_assumed_rank #else module procedure & rocsolver_dpotf2_strided_batched_rank_0,& rocsolver_dpotf2_strided_batched_rank_1,& rocsolver_dpotf2_strided_batched_full_rank #endif #endif end interface interface rocsolver_cpotf2_strided_batched function rocsolver_cpotf2_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_cpotf2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cpotf2_strided_batched_assumed_rank #else module procedure & rocsolver_cpotf2_strided_batched_rank_0,& rocsolver_cpotf2_strided_batched_rank_1,& rocsolver_cpotf2_strided_batched_full_rank #endif #endif end interface interface rocsolver_zpotf2_strided_batched function rocsolver_zpotf2_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_zpotf2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zpotf2_strided_batched_assumed_rank #else module procedure & rocsolver_zpotf2_strided_batched_rank_0,& rocsolver_zpotf2_strided_batched_rank_1,& rocsolver_zpotf2_strided_batched_full_rank #endif #endif end interface interface rocsolver_spotf2_strided_batched_64 function rocsolver_spotf2_strided_batched_64_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_spotf2_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotf2_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dpotf2_strided_batched_64 function rocsolver_dpotf2_strided_batched_64_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_dpotf2_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cpotf2_strided_batched_64 function rocsolver_cpotf2_strided_batched_64_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_cpotf2_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zpotf2_strided_batched_64 function rocsolver_zpotf2_strided_batched_64_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_zpotf2_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The POTRF functions compute the Cholesky factorization of a real symmetric (complex !> Hermitian) positive definite matrix A. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The factorization has the form: !> !> \f[ !> \begin{array}{cl} !> A = U^H U & \: \text{if uplo is upper, or}\\% !> A = L L^H & \: \text{if uplo is lower.} !> \end{array} !> \f] !> !> U is an upper triangular matrix and L is lower triangular. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the factorization is upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) part of A is not !> used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A to be factored. On exit, the lower or upper triangular !> factor. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful factorization of matrix A. !> If info = i > 0, the leading minor of order i of A is not positive definite. !> The factorization stopped at this point. interface rocsolver_spotrf function rocsolver_spotrf_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_spotrf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrf_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_spotrf_assumed_rank #else module procedure & rocsolver_spotrf_rank_0,& rocsolver_spotrf_rank_1,& rocsolver_spotrf_full_rank #endif #endif end interface interface rocsolver_dpotrf function rocsolver_dpotrf_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_dpotrf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dpotrf_assumed_rank #else module procedure & rocsolver_dpotrf_rank_0,& rocsolver_dpotrf_rank_1,& rocsolver_dpotrf_full_rank #endif #endif end interface interface rocsolver_cpotrf function rocsolver_cpotrf_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_cpotrf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cpotrf_assumed_rank #else module procedure & rocsolver_cpotrf_rank_0,& rocsolver_cpotrf_rank_1,& rocsolver_cpotrf_full_rank #endif #endif end interface interface rocsolver_zpotrf function rocsolver_zpotrf_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_zpotrf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zpotrf_assumed_rank #else module procedure & rocsolver_zpotrf_rank_0,& rocsolver_zpotrf_rank_1,& rocsolver_zpotrf_full_rank #endif #endif end interface interface rocsolver_spotrf_64 function rocsolver_spotrf_64_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_spotrf_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrf_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo end function end interface interface rocsolver_dpotrf_64 function rocsolver_dpotrf_64_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_dpotrf_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo end function end interface interface rocsolver_cpotrf_64 function rocsolver_cpotrf_64_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_cpotrf_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo end function end interface interface rocsolver_zpotrf_64 function rocsolver_zpotrf_64_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_zpotrf_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo end function end interface !> \brief The POTRF_BATCHED functions compute the Cholesky factorization of a !> batch of real symmetric (complex Hermitian) positive definite matrices. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form: !> !> \f[ !> \begin{array}{cl} !> A_l^{} = U_l^H U_l^{} & \: \text{if uplo is upper, or}\\% !> A_l^{} = L_l^{}L_l^H & \: \text{if uplo is lower.} !> \end{array} !> \f] !> !> \f$U_l\f$ is an upper triangular matrix and \f$L_l\f$ is lower triangular. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the factorization is upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l is !> not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of matrix A_l. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l to be factored. On exit, the upper or lower !> triangular factors. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful factorization of matrix A_l. !> If info[l] = i > 0, the leading minor of order i of A_l is not positive !> definite. !> The l-th factorization stopped at this point. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_spotrf_batched function rocsolver_spotrf_batched_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_spotrf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrf_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dpotrf_batched function rocsolver_dpotrf_batched_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_dpotrf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_cpotrf_batched function rocsolver_cpotrf_batched_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_cpotrf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zpotrf_batched function rocsolver_zpotrf_batched_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_zpotrf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_spotrf_batched_64 function rocsolver_spotrf_batched_64_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_spotrf_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrf_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dpotrf_batched_64 function rocsolver_dpotrf_batched_64_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_dpotrf_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cpotrf_batched_64 function rocsolver_cpotrf_batched_64_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_cpotrf_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zpotrf_batched_64 function rocsolver_zpotrf_batched_64_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_zpotrf_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The POTRF_STRIDED_BATCHED functions computes the Cholesky factorization of a !> batch of real symmetric (complex Hermitian) positive definite matrices. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The factorization of matrix \f$A_l\f$ in the batch has the form: !> !> \f[ !> \begin{array}{cl} !> A_l^{} = U_l^H U_l^{} & \: \text{if uplo is upper, or}\\% !> A_l^{} = L_l^{}L_l^H & \: \text{if uplo is lower.} !> \end{array} !> \f] !> !> \f$U_l\f$ is an upper triangular matrix and \f$L_l\f$ is lower triangular. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the factorization is upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l is !> not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of matrix A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l to be factored. On exit, the upper or lower !> triangular factors. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful factorization of matrix A_l. !> If info[l] = i > 0, the leading minor of order i of A_l is not positive !> definite. !> The l-th factorization stopped at this point. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_spotrf_strided_batched function rocsolver_spotrf_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_spotrf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrf_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_spotrf_strided_batched_assumed_rank #else module procedure & rocsolver_spotrf_strided_batched_rank_0,& rocsolver_spotrf_strided_batched_rank_1,& rocsolver_spotrf_strided_batched_full_rank #endif #endif end interface interface rocsolver_dpotrf_strided_batched function rocsolver_dpotrf_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_dpotrf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dpotrf_strided_batched_assumed_rank #else module procedure & rocsolver_dpotrf_strided_batched_rank_0,& rocsolver_dpotrf_strided_batched_rank_1,& rocsolver_dpotrf_strided_batched_full_rank #endif #endif end interface interface rocsolver_cpotrf_strided_batched function rocsolver_cpotrf_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_cpotrf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cpotrf_strided_batched_assumed_rank #else module procedure & rocsolver_cpotrf_strided_batched_rank_0,& rocsolver_cpotrf_strided_batched_rank_1,& rocsolver_cpotrf_strided_batched_full_rank #endif #endif end interface interface rocsolver_zpotrf_strided_batched function rocsolver_zpotrf_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_zpotrf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zpotrf_strided_batched_assumed_rank #else module procedure & rocsolver_zpotrf_strided_batched_rank_0,& rocsolver_zpotrf_strided_batched_rank_1,& rocsolver_zpotrf_strided_batched_full_rank #endif #endif end interface interface rocsolver_spotrf_strided_batched_64 function rocsolver_spotrf_strided_batched_64_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_spotrf_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrf_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dpotrf_strided_batched_64 function rocsolver_dpotrf_strided_batched_64_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_dpotrf_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cpotrf_strided_batched_64 function rocsolver_cpotrf_strided_batched_64_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_cpotrf_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zpotrf_strided_batched_64 function rocsolver_zpotrf_strided_batched_64_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_zpotrf_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The POTRS functions solve a symmetric/Hermitian system of ``n`` linear equations on !> ``n`` variables in its factorized form. !> !> \details !> It solves the system !> !> \f[ !> A X = B !> \f] !> !> where ``A`` is a real symmetric (complex Hermitian) positive definite matrix defined by its !> triangular factor !> !> \f[ !> \begin{array}{cl} !> A = U^H U & \: \text{if uplo is upper, or}\\% !> A = L L^H & \: \text{if uplo is lower.} !> \end{array} !> \f] !> !> as returned by \ref rocsolver_spotrf "POTRF". !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the factorization is upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) part of A is not !> used. !> @param[in] n - rocblas_int. n >= 0. !> The order of the system, that is, the number of columns and rows of A. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of the matrix B. !> @param[in] A - pointer to type. Array on the GPU of dimension lda*n. !> The factor L or U of the Cholesky factorization of A returned by \ref !> rocsolver_spotrf "POTRF". !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A. !> @param[inout] B - pointer to type. Array on the GPU of dimension ldb*nrhs. !> On entry, the right hand side matrix B. !> On exit, the solution matrix X. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of B. interface rocsolver_spotrs function rocsolver_spotrs_(handle,uplo,n,nrhs,A,lda,B,ldb) bind(c, name="rocsolver_spotrs") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrs_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_spotrs_assumed_rank #else module procedure & rocsolver_spotrs_rank_0,& rocsolver_spotrs_rank_1,& rocsolver_spotrs_full_rank #endif #endif end interface interface rocsolver_dpotrs function rocsolver_dpotrs_(handle,uplo,n,nrhs,A,lda,B,ldb) bind(c, name="rocsolver_dpotrs") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dpotrs_assumed_rank #else module procedure & rocsolver_dpotrs_rank_0,& rocsolver_dpotrs_rank_1,& rocsolver_dpotrs_full_rank #endif #endif end interface interface rocsolver_cpotrs function rocsolver_cpotrs_(handle,uplo,n,nrhs,A,lda,B,ldb) bind(c, name="rocsolver_cpotrs") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cpotrs_assumed_rank #else module procedure & rocsolver_cpotrs_rank_0,& rocsolver_cpotrs_rank_1,& rocsolver_cpotrs_full_rank #endif #endif end interface interface rocsolver_zpotrs function rocsolver_zpotrs_(handle,uplo,n,nrhs,A,lda,B,ldb) bind(c, name="rocsolver_zpotrs") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zpotrs_assumed_rank #else module procedure & rocsolver_zpotrs_rank_0,& rocsolver_zpotrs_rank_1,& rocsolver_zpotrs_full_rank #endif #endif end interface interface rocsolver_spotrs_64 function rocsolver_spotrs_64_(handle,uplo,n,nrhs,A,lda,B,ldb) & bind(c, name="rocsolver_spotrs_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrs_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface interface rocsolver_dpotrs_64 function rocsolver_dpotrs_64_(handle,uplo,n,nrhs,A,lda,B,ldb) & bind(c, name="rocsolver_dpotrs_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface interface rocsolver_cpotrs_64 function rocsolver_cpotrs_64_(handle,uplo,n,nrhs,A,lda,B,ldb) & bind(c, name="rocsolver_cpotrs_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface interface rocsolver_zpotrs_64 function rocsolver_zpotrs_64_(handle,uplo,n,nrhs,A,lda,B,ldb) & bind(c, name="rocsolver_zpotrs_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb end function end interface !> \brief The POTRS_BATCHED functions solve a batch of symmetric/Hermitian systems of ``n`` !> linear equations on ``n`` !> variables in its factorized forms. !> !> \details !> For each instance l in the batch, it solves the system !> !> \f[ !> A_l X_l = B_l !> \f] !> !> where \f$A_l\f$ is a real symmetric (complex Hermitian) positive definite matrix defined by !> its !> triangular factor !> !> \f[ !> \begin{array}{cl} !> A_l^{} = U_l^H U_l^{} & \: \text{if uplo is upper, or}\\% !> A_l^{} = L_l^{}L_l^H & \: \text{if uplo is lower.} !> \end{array} !> \f] !> !> as returned by \ref rocsolver_spotrf "POTRF_BATCHED". !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the factorization is upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l is !> not used. !> @param[in] n - rocblas_int. n >= 0. !> The order of the system, that is, the number of columns and rows of all A_l !> matrices. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of all the matrices B_l. !> @param[in] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> The factor L_l or U_l of the Cholesky factorization of A_l returned by \ref !> rocsolver_spotrf_batched "POTRF_BATCHED". !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of matrices A_l. !> @param[inout] B - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*nrhs. !> On entry, the right hand side matrices B_l. !> On exit, the solution matrix X_l of each system in the batch. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of matrices B_l. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of instances (systems) in the batch. interface rocsolver_spotrs_batched function rocsolver_spotrs_batched_(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_spotrs_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrs_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 integer(c_int),value :: batch_count end function end interface interface rocsolver_dpotrs_batched function rocsolver_dpotrs_batched_(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_dpotrs_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 integer(c_int),value :: batch_count end function end interface interface rocsolver_cpotrs_batched function rocsolver_cpotrs_batched_(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_cpotrs_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 integer(c_int),value :: batch_count end function end interface interface rocsolver_zpotrs_batched function rocsolver_zpotrs_batched_(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_zpotrs_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 integer(c_int),value :: batch_count end function end interface interface rocsolver_spotrs_batched_64 function rocsolver_spotrs_batched_64_(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_spotrs_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrs_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dpotrs_batched_64 function rocsolver_dpotrs_batched_64_(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_dpotrs_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cpotrs_batched_64 function rocsolver_cpotrs_batched_64_(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_cpotrs_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zpotrs_batched_64 function rocsolver_zpotrs_batched_64_(handle,uplo,n,nrhs,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_zpotrs_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: batch_count end function end interface !> \brief The POTRS_STRIDED_BATCHED functions solve a batch of symmetric/Hermitian systems of !> ``n`` linear equations !> on ``n`` variables in its factorized forms. !> !> \details !> For each instance l in the batch, it solves the system !> !> \f[ !> A_l X_l = B_l !> \f] !> !> where \f$A_l\f$ is a real symmetric (complex Hermitian) positive definite matrix defined by !> its !> triangular factor !> !> \f[ !> \begin{array}{cl} !> A_l^{} = U_l^H U_l^{} & \: \text{if uplo is upper, or}\\% !> A_l^{} = L_l^{}L_l^H & \: \text{if uplo is lower.} !> \end{array} !> \f] !> !> as returned by \ref rocsolver_spotrf "POTRF_STRIDED_BATCHED". !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the factorization is upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l is !> not used. !> @param[in] n - rocblas_int. n >= 0. !> The order of the system, that is, the number of columns and rows of all A_l !> matrices. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of all the matrices B_l. !> @param[in] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> The factor L_l or U_l of the Cholesky factorization of A_l returned by \ref !> rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED". !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[inout] B - pointer to type. Array on the GPU (size depends on the value of strideB). !> On entry, the right hand side matrices B_l. !> On exit, the solution matrix X_l of each system in the batch. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of matrices B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. The normal use case is !> strideB >= ldb*nrhs. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of instances (systems) in the batch. interface rocsolver_spotrs_strided_batched function rocsolver_spotrs_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB, & batch_count) & bind(c, name="rocsolver_spotrs_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrs_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_spotrs_strided_batched_assumed_rank #else module procedure & rocsolver_spotrs_strided_batched_rank_0,& rocsolver_spotrs_strided_batched_rank_1,& rocsolver_spotrs_strided_batched_full_rank #endif #endif end interface interface rocsolver_dpotrs_strided_batched function rocsolver_dpotrs_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB, & batch_count) & bind(c, name="rocsolver_dpotrs_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dpotrs_strided_batched_assumed_rank #else module procedure & rocsolver_dpotrs_strided_batched_rank_0,& rocsolver_dpotrs_strided_batched_rank_1,& rocsolver_dpotrs_strided_batched_full_rank #endif #endif end interface interface rocsolver_cpotrs_strided_batched function rocsolver_cpotrs_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB, & batch_count) & bind(c, name="rocsolver_cpotrs_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cpotrs_strided_batched_assumed_rank #else module procedure & rocsolver_cpotrs_strided_batched_rank_0,& rocsolver_cpotrs_strided_batched_rank_1,& rocsolver_cpotrs_strided_batched_full_rank #endif #endif end interface interface rocsolver_zpotrs_strided_batched function rocsolver_zpotrs_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB, & batch_count) & bind(c, name="rocsolver_zpotrs_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zpotrs_strided_batched_assumed_rank #else module procedure & rocsolver_zpotrs_strided_batched_rank_0,& rocsolver_zpotrs_strided_batched_rank_1,& rocsolver_zpotrs_strided_batched_full_rank #endif #endif end interface interface rocsolver_spotrs_strided_batched_64 function rocsolver_spotrs_strided_batched_64_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB, & batch_count) & bind(c, name="rocsolver_spotrs_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrs_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dpotrs_strided_batched_64 function rocsolver_dpotrs_strided_batched_64_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB, & batch_count) & bind(c, name="rocsolver_dpotrs_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_cpotrs_strided_batched_64 function rocsolver_cpotrs_strided_batched_64_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB, & batch_count) & bind(c, name="rocsolver_cpotrs_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zpotrs_strided_batched_64 function rocsolver_zpotrs_strided_batched_64_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB, & batch_count) & bind(c, name="rocsolver_zpotrs_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n integer(c_int64_t),value :: nrhs type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int64_t),value :: ldb integer(c_int64_t),value :: strideB integer(c_int64_t),value :: batch_count end function end interface !> \brief The POSV functions solve a symmetric/Hermitian system of ``n`` linear equations on !> ``n`` variables. !> !> \details !> It solves the system !> !> \f[ !> A X = B !> \f] !> !> where ``A`` is a real symmetric (complex Hermitian) positive definite matrix. Matrix ``A`` !> is first !> factorized as \f$A=L L^H\f$ or \f$A=U^H U\f$, depending on the value of ``uplo``, using !> \ref rocsolver_spotrf "POTRF", !> then the solution is computed with \ref rocsolver_spotrs "POTRS". !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the factorization is upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) part of A is not !> used. !> @param[in] n - rocblas_int. n >= 0. !> The order of the system, that is, the number of columns and rows of A. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of the matrix B. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the symmetric/Hermitian matrix A. !> On exit, if info = 0, the factor L or U of the Cholesky factorization of A !> returned by !> \ref rocsolver_spotrf "POTRF". !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A. !> @param[inout] B - pointer to type. Array on the GPU of dimension ldb*nrhs. !> On entry, the right hand side matrix B. !> On exit, the solution matrix X. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of B. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, the leading minor of order i of A is not positive definite. !> The solution could not be computed. interface rocsolver_sposv function rocsolver_sposv_(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) bind(c, name="rocsolver_sposv") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sposv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sposv_assumed_rank #else module procedure & rocsolver_sposv_rank_0,& rocsolver_sposv_rank_1,& rocsolver_sposv_full_rank #endif #endif end interface interface rocsolver_dposv function rocsolver_dposv_(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) bind(c, name="rocsolver_dposv") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dposv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dposv_assumed_rank #else module procedure & rocsolver_dposv_rank_0,& rocsolver_dposv_rank_1,& rocsolver_dposv_full_rank #endif #endif end interface interface rocsolver_cposv function rocsolver_cposv_(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) bind(c, name="rocsolver_cposv") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cposv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cposv_assumed_rank #else module procedure & rocsolver_cposv_rank_0,& rocsolver_cposv_rank_1,& rocsolver_cposv_full_rank #endif #endif end interface interface rocsolver_zposv function rocsolver_zposv_(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) bind(c, name="rocsolver_zposv") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zposv_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zposv_assumed_rank #else module procedure & rocsolver_zposv_rank_0,& rocsolver_zposv_rank_1,& rocsolver_zposv_full_rank #endif #endif end interface !> \brief The POSV_BATCHED functions solve a batch of symmetric/Hermitian systems of ``n`` !> linear equations on ``n`` !> variables. !> !> \details !> For each instance l in the batch, it solves the system !> !> \f[ !> A_l X_l = B_l !> \f] !> !> where \f$A_l\f$ is a real symmetric (complex Hermitian) positive definite matrix. Matrix !> \f$A_l\f$ is first !> factorized as \f$A_l^{}=L_l^{}L_l^H\f$ or \f$A_l^{}=U_l^H U_l^{}\f$, depending on the value !> of ``uplo``, using \ref rocsolver_spotrf_batched "POTRF_BATCHED", !> then the solution is computed with \ref rocsolver_spotrs_batched "POTRS_BATCHED". !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the factorization is upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l is !> not used. !> @param[in] n - rocblas_int. n >= 0. !> The order of the system, that is, the number of columns and rows of all A_l !> matrices. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of all the matrices B_l. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the symmetric/Hermitian matrices A_l. !> On exit, if info[l] = 0, the factor L_l or U_l of the Cholesky factorization of !> A_l returned by !> \ref rocsolver_spotrf_batched "POTRF_BATCHED". !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of matrices A_l. !> @param[inout] B - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*nrhs. !> On entry, the right hand side matrices B_l. !> On exit, the solution matrix X_l of each system in the batch. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of matrices B_l. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit. !> If info[l] = i > 0, the leading minor of order i of A_l is not positive !> definite. !> The l-th solution could not be computed. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of instances (systems) in the batch. interface rocsolver_sposv_batched function rocsolver_sposv_batched_(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count) & bind(c, name="rocsolver_sposv_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sposv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dposv_batched function rocsolver_dposv_batched_(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count) & bind(c, name="rocsolver_dposv_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dposv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_cposv_batched function rocsolver_cposv_batched_(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count) & bind(c, name="rocsolver_cposv_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cposv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zposv_batched function rocsolver_zposv_batched_(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo,batch_count) & bind(c, name="rocsolver_zposv_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zposv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The POSV_STRIDED_BATCHED functions solve a batch of symmetric/Hermitian systems of !> ``n`` linear equations !> on n variables. !> !> \details !> For each instance l in the batch, it solves the system !> !> \f[ !> A_l X_l = B_l !> \f] !> !> where \f$A_l\f$ is a real symmetric (complex Hermitian) positive definite matrix. Matrix !> \f$A_l\f$ is first !> factorized as \f$A_l^{}=L_l^{}L_l^H\f$ or \f$A_l^{}=U_l^H U_l^{}\f$, depending on the value !> of ``uplo``, using \ref rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED", !> then the solution is computed with \ref rocsolver_spotrs_strided_batched !> "POTRS_STRIDED_BATCHED". !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the factorization is upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l is !> not used. !> @param[in] n - rocblas_int. n >= 0. !> The order of the system, that is, the number of columns and rows of all A_l !> matrices. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns !> of all the matrices B_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the symmetric/Hermitian matrices A_l. !> On exit, if info[l] = 0, the factor L_l or U_l of the Cholesky factorization of !> A_l returned by !> \ref rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED". !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[inout] B - pointer to type. Array on the GPU (size depends on the value of strideB). !> On entry, the right hand side matrices B_l. !> On exit, the solution matrix X_l of each system in the batch. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of matrices B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. The normal use case is !> strideB >= ldb*nrhs. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit. !> If info[l] = i > 0, the leading minor of order i of A_l is not positive !> definite. !> The l-th solution could not be computed. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of instances (systems) in the batch. interface rocsolver_sposv_strided_batched function rocsolver_sposv_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB, & myInfo,batch_count) & bind(c, name="rocsolver_sposv_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sposv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sposv_strided_batched_assumed_rank #else module procedure & rocsolver_sposv_strided_batched_rank_0,& rocsolver_sposv_strided_batched_rank_1,& rocsolver_sposv_strided_batched_full_rank #endif #endif end interface interface rocsolver_dposv_strided_batched function rocsolver_dposv_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB, & myInfo,batch_count) & bind(c, name="rocsolver_dposv_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dposv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dposv_strided_batched_assumed_rank #else module procedure & rocsolver_dposv_strided_batched_rank_0,& rocsolver_dposv_strided_batched_rank_1,& rocsolver_dposv_strided_batched_full_rank #endif #endif end interface interface rocsolver_cposv_strided_batched function rocsolver_cposv_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB, & myInfo,batch_count) & bind(c, name="rocsolver_cposv_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cposv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cposv_strided_batched_assumed_rank #else module procedure & rocsolver_cposv_strided_batched_rank_0,& rocsolver_cposv_strided_batched_rank_1,& rocsolver_cposv_strided_batched_full_rank #endif #endif end interface interface rocsolver_zposv_strided_batched function rocsolver_zposv_strided_batched_(handle,uplo,n,nrhs,A,lda,strideA,B,ldb,strideB, & myInfo,batch_count) & bind(c, name="rocsolver_zposv_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zposv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo 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 :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zposv_strided_batched_assumed_rank #else module procedure & rocsolver_zposv_strided_batched_rank_0,& rocsolver_zposv_strided_batched_rank_1,& rocsolver_zposv_strided_batched_full_rank #endif #endif end interface !> \brief The POTRI functions invert a symmetric/Hermitian positive definite matrix ``A``. !> !> \details !> The inverse of matrix \f$A\f$ is computed as !> !> \f[ !> \begin{array}{cl} !> A^{-1} = U^{-1} {U^{-1}}^H & \: \text{if uplo is upper, or}\\% !> A^{-1} = {L^{-1}}^H L^{-1} & \: \text{if uplo is lower.} !> \end{array} !> \f] !> !> where \f$U\f$ or \f$L\f$ is the triangular factor of the Cholesky factorization of \f$A\f$ !> returned by !> \ref rocsolver_spotrf "POTRF". !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the factorization is upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) part of A is not !> used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the factor L or U of the Cholesky factorization of A returned by !> \ref rocsolver_spotrf "POTRF". !> On exit, the inverse of A if info = 0. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit for inversion of A. !> If info = i > 0, A is singular. L[i,i] or U[i,i] is zero. interface rocsolver_spotri function rocsolver_spotri_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_spotri") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotri_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_spotri_assumed_rank #else module procedure & rocsolver_spotri_rank_0,& rocsolver_spotri_rank_1,& rocsolver_spotri_full_rank #endif #endif end interface interface rocsolver_dpotri function rocsolver_dpotri_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_dpotri") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotri_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dpotri_assumed_rank #else module procedure & rocsolver_dpotri_rank_0,& rocsolver_dpotri_rank_1,& rocsolver_dpotri_full_rank #endif #endif end interface interface rocsolver_cpotri function rocsolver_cpotri_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_cpotri") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotri_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cpotri_assumed_rank #else module procedure & rocsolver_cpotri_rank_0,& rocsolver_cpotri_rank_1,& rocsolver_cpotri_full_rank #endif #endif end interface interface rocsolver_zpotri function rocsolver_zpotri_(handle,uplo,n,A,lda,myInfo) bind(c, name="rocsolver_zpotri") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotri_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zpotri_assumed_rank #else module procedure & rocsolver_zpotri_rank_0,& rocsolver_zpotri_rank_1,& rocsolver_zpotri_full_rank #endif #endif end interface !> \brief The POTRI_BATCHED functions invert a batch of symmetric/Hermitian positive definite !> matrices \f$A_l\f$. !> !> \details !> The inverse of matrix \f$A_l\f$ in the batch is computed as !> !> \f[ !> \begin{array}{cl} !> A_l^{-1} = U_l^{-1} {U_l^{-1}}^H & \: \text{if uplo is upper, or}\\% !> A_l^{-1} = {L_l^{-1}}^H L_l^{-1} & \: \text{if uplo is lower.} !> \end{array} !> \f] !> !> where \f$U_l\f$ or \f$L_l\f$ is the triangular factor of the Cholesky factorization of !> \f$A_l\f$ returned by !> \ref rocsolver_spotrf_batched "POTRF_BATCHED". !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the factorization is upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l is !> not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of matrix A_l. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the factor L_l or U_l of the Cholesky factorization of A_l returned !> by !> \ref rocsolver_spotrf_batched "POTRF_BATCHED". !> On exit, the inverses of A_l if info[l] = 0. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for inversion of A_l. !> If info[l] = i > 0, A_l is singular. L_l[i,i] or U_l[i,i] is zero. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_spotri_batched function rocsolver_spotri_batched_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_spotri_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotri_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dpotri_batched function rocsolver_dpotri_batched_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_dpotri_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotri_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_cpotri_batched function rocsolver_cpotri_batched_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_cpotri_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotri_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zpotri_batched function rocsolver_zpotri_batched_(handle,uplo,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_zpotri_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotri_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The POTRI_STRIDED_BATCHED functions invert a batch of symmetric/Hermitian positive !> definite matrices \f$A_l\f$. !> !> \details !> The inverse of matrix \f$A_l\f$ in the batch is computed as !> !> \f[ !> \begin{array}{cl} !> A_l^{-1} = U_l^{-1} {U_l^{-1}}^H & \: \text{if uplo is upper, or}\\% !> A_l^{-1} = {L_l^{-1}}^H L_l^{-1} & \: \text{if uplo is lower.} !> \end{array} !> \f] !> !> where \f$U_l\f$ or \f$L_l\f$ is the triangular factor of the Cholesky factorization of !> \f$A_l\f$ returned by !> \ref rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED". !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the factorization is upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l is !> not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of matrix A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the factor L_l or U_l of the Cholesky factorization of A_l returned !> by !> \ref rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED". !> On exit, the inverses of A_l if info[l] = 0. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for inversion of A_l. !> If info[l] = i > 0, A_l is singular. L_l[i,i] or U_l[i,i] is zero. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_spotri_strided_batched function rocsolver_spotri_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_spotri_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotri_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_spotri_strided_batched_assumed_rank #else module procedure & rocsolver_spotri_strided_batched_rank_0,& rocsolver_spotri_strided_batched_rank_1,& rocsolver_spotri_strided_batched_full_rank #endif #endif end interface interface rocsolver_dpotri_strided_batched function rocsolver_dpotri_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_dpotri_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotri_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dpotri_strided_batched_assumed_rank #else module procedure & rocsolver_dpotri_strided_batched_rank_0,& rocsolver_dpotri_strided_batched_rank_1,& rocsolver_dpotri_strided_batched_full_rank #endif #endif end interface interface rocsolver_cpotri_strided_batched function rocsolver_cpotri_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_cpotri_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotri_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cpotri_strided_batched_assumed_rank #else module procedure & rocsolver_cpotri_strided_batched_rank_0,& rocsolver_cpotri_strided_batched_rank_1,& rocsolver_cpotri_strided_batched_full_rank #endif #endif end interface interface rocsolver_zpotri_strided_batched function rocsolver_zpotri_strided_batched_(handle,uplo,n,A,lda,strideA,myInfo,batch_count) & bind(c, name="rocsolver_zpotri_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotri_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zpotri_strided_batched_assumed_rank #else module procedure & rocsolver_zpotri_strided_batched_rank_0,& rocsolver_zpotri_strided_batched_rank_1,& rocsolver_zpotri_strided_batched_full_rank #endif #endif end interface !> \brief The GESVD functions compute the singular values and optionally the singular !> vectors of a general ``m``-by-``n`` matrix ``A`` (Singular Value Decomposition). !> !> \details !> The SVD of matrix ``A`` is given by: !> !> \f[ !> A = U S V^H !> \f] !> !> where the ``m``-by-``n`` matrix S is zero except, possibly, for its min(m,n) !> diagonal elements, which are the singular values of ``A``. ``U`` and ``V`` are orthogonal !> (unitary) matrices. The first min(m,n) columns of ``U`` and ``V`` are the left and !> right singular vectors of ``A``, respectively. !> !> The computation of the singular vectors is optional and is controlled by !> the function arguments ``left_svect`` and ``right_svect``, as described below. When !> computed, this function returns the transpose (or transpose conjugate) of the !> right singular vectors, that is, the rows of \f$V^H\f$. !> !> ``left_svect`` and ``right_svect`` are `rocblas_svect` enums that can take the !> following values: !> !> - ``rocblas_svect_all``: the entire matrix ``U`` (or \f$V^H\f$) is computed, !> - ``rocblas_svect_singular``: only the singular vectors (first min(m,n) !> columns of ``U`` or rows of \f$V^H\f$) are computed, !> - ``rocblas_svect_overwrite``: the first !> columns (or rows) of ``A`` are overwritten with the singular vectors, or !> - ``rocblas_svect_none``: no columns (or rows) of ``U`` (or \f$V^H\f$) are computed, i.e. !> no singular vectors. !> !> ``left_svect`` and ``right_svect`` cannot both be set to overwrite. When neither is !> set to overwrite, the contents of ``A`` are destroyed by the time the function !> returns. !> !> \note !> When ``m`` >> ``n`` (or ``n`` >> ``m``) the algorithm could be sped up by compressing !> the matrix ``A`` via a QR (or LQ) factorization, and working with the triangular !> factor afterwards (thin-SVD). If the singular vectors are also requested, its !> computation could be sped up as well via executing some intermediate !> operations out-of-place and relying more on matrix multiplications (GEMMs), but !> this will require a larger memory workspace. The parameter ``fast_alg`` !> controls whether the fast algorithm is executed or not. For more details, see !> the "rocSOLVER performance tuning" and "Memory model" sections of the documentation. !> !> \note !> In order to carry out calculations, this method could potentially synchronize the stream !> contained !> within the ``rocblas_handle``. !> !> \note !> A hybrid (CPU+GPU) approach is available for GESVD, primarily intended for homogeneous !> architectures. !> Use \ref rocsolver_set_alg_mode to enable it. !> !> @param[in] handle - rocblas_handle. !> @param[in] left_svect - `rocblas_svect`. !> Specifies how the left singular vectors are computed. !> @param[in] right_svect - `rocblas_svect`. !> Specifies how the right singular vectors are computed. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. !> On exit, if left_svect (or right_svect) is equal to overwrite, !> the first columns (or rows) contain the left (or right) singular vectors. !> Otherwise, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= m. !> The leading dimension of A. !> @param[out] S - pointer to real type. Array on the GPU of dimension min(m,n). !> The singular values of A in decreasing order. !> @param[out] U - pointer to type. Array on the GPU of dimension ldu*min(m,n) if !> left_svect is set to singular, or ldu*m when left_svect is equal to all. !> The matrix of left singular vectors stored as columns. Not !> referenced if left_svect is set to overwrite or none. !> @param[in] ldu - rocblas_int. ldu >= m if left_svect is all or singular, and ldu >= 1 !> otherwise. !> The leading dimension of U. !> @param[out] V - pointer to type. Array on the GPU of dimension ldv*n. !> The matrix of right singular vectors stored as rows (transposed / !> conjugate-transposed). !> Not referenced if right_svect is set to overwrite or none. !> @param[in] ldv - rocblas_int. ldv >= n if right_svect is all, and ldv >= min(m,n) if !> right_svect is !> set to singular, or ldv >= 1 otherwise. !> The leading dimension of V. !> @param[out] E - pointer to real type. Array on the GPU of dimension min(m,n)-1. !> This array is used to work internally with the bidiagonal matrix !> B associated with A (using \ref rocsolver_sbdsqr "BDSQR"). On exit, if info > !> 0, it contains the !> unconverged off-diagonal elements of B (or properly speaking, a bidiagonal !> matrix orthogonally equivalent to B). The diagonal elements of this matrix !> are in S. Those that converged correspond to a subset of the singular values !> of A (not necessarily ordered). !> @param[in] fast_alg - `rocblas_workmode`. !> If set to rocblas_outofplace, the function will execute the !> fast thin-SVD version of the algorithm when possible. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, \ref rocsolver_sbdsqr "BDSQR" did not converge. i elements of !> E did not converge to zero. interface rocsolver_sgesvd function rocsolver_sgesvd_(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg, & myInfo) & bind(c, name="rocsolver_sgesvd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: E integer(kind(rocblas_outofplace)),value :: fast_alg type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgesvd_assumed_rank #else module procedure & rocsolver_sgesvd_rank_0,& rocsolver_sgesvd_rank_1,& rocsolver_sgesvd_full_rank #endif #endif end interface interface rocsolver_dgesvd function rocsolver_dgesvd_(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg, & myInfo) & bind(c, name="rocsolver_dgesvd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: E integer(kind(rocblas_outofplace)),value :: fast_alg type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgesvd_assumed_rank #else module procedure & rocsolver_dgesvd_rank_0,& rocsolver_dgesvd_rank_1,& rocsolver_dgesvd_full_rank #endif #endif end interface interface rocsolver_cgesvd function rocsolver_cgesvd_(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg, & myInfo) & bind(c, name="rocsolver_cgesvd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: E integer(kind(rocblas_outofplace)),value :: fast_alg type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgesvd_assumed_rank #else module procedure & rocsolver_cgesvd_rank_0,& rocsolver_cgesvd_rank_1,& rocsolver_cgesvd_full_rank #endif #endif end interface interface rocsolver_zgesvd function rocsolver_zgesvd_(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E,fast_alg, & myInfo) & bind(c, name="rocsolver_zgesvd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: E integer(kind(rocblas_outofplace)),value :: fast_alg type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgesvd_assumed_rank #else module procedure & rocsolver_zgesvd_rank_0,& rocsolver_zgesvd_rank_1,& rocsolver_zgesvd_full_rank #endif #endif end interface !> \brief The GESVD_BATCHED functions compute the singular values and optionally the !> singular vectors of a batch of general ``m``-by-``n`` matrices A_l (Singular Value !> Decomposition). !> !> \details !> The SVD of matrix A_l in the batch is given by: !> !> \f[ !> A_l^{} = U_l^{} S_l^{} V_l^H !> \f] !> !> where the ``m``-by-``n`` matrix \f$S_l\f$ is zero except, possibly, for its min(m,n) !> diagonal elements, which are the singular values of \f$A_l\f$. \f$U_l\f$ and \f$V_l\f$ are !> orthogonal (unitary) matrices. The first min(m,n) columns of \f$U_l\f$ and \f$V_l\f$ are !> the left and right singular vectors of \f$A_l\f$, respectively. !> !> The computation of the singular vectors is optional and is controlled by !> the function arguments ``left_svect`` and ``right_svect``, as described below. When !> computed, this function returns the transpose (or transpose conjugate) of the !> right singular vectors, that is, the rows of \f$V_l^H\f$. !> !> ``left_svect`` and ``right_svect`` are `rocblas_svect` enums that can take the !> following values: !> !> - ``rocblas_svect_all``: the entire matrix \f$U_l\f$ (or \f$V_l^H\f$) is computed, !> - ``rocblas_svect_singular``: only the singular vectors (first min(m,n) !> columns of \f$U_l\f$ or rows of \f$V_l^H\f$) are computed, !> - ``rocblas_svect_overwrite``: the !> first columns (or rows) of \f$A_l\f$ are overwritten with the singular vectors, or !> - ``rocblas_svect_none``: no columns (or rows) of \f$U_l\f$ (or \f$V_l^H\f$) are computed, !> that is, no singular vectors. !> !> ``left_svect`` and ``right_svect`` cannot both be set to overwrite. When neither is !> set to overwrite, the contents of \f$A_l\f$ are destroyed by the time the function !> returns. !> !> \note !> When ``m`` >> ``n`` (or ``n`` >> ``m``) the algorithm could be sped up by compressing !> the matrix \f$A_l\f$ via a QR (or LQ) factorization and working with the !> triangular factor afterwards (thin-SVD). If the singular vectors are also !> requested, its computation could be sped up as well via executing some !> intermediate operations out-of-place and relying more on matrix !> multiplications (GEMMs), but this will require a larger memory !> workspace. The parameter ``fast_alg`` controls whether the fast algorithm is !> executed or not. For more details, see the "rocSOLVER performance tuning" !> and "Memory model" sections of the documentation. !> !> \note !> In order to carry out calculations, this method could potentially synchronize the stream !> contained !> within the ``rocblas_handle``. !> !> \note !> A hybrid (CPU+GPU) approach is available for GESVD_BATCHED, primarily intended for !> homogeneous architectures. Use \ref rocsolver_set_alg_mode to enable it. !> !> @param[in] handle - rocblas_handle. !> @param[in] left_svect - `rocblas_svect`. !> Specifies how the left singular vectors are computed. !> @param[in] right_svect - `rocblas_svect`. !> Specifies how the right singular vectors are computed. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all matrices A_l in the batch. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on !> the GPU of dimension lda*n. !> On entry, the matrices A_l. !> On exit, if left_svect (or right_svect) is equal to overwrite, !> the first columns (or rows) of A_l contain the left (or right) !> corresponding singular vectors. Otherwise, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= m. !> The leading dimension of A_l. !> @param[out] S - pointer to real type. Array on the GPU (the size depends on the value of !> strideS). !> The singular values of A_l in decreasing order. !> @param[in] strideS - rocblas_stride. !> Stride from the start of one vector S_l to the next one S_(l+1). !> There is no restriction for the value of strideS. !> The normal use case is strideS >= min(m,n). !> @param[out] U - pointer to type. Array on the GPU (the side depends on the value of !> strideU). !> The matrices U_l of left singular vectors stored as columns. !> Not referenced if left_svect is set to overwrite or none. !> @param[in] ldu - rocblas_int. ldu >= m if left_svect is all or singular, and ldu >= 1 !> otherwise. !> The leading dimension of U_l. !> @param[in] strideU - rocblas_stride. !> Stride from the start of one matrix U_l to the next one U_(l+1). !> There is no restriction for the value of strideU. !> The normal use case is strideU >= ldu*min(m,n) if left_svect is set to !> singular, !> or strideU >= ldu*m when left_svect is equal to all. !> @param[out] V - pointer to type. Array on the GPU (the size depends on the value of !> strideV). !> The matrices V_l of right singular vectors stored as rows (transposed / !> conjugate-transposed). !> Not referenced if right_svect is set to overwrite or none. !> @param[in] ldv - rocblas_int. ldv >= n if right_svect is all, and ldv >= min(m,n) if !> right_svect is set to singular or ldv >= 1 otherwise. !> The leading dimension of V_l. !> @param[in] strideV - rocblas_stride. !> Stride from the start of one matrix V_l to the next one V_(l+1). !> There is no restriction for the value of strideV. !> The normal use case is strideV >= ldv*n. !> @param[out] E - pointer to real type. Array on the GPU (the size depends on the value of !> strideE). !> This array is used to work internally with the bidiagonal matrix B_l associated !> with A_l (using \ref rocsolver_sbdsqr "BDSQR"). !> On exit, if info[l] > 0, E_l contains the unconverged off-diagonal elements of !> B_l (or properly speaking, !> a bidiagonal matrix orthogonally equivalent to B_l). The diagonal elements of !> this matrix are in S_l. !> Those that converged correspond to a subset of the singular values of A_l (not !> necessarily ordered). !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= min(m,n)-1. !> @param[in] fast_alg - `rocblas_workmode`. !> If set to rocblas_outofplace, the function will execute the fast thin-SVD !> version !> of the algorithm when possible. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info[l] = 0, successful exit. !> If info[l] = i > 0, \ref rocsolver_sbdsqr "BDSQR" did not converge. i elements !> of E_l did not converge to zero. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgesvd_batched function rocsolver_sgesvd_batched_(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu, & strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) & bind(c, name="rocsolver_sgesvd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: E integer(c_int64_t),value :: strideE integer(kind(rocblas_outofplace)),value :: fast_alg type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgesvd_batched_assumed_rank #else module procedure & rocsolver_sgesvd_batched_rank_0,& rocsolver_sgesvd_batched_rank_1,& rocsolver_sgesvd_batched_full_rank #endif #endif end interface interface rocsolver_dgesvd_batched function rocsolver_dgesvd_batched_(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu, & strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) & bind(c, name="rocsolver_dgesvd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: E integer(c_int64_t),value :: strideE integer(kind(rocblas_outofplace)),value :: fast_alg type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgesvd_batched_assumed_rank #else module procedure & rocsolver_dgesvd_batched_rank_0,& rocsolver_dgesvd_batched_rank_1,& rocsolver_dgesvd_batched_full_rank #endif #endif end interface interface rocsolver_cgesvd_batched function rocsolver_cgesvd_batched_(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu, & strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) & bind(c, name="rocsolver_cgesvd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: E integer(c_int64_t),value :: strideE integer(kind(rocblas_outofplace)),value :: fast_alg type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgesvd_batched_assumed_rank #else module procedure & rocsolver_cgesvd_batched_rank_0,& rocsolver_cgesvd_batched_rank_1,& rocsolver_cgesvd_batched_full_rank #endif #endif end interface interface rocsolver_zgesvd_batched function rocsolver_zgesvd_batched_(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu, & strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) & bind(c, name="rocsolver_zgesvd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: E integer(c_int64_t),value :: strideE integer(kind(rocblas_outofplace)),value :: fast_alg type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgesvd_batched_assumed_rank #else module procedure & rocsolver_zgesvd_batched_rank_0,& rocsolver_zgesvd_batched_rank_1,& rocsolver_zgesvd_batched_full_rank #endif #endif end interface !> \brief The GESVD_STRIDED_BATCHED functions compute the singular values and optionally the !> singular vectors of a batch of general ``m``-by-``n`` matrices A_l (Singular Value !> Decomposition). !> !> \details !> The SVD of matrix A_l in the batch is given by: !> !> \f[ !> A_l^{} = U_l^{} S_l^{} V_l^H !> \f] !> !> where the ``m``-by-``n`` matrix \f$S_l\f$ is zero except, possibly, for its min(m,n) !> diagonal elements, which are the singular values of \f$A_l\f$. \f$U_l\f$ and \f$V_l\f$ are !> orthogonal (unitary) matrices. The first min(m,n) columns of \f$U_l\f$ and \f$V_l\f$ are !> the left and right singular vectors of \f$A_l\f$, respectively. !> !> The computation of the singular vectors is optional and is controlled by !> the function arguments ``left_svect`` and ``right_svect``, as described below. When !> computed, this function returns the transpose (or transpose conjugate) of the !> right singular vectors, that is, the rows of \f$V_l^H\f$. !> !> ``left_svect`` and ``right_svect`` are `rocblas_svect` enums that can take the !> following values: !> !> - ``rocblas_svect_all``: the entire matrix \f$U_l\f$ (or \f$V_l^H\f$) is computed, !> - ``rocblas_svect_singular``: only the singular vectors (first min(m,n) !> columns of \f$U_l\f$ or rows of \f$V_l^H\f$) are computed, !> - ``rocblas_svect_overwrite``: the !> first columns (or rows) of \f$A_l\f$ are overwritten with the singular vectors, or !> - ``rocblas_svect_none``: no columns (or rows) of \f$U_l\f$ (or \f$V_l^H\f$) are computed, !> that is, no singular vectors. !> !> ``left_svect`` and ``right_svect`` cannot both be set to overwrite. When neither is !> set to overwrite, the contents of \f$A_l\f$ are destroyed by the time the function !> returns. !> !> \note !> When ``m`` >> ``n`` (or ``n`` >> ``m``) the algorithm could be sped up by compressing !> the matrix \f$A_l\f$ via a QR (or LQ) factorization, and working with the !> triangular factor afterwards (thin-SVD). If the singular vectors are also !> requested, its computation could be sped up as well via executing some !> intermediate operations out-of-place, and relying more on matrix !> multiplications (GEMMs), but this will require a larger memory !> workspace. The parameter ``fast_alg`` controls whether the fast algorithm is !> executed or not. For more details, see the "rocSOLVER performance tuning" !> and "Memory model" sections of the documentation. !> !> \note !> In order to carry out calculations, this method could potentially synchronize the stream !> contained !> within the ``rocblas_handle``. !> !> \note !> A hybrid (CPU+GPU) approach is available for GESVD_STRIDED_BATCHED, primarily intended !> for homogeneous architectures. Use \ref rocsolver_set_alg_mode to enable it. !> !> @param[in] handle - rocblas_handle. !> @param[in] left_svect - `rocblas_svect`. !> Specifies how the left singular vectors are computed. !> @param[in] right_svect - `rocblas_svect`. !> Specifies how the right singular vectors are computed. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, if left_svect (or right_svect) is equal to !> overwrite, the first columns (or rows) of A_l contain the left (or right) !> corresponding singular vectors. Otherwise, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= m. !> The leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. !> The normal use case is strideA >= lda*n. !> @param[out] S - pointer to real type. Array on the GPU (the size depends on the value of !> strideS). !> The singular values of A_l in decreasing order. !> @param[in] strideS - rocblas_stride. !> Stride from the start of one vector S_l to the next one S_(l+1). !> There is no restriction for the value of strideS. !> The normal use case is strideS >= min(m,n). !> @param[out] U - pointer to type. Array on the GPU (the side depends on the value of !> strideU). !> The matrices U_l of left singular vectors stored as columns. !> Not referenced if left_svect is set to overwrite or none. !> @param[in] ldu - rocblas_int. ldu >= m if left_svect is all or singular and ldu >= 1 !> otherwise. !> The leading dimension of U_l. !> @param[in] strideU - rocblas_stride. !> Stride from the start of one matrix U_l to the next one U_(l+1). !> There is no restriction for the value of strideU. !> The normal use case is strideU >= ldu*min(m,n) if left_svect is set to !> singular, !> or strideU >= ldu*m when left_svect is equal to all. !> @param[out] V - pointer to type. Array on the GPU (the size depends on the value of !> strideV). !> The matrices V_l of right singular vectors stored as rows (transposed / !> conjugate-transposed). !> Not referenced if right_svect is set to overwrite or none. !> @param[in] ldv - rocblas_int. ldv >= n if right_svect is all, and ldv >= min(m,n) if !> right_svect is !> set to singular or ldv >= 1 otherwise. !> The leading dimension of V_l. !> @param[in] strideV - rocblas_stride. !> Stride from the start of one matrix V_l to the next one V_(l+1). !> There is no restriction for the value of strideV. !> The normal use case is strideV >= ldv*n. !> @param[out] E - pointer to real type. Array on the GPU (the size depends on the value of !> strideE). !> This array is used to work internally with the bidiagonal matrix B_l associated !> with A_l (using \ref rocsolver_sbdsqr "BDSQR"). !> On exit, if info[l] > 0, E_l contains the unconverged off-diagonal elements of !> B_l (or properly speaking, !> a bidiagonal matrix orthogonally equivalent to B_l). The diagonal elements of !> this matrix are in S_l. !> Those that converged correspond to a subset of the singular values of A_l (not !> necessarily ordered). !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. !> The normal use case is strideE >= min(m,n)-1. !> @param[in] fast_alg - `rocblas_workmode`. !> If set to rocblas_outofplace, the function will execute the fast thin-SVD !> version !> of the algorithm when possible. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info[l] = 0, successful exit. !> If info[l] = i > 0, BDSQR did not converge. i elements of E_l did not converge !> to zero. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgesvd_strided_batched function rocsolver_sgesvd_strided_batched_(handle,left_svect,right_svect,m,n,A,lda,strideA,S, & strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) & bind(c, name="rocsolver_sgesvd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: E integer(c_int64_t),value :: strideE integer(kind(rocblas_outofplace)),value :: fast_alg type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgesvd_strided_batched_assumed_rank #else module procedure & rocsolver_sgesvd_strided_batched_rank_0,& rocsolver_sgesvd_strided_batched_rank_1,& rocsolver_sgesvd_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgesvd_strided_batched function rocsolver_dgesvd_strided_batched_(handle,left_svect,right_svect,m,n,A,lda,strideA,S, & strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) & bind(c, name="rocsolver_dgesvd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: E integer(c_int64_t),value :: strideE integer(kind(rocblas_outofplace)),value :: fast_alg type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgesvd_strided_batched_assumed_rank #else module procedure & rocsolver_dgesvd_strided_batched_rank_0,& rocsolver_dgesvd_strided_batched_rank_1,& rocsolver_dgesvd_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgesvd_strided_batched function rocsolver_cgesvd_strided_batched_(handle,left_svect,right_svect,m,n,A,lda,strideA,S, & strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) & bind(c, name="rocsolver_cgesvd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: E integer(c_int64_t),value :: strideE integer(kind(rocblas_outofplace)),value :: fast_alg type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgesvd_strided_batched_assumed_rank #else module procedure & rocsolver_cgesvd_strided_batched_rank_0,& rocsolver_cgesvd_strided_batched_rank_1,& rocsolver_cgesvd_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgesvd_strided_batched function rocsolver_zgesvd_strided_batched_(handle,left_svect,right_svect,m,n,A,lda,strideA,S, & strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) & bind(c, name="rocsolver_zgesvd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: E integer(c_int64_t),value :: strideE integer(kind(rocblas_outofplace)),value :: fast_alg type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgesvd_strided_batched_assumed_rank #else module procedure & rocsolver_zgesvd_strided_batched_rank_0,& rocsolver_zgesvd_strided_batched_rank_1,& rocsolver_zgesvd_strided_batched_full_rank #endif #endif end interface !> \brief GESDD computes the singular values and optionally the singular !> vectors of a general m-by-n matrix A (Singular Value Decomposition). !> !> \details !> The SVD of matrix A is given by: !> !> \f[ !> A = U S V^H !> \f] !> !> where the m-by-n matrix S is zero except, possibly, for its min(m,n) !> diagonal elements, which are the singular values of A. U and V are orthogonal !> (unitary) matrices. The first min(m,n) columns of U and V are the left and !> right singular vectors of A, respectively. !> !> The computation of the singular vectors is optional and it is controlled by !> the function arguments left_svect and right_svect as described below. When !> computed, this function returns the transpose (or transpose conjugate) of the !> right singular vectors, i.e. the rows of \f$V^H\f$. !> !> left_svect and right_svect are `rocblas_svect` enums that can take the !> following values: !> !> - rocblas_svect_all: the entire matrix U (or \f$V^H\f$) is computed, !> - rocblas_svect_singular: the singular vectors (first min(m,n) !> columns of U or rows of \f$V^H\f$) are computed, or !> - rocblas_svect_none: no columns (or rows) of U (or \f$V^H\f$) are computed, i.e. !> no singular vectors. !> !> The singular values are computed by applying QR factorization to \f$AV\f$ if \f$m ≥ n\f$ !> (resp. LQ factorization to \f$U^H A\f$ if \f$m < n\f$), where \f$V\f$ (resp. \f$U\f$) is !> found as the !> eigenvectors of \f$A^H A\f$ (resp. \f$A A^H\f$) using the Divide-and-Conquer eigensolver. !> !> @param[in] handle - rocblas_handle. !> @param[in] left_svect - `rocblas_svect`. !> Specifies how the left singular vectors are computed. !> rocblas_svect_overwrite is not supported. !> @param[in] right_svect - `rocblas_svect`. !> Specifies how the right singular vectors are computed. !> rocblas_svect_overwrite is not supported. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. !> On exit, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= m. !> The leading dimension of A. !> @param[out] S - pointer to real type. Array on the GPU of dimension min(m,n). !> The singular values of A in decreasing order. !> @param[out] U - pointer to type. Array on the GPU of dimension ldu*min(m,n) if !> left_svect is set to singular, or ldu*m when left_svect is equal to all. !> The matrix of left singular vectors stored as columns. Not !> referenced if left_svect is set to none. !> @param[in] ldu - rocblas_int. ldu >= m if left_svect is set to all or singular; ldu >= 1 !> otherwise. !> The leading dimension of U. !> @param[out] V - pointer to type. Array on the GPU of dimension ldv*n. !> The matrix of right singular vectors stored as rows (transposed / !> conjugate-transposed). !> Not referenced if right_svect is set to none. !> @param[in] ldv - rocblas_int. ldv >= n if right_svect is set to all; ldv >= min(m,n) if !> right_svect is !> set to singular; or ldv >= 1 otherwise. !> The leading dimension of V. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. If info = 1, the algorithm did not converge. interface rocsolver_sgesdd function rocsolver_sgesdd_(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,myInfo) & bind(c, name="rocsolver_sgesdd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesdd_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: myInfo end function end interface interface rocsolver_dgesdd function rocsolver_dgesdd_(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,myInfo) & bind(c, name="rocsolver_dgesdd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesdd_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: myInfo end function end interface interface rocsolver_cgesdd function rocsolver_cgesdd_(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,myInfo) & bind(c, name="rocsolver_cgesdd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesdd_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: myInfo end function end interface interface rocsolver_zgesdd function rocsolver_zgesdd_(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,myInfo) & bind(c, name="rocsolver_zgesdd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesdd_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: myInfo end function end interface !> \brief GESDD_BATCHED computes the singular values and optionally the !> singular vectors of a batch of general m-by-n matrix A (Singular Value !> Decomposition). !> !> \details !> The SVD of matrix A_l in the batch is given by: !> !> \f[ !> A_l = U_l S_l V_l^H !> \f] !> !> where the m-by-n matrix \f$S_l\f$ is zero except, possibly, for its min(m,n) !> diagonal elements, which are the singular values of \f$A_l\f$. \f$U_l\f$ and \f$V_l\f$ are !> orthogonal (unitary) matrices. The first min(m,n) columns of \f$U_l\f$ and \f$V_l\f$ are !> the left and right singular vectors of \f$A_l\f$, respectively. !> !> The computation of the singular vectors is optional and it is controlled by !> the function arguments left_svect and right_svect as described below. When !> computed, this function returns the transpose (or transpose conjugate) of the !> right singular vectors, i.e. the rows of \f$V_l^H\f$. !> !> left_svect and right_svect are `rocblas_svect` enums that can take the !> following values: !> !> - rocblas_svect_all: the entire matrix \f$U_l\f$ (or \f$V_l^H\f$) is computed, !> - rocblas_svect_singular: the singular vectors (first min(m,n) !> columns of \f$U_l\f$ or rows of \f$V_l^H\f$) are computed, or !> - rocblas_svect_none: no columns (or rows) of \f$U_l\f$ (or \f$V_l^H\f$) are computed, !> i.e. no singular vectors. !> !> The singular values are computed by applying QR factorization to \f$A_lV_l\f$ if m >= n !> (resp. LQ factorization to \f$U_l^H A_l\f$ if m < n), where \f$V_l\f$ (resp. \f$U_l\f$) is !> found as the eigenvectors of \f$A_l^H A_l\f$ (resp. \f$A_l A_l^H\f$) using the !> Divide-and-Conquer !> eigensolver. !> !> @param[in] handle - rocblas_handle. !> @param[in] left_svect - `rocblas_svect`. !> Specifies how the left singular vectors are computed. !> rocblas_svect_overwrite is not supported. !> @param[in] right_svect - `rocblas_svect`. !> Specifies how the right singular vectors are computed. !> rocblas_svect_overwrite is not supported. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all matrices A_l in the batch. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on !> the GPU of dimension lda*n. !> On entry, the matrices A_l. !> On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= m. !> The leading dimension of A_l. !> @param[out] S - pointer to real type. Array on the GPU (the size depends on the value of !> strideS). !> The singular values of A_l in decreasing order. !> @param[in] strideS - rocblas_stride. !> Stride from the start of one vector S_l to the next one S(l+1). !> There is no restriction for the value of strideS. !> Normal use case is strideS >= min(m,n). !> @param[out] U - pointer to type. Array on the GPU (the side depends on the value of !> strideU). !> The matrices U_l of left singular vectors stored as columns. !> Not referenced if left_svect is set to none. !> @param[in] ldu - rocblas_int. ldu >= m if left_svect is set to all or singular; ldu >= 1 !> otherwise. !> The leading dimension of U_l. !> @param[in] strideU - rocblas_stride. !> Stride from the start of one matrix U_l to the next one U(l+1). !> There is no restriction for the value of strideU. !> Normal use case is strideU >= ldu*min(m,n) if left_svect is set to singular, !> or strideU >= ldu*m when left_svect is equal to all. !> @param[out] V - pointer to type. Array on the GPU (the size depends on the value of !> strideV). !> The matrices V_l of right singular vectors stored as rows (transposed / !> conjugate-transposed). !> Not referenced if right_svect is set to none. !> @param[in] ldv - rocblas_int. ldv >= n if right_svect is set to all; ldv >= min(m,n) if !> right_svect is !> set to singular; or ldv >= 1 otherwise. !> The leading dimension of V. !> @param[in] strideV - rocblas_stride. !> Stride from the start of one matrix V_l to the next one V(l+1). !> There is no restriction for the value of strideV. !> Normal use case is strideV >= ldv*n. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info[l] = 0, successful exit. If info[l] = 1, the algorithm did not !> converge. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgesdd_batched function rocsolver_sgesdd_batched_(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu, & strideU,V,ldv,strideV,myInfo,batch_count) & bind(c, name="rocsolver_sgesdd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesdd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dgesdd_batched function rocsolver_dgesdd_batched_(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu, & strideU,V,ldv,strideV,myInfo,batch_count) & bind(c, name="rocsolver_dgesdd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesdd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_cgesdd_batched function rocsolver_cgesdd_batched_(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu, & strideU,V,ldv,strideV,myInfo,batch_count) & bind(c, name="rocsolver_cgesdd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesdd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zgesdd_batched function rocsolver_zgesdd_batched_(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U,ldu, & strideU,V,ldv,strideV,myInfo,batch_count) & bind(c, name="rocsolver_zgesdd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesdd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief GESDD_STRIDED_BATCHED computes the singular values and optionally the !> singular vectors of a batch of general m-by-n matrix A (Singular Value !> Decomposition). !> !> \details !> The SVD of matrix A_l in the batch is given by: !> !> \f[ !> A_l = U_l S_l V_l^H !> \f] !> !> where the m-by-n matrix \f$S_l\f$ is zero except, possibly, for its min(m,n) !> diagonal elements, which are the singular values of \f$A_l\f$. \f$U_l\f$ and \f$V_l\f$ are !> orthogonal (unitary) matrices. The first min(m,n) columns of \f$U_l\f$ and \f$V_l\f$ are !> the left and right singular vectors of \f$A_l\f$, respectively. !> !> The computation of the singular vectors is optional and it is controlled by !> the function arguments left_svect and right_svect as described below. When !> computed, this function returns the transpose (or transpose conjugate) of the !> right singular vectors, i.e. the rows of \f$V_l^H\f$. !> !> left_svect and right_svect are `rocblas_svect` enums that can take the !> following values: !> !> - rocblas_svect_all: the entire matrix \f$U_l\f$ (or \f$V_l^H\f$) is computed, !> - rocblas_svect_singular: the singular vectors (first min(m,n) !> columns of \f$U_l\f$ or rows of \f$V_l^H\f$) are computed, or !> - rocblas_svect_none: no columns (or rows) of \f$U_l\f$ (or \f$V_l^H\f$) are computed, !> i.e. no singular vectors. !> !> The singular values are computed by applying QR factorization to \f$A_lV_l\f$ if m >= n !> (resp. LQ factorization to \f$U_l^H A_l\f$ if m < n), where \f$V_l\f$ (resp. \f$U_l\f$) is !> found as the eigenvectors of \f$A_l^H A_l\f$ (resp. \f$A_l A_l^H\f$) using the !> Divide-and-Conquer !> eigensolver. !> !> @param[in] handle - rocblas_handle. !> @param[in] left_svect - `rocblas_svect`. !> Specifies how the left singular vectors are computed. !> rocblas_svect_overwrite is not supported. !> @param[in] right_svect - `rocblas_svect`. !> Specifies how the right singular vectors are computed. !> rocblas_svect_overwrite is not supported. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. !> On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= m. !> The leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. !> Normal use case is strideA >= lda*n. !> @param[out] S - pointer to real type. Array on the GPU (the size depends on the value of !> strideS). !> The singular values of A_l in decreasing order. !> @param[in] strideS - rocblas_stride. !> Stride from the start of one vector S_l to the next one S_(j+1). !> There is no restriction for the value of strideS. !> Normal use case is strideS >= min(m,n). !> @param[out] U - pointer to type. Array on the GPU (the side depends on the value of !> strideU). !> The matrices U_l of left singular vectors stored as columns. !> Not referenced if left_svect is set to none. !> @param[in] ldu - rocblas_int. ldu >= m if left_svect is set to all or singular; ldu >= 1 !> otherwise. !> The leading dimension of U_l. !> @param[in] strideU - rocblas_stride. !> Stride from the start of one matrix U_l to the next one U_(j+1). !> There is no restriction for the value of strideU. !> Normal use case is strideU >= ldu*min(m,n) if left_svect is set to singular, !> or strideU >= ldu*m when left_svect is equal to all. !> @param[out] V - pointer to type. Array on the GPU (the size depends on the value of !> strideV). !> The matrices V_l of right singular vectors stored as rows (transposed / !> conjugate-transposed). !> Not referenced if right_svect is set to none. !> @param[in] ldv - rocblas_int. ldv >= n if right_svect is set to all; ldv >= min(m,n) if !> right_svect is !> set to singular; or ldv >= 1 otherwise. !> The leading dimension of V. !> @param[in] strideV - rocblas_stride. !> Stride from the start of one matrix V_l to the next one V_(j+1). !> There is no restriction for the value of strideV. !> Normal use case is strideV >= ldv*n. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info[l] = 0, successful exit. If info[l] = 1, the algorithm did not !> converge. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgesdd_strided_batched function rocsolver_sgesdd_strided_batched_(handle,left_svect,right_svect,m,n,A,lda,strideA,S, & strideS,U,ldu,strideU,V,ldv,strideV,myInfo,batch_count) & bind(c, name="rocsolver_sgesdd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesdd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dgesdd_strided_batched function rocsolver_dgesdd_strided_batched_(handle,left_svect,right_svect,m,n,A,lda,strideA,S, & strideS,U,ldu,strideU,V,ldv,strideV,myInfo,batch_count) & bind(c, name="rocsolver_dgesdd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesdd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_cgesdd_strided_batched function rocsolver_cgesdd_strided_batched_(handle,left_svect,right_svect,m,n,A,lda,strideA,S, & strideS,U,ldu,strideU,V,ldv,strideV,myInfo,batch_count) & bind(c, name="rocsolver_cgesdd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesdd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zgesdd_strided_batched function rocsolver_zgesdd_strided_batched_(handle,left_svect,right_svect,m,n,A,lda,strideA,S, & strideS,U,ldu,strideU,V,ldv,strideV,myInfo,batch_count) & bind(c, name="rocsolver_zgesdd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesdd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The GESVDJ functions compute the singular values and optionally the singular !> vectors of a general ``m``-by-``n`` matrix ``A`` (Singular Value Decomposition). !> !> \details !> The SVD of matrix ``A`` is given by: !> !> \f[ !> A = U S V^H !> \f] !> !> where the ``m``-by-``n`` matrix S is zero except, possibly, for its min(m,n) !> diagonal elements, which are the singular values of ``A``. ``U`` and ``V`` are orthogonal !> (unitary) matrices. The first min(m,n) columns of ``U`` and ``V`` are the left and !> right singular vectors of ``A``, respectively. !> !> The computation of the singular vectors is optional and is controlled by !> the function arguments ``left_svect`` and ``right_svect``, as described below. When !> computed, this function returns the transpose (or transpose conjugate) of the !> right singular vectors, that is, the rows of \f$V^H\f$. !> !> ``left_svect`` and ``right_svect`` are `rocblas_svect` enums that can take the !> following values: !> !> - ``rocblas_svect_all``: the entire matrix ``U`` (or \f$V^H\f$) is computed, !> - ``rocblas_svect_singular``: the singular vectors (first min(m,n) !> columns of ``U`` or rows of \f$V^H\f$) are computed, or !> - ``rocblas_svect_none``: no columns (or rows) of ``U`` (or \f$V^H\f$) are computed, that !> is, !> no singular vectors. !> !> The singular values are computed by applying QR factorization to \f$AV\f$ if \f$m ≥ n\f$ !> (resp. LQ factorization to \f$U^H A\f$ if \f$m < n\f$), where \f$V\f$ (resp. \f$U\f$) is !> found as the !> eigenvectors of \f$A^H A\f$ (resp. \f$A A^H\f$) using the Jacobi eigenvalue algorithm. !> !> \note !> In order to carry out calculations, this method could potentially synchronize the stream !> contained within the !> ``rocblas_handle``. !> !> @param[in] handle - rocblas_handle. !> @param[in] left_svect - `rocblas_svect`. !> Specifies how the left singular vectors are computed. !> rocblas_svect_overwrite is not supported. !> @param[in] right_svect - `rocblas_svect`. !> Specifies how the right singular vectors are computed. !> rocblas_svect_overwrite is not supported. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. !> On exit, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= m. !> The leading dimension of A. !> @param[in] abstol - real type. !> The absolute tolerance. The algorithm is considered to have converged once !> \f$\mathrm{off}(A^H A) ≤ \mathrm{norm}(A^H A) \cdot \mathrm{abstol}\f$ !> [resp. \f$\mathrm{off}(A A^H) ≤ \mathrm{norm}(A A^H) \cdot !> \mathrm{abstol}\f$]. If abstol <= 0, !> then the tolerance will be set to machine precision. !> @param[out] residual - pointer to real type on the GPU. !> The Frobenius norm of the off-diagonal elements of \f$A^H A\f$ (resp. \f$A !> A^H\f$) at the final !> iteration. !> @param[in] max_sweeps - rocblas_int. max_sweeps > 0. !> Maximum number of sweeps (iterations) to be used by the algorithm. !> @param[out] n_sweeps - pointer to a rocblas_int on the GPU. !> The actual number of sweeps (iterations) used by the algorithm. !> @param[out] S - pointer to real type. Array on the GPU of dimension min(m,n). !> The singular values of A in decreasing order. !> @param[out] U - pointer to type. Array on the GPU of dimension ldu*min(m,n) if !> left_svect is set to singular, or ldu*m when left_svect is equal to all. !> The matrix of left singular vectors stored as columns. Not !> referenced if left_svect is set to none. !> @param[in] ldu - rocblas_int. ldu >= m if left_svect is set to all or singular, and ldu >= !> 1 otherwise. !> The leading dimension of U. !> @param[out] V - pointer to type. Array on the GPU of dimension ldv*n. !> The matrix of right singular vectors stored as rows (transposed / !> conjugate-transposed). !> Not referenced if right_svect is set to none. !> @param[in] ldv - rocblas_int. ldv >= n if right_svect is set to all, and ldv >= min(m,n) if !> right_svect is !> set to singular; or ldv >= 1 otherwise. !> The leading dimension of V. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. If info = 1, the algorithm did not converge. interface rocsolver_sgesvdj function rocsolver_sgesvdj_(handle,left_svect,right_svect,m,n,A,lda,abstol,residual, & max_sweeps,n_sweeps,S,U,ldu,V,ldv,myInfo) & bind(c, name="rocsolver_sgesvdj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvdj_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: myInfo end function end interface interface rocsolver_dgesvdj function rocsolver_dgesvdj_(handle,left_svect,right_svect,m,n,A,lda,abstol,residual, & max_sweeps,n_sweeps,S,U,ldu,V,ldv,myInfo) & bind(c, name="rocsolver_dgesvdj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvdj_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: myInfo end function end interface interface rocsolver_cgesvdj function rocsolver_cgesvdj_(handle,left_svect,right_svect,m,n,A,lda,abstol,residual, & max_sweeps,n_sweeps,S,U,ldu,V,ldv,myInfo) & bind(c, name="rocsolver_cgesvdj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvdj_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: myInfo end function end interface interface rocsolver_zgesvdj function rocsolver_zgesvdj_(handle,left_svect,right_svect,m,n,A,lda,abstol,residual, & max_sweeps,n_sweeps,S,U,ldu,V,ldv,myInfo) & bind(c, name="rocsolver_zgesvdj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvdj_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: myInfo end function end interface !> \brief The GESVDJ_BATCHED functions compute the singular values and optionally the !> singular vectors of a batch of general ``m``-by-``n`` matrices ``A`` (Singular Value !> Decomposition). !> !> \details !> The SVD of matrix A_l in the batch is given by: !> !> \f[ !> A_l = U_l S_l V_l^H !> \f] !> !> where the ``m``-by-``n`` matrix \f$S_l\f$ is zero except, possibly, for its min(m,n) !> diagonal elements, which are the singular values of \f$A_l\f$. \f$U_l\f$ and \f$V_l\f$ are !> orthogonal (unitary) matrices. The first min(m,n) columns of \f$U_l\f$ and \f$V_l\f$ are !> the left and right singular vectors of \f$A_l\f$, respectively. !> !> The computation of the singular vectors is optional and is controlled by !> the function arguments ``left_svect`` and ``right_svect``, as described below. When !> computed, this function returns the transpose (or transpose conjugate) of the !> right singular vectors, that is, the rows of \f$V_l^H\f$. !> !> ``left_svect`` and ``right_svect`` are `rocblas_svect` enums that can take the !> following values: !> !> - ``rocblas_svect_all``: the entire matrix \f$U_l\f$ (or \f$V_l^H\f$) is computed, !> - ``rocblas_svect_singular``: the singular vectors (first min(m,n) !> columns of \f$U_l\f$ or rows of \f$V_l^H\f$) are computed, or !> - ``rocblas_svect_none``: no columns (or rows) of \f$U_l\f$ (or \f$V_l^H\f$) are computed, !> that is, no singular vectors. !> !> The singular values are computed by applying QR factorization to \f$A_lV_l\f$ if ``m`` >= !> ``n`` !> (resp. LQ factorization to \f$U_l^H A_l\f$ if ``m`` < ``n`` ), where \f$V_l\f$ (resp. !> \f$U_l\f$) is !> found as the eigenvectors of \f$A_l^H A_l\f$ (resp. \f$A_l A_l^H\f$) using the Jacobi !> eigenvalue algorithm. !> !> \note !> In order to carry out calculations, this method could potentially synchronize the stream !> contained within the !> ``rocblas_handle``. !> !> @param[in] handle - rocblas_handle. !> @param[in] left_svect - `rocblas_svect`. !> Specifies how the left singular vectors are computed. !> rocblas_svect_overwrite is not supported. !> @param[in] right_svect - `rocblas_svect`. !> Specifies how the right singular vectors are computed. !> rocblas_svect_overwrite is not supported. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all matrices A_l in the batch. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on !> the GPU of dimension lda*n. !> On entry, the matrices A_l. !> On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= m. !> The leading dimension of A_l. !> @param[in] abstol - real type. !> The absolute tolerance. The algorithm is considered to have converged once !> \f$\mathrm{off}(A_l^H A_l) ≤ \mathrm{norm}(A_l^H A_l) \cdot !> \mathrm{abstol}\f$ !> [resp. \f$\mathrm{off}(A_l A_l^H) ≤ \mathrm{norm}(A_l A_l^H) \cdot !> \mathrm{abstol}\f$]. If abstol <= 0, !> then the tolerance will be set to machine precision. !> @param[out] residual - pointer to real type on the GPU. !> The Frobenius norm of the off-diagonal elements of \f$A_l^H A_l\f$ (resp. !> \f$A_l A_l^H\f$) at the final !> iteration. !> @param[in] max_sweeps - rocblas_int. max_sweeps > 0. !> Maximum number of sweeps (iterations) to be used by the algorithm. !> @param[out] n_sweeps - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The actual number of sweeps (iterations) used by the algorithm for each batch !> instance. !> @param[out] S - pointer to real type. Array on the GPU (the size depends on the value of !> strideS). !> The singular values of A_l in decreasing order. !> @param[in] strideS - rocblas_stride. !> Stride from the start of one vector S_l to the next one S(l+1). !> There is no restriction for the value of strideS. !> The normal use case is strideS >= min(m,n). !> @param[out] U - pointer to type. Array on the GPU (the side depends on the value of !> strideU). !> The matrices U_l of left singular vectors stored as columns. !> Not referenced if left_svect is set to none. !> @param[in] ldu - rocblas_int. ldu >= m if left_svect is set to all or singular, and ldu >= !> 1 otherwise. !> The leading dimension of U_l. !> @param[in] strideU - rocblas_stride. !> Stride from the start of one matrix U_l to the next one U(l+1). !> There is no restriction for the value of strideU. !> The normal use case is strideU >= ldu*min(m,n) if left_svect is set to !> singular, !> or strideU >= ldu*m when left_svect is equal to all. !> @param[out] V - pointer to type. Array on the GPU (the size depends on the value of !> strideV). !> The matrices V_l of right singular vectors stored as rows (transposed / !> conjugate-transposed). !> Not referenced if right_svect is set to none. !> @param[in] ldv - rocblas_int. ldv >= n if right_svect is set to all, and ldv >= min(m,n) if !> right_svect is !> set to singular, or ldv >= 1 otherwise. !> The leading dimension of V. !> @param[in] strideV - rocblas_stride. !> Stride from the start of one matrix V_l to the next one V(l+1). !> There is no restriction for the value of strideV. !> The normal use case is strideV >= ldv*n. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info[l] = 0, successful exit. If info[l] = 1, the algorithm did not !> converge. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgesvdj_batched function rocsolver_sgesvdj_batched_(handle,left_svect,right_svect,m,n,A,lda,abstol,residual, & max_sweeps,n_sweeps,S,strideS,U,ldu,strideU,V,ldv,strideV,myInfo,batch_count) & bind(c, name="rocsolver_sgesvdj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvdj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dgesvdj_batched function rocsolver_dgesvdj_batched_(handle,left_svect,right_svect,m,n,A,lda,abstol,residual, & max_sweeps,n_sweeps,S,strideS,U,ldu,strideU,V,ldv,strideV,myInfo,batch_count) & bind(c, name="rocsolver_dgesvdj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvdj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_cgesvdj_batched function rocsolver_cgesvdj_batched_(handle,left_svect,right_svect,m,n,A,lda,abstol,residual, & max_sweeps,n_sweeps,S,strideS,U,ldu,strideU,V,ldv,strideV,myInfo,batch_count) & bind(c, name="rocsolver_cgesvdj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvdj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zgesvdj_batched function rocsolver_zgesvdj_batched_(handle,left_svect,right_svect,m,n,A,lda,abstol,residual, & max_sweeps,n_sweeps,S,strideS,U,ldu,strideU,V,ldv,strideV,myInfo,batch_count) & bind(c, name="rocsolver_zgesvdj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvdj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The GESVDJ_STRIDED_BATCHED functions compute the singular values and optionally the !> singular vectors of a batch of general ``m``-by-``n`` matrices ``A`` (Singular Value !> Decomposition). !> !> \details !> The SVD of matrix A_l in the batch is given by: !> !> \f[ !> A_l = U_l S_l V_l^H !> \f] !> !> where the ``m``-by-``n`` matrix \f$S_l\f$ is zero except, possibly, for its min(m,n) !> diagonal elements, which are the singular values of \f$A_l\f$. \f$U_l\f$ and \f$V_l\f$ are !> orthogonal (unitary) matrices. The first min(m,n) columns of \f$U_l\f$ and \f$V_l\f$ are !> the left and right singular vectors of \f$A_l\f$, respectively. !> !> The computation of the singular vectors is optional and is controlled by !> the function arguments ``left_svect`` and ``right_svect``, as described below. When !> computed, this function returns the transpose (or transpose conjugate) of the !> right singular vectors, that is, the rows of \f$V_l^H\f$. !> !> ``left_svect`` and ``right_svect`` are `rocblas_svect` enums that can take the !> following values: !> !> - ``rocblas_svect_all``: the entire matrix \f$U_l\f$ (or \f$V_l^H\f$) is computed, !> - ``rocblas_svect_singular``: the singular vectors (first min(m,n) !> columns of \f$U_l\f$ or rows of \f$V_l^H\f$) are computed, or !> - ``rocblas_svect_none``: no columns (or rows) of \f$U_l\f$ (or \f$V_l^H\f$) are computed, !> that is, no singular vectors. !> !> The singular values are computed by applying QR factorization to \f$A_lV_l\f$ if ``m`` >= !> ``n`` !> (resp. LQ factorization to \f$U_l^H A_l\f$ if ``m`` < ``n`` ), where \f$V_l\f$ (resp. !> \f$U_l\f$) is !> found as the eigenvectors of \f$A_l^H A_l\f$ (resp. \f$A_l A_l^H\f$) using the Jacobi !> eigenvalue algorithm. !> !> \note !> In order to carry out calculations, this method could potentially synchronize the stream !> contained within the !> ``rocblas_handle``. !> !> @param[in] handle - rocblas_handle. !> @param[in] left_svect - `rocblas_svect`. !> Specifies how the left singular vectors are computed. !> rocblas_svect_overwrite is not supported. !> @param[in] right_svect - `rocblas_svect`. !> Specifies how the right singular vectors are computed. !> rocblas_svect_overwrite is not supported. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of all matrices A_l in the batch. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of all matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. !> On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= m. !> The leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. !> The normal use case is strideA >= lda*n. !> @param[in] abstol - real type. !> The absolute tolerance. The algorithm is considered to have converged once !> \f$\mathrm{off}(A_l^H A_l) ≤ \mathrm{norm}(A_l^H A_l) \cdot !> \mathrm{abstol}\f$ !> [resp. \f$\mathrm{off}(A_l A_l^H) ≤ \mathrm{norm}(A_l A_l^H) \cdot !> \mathrm{abstol}\f$]. If abstol <= 0, !> then the tolerance will be set to machine precision. !> @param[out] residual - pointer to real type on the GPU. !> The Frobenius norm of the off-diagonal elements of \f$A_l^H A_l\f$ (resp. !> \f$A_l A_l^H\f$) at the final !> iteration. !> @param[in] max_sweeps - rocblas_int. max_sweeps > 0. !> Maximum number of sweeps (iterations) to be used by the algorithm. !> @param[out] n_sweeps - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The actual number of sweeps (iterations) used by the algorithm for each batch !> instance. !> @param[out] S - pointer to real type. Array on the GPU (the size depends on the value of !> strideS). !> The singular values of A_l in decreasing order. !> @param[in] strideS - rocblas_stride. !> Stride from the start of one vector S_l to the next one S_(j+1). !> There is no restriction for the value of strideS. !> The normal use case is strideS >= min(m,n). !> @param[out] U - pointer to type. Array on the GPU (the side depends on the value of !> strideU). !> The matrices U_l of left singular vectors stored as columns. !> Not referenced if left_svect is set to none. !> @param[in] ldu - rocblas_int. ldu >= m if left_svect is set to all or singular, and ldu >= !> 1 otherwise. !> The leading dimension of U_l. !> @param[in] strideU - rocblas_stride. !> Stride from the start of one matrix U_l to the next one U_(j+1). !> There is no restriction for the value of strideU. !> The normal use case is strideU >= ldu*min(m,n) if left_svect is set to !> singular, !> or strideU >= ldu*m when left_svect is equal to all. !> @param[out] V - pointer to type. Array on the GPU (the size depends on the value of !> strideV). !> The matrices V_l of right singular vectors stored as rows (transposed / !> conjugate-transposed). !> Not referenced if right_svect is set to none. !> @param[in] ldv - rocblas_int. ldv >= n if right_svect is set to all, and ldv >= min(m,n) if !> right_svect is !> set to singular, or ldv >= 1 otherwise. !> The leading dimension of V. !> @param[in] strideV - rocblas_stride. !> Stride from the start of one matrix V_l to the next one V_(j+1). !> There is no restriction for the value of strideV. !> The normal use case is strideV >= ldv*n. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info[l] = 0, successful exit. If info[l] = 1, the algorithm did not !> converge. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgesvdj_strided_batched function rocsolver_sgesvdj_strided_batched_(handle,left_svect,right_svect,m,n,A,lda,strideA, & abstol,residual,max_sweeps,n_sweeps,S,strideS,U,ldu,strideU,V,ldv,strideV,myInfo, & batch_count) & bind(c, name="rocsolver_sgesvdj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvdj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_float),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dgesvdj_strided_batched function rocsolver_dgesvdj_strided_batched_(handle,left_svect,right_svect,m,n,A,lda,strideA, & abstol,residual,max_sweeps,n_sweeps,S,strideS,U,ldu,strideU,V,ldv,strideV,myInfo, & batch_count) & bind(c, name="rocsolver_dgesvdj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvdj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_double),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_cgesvdj_strided_batched function rocsolver_cgesvdj_strided_batched_(handle,left_svect,right_svect,m,n,A,lda,strideA, & abstol,residual,max_sweeps,n_sweeps,S,strideS,U,ldu,strideU,V,ldv,strideV,myInfo, & batch_count) & bind(c, name="rocsolver_cgesvdj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvdj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_float),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zgesvdj_strided_batched function rocsolver_zgesvdj_strided_batched_(handle,left_svect,right_svect,m,n,A,lda,strideA, & abstol,residual,max_sweeps,n_sweeps,S,strideS,U,ldu,strideU,V,ldv,strideV,myInfo, & batch_count) & bind(c, name="rocsolver_zgesvdj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvdj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_double),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The GESVDX functions compute a set of singular values and optionally the !> corresponding singular !> vectors of a general ``m``-by-``n`` matrix ``A`` (partial Singular Value Decomposition). !> !> \details !> This function computes all the singular values of ``A``, all the singular values in the !> half-open interval !> \f$[vl, vu)\f$, or the ``il`` -th through ``iu`` -th singular values, depending on the !> value of ``srange``. !> !> The full SVD of matrix ``A`` is given by: !> !> \f[ !> A = U S V^H !> \f] !> !> where the ``m``-by-``n`` matrix ``S`` is zero except, possibly, for its min(m,n) !> diagonal elements, which are the singular values of ``A``. ``U`` and ``V`` are orthogonal !> (unitary) matrices. The first min(m,n) columns of ``U`` and ``V`` are the left and !> right singular vectors of ``A``, respectively. !> !> The computation of the singular vectors is optional and is controlled by !> the function arguments ``left_svect`` and ``right_svect``, as described below. When !> computed, this function returns the transpose (or transpose conjugate) of the !> right singular vectors, that is, the rows of \f$V^H\f$. !> !> ``left_svect`` and ``right_svect`` are `rocblas_svect` enums that, for this function, can !> take the !> following values: !> !> - ``rocblas_svect_singular``: the singular vectors (first min(m,n) !> columns of ``U`` or rows of \f$V^H\f$) corresponding to the computed singular values are !> computed, !> - ``rocblas_svect_none``: no columns (or rows) of ``U`` (or \f$V^H\f$) are computed, that !> is, !> no singular vectors. !> !> @param[in] handle - rocblas_handle. !> @param[in] left_svect - `rocblas_svect`. !> Specifies if the left singular vectors are computed. !> @param[in] right_svect - `rocblas_svect`. !> Specifies if the right singular vectors are computed. !> @param[in] srange - `rocblas_srange`. !> Specifies the type of range or interval of the singular values to be computed. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of matrix A. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. !> On exit, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= m. !> The leading dimension of A. !> @param[in] vl - real type. 0 <= vl < vu. !> The lower bound of the search interval [vl, vu). Ignored if srange indicates to !> look !> for all the singular values of A or the singular values within a set of !> indices. !> @param[in] vu - real type. 0 <= vl < vu. !> The upper bound of the search interval [vl, vu). Ignored if srange indicates to !> look !> for all the singular values of A or the singular values within a set of !> indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest singular value to be computed. Ignored if srange !> indicates to look !> for all the singular values of A or the singular values in a half-open !> interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest singular value to be computed. Ignored if srange !> indicates to look !> for all the singular values of A or the singular values in a half-open !> interval. !> @param[out] nsv - pointer to a rocblas_int on the GPU. !> The total number of singular values found. If srange is rocblas_srange_all, nsv !> = min(m,n). !> If srange is rocblas_srange_index, nsv = iu - il + 1. Otherwise, 0 <= nsv <= !> min(m,n). !> @param[out] S - pointer to real type. Array on the GPU of dimension nsv. !> The first nsv elements contain the computed singular values in descending !> order. !> - Note: If srange is rocblas_srange_value, then the value of nsv is not known !> in advance. !> In this case, the user should ensure that S is large enough to hold min(m,n) !> values. !> @param[out] U - pointer to type. Array on the GPU of dimension ldu*nsv. !> The matrix of left singular vectors stored as columns. Not !> referenced if left_svect is set to none. !> - Note: If srange is rocblas_srange_value, then the value of nsv is not known !> in advance. !> In this case, the user should ensure that U is large enough to hold min(m,n) !> columns. !> @param[in] ldu - rocblas_int. ldu >= m if left_svect singular, and ldu >= 1 otherwise. !> The leading dimension of U. !> @param[out] V - pointer to type. Array on the GPU of dimension ldv*n. !> The matrix of right singular vectors stored as rows (transposed / !> conjugate-transposed). !> Not referenced if right_svect is set to none. !> @param[in] ldv - rocblas_int. ldv >= nsv if right_svect is set to singular, or ldv >= 1 !> otherwise. !> The leading dimension of V. !> Note: If srange is rocblas_srange_value, then the value of nsv is not known in !> advance. !> In this case, the user should ensure that V is large enough to hold min(m,n) !> rows. !> @param[out] ifail - pointer to rocblas_int. Array on the GPU of dimension min(m,n). !> If info = 0, the first nsv elements of ifail are zero. !> Otherwise, contains the indices of those eigenvectors that failed !> to converge, as returned by \ref rocsolver_sbdsvdx "BDSVDX". !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, i eigenvectors did not converge in \ref rocsolver_sbdsvdx !> "BDSVDX". Their !> indices are stored in ifail. interface rocsolver_sgesvdx function rocsolver_sgesvdx_(handle,left_svect,right_svect,srange,m,n,A,lda,vl,vu,il,iu,nsv,S, & U,ldu,V,ldv,ifail,myInfo) & bind(c, name="rocsolver_sgesvdx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvdx_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(kind(rocblas_srange_all)),value :: srange integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nsv type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: ifail type(c_ptr),value :: myInfo end function end interface interface rocsolver_dgesvdx function rocsolver_dgesvdx_(handle,left_svect,right_svect,srange,m,n,A,lda,vl,vu,il,iu,nsv,S, & U,ldu,V,ldv,ifail,myInfo) & bind(c, name="rocsolver_dgesvdx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvdx_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(kind(rocblas_srange_all)),value :: srange integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nsv type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: ifail type(c_ptr),value :: myInfo end function end interface interface rocsolver_cgesvdx function rocsolver_cgesvdx_(handle,left_svect,right_svect,srange,m,n,A,lda,vl,vu,il,iu,nsv,S, & U,ldu,V,ldv,ifail,myInfo) & bind(c, name="rocsolver_cgesvdx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvdx_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(kind(rocblas_srange_all)),value :: srange integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nsv type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: ifail type(c_ptr),value :: myInfo end function end interface interface rocsolver_zgesvdx function rocsolver_zgesvdx_(handle,left_svect,right_svect,srange,m,n,A,lda,vl,vu,il,iu,nsv,S, & U,ldu,V,ldv,ifail,myInfo) & bind(c, name="rocsolver_zgesvdx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvdx_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(kind(rocblas_srange_all)),value :: srange integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nsv type(c_ptr),value :: S type(c_ptr),value :: U integer(c_int),value :: ldu type(c_ptr),value :: V integer(c_int),value :: ldv type(c_ptr),value :: ifail type(c_ptr),value :: myInfo end function end interface !> \brief The GESVDX_BATCHED functions compute a set of singular values and optionally the !> corresponding singular !> vectors of a batch of general ``m`` -by-``n`` matrices \f$A_l\f$ (partial Singular Value !> Decomposition). !> !> \details !> This function computes all the singular values of \f$A_l\f$, all the singular values in the !> half-open interval !> \f$[vl, vu)\f$, or the ``il`` -th through ``iu`` -th singular values, depending on the !> value of ``srange``. !> !> The full SVD of matrix \f$A_l\f$ is given by: !> !> \f[ !> A_l = U_l S_l V_l^H !> \f] !> !> where the ``m``-by-``n`` matrix \f$S_l\f$ is zero except, possibly, for its min(m,n) !> diagonal elements, which are the singular values of \f$A_l\f$. \f$U_l\f$ and \f$V_l\f$ are !> orthogonal !> (unitary) matrices. The first min(m,n) columns of \f$U_l\f$ and \f$V_l\f$ are the left and !> right singular vectors of \f$A_l\f$, respectively. !> !> The computation of the singular vectors is optional and is controlled by !> the function arguments ``left_svect`` and ``right_svect`` as described below. When !> computed, this function returns the transpose (or transpose conjugate) of the !> right singular vectors, that is, the rows of \f$V_l^H\f$. !> !> ``left_svect`` and ``right_svect`` are `rocblas_svect` enums that, for this function, can !> take the !> following values: !> !> - ``rocblas_svect_singular``: the singular vectors (first min(m,n) !> columns of \f$U_l\f$ or rows of \f$V_l^H\f$ ) corresponding to the computed singular !> values are computed, !> - ``rocblas_svect_none``: no columns (or rows) of \f$U_l\f$ (or \f$V_l^H\f$ ) are computed, !> that is, !> no singular vectors. !> !> @param[in] handle - rocblas_handle. !> @param[in] left_svect - `rocblas_svect`. !> Specifies if the left singular vectors are computed. !> @param[in] right_svect - `rocblas_svect`. !> Specifies if the right singular vectors are computed. !> @param[in] srange - `rocblas_srange`. !> Specifies the type of range or interval of the singular values to be computed. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of matrix A_l. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of matrix A_l. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. !> On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= m. !> The leading dimension of A_l. !> @param[in] vl - real type. 0 <= vl < vu. !> The lower bound of the search interval [vl, vu). Ignored if srange indicates to !> look !> for all the singular values of A_l or the singular values within a set of !> indices. !> @param[in] vu - real type. 0 <= vl < vu. !> The upper bound of the search interval [vl, vu). Ignored if srange indicates to !> look !> for all the singular values of A_l or the singular values within a set of !> indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest singular value to be computed. Ignored if srange !> indicates to look !> for all the singular values of A_l or the singular values in a half-open !> interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest singular value to be computed. Ignored if srange !> indicates to look !> for all the singular values of A_l or the singular values in a half-open !> interval. !> @param[out] nsv - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The total number of singular values found. If srange is rocblas_srange_all, !> nsv[l] = min(m,n). !> If srange is rocblas_srange_index, nsv[l] = iu - il + 1. Otherwise, 0 <= nsv[l] !> <= min(m,n). !> @param[out] S - pointer to real type. Array on the GPU (the size depends on the value of !> strideS). !> The first nsv_l elements contain the computed singular values in descending !> order. !> (The remaining elements can be used as workspace for internal computations.) !> @param[in] strideS - rocblas_stride. !> Stride from the start of one vector S_l to the next one S_(l+1). !> There is no restriction for the value of strideS. The normal use case is !> strideS >= nsv_l. !> - Note: If srange is rocblas_srange_value, then the value of nsv_l is not known !> in advance. !> In this case, the user should ensure that S_l is large enough to hold min(m,n) !> values. !> @param[out] U - pointer to type. Array on the GPU (the size depends on the value of !> strideU). !> The matrix U_l of left singular vectors stored as columns. Not !> referenced if left_svect is set to none. !> @param[in] ldu - rocblas_int. ldu >= m if left_svect singular, and ldu >= 1 otherwise. !> The leading dimension of U_l. !> @param[in] strideU - rocblas_stride. !> Stride from the start of one matrix U_l to the next one U_(l+1). !> There is no restriction for the value of strideU. The normal use case is !> strideU >= ldu*nsv_l. !> - Note: If srange is rocblas_srange_value, then the value of nsv_l is not known !> in advance. !> In this case, the user should ensure that U_l is large enough to hold min(m,n) !> columns. !> @param[out] V - pointer to type. Array on the GPU (the size depends on the value of !> strideV). !> The matrix V_l of right singular vectors stored as rows (transposed / !> conjugate-transposed). !> Not referenced if right_svect is set to none. !> @param[in] ldv - rocblas_int. ldv >= nsv_l if right_svect is set to singular, or ldv >= 1 !> otherwise. !> The leading dimension of V_l. !> - Note: If srange is rocblas_srange_value, then the value of nsv_l is not known !> in advance. !> In this case, the user should ensure that V_l is large enough to hold min(m,n) !> rows. !> @param[in] strideV - rocblas_stride. !> Stride from the start of one matrix V_l to the next one V_(l+1). !> There is no restriction for the value of strideV. The normal use case is !> strideV >= ldv*n. !> @param[out] ifail - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideF). !> If info[l] = 0, the first nsv[l] elements of ifail_l are zero. !> Otherwise, contains the indices of those eigenvectors that failed !> to converge, as returned by \ref rocsolver_sbdsvdx "BDSVDX". !> @param[in] strideF - rocblas_stride. !> Stride from the start of one vector ifail_l to the next one ifail_(l+1). !> There is no restriction for the value of strideF. The normal use case is !> strideF >= min(m,n). !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info[l] = 0, successful exit. !> If info[l] = i > 0, i eigenvectors did not converge in \ref rocsolver_sbdsvdx !> "BDSVDX". Their !> indices are stored in ifail_l. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgesvdx_batched function rocsolver_sgesvdx_batched_(handle,left_svect,right_svect,srange,m,n,A,lda,vl,vu,il, & iu,nsv,S,strideS,U,ldu,strideU,V,ldv,strideV,ifail,strideF,myInfo,batch_count) & bind(c, name="rocsolver_sgesvdx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvdx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(kind(rocblas_srange_all)),value :: srange integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nsv type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dgesvdx_batched function rocsolver_dgesvdx_batched_(handle,left_svect,right_svect,srange,m,n,A,lda,vl,vu,il, & iu,nsv,S,strideS,U,ldu,strideU,V,ldv,strideV,ifail,strideF,myInfo,batch_count) & bind(c, name="rocsolver_dgesvdx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvdx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(kind(rocblas_srange_all)),value :: srange integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nsv type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_cgesvdx_batched function rocsolver_cgesvdx_batched_(handle,left_svect,right_svect,srange,m,n,A,lda,vl,vu,il, & iu,nsv,S,strideS,U,ldu,strideU,V,ldv,strideV,ifail,strideF,myInfo,batch_count) & bind(c, name="rocsolver_cgesvdx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvdx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(kind(rocblas_srange_all)),value :: srange integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nsv type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zgesvdx_batched function rocsolver_zgesvdx_batched_(handle,left_svect,right_svect,srange,m,n,A,lda,vl,vu,il, & iu,nsv,S,strideS,U,ldu,strideU,V,ldv,strideV,ifail,strideF,myInfo,batch_count) & bind(c, name="rocsolver_zgesvdx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvdx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(kind(rocblas_srange_all)),value :: srange integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nsv type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The GESVDX_STRIDED_BATCHED functions compute a set of singular values and optionally !> the corresponding singular !> vectors of a batch of general ``m`` -by-``n`` matrices \f$A_l\f$ (partial Singular Value !> Decomposition). !> !> \details !> This function computes all the singular values of \f$A_l\f$, all the singular values in the !> half-open interval !> \f$[vl, vu)\f$, or the ``il`` -th through ``iu`` -th singular values, depending on the !> value of ``srange``. !> !> The full SVD of matrix \f$A_l\f$ is given by: !> !> \f[ !> A_l = U_l S_l V_l^H !> \f] !> !> where the ``m``-by-``n`` matrix \f$S_l\f$ is zero except, possibly, for its min(m,n) !> diagonal elements, which are the singular values of \f$A_l\f$. \f$U_l\f$ and \f$V_l\f$ are !> orthogonal !> (unitary) matrices. The first min(m,n) columns of \f$U_l\f$ and \f$V_l\f$ are the left and !> right singular vectors of \f$A_l\f$, respectively. !> !> The computation of the singular vectors is optional and it is controlled by !> the function arguments ``left_svect`` and ``right_svect``, as described below. When !> computed, this function returns the transpose (or transpose conjugate) of the !> right singular vectors, that is, the rows of \f$V_l^H\f$. !> !> ``left_svect`` and ``right_svect`` are `rocblas_svect` enums that, for this function, can !> take the !> following values: !> !> - ``rocblas_svect_singular``: the singular vectors (first min(m,n) !> columns of \f$U_l\f$ or rows of \f$V_l^H\f$ ) corresponding to the computed singular !> values are computed, !> - ``rocblas_svect_none``: no columns (or rows) of \f$U_l\f$ (or \f$V_l^H\f$ ) are computed, !> that is, !> no singular vectors. !> !> @param[in] handle - rocblas_handle. !> @param[in] left_svect - `rocblas_svect`. !> Specifies if the left singular vectors are computed. !> @param[in] right_svect - `rocblas_svect`. !> Specifies if the right singular vectors are computed. !> @param[in] srange - `rocblas_srange`. !> Specifies the type of range or interval of the singular values to be computed. !> @param[in] m - rocblas_int. m >= 0. !> The number of rows of matrix A_l. !> @param[in] n - rocblas_int. n >= 0. !> The number of columns of matrix A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. !> On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= m. !> The leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[in] vl - real type. 0 <= vl < vu. !> The lower bound of the search interval [vl, vu). Ignored if srange indicates to !> look !> for all the singular values of A_l or the singular values within a set of !> indices. !> @param[in] vu - real type. 0 <= vl < vu. !> The upper bound of the search interval [vl, vu). Ignored if srange indicates to !> look !> for all the singular values of A_l or the singular values within a set of !> indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest singular value to be computed. Ignored if srange !> indicates to look !> for all the singular values of A_l or the singular values in a half-open !> interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest singular value to be computed. Ignored if srange !> indicates to look !> for all the singular values of A_l or the singular values in a half-open !> interval. !> @param[out] nsv - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The total number of singular values found. If srange is rocblas_srange_all, !> nsv[l] = min(m,n). !> If srange is rocblas_srange_index, nsv[l] = iu - il + 1. Otherwise, 0 <= nsv[l] !> <= min(m,n). !> @param[out] S - pointer to real type. Array on the GPU (the size depends on the value of !> strideS). !> The first nsv_l elements contain the computed singular values in descending !> order. !> (The remaining elements can be used as workspace for internal computations.) !> @param[in] strideS - rocblas_stride. !> Stride from the start of one vector S_l to the next one S_(l+1). !> There is no restriction for the value of strideS. The normal use case is !> strideS >= nsv_l. !> - Note: If srange is rocblas_srange_value, then the value of nsv_l is not known !> in advance. !> In this case, the user should ensure that S_l is large enough to hold min(m,n) !> values. !> @param[out] U - pointer to type. Array on the GPU (the size depends on the value of !> strideU). !> The matrix U_l of left singular vectors stored as columns. Not !> referenced if left_svect is set to none. !> @param[in] ldu - rocblas_int. ldu >= m if left_svect singular, and ldu >= 1 otherwise. !> The leading dimension of U_l. !> @param[in] strideU - rocblas_stride. !> Stride from the start of one matrix U_l to the next one U_(l+1). !> There is no restriction for the value of strideU. The normal use case is !> strideU >= ldu*nsv_l. !> - Note: If srange is rocblas_srange_value, then the value of nsv_l is not known !> in advance. !> In this case, the user should ensure that U_l is large enough to hold min(m,n) !> columns. !> @param[out] V - pointer to type. Array on the GPU (the size depends on the value of !> strideV). !> The matrix V_l of right singular vectors stored as rows (transposed / !> conjugate-transposed). !> Not referenced if right_svect is set to none. !> @param[in] ldv - rocblas_int. ldv >= nsv_l if right_svect is set to singular, or ldv >= 1 !> otherwise. !> The leading dimension of V_l. !> - Note: If srange is rocblas_srange_value, then the value of nsv_l is not known !> in advance. !> In this case, the user should ensure that V_l is large enough to hold min(m,n) !> rows. !> @param[in] strideV - rocblas_stride. !> Stride from the start of one matrix V_l to the next one V_(l+1). !> There is no restriction for the value of strideV. The normal use case is !> strideV >= ldv*n. !> @param[out] ifail - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideF). !> If info[l] = 0, the first nsv[l] elements of ifail_l are zero. !> Otherwise, contains the indices of those eigenvectors that failed !> to converge, as returned by \ref rocsolver_sbdsvdx "BDSVDX". !> @param[in] strideF - rocblas_stride. !> Stride from the start of one vector ifail_l to the next one ifail_(l+1). !> There is no restriction for the value of strideF. The normal use case is !> strideF >= min(m,n). !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info[l] = 0, successful exit. !> If info[l] = i > 0, i eigenvectors did not converge in \ref rocsolver_sbdsvdx !> "BDSVDX". Their !> indices are stored in ifail_l. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgesvdx_strided_batched function rocsolver_sgesvdx_strided_batched_(handle,left_svect,right_svect,srange,m,n,A,lda, & strideA,vl,vu,il,iu,nsv,S,strideS,U,ldu,strideU,V,ldv,strideV,ifail,strideF,myInfo, & batch_count) & bind(c, name="rocsolver_sgesvdx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvdx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(kind(rocblas_srange_all)),value :: srange integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nsv type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dgesvdx_strided_batched function rocsolver_dgesvdx_strided_batched_(handle,left_svect,right_svect,srange,m,n,A,lda, & strideA,vl,vu,il,iu,nsv,S,strideS,U,ldu,strideU,V,ldv,strideV,ifail,strideF,myInfo, & batch_count) & bind(c, name="rocsolver_dgesvdx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvdx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(kind(rocblas_srange_all)),value :: srange integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nsv type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_cgesvdx_strided_batched function rocsolver_cgesvdx_strided_batched_(handle,left_svect,right_svect,srange,m,n,A,lda, & strideA,vl,vu,il,iu,nsv,S,strideS,U,ldu,strideU,V,ldv,strideV,ifail,strideF,myInfo, & batch_count) & bind(c, name="rocsolver_cgesvdx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvdx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(kind(rocblas_srange_all)),value :: srange integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nsv type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zgesvdx_strided_batched function rocsolver_zgesvdx_strided_batched_(handle,left_svect,right_svect,srange,m,n,A,lda, & strideA,vl,vu,il,iu,nsv,S,strideS,U,ldu,strideU,V,ldv,strideV,ifail,strideF,myInfo, & batch_count) & bind(c, name="rocsolver_zgesvdx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvdx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_svect_all)),value :: left_svect integer(kind(rocblas_svect_all)),value :: right_svect integer(kind(rocblas_srange_all)),value :: srange integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nsv type(c_ptr),value :: S integer(c_int64_t),value :: strideS type(c_ptr),value :: U integer(c_int),value :: ldu integer(c_int64_t),value :: strideU type(c_ptr),value :: V integer(c_int),value :: ldv integer(c_int64_t),value :: strideV type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The SYTD2 functions compute the tridiagonal form of a real symmetric matrix ``A``. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The tridiagonal form is given by: !> !> \f[ !> T = Q^H A Q !> \f] !> !> where T is symmetric tridiagonal and Q is an orthogonal matrix represented as the product !> of Householder matrices !> !> \f[ !> \begin{array}{cl} !> Q = H(1)H(2)\cdots H(n-1) & \: \text{if uplo indicates lower, or}\\% !> Q = H(n-1)H(n-2)\cdots H(1) & \: \text{if uplo indicates upper.} !> \end{array} !> \f] !> !> Each Householder matrix \f$H(i)\f$ is given by !> !> \f[ !> H(i) = I - \text{tau}[i] \cdot v_i^{} v_i^H !> \f] !> !> where tau[i] is the corresponding Householder scalar. When ``uplo`` indicates ``lower``, !> the first i !> elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i+1] = 1\f$. If ``uplo`` !> indicates ``upper``, !> the last n-i elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix to be factored. !> On exit, if upper, then the elements on the diagonal and superdiagonal !> contain the tridiagonal form T, and the elements above the superdiagonal !> contain !> the first i-1 elements of the Householder vectors v_i stored as columns. !> If lower, then the elements on the diagonal and subdiagonal !> contain the tridiagonal form T, and the elements below the subdiagonal contain !> the last n-i-1 elements of the Householder vectors v_i stored as columns. !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A. !> @param[out] D - pointer to type. Array on the GPU of dimension n. !> The diagonal elements of T. !> @param[out] E - pointer to type. Array on the GPU of dimension n-1. !> The off-diagonal elements of T. !> @param[out] tau - pointer to type. Array on the GPU of dimension n-1. !> The Householder scalars. interface rocsolver_ssytd2 function rocsolver_ssytd2_(handle,uplo,n,A,lda,D,E,tau) bind(c, name="rocsolver_ssytd2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tau end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssytd2_assumed_rank #else module procedure & rocsolver_ssytd2_rank_0,& rocsolver_ssytd2_rank_1,& rocsolver_ssytd2_full_rank #endif #endif end interface interface rocsolver_dsytd2 function rocsolver_dsytd2_(handle,uplo,n,A,lda,D,E,tau) bind(c, name="rocsolver_dsytd2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tau end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsytd2_assumed_rank #else module procedure & rocsolver_dsytd2_rank_0,& rocsolver_dsytd2_rank_1,& rocsolver_dsytd2_full_rank #endif #endif end interface !> \brief The HETD2 functions compute the tridiagonal form of a complex Hermitian matrix !> ``A``. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The tridiagonal form is given by: !> !> \f[ !> T = Q^H A Q !> \f] !> !> where T is Hermitian tridiagonal and Q is an unitary matrix represented as the product !> of Householder matrices !> !> \f[ !> \begin{array}{cl} !> Q = H(1)H(2)\cdots H(n-1) & \: \text{if uplo indicates lower, or}\\% !> Q = H(n-1)H(n-2)\cdots H(1) & \: \text{if uplo indicates upper.} !> \end{array} !> \f] !> !> Each Householder matrix \f$H(i)\f$ is given by !> !> \f[ !> H(i) = I - \text{tau}[i] \cdot v_i^{} v_i^H !> \f] !> !> where tau[i] is the corresponding Householder scalar. When ``uplo`` indicates ``lower``, !> the first i !> elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i+1] = 1\f$. If ``uplo`` !> indicates ``upper``, !> the last n-i elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the Hermitian matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix to be factored. !> On exit, if upper, then the elements on the diagonal and superdiagonal !> contain the tridiagonal form T, and the elements above the superdiagonal !> contain !> the first i-1 elements of the Householders vector v_i stored as columns. !> If lower, then the elements on the diagonal and subdiagonal !> contain the tridiagonal form T, and the elements below the subdiagonal contain !> the last n-i-1 elements of the Householder vectors v_i stored as columns. !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A. !> @param[out] D - pointer to real type. Array on the GPU of dimension n. !> The diagonal elements of T. !> @param[out] E - pointer to real type. Array on the GPU of dimension n-1. !> The off-diagonal elements of T. !> @param[out] tau - pointer to type. Array on the GPU of dimension n-1. !> The Householder scalars. interface rocsolver_chetd2 function rocsolver_chetd2_(handle,uplo,n,A,lda,D,E,tau) bind(c, name="rocsolver_chetd2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetd2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tau end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_chetd2_assumed_rank #else module procedure & rocsolver_chetd2_rank_0,& rocsolver_chetd2_rank_1,& rocsolver_chetd2_full_rank #endif #endif end interface interface rocsolver_zhetd2 function rocsolver_zhetd2_(handle,uplo,n,A,lda,D,E,tau) bind(c, name="rocsolver_zhetd2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tau end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zhetd2_assumed_rank #else module procedure & rocsolver_zhetd2_rank_0,& rocsolver_zhetd2_rank_1,& rocsolver_zhetd2_full_rank #endif #endif end interface !> \brief The SYTD2_BATCHED functions compute the tridiagonal form of a batch of real !> symmetric matrices A_l. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The tridiagonal form of \f$A_l\f$ is given by: !> !> \f[ !> T_l^{} = Q_l^H A_l^{} Q_l^{} !> \f] !> !> where \f$T_l\f$ is symmetric tridiagonal and \f$Q_l\f$ is an orthogonal matrix represented !> as the product !> of Householder matrices !> !> \f[ !> \begin{array}{cl} !> Q_l = H_l(1)H_l(2)\cdots H_l(n-1) & \: \text{if uplo indicates lower, or}\\% !> Q_l = H_l(n-1)H_l(n-2)\cdots H_l(1) & \: \text{if uplo indicates upper.} !> \end{array} !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{tau}_l^{}[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where \f$\text{tau}_l[i]\f$ is the corresponding Householder scalar. When ``uplo`` !> indicates ``lower``, the first i !> elements of the Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i+1] = 1\f$. If !> ``uplo`` indicates ``upper``, !> the last n-i elements of the Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i] = !> 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrix A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A_l is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrices A_l. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l to be factored. !> On exit, if upper, then the elements on the diagonal and superdiagonal !> contain the tridiagonal form T_l, and the elements above the superdiagonal !> contain !> the first i-1 elements of the Householder vectors v_(l_i) stored as columns. !> If lower, then the elements on the diagonal and subdiagonal !> contain the tridiagonal form T_l, and the elements below the subdiagonal !> contain !> the last n-i-1 elements of the Householder vectors v_(l_i) stored as columns. !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A_l. !> @param[out] D - pointer to type. Array on the GPU (the size depends on the value of !> strideD). !> The diagonal elements of T_l. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] E - pointer to type. Array on the GPU (the size depends on the value of !> strideE). !> The off-diagonal elements of T_l. !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= n-1. !> @param[out] tau - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors tau_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector tau_l to the next one tau_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= n-1. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssytd2_batched function rocsolver_ssytd2_batched_(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) & bind(c, name="rocsolver_ssytd2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tau integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssytd2_batched_assumed_rank #else module procedure & rocsolver_ssytd2_batched_rank_0,& rocsolver_ssytd2_batched_rank_1 #endif #endif end interface interface rocsolver_dsytd2_batched function rocsolver_dsytd2_batched_(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) & bind(c, name="rocsolver_dsytd2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tau integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsytd2_batched_assumed_rank #else module procedure & rocsolver_dsytd2_batched_rank_0,& rocsolver_dsytd2_batched_rank_1 #endif #endif end interface !> \brief The HETD2_BATCHED functions compute the tridiagonal form of a batch of complex !> Hermitian matrices A_l. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The tridiagonal form of \f$A_l\f$ is given by: !> !> \f[ !> T_l^{} = Q_l^H A_l^{} Q_l^{} !> \f] !> !> where \f$T_l\f$ is Hermitian tridiagonal and \f$Q_l\f$ is a unitary matrix represented as !> the product !> of Householder matrices !> !> \f[ !> \begin{array}{cl} !> Q_l = H_l(1)H_l(2)\cdots H_l(n-1) & \: \text{if uplo indicates lower, or}\\% !> Q_l = H_l(n-1)H_l(n-2)\cdots H_l(1) & \: \text{if uplo indicates upper.} !> \end{array} !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{tau}_l[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where \f$\text{tau}_l[i]\f$ is the corresponding Householder scalar. When ``uplo`` !> indicates ``lower``, the first i !> elements of the Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i+1] = 1\f$. If !> ``uplo`` indicates ``upper``, !> the last n-i elements of the Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i] = !> 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the Hermitian matrix A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A_l is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrices A_l. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l to be factored. !> On exit, if upper, then the elements on the diagonal and superdiagonal !> contain the tridiagonal form T_l, and the elements above the superdiagonal !> contain !> the first i-1 elements of the Householder vectors v_(l_i) stored as columns. !> If lower, then the elements on the diagonal and subdiagonal !> contain the tridiagonal form T_l, and the elements below the subdiagonal !> contain !> the last n-i-1 elements of the Householder vectors v_(l_i) stored as columns. !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A_l. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> The diagonal elements of T_l. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] E - pointer to real type. Array on the GPU (the size depends on the value of !> strideE). !> The off-diagonal elements of T_l. !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= n-1. !> @param[out] tau - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors tau_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector tau_l to the next one tau_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= n-1. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_chetd2_batched function rocsolver_chetd2_batched_(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) & bind(c, name="rocsolver_chetd2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetd2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tau integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_chetd2_batched_assumed_rank #else module procedure & rocsolver_chetd2_batched_rank_0,& rocsolver_chetd2_batched_rank_1 #endif #endif end interface interface rocsolver_zhetd2_batched function rocsolver_zhetd2_batched_(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) & bind(c, name="rocsolver_zhetd2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tau integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zhetd2_batched_assumed_rank #else module procedure & rocsolver_zhetd2_batched_rank_0,& rocsolver_zhetd2_batched_rank_1 #endif #endif end interface !> \brief The SYTD2_STRIDED_BATCHED functions compute the tridiagonal form of a batch of real !> symmetric matrices A_l. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The tridiagonal form of \f$A_l\f$ is given by: !> !> \f[ !> T_l^{} = Q_l^H A_l^{} Q_l^{} !> \f] !> !> where \f$T_l\f$ is symmetric tridiagonal and \f$Q_l\f$ is an orthogonal matrix represented !> as the product !> of Householder matrices !> !> \f[ !> \begin{array}{cl} !> Q_l = H_l(1)H_l(2)\cdots H_l(n-1) & \: \text{if uplo indicates lower, or}\\% !> Q_l = H_l(n-1)H_l(n-2)\cdots H_l(1) & \: \text{if uplo indicates upper.} !> \end{array} !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{tau}_l[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where \f$\text{tau}_l[i]\f$ is the corresponding Householder scalar. When ``uplo`` !> indicates ``lower``, the first i !> elements of the Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i+1] = 1\f$. If !> ``uplo`` indicates ``upper``, !> the last n-i elements of the Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i] = !> 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrix A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A_l is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrices A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l to be factored. !> On exit, if upper, then the elements on the diagonal and superdiagonal !> contain the tridiagonal form T_l, and the elements above the superdiagonal !> contain !> the first i-1 elements of the Householder vectors v_(l_i) stored as columns. !> If lower, then the elements on the diagonal and subdiagonal !> contain the tridiagonal form T_l, and the elements below the subdiagonal !> contain !> the last n-i-1 elements of the Householder vectors v_(l_i) stored as columns. !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] D - pointer to type. Array on the GPU (the size depends on the value of !> strideD). !> The diagonal elements of T_l. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] E - pointer to type. Array on the GPU (the size depends on the value of !> strideE). !> The off-diagonal elements of T_l. !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= n-1. !> @param[out] tau - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors tau_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector tau_l to the next one tau_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= n-1. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssytd2_strided_batched function rocsolver_ssytd2_strided_batched_(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE, & tau,strideP,batch_count) & bind(c, name="rocsolver_ssytd2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tau integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssytd2_strided_batched_assumed_rank #else module procedure & rocsolver_ssytd2_strided_batched_rank_0,& rocsolver_ssytd2_strided_batched_rank_1,& rocsolver_ssytd2_strided_batched_full_rank #endif #endif end interface interface rocsolver_dsytd2_strided_batched function rocsolver_dsytd2_strided_batched_(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE, & tau,strideP,batch_count) & bind(c, name="rocsolver_dsytd2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tau integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsytd2_strided_batched_assumed_rank #else module procedure & rocsolver_dsytd2_strided_batched_rank_0,& rocsolver_dsytd2_strided_batched_rank_1,& rocsolver_dsytd2_strided_batched_full_rank #endif #endif end interface !> \brief The HETD2_STRIDED_BATCHED functions compute the tridiagonal form of a batch of !> complex Hermitian matrices A_l. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The tridiagonal form of \f$A_l\f$ is given by: !> !> \f[ !> T_l^{} = Q_l^H A_l^{} Q_l^{} !> \f] !> !> where \f$T_l\f$ is Hermitian tridiagonal and \f$Q_l\f$ is a unitary matrix represented as !> the product !> of Householder matrices !> !> \f[ !> \begin{array}{cl} !> Q_l = H_l(1)H_l(2)\cdots H_l(n-1) & \: \text{if uplo indicates lower, or}\\% !> Q_l = H_l(n-1)H_l(n-2)\cdots H_l(1) & \: \text{if uplo indicates upper.} !> \end{array} !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{tau}_l[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where \f$\text{tau}_l[i]\f$ is the corresponding Householder scalar. When ``uplo`` !> indicates ``lower``, the first i !> elements of the Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i+1] = 1\f$. If !> ``uplo`` indicates ``upper``, !> the last n-i elements of the Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i] = !> 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the Hermitian matrix A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A_l is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrices A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l to be factored. !> On exit, if upper, then the elements on the diagonal and superdiagonal !> contain the tridiagonal form T_l, and the elements above the superdiagonal !> contain !> the first i-1 elements of the Householder vectors v_(l_i) stored as columns. !> If lower, then the elements on the diagonal and subdiagonal !> contain the tridiagonal form T_l, and the elements below the subdiagonal !> contain !> the last n-i-1 elements of the Householder vectors v_(l_i) stored as columns. !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> The diagonal elements of T_l. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] E - pointer to real type. Array on the GPU (the size depends on the value of !> strideE). !> The off-diagonal elements of T_l. !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= n-1. !> @param[out] tau - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors tau_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector tau_l to the next one tau_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= n-1. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_chetd2_strided_batched function rocsolver_chetd2_strided_batched_(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE, & tau,strideP,batch_count) & bind(c, name="rocsolver_chetd2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetd2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tau integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_chetd2_strided_batched_assumed_rank #else module procedure & rocsolver_chetd2_strided_batched_rank_0,& rocsolver_chetd2_strided_batched_rank_1,& rocsolver_chetd2_strided_batched_full_rank #endif #endif end interface interface rocsolver_zhetd2_strided_batched function rocsolver_zhetd2_strided_batched_(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE, & tau,strideP,batch_count) & bind(c, name="rocsolver_zhetd2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tau integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zhetd2_strided_batched_assumed_rank #else module procedure & rocsolver_zhetd2_strided_batched_rank_0,& rocsolver_zhetd2_strided_batched_rank_1,& rocsolver_zhetd2_strided_batched_full_rank #endif #endif end interface !> \brief The SYTRD functions compute the tridiagonal form of a real symmetric matrix ``A``. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The tridiagonal form is given by: !> !> \f[ !> T = Q^H A Q !> \f] !> !> where T is symmetric tridiagonal and Q is an orthogonal matrix represented as the product !> of Householder matrices !> !> \f[ !> \begin{array}{cl} !> Q = H(1)H(2)\cdots H_(n-1) & \: \text{if uplo indicates lower, or}\\% !> Q = H(n-1)H(n-2)\cdots H(1) & \: \text{if uplo indicates upper.} !> \end{array} !> \f] !> !> Each Householder matrix \f$H(i)\f$ is given by !> !> \f[ !> H(i) = I - \text{tau}[i] \cdot v_i^{} v_i^H !> \f] !> !> where tau[i] is the corresponding Householder scalar. When ``uplo`` indicates ``lower``, !> the first i !> elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i+1] = 1\f$. If ``uplo`` !> indicates ``upper``, !> the last n-i elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix to be factored. !> On exit, if upper, then the elements on the diagonal and superdiagonal !> contain the tridiagonal form T, and the elements above the superdiagonal !> contain !> the first i-1 elements of the Householder vectors v_i stored as columns. !> If lower, then the elements on the diagonal and subdiagonal !> contain the tridiagonal form T, and the elements below the subdiagonal contain !> the last n-i-1 elements of the Householder vectors v_i stored as columns. !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A. !> @param[out] D - pointer to type. Array on the GPU of dimension n. !> The diagonal elements of T. !> @param[out] E - pointer to type. Array on the GPU of dimension n-1. !> The off-diagonal elements of T. !> @param[out] tau - pointer to type. Array on the GPU of dimension n-1. !> The Householder scalars. interface rocsolver_ssytrd function rocsolver_ssytrd_(handle,uplo,n,A,lda,D,E,tau) bind(c, name="rocsolver_ssytrd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tau end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssytrd_assumed_rank #else module procedure & rocsolver_ssytrd_rank_0,& rocsolver_ssytrd_rank_1,& rocsolver_ssytrd_full_rank #endif #endif end interface interface rocsolver_dsytrd function rocsolver_dsytrd_(handle,uplo,n,A,lda,D,E,tau) bind(c, name="rocsolver_dsytrd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tau end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsytrd_assumed_rank #else module procedure & rocsolver_dsytrd_rank_0,& rocsolver_dsytrd_rank_1,& rocsolver_dsytrd_full_rank #endif #endif end interface !> \brief The HETRD functions compute the tridiagonal form of a complex Hermitian matrix !> ``A``. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The tridiagonal form is given by: !> !> \f[ !> T = Q^H A Q !> \f] !> !> where T is Hermitian tridiagonal and Q is an unitary matrix represented as the product !> of Householder matrices !> !> \f[ !> \begin{array}{cl} !> Q = H(1)H(2)\cdots H(n-1) & \: \text{if uplo indicates lower, or}\\% !> Q = H(n-1)H(n-2)\cdots H(1) & \: \text{if uplo indicates upper.} !> \end{array} !> \f] !> !> Each Householder matrix \f$H(i)\f$ is given by !> !> \f[ !> H(i) = I - \text{tau}[i] \cdot v_i^{} v_i^H !> \f] !> !> where tau[i] is the corresponding Householder scalar. When ``uplo`` indicates ``lower``, !> the first i !> elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i+1] = 1\f$. If ``uplo`` !> indicates ``upper``, !> the last n-i elements of the Householder vector \f$v_i\f$ are zero, and \f$v_i[i] = 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the Hermitian matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix to be factored. !> On exit, if upper, then the elements on the diagonal and superdiagonal !> contain the tridiagonal form T, and the elements above the superdiagonal !> contain !> the first i-1 elements of the Householder vectors v_i stored as columns. !> If lower, then the elements on the diagonal and subdiagonal !> contain the tridiagonal form T, and the elements below the subdiagonal contain !> the last n-i-1 elements of the Householder vectors v_i stored as columns. !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A. !> @param[out] D - pointer to real type. Array on the GPU of dimension n. !> The diagonal elements of T. !> @param[out] E - pointer to real type. Array on the GPU of dimension n-1. !> The off-diagonal elements of T. !> @param[out] tau - pointer to type. Array on the GPU of dimension n-1. !> The Householder scalars. interface rocsolver_chetrd function rocsolver_chetrd_(handle,uplo,n,A,lda,D,E,tau) bind(c, name="rocsolver_chetrd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetrd_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tau end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_chetrd_assumed_rank #else module procedure & rocsolver_chetrd_rank_0,& rocsolver_chetrd_rank_1,& rocsolver_chetrd_full_rank #endif #endif end interface interface rocsolver_zhetrd function rocsolver_zhetrd_(handle,uplo,n,A,lda,D,E,tau) bind(c, name="rocsolver_zhetrd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: tau end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zhetrd_assumed_rank #else module procedure & rocsolver_zhetrd_rank_0,& rocsolver_zhetrd_rank_1,& rocsolver_zhetrd_full_rank #endif #endif end interface !> \brief The SYTRD_BATCHED functions compute the tridiagonal form of a batch of real !> symmetric matrices A_l. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The tridiagonal form of \f$A_l\f$ is given by: !> !> \f[ !> T_l^{} = Q_l^H A_l^{} Q_l^{} !> \f] !> !> where \f$T_l\f$ is symmetric tridiagonal and \f$Q_l\f$ is an orthogonal matrix represented !> as the product !> of Householder matrices !> !> \f[ !> \begin{array}{cl} !> Q_l = H_l(1)H_l(2)\cdots H_l(n-1) & \: \text{if uplo indicates lower, or}\\% !> Q_l = H_l(n-1)H_l(n-2)\cdots H_l(1) & \: \text{if uplo indicates upper.} !> \end{array} !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{tau}_l[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where \f$\text{tau}_l[i]\f$ is the corresponding Householder scalar. When ``uplo`` !> indicates ``lower``, the first i !> elements of the Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i+1] = 1\f$. If !> ``uplo`` indicates ``upper``, !> the last n-i elements of the Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i] = !> 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrix A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A_l is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrices A_l. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l to be factored. !> On exit, if upper, then the elements on the diagonal and superdiagonal !> contain the tridiagonal form T_l, and the elements above the superdiagonal !> contain !> the first i-1 elements of the Householder vectors v_(l_i) stored as columns. !> If lower, then the elements on the diagonal and subdiagonal !> contain the tridiagonal form T_l, and the elements below the subdiagonal !> contain !> the last n-i-1 elements of the Householder vectors v_(l_i) stored as columns. !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A_l. !> @param[out] D - pointer to type. Array on the GPU (the size depends on the value of !> strideD). !> The diagonal elements of T_l. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] E - pointer to type. Array on the GPU (the size depends on the value of !> strideE). !> The off-diagonal elements of T_l. !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= n-1. !> @param[out] tau - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors tau_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector tau_l to the next one tau_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= n-1. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssytrd_batched function rocsolver_ssytrd_batched_(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) & bind(c, name="rocsolver_ssytrd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tau integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssytrd_batched_assumed_rank #else module procedure & rocsolver_ssytrd_batched_rank_0,& rocsolver_ssytrd_batched_rank_1 #endif #endif end interface interface rocsolver_dsytrd_batched function rocsolver_dsytrd_batched_(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) & bind(c, name="rocsolver_dsytrd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tau integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsytrd_batched_assumed_rank #else module procedure & rocsolver_dsytrd_batched_rank_0,& rocsolver_dsytrd_batched_rank_1 #endif #endif end interface !> \brief The HETRD_BATCHED functions compute the tridiagonal form of a batch of complex !> Hermitian matrices A_l. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The tridiagonal form of \f$A_l\f$ is given by: !> !> \f[ !> T_l^{} = Q_l^H A_l^{} Q_l^{} !> \f] !> !> where \f$T_l\f$ is Hermitian tridiagonal and \f$Q_l\f$ is a unitary matrix represented as !> the product !> of Householder matrices !> !> \f[ !> \begin{array}{cl} !> Q_l = H_l(1)H_l(2)\cdots H_l(n-1) & \: \text{if uplo indicates lower, or}\\% !> Q_l = H_l(n-1)H_l(n-2)\cdots H_l(1) & \: \text{if uplo indicates upper.} !> \end{array} !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{tau}_l[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where \f$\text{tau}_l[i]\f$ is the corresponding Householder scalar. When ``uplo`` !> indicates ``lower``, the first i !> elements of the Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i+1] = 1\f$. If !> ``uplo`` indicates ``upper``, !> the last n-i elements of the Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i] = !> 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the Hermitian matrix A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A_l is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrices A_l. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l to be factored. !> On exit, if upper, then the elements on the diagonal and superdiagonal !> contain the tridiagonal form T_l, and the elements above the superdiagonal !> contain !> the first i-1 elements of the Householder vectors v_(l_i) stored as columns. !> If lower, then the elements on the diagonal and subdiagonal !> contain the tridiagonal form T_l, and the elements below the subdiagonal !> contain !> the last n-i-1 elements of the Householder vectors v_(l_i) stored as columns. !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A_l. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> The diagonal elements of T_l. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] E - pointer to real type. Array on the GPU (the size depends on the value of !> strideE). !> The off-diagonal elements of T_l. !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= n-1. !> @param[out] tau - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors tau_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector tau_l to the next one tau_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= n-1. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_chetrd_batched function rocsolver_chetrd_batched_(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) & bind(c, name="rocsolver_chetrd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetrd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tau integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_chetrd_batched_assumed_rank #else module procedure & rocsolver_chetrd_batched_rank_0,& rocsolver_chetrd_batched_rank_1 #endif #endif end interface interface rocsolver_zhetrd_batched function rocsolver_zhetrd_batched_(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) & bind(c, name="rocsolver_zhetrd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tau integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zhetrd_batched_assumed_rank #else module procedure & rocsolver_zhetrd_batched_rank_0,& rocsolver_zhetrd_batched_rank_1 #endif #endif end interface !> \brief The SYTRD_STRIDED_BATCHED functions compute the tridiagonal form of a batch of real !> symmetric matrices A_l. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The tridiagonal form of \f$A_l\f$ is given by: !> !> \f[ !> T_l^{} = Q_l^H A_l^{} Q_l^{} !> \f] !> !> where \f$T_l\f$ is symmetric tridiagonal and \f$Q_l\f$ is an orthogonal matrix represented !> as the product !> of Householder matrices !> !> \f[ !> \begin{array}{cl} !> Q_l = H_l(1)H_l(2)\cdots H_l(n-1) & \: \text{if uplo indicates lower, or}\\% !> Q_l = H_l(n-1)H_l(n-2)\cdots H_l(1) & \: \text{if uplo indicates upper.} !> \end{array} !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{tau}_l[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where \f$\text{tau}_l[i]\f$ is the corresponding Householder scalar. When ``uplo`` !> indicates ``lower``, the first i !> elements of the Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i+1] = 1\f$. If !> ``uplo`` indicates ``upper``, !> the last n-i elements of the Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i] = !> 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrix A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A_l is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrices A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l to be factored. !> On exit, if upper, then the elements on the diagonal and superdiagonal !> contain the tridiagonal form T_l, and the elements above the superdiagonal !> contain !> the first i-1 elements of the Householder vectors v_(l_i) stored as columns. !> If lower, then the elements on the diagonal and subdiagonal !> contain the tridiagonal form T_l, and the elements below the subdiagonal !> contain !> the last n-i-1 elements of the Householder vectors v_(l_i) stored as columns. !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] D - pointer to type. Array on the GPU (the size depends on the value of !> strideD). !> The diagonal elements of T_l. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] E - pointer to type. Array on the GPU (the size depends on the value of !> strideE). !> The off-diagonal elements of T_l. !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= n-1. !> @param[out] tau - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors tau_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector tau_l to the next one tau_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= n-1. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssytrd_strided_batched function rocsolver_ssytrd_strided_batched_(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE, & tau,strideP,batch_count) & bind(c, name="rocsolver_ssytrd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tau integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssytrd_strided_batched_assumed_rank #else module procedure & rocsolver_ssytrd_strided_batched_rank_0,& rocsolver_ssytrd_strided_batched_rank_1,& rocsolver_ssytrd_strided_batched_full_rank #endif #endif end interface interface rocsolver_dsytrd_strided_batched function rocsolver_dsytrd_strided_batched_(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE, & tau,strideP,batch_count) & bind(c, name="rocsolver_dsytrd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tau integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsytrd_strided_batched_assumed_rank #else module procedure & rocsolver_dsytrd_strided_batched_rank_0,& rocsolver_dsytrd_strided_batched_rank_1,& rocsolver_dsytrd_strided_batched_full_rank #endif #endif end interface !> \brief The HETRD_STRIDED_BATCHED functions compute the tridiagonal form of a batch of !> complex Hermitian matrices A_l. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The tridiagonal form of \f$A_l\f$ is given by: !> !> \f[ !> T_l^{} = Q_l^H A_l^{} Q_l^{} !> \f] !> !> where \f$T_l\f$ is Hermitian tridiagonal and \f$Q_l\f$ is a unitary matrix represented as !> the product !> of Householder matrices !> !> \f[ !> \begin{array}{cl} !> Q_l = H_l(1)H_l(2)\cdots H_l(n-1) & \: \text{if uplo indicates lower, or}\\% !> Q_l = H_l(n-1)H_l(n-2)\cdots H_l(1) & \: \text{if uplo indicates upper.} !> \end{array} !> \f] !> !> Each Householder matrix \f$H_l(i)\f$ is given by !> !> \f[ !> H_l^{}(i) = I - \text{tau}_l[i] \cdot v_{l_i}^{} v_{l_i}^H !> \f] !> !> where \f$\text{tau}_l[i]\f$ is the corresponding Householder scalar. When ``uplo`` !> indicates ``lower``, the first i !> elements of the Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i+1] = 1\f$. If !> ``uplo`` indicates ``upper``, !> the last n-i elements of the Householder vector \f$v_{l_i}\f$ are zero, and \f$v_{l_i}[i] = !> 1\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the Hermitian matrix A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A_l is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrices A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l to be factored. !> On exit, if upper, then the elements on the diagonal and superdiagonal !> contain the tridiagonal form T_l, and the elements above the superdiagonal !> contain !> the first i-1 elements of the Householder vectors v_(l_i) stored as columns. !> If lower, then the elements on the diagonal and subdiagonal !> contain the tridiagonal form T_l, and the elements below the subdiagonal !> contain !> the last n-i-1 elements of the Householder vectors v_(l_i) stored as columns. !> @param[in] lda - rocblas_int. lda >= n. !> The leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> The diagonal elements of T_l. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] E - pointer to real type. Array on the GPU (the size depends on the value of !> strideE). !> The off-diagonal elements of T_l. !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= n-1. !> @param[out] tau - pointer to type. Array on the GPU (the size depends on the value of !> strideP). !> Contains the vectors tau_l of corresponding Householder scalars. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector tau_l to the next one tau_(l+1). !> There is no restriction for the value !> of strideP. Normal usage is strideP >= n-1. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_chetrd_strided_batched function rocsolver_chetrd_strided_batched_(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE, & tau,strideP,batch_count) & bind(c, name="rocsolver_chetrd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetrd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tau integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_chetrd_strided_batched_assumed_rank #else module procedure & rocsolver_chetrd_strided_batched_rank_0,& rocsolver_chetrd_strided_batched_rank_1,& rocsolver_chetrd_strided_batched_full_rank #endif #endif end interface interface rocsolver_zhetrd_strided_batched function rocsolver_zhetrd_strided_batched_(handle,uplo,n,A,lda,strideA,D,strideD,E,strideE, & tau,strideP,batch_count) & bind(c, name="rocsolver_zhetrd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: tau integer(c_int64_t),value :: strideP integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zhetrd_strided_batched_assumed_rank #else module procedure & rocsolver_zhetrd_strided_batched_rank_0,& rocsolver_zhetrd_strided_batched_rank_1,& rocsolver_zhetrd_strided_batched_full_rank #endif #endif end interface !> \brief The SYGS2 functions reduce a real symmetric-definite generalized eigenproblem to !> standard !> form. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A X = \lambda B X & \: \text{1st form,}\\% !> A B X = \lambda X & \: \text{2nd form, or}\\% !> B A X = \lambda X & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. !> !> If the problem is of the first form, then ``A`` is overwritten with !> !> \f[ !> \begin{array}{cl} !> U^{-T} A U^{-1}, & \: \text{or}\\% !> L^{-1} A L^{-T}, !> \end{array} !> \f] !> !> where the symmetric-definite matrix ``B`` has been factorized as either \f$U^T U\f$ or !> \f$L L^T\f$, as returned by \ref rocsolver_spotrf "POTRF", depending on the value of !> ``uplo``. !> !> If the problem is of the second or third form, then ``A`` is overwritten with !> !> \f[ !> \begin{array}{cl} !> U A U^T, & \: \text{or}\\% !> L^T A L, !> \end{array} !> \f] !> !> also depending on the value of ``uplo``. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblem. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrix A is stored, and !> whether the factorization applied to B was upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) parts of A and !> B are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the transformed matrix associated with !> the equivalent standard eigenvalue problem. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] B - pointer to type. Array on the GPU of dimension ldb*n. !> The triangular factor of the matrix B, as returned by \ref rocsolver_spotrf !> "POTRF". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B. interface rocsolver_ssygs2 function rocsolver_ssygs2_(handle,itype,uplo,n,A,lda,B,ldb) bind(c, name="rocsolver_ssygs2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssygs2_assumed_rank #else module procedure & rocsolver_ssygs2_rank_0,& rocsolver_ssygs2_rank_1,& rocsolver_ssygs2_full_rank #endif #endif end interface interface rocsolver_dsygs2 function rocsolver_dsygs2_(handle,itype,uplo,n,A,lda,B,ldb) bind(c, name="rocsolver_dsygs2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsygs2_assumed_rank #else module procedure & rocsolver_dsygs2_rank_0,& rocsolver_dsygs2_rank_1,& rocsolver_dsygs2_full_rank #endif #endif end interface !> \brief The HEGS2 functions reduce a Hermitian-definite generalized eigenproblem to standard !> form. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A X = \lambda B X & \: \text{1st form,}\\% !> A B X = \lambda X & \: \text{2nd form, or}\\% !> B A X = \lambda X & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. !> !> If the problem is of the first form, then ``A`` is overwritten with !> !> \f[ !> \begin{array}{cl} !> U^{-H} A U^{-1}, & \: \text{or}\\% !> L^{-1} A L^{-H}, !> \end{array} !> \f] !> !> where the Hermitian-definite matrix ``B`` has been factorized as either \f$U^H U\f$ or !> \f$L L^H\f$, as returned by \ref rocsolver_spotrf "POTRF", depending on the value of !> ``uplo``. !> !> If the problem is of the second or third form, then ``A`` is overwritten with !> !> \f[ !> \begin{array}{cl} !> U A U^H, & \: \text{or}\\% !> L^H A L, !> \end{array} !> \f] !> !> also depending on the value of ``uplo``. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblem. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrix A is stored, and !> whether the factorization applied to B was upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) parts of A and !> B are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the transformed matrix associated with !> the equivalent standard eigenvalue problem. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] B - pointer to type. Array on the GPU of dimension ldb*n. !> The triangular factor of the matrix B, as returned by \ref rocsolver_spotrf !> "POTRF". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B. interface rocsolver_chegs2 function rocsolver_chegs2_(handle,itype,uplo,n,A,lda,B,ldb) bind(c, name="rocsolver_chegs2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegs2_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_chegs2_assumed_rank #else module procedure & rocsolver_chegs2_rank_0,& rocsolver_chegs2_rank_1,& rocsolver_chegs2_full_rank #endif #endif end interface interface rocsolver_zhegs2 function rocsolver_zhegs2_(handle,itype,uplo,n,A,lda,B,ldb) bind(c, name="rocsolver_zhegs2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zhegs2_assumed_rank #else module procedure & rocsolver_zhegs2_rank_0,& rocsolver_zhegs2_rank_1,& rocsolver_zhegs2_full_rank #endif #endif end interface !> \brief The SYGS2_BATCHED functions reduce a batch of real symmetric-definite generalized !> eigenproblems !> to standard form. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. !> !> If the problem is of the first form, then \f$A_l\f$ is overwritten with !> !> \f[ !> \begin{array}{cl} !> U_l^{-T} A_l^{} U_l^{-1}, & \: \text{or}\\% !> L_l^{-1} A_l^{} L_l^{-T}, !> \end{array} !> \f] !> !> where the symmetric-definite matrix \f$B_l\f$ has been factorized as either \f$U_l^T !> U_l^{}\f$ or !> \f$L_l^{} L_l^T\f$, as returned by \ref rocsolver_spotrf "POTRF", depending on the value of !> ``uplo``. !> !> If the problem is of the second or third form, then ``A`` is overwritten with !> !> \f[ !> \begin{array}{cl} !> U_l^{} A_l^{} U_l^T, & \: \text{or}\\% !> L_l^T A_l^{} L_l^{}, !> \end{array} !> \f] !> !> also depending on the value of ``uplo``. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrices A_l are stored, and !> whether the factorization applied to B_l was upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) parts of A_l and !> B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the transformed matrices associated with !> the equivalent standard eigenvalue problems. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[out] B - array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*n. !> The triangular factors of the matrices B_l, as returned by \ref !> rocsolver_spotrf_batched "POTRF_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssygs2_batched function rocsolver_ssygs2_batched_(handle,itype,uplo,n,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_ssygs2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function end interface interface rocsolver_dsygs2_batched function rocsolver_dsygs2_batched_(handle,itype,uplo,n,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_dsygs2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function end interface !> \brief The HEGS2_BATCHED functions reduce a batch of Hermitian-definite generalized !> eigenproblems to !> standard form. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. !> !> If the problem is of the first form, then \f$A_l\f$ is overwritten with !> !> \f[ !> \begin{array}{cl} !> U_l^{-H} A_l^{} U_l^{-1}, & \: \text{or}\\% !> L_l^{-1} A_l^{} L_l^{-H}, !> \end{array} !> \f] !> !> where the Hermitian-definite matrix \f$B_l\f$ has been factorized as either \f$U_l^H !> U_l^{}\f$ or !> \f$L_l^{} L_l^H\f$, as returned by \ref rocsolver_spotrf "POTRF", depending on the value of !> ``uplo``. !> !> If the problem is of the second or third form, then ``A`` is overwritten with !> !> \f[ !> \begin{array}{cl} !> U_l^{} A_l^{} U_l^H, & \: \text{or}\\% !> L_l^H A_l^{} L_l^{}, !> \end{array} !> \f] !> !> also depending on the value of ``uplo``. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrices A_l are stored, and !> whether the factorization applied to B_l was upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) parts of A_l and !> B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the transformed matrices associated with !> the equivalent standard eigenvalue problems. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[out] B - array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*n. !> The triangular factors of the matrices B_l, as returned by \ref !> rocsolver_spotrf_batched "POTRF_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_chegs2_batched function rocsolver_chegs2_batched_(handle,itype,uplo,n,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_chegs2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegs2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function end interface interface rocsolver_zhegs2_batched function rocsolver_zhegs2_batched_(handle,itype,uplo,n,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_zhegs2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function end interface !> \brief The SYGS2_STRIDED_BATCHED functions reduce a batch of real symmetric-definite !> generalized !> eigenproblems to standard form. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. !> !> If the problem is of the first form, then \f$A_l\f$ is overwritten with !> !> \f[ !> \begin{array}{cl} !> U_l^{-T} A_l^{} U_l^{-1}, & \: \text{or}\\% !> L_l^{-1} A_l^{} L_l^{-T}, !> \end{array} !> \f] !> !> where the symmetric-definite matrix \f$B_l\f$ has been factorized as either \f$U_l^T !> U_l^{}\f$ or !> \f$L_l^{} L_l^T\f$, as returned by \ref rocsolver_spotrf "POTRF", depending on the value of !> ``uplo``. !> !> If the problem is of the second or third form, then ``A`` is overwritten with !> !> \f[ !> \begin{array}{cl} !> U_l^{} A_l^{} U_l^T, & \: \text{or}\\% !> L_l^T A_l^{} L_l^{}, !> \end{array} !> \f] !> !> also depending on the value of ``uplo``. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrices A_l are stored, and !> whether the factorization applied to B_l was upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) parts of A_l and !> B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the transformed matrices associated with !> the equivalent standard eigenvalue problems. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> The triangular factors of the matrices B_l, as returned by \ref !> rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. The normal use case is !> strideB >= ldb*n. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssygs2_strided_batched function rocsolver_ssygs2_strided_batched_(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB, & batch_count) & bind(c, name="rocsolver_ssygs2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssygs2_strided_batched_assumed_rank #else module procedure & rocsolver_ssygs2_strided_batched_rank_0,& rocsolver_ssygs2_strided_batched_rank_1,& rocsolver_ssygs2_strided_batched_full_rank #endif #endif end interface interface rocsolver_dsygs2_strided_batched function rocsolver_dsygs2_strided_batched_(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB, & batch_count) & bind(c, name="rocsolver_dsygs2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsygs2_strided_batched_assumed_rank #else module procedure & rocsolver_dsygs2_strided_batched_rank_0,& rocsolver_dsygs2_strided_batched_rank_1,& rocsolver_dsygs2_strided_batched_full_rank #endif #endif end interface !> \brief The HEGS2_STRIDED_BATCHED functions reduce a batch of Hermitian-definite generalized !> eigenproblems to standard form. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. !> !> If the problem is of the first form, then \f$A_l\f$ is overwritten with !> !> \f[ !> \begin{array}{cl} !> U_l^{-H} A_l^{} U_l^{-1}, & \: \text{or}\\% !> L_l^{-1} A_l^{} L_l^{-H}, !> \end{array} !> \f] !> !> where the Hermitian-definite matrix \f$B_l\f$ has been factorized as either \f$U_l^H !> U_l^{}\f$ or !> \f$L_l^{} L_l^H\f$, as returned by \ref rocsolver_spotrf "POTRF", depending on the value of !> ``uplo``. !> !> If the problem is of the second or third form, then ``A`` is overwritten with !> !> \f[ !> \begin{array}{cl} !> U_l^{} A_l^{} U_l^H, & \: \text{or}\\% !> L_l^H A_l^{} L_l^{}, !> \end{array} !> \f] !> !> also depending on the value of ``uplo``. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrices A_l are stored, and !> whether the factorization applied to B_l was upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) parts of A_l and !> B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the transformed matrices associated with !> the equivalent standard eigenvalue problems. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> The triangular factors of the matrices B_l, as returned by \ref !> rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. The normal use case is !> strideB >= ldb*n. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_chegs2_strided_batched function rocsolver_chegs2_strided_batched_(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB, & batch_count) & bind(c, name="rocsolver_chegs2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegs2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_chegs2_strided_batched_assumed_rank #else module procedure & rocsolver_chegs2_strided_batched_rank_0,& rocsolver_chegs2_strided_batched_rank_1,& rocsolver_chegs2_strided_batched_full_rank #endif #endif end interface interface rocsolver_zhegs2_strided_batched function rocsolver_zhegs2_strided_batched_(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB, & batch_count) & bind(c, name="rocsolver_zhegs2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zhegs2_strided_batched_assumed_rank #else module procedure & rocsolver_zhegs2_strided_batched_rank_0,& rocsolver_zhegs2_strided_batched_rank_1,& rocsolver_zhegs2_strided_batched_full_rank #endif #endif end interface !> \brief The SYGST functions reduce a real symmetric-definite generalized eigenproblem to !> standard !> form. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A X = \lambda B X & \: \text{1st form,}\\% !> A B X = \lambda X & \: \text{2nd form, or}\\% !> B A X = \lambda X & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. !> !> If the problem is of the first form, then ``A`` is overwritten with !> !> \f[ !> \begin{array}{cl} !> U^{-T} A U^{-1}, & \: \text{or}\\% !> L^{-1} A L^{-T}, !> \end{array} !> \f] !> !> where the symmetric-definite matrix ``B`` has been factorized as either \f$U^T U\f$ or !> \f$L L^T\f$ as returned by \ref rocsolver_spotrf "POTRF", depending on the value of !> ``uplo``. !> !> If the problem is of the second or third form, then ``A`` is overwritten with !> !> \f[ !> \begin{array}{cl} !> U A U^T, & \: \text{or}\\% !> L^T A L, !> \end{array} !> \f] !> !> also depending on the value of ``uplo``. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblem. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrix A is stored, and !> whether the factorization applied to B was upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) parts of A and !> B are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the transformed matrix associated with !> the equivalent standard eigenvalue problem. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] B - pointer to type. Array on the GPU of dimension ldb*n. !> The triangular factor of the matrix B, as returned by \ref rocsolver_spotrf !> "POTRF". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B. interface rocsolver_ssygst function rocsolver_ssygst_(handle,itype,uplo,n,A,lda,B,ldb) bind(c, name="rocsolver_ssygst") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygst_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssygst_assumed_rank #else module procedure & rocsolver_ssygst_rank_0,& rocsolver_ssygst_rank_1,& rocsolver_ssygst_full_rank #endif #endif end interface interface rocsolver_dsygst function rocsolver_dsygst_(handle,itype,uplo,n,A,lda,B,ldb) bind(c, name="rocsolver_dsygst") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygst_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsygst_assumed_rank #else module procedure & rocsolver_dsygst_rank_0,& rocsolver_dsygst_rank_1,& rocsolver_dsygst_full_rank #endif #endif end interface !> \brief The HEGST functions reduce a Hermitian-definite generalized eigenproblem to standard !> form. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A X = \lambda B X & \: \text{1st form,}\\% !> A B X = \lambda X & \: \text{2nd form, or}\\% !> B A X = \lambda X & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. !> !> If the problem is of the first form, then ``A`` is overwritten with !> !> \f[ !> \begin{array}{cl} !> U^{-H} A U^{-1}, & \: \text{or}\\% !> L^{-1} A L^{-H}, !> \end{array} !> \f] !> !> where the Hermitian-definite matrix ``B`` has been factorized as either \f$U^H U\f$ or !> \f$L L^H\f$, as returned by \ref rocsolver_spotrf "POTRF", depending on the value of !> ``uplo``. !> !> If the problem is of the second or third form, then ``A`` is overwritten with !> !> \f[ !> \begin{array}{cl} !> U A U^H, & \: \text{or}\\% !> L^H A L, !> \end{array} !> \f] !> !> also depending on the value of ``uplo``. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblem. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrix A is stored, and !> whether the factorization applied to B was upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) parts of A and !> B are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the transformed matrix associated with !> the equivalent standard eigenvalue problem. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] B - pointer to type. Array on the GPU of dimension ldb*n. !> The triangular factor of the matrix B, as returned by \ref rocsolver_spotrf !> "POTRF". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B. interface rocsolver_chegst function rocsolver_chegst_(handle,itype,uplo,n,A,lda,B,ldb) bind(c, name="rocsolver_chegst") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegst_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_chegst_assumed_rank #else module procedure & rocsolver_chegst_rank_0,& rocsolver_chegst_rank_1,& rocsolver_chegst_full_rank #endif #endif end interface interface rocsolver_zhegst function rocsolver_zhegst_(handle,itype,uplo,n,A,lda,B,ldb) bind(c, name="rocsolver_zhegst") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegst_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zhegst_assumed_rank #else module procedure & rocsolver_zhegst_rank_0,& rocsolver_zhegst_rank_1,& rocsolver_zhegst_full_rank #endif #endif end interface !> \brief The SYGST_BATCHED functions reduce a batch of real symmetric-definite generalized !> eigenproblems !> to standard form. !> !> \details !> (This is the blocked version of the algorithm.) !> !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. !> !> If the problem is of the first form, then \f$A_l\f$ is overwritten with !> !> \f[ !> \begin{array}{cl} !> U_l^{-T} A_l^{} U_l^{-1}, & \: \text{or}\\% !> L_l^{-1} A_l^{} L_l^{-T}, !> \end{array} !> \f] !> !> where the symmetric-definite matrix \f$B_l\f$ has been factorized as either \f$U_l^T !> U_l^{}\f$ or !> \f$L_l^{} L_l^T\f$, as returned by \ref rocsolver_spotrf "POTRF", depending on the value of !> ``uplo``. !> !> If the problem is of the second or third form, then ``A`` is overwritten with !> !> \f[ !> \begin{array}{cl} !> U_l^{} A_l^{} U_l^T, & \: \text{or}\\% !> L_l^T A_l^{} L_l^{}, !> \end{array} !> \f] !> !> also depending on the value of ``uplo``. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrices A_l are stored, and !> whether the factorization applied to B_l was upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) parts of A_l and !> B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the transformed matrices associated with !> the equivalent standard eigenvalue problems. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[out] B - array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*n. !> The triangular factors of the matrices B_l, as returned by \ref !> rocsolver_spotrf_batched "POTRF_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssygst_batched function rocsolver_ssygst_batched_(handle,itype,uplo,n,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_ssygst_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygst_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function end interface interface rocsolver_dsygst_batched function rocsolver_dsygst_batched_(handle,itype,uplo,n,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_dsygst_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygst_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function end interface !> \brief The HEGST_BATCHED functions reduce a batch of Hermitian-definite generalized !> eigenproblems to !> standard form. !> !> \details !> (This is the blocked version of the algorithm.) !> !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. !> !> If the problem is of the first form, then \f$A_l\f$ is overwritten with !> !> \f[ !> \begin{array}{cl} !> U_l^{-H} A_l^{} U_l^{-1}, & \: \text{or}\\% !> L_l^{-1} A_l^{} L_l^{-H}, !> \end{array} !> \f] !> !> where the Hermitian-definite matrix \f$B_l\f$ has been factorized as either \f$U_l^H !> U_l^{}\f$ or !> \f$L_l^{} L_l^H\f$, as returned by \ref rocsolver_spotrf "POTRF", depending on the value of !> ``uplo``. !> !> If the problem is of the second or third form, then ``A`` is overwritten with !> !> \f[ !> \begin{array}{cl} !> U_l^{} A_l^{} U_l^H, & \: \text{or}\\% !> L_l^H A_l^{} L_l^{}, !> \end{array} !> \f] !> !> also depending on the value of ``uplo``. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrices A_l are stored, and !> whether the factorization applied to B_l was upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) parts of A_l and !> B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the transformed matrices associated with !> the equivalent standard eigenvalue problems. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[out] B - array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*n. !> The triangular factors of the matrices B_l, as returned by \ref !> rocsolver_spotrf_batched "POTRF_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_chegst_batched function rocsolver_chegst_batched_(handle,itype,uplo,n,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_chegst_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegst_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function end interface interface rocsolver_zhegst_batched function rocsolver_zhegst_batched_(handle,itype,uplo,n,A,lda,B,ldb,batch_count) & bind(c, name="rocsolver_zhegst_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegst_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_int),value :: batch_count end function end interface !> \brief The SYGST_STRIDED_BATCHED functions reduce a batch of real symmetric-definite !> generalized !> eigenproblems to standard form. !> !> \details !> (This is the blocked version of the algorithm.) !> !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. !> !> If the problem is of the first form, then \f$A_l\f$ is overwritten with !> !> \f[ !> \begin{array}{cl} !> U_l^{-T} A_l^{} U_l^{-1}, & \: \text{or}\\% !> L_l^{-1} A_l^{} L_l^{-T}, !> \end{array} !> \f] !> !> where the symmetric-definite matrix \f$B_l\f$ has been factorized as either \f$U_l^T !> U_l^{}\f$ or !> \f$L_l^{} L_l^T\f$, as returned by \ref rocsolver_spotrf "POTRF", depending on the value of !> ``uplo``. !> !> If the problem is of the second or third form, then ``A`` is overwritten with !> !> \f[ !> \begin{array}{cl} !> U_l^{} A_l^{} U_l^T, & \: \text{or}\\% !> L_l^T A_l^{} L_l^{}, !> \end{array} !> \f] !> !> also depending on the value of ``uplo``. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrices A_l are stored, and !> whether the factorization applied to B_l was upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) parts of A_l and !> B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the transformed matrices associated with !> the equivalent standard eigenvalue problems. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> The triangular factors of the matrices B_l, as returned by \ref !> rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. The normal use case is !> strideB >= ldb*n. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssygst_strided_batched function rocsolver_ssygst_strided_batched_(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB, & batch_count) & bind(c, name="rocsolver_ssygst_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygst_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssygst_strided_batched_assumed_rank #else module procedure & rocsolver_ssygst_strided_batched_rank_0,& rocsolver_ssygst_strided_batched_rank_1,& rocsolver_ssygst_strided_batched_full_rank #endif #endif end interface interface rocsolver_dsygst_strided_batched function rocsolver_dsygst_strided_batched_(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB, & batch_count) & bind(c, name="rocsolver_dsygst_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygst_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsygst_strided_batched_assumed_rank #else module procedure & rocsolver_dsygst_strided_batched_rank_0,& rocsolver_dsygst_strided_batched_rank_1,& rocsolver_dsygst_strided_batched_full_rank #endif #endif end interface !> \brief The HEGST_STRIDED_BATCHED functions reduce a batch of Hermitian-definite generalized !> eigenproblems to standard form. !> !> \details !> (This is the blocked version of the algorithm.) !> !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. !> !> If the problem is of the first form, then \f$A_l\f$ is overwritten with !> !> \f[ !> \begin{array}{cl} !> U_l^{-H} A_l^{} U_l^{-1}, & \: \text{or}\\% !> L_l^{-1} A_l^{} L_l^{-H}, !> \end{array} !> \f] !> !> where the Hermitian-definite matrix \f$B_l\f$ has been factorized as either \f$U_l^H !> U_l^{}\f$ or !> \f$L_l^{} L_l^H\f$, as returned by \ref rocsolver_spotrf "POTRF", depending on the value of !> ``uplo``. !> !> If the problem is of the second or third form, then ``A`` is overwritten with !> !> \f[ !> \begin{array}{cl} !> U_l^{} A_l^{} U_l^H, & \: \text{or}\\% !> L_l^H A_l^{} L_l^{}, !> \end{array} !> \f] !> !> also depending on the value of ``uplo``. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrices A_l are stored, and !> whether the factorization applied to B_l was upper or lower triangular. !> If uplo indicates lower (or upper), then the upper (or lower) parts of A_l and !> B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the transformed matrices associated with !> the equivalent standard eigenvalue problems. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> The triangular factors of the matrices B_l, as returned by \ref !> rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. The normal use case is !> strideB >= ldb*n. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_chegst_strided_batched function rocsolver_chegst_strided_batched_(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB, & batch_count) & bind(c, name="rocsolver_chegst_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegst_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_chegst_strided_batched_assumed_rank #else module procedure & rocsolver_chegst_strided_batched_rank_0,& rocsolver_chegst_strided_batched_rank_1,& rocsolver_chegst_strided_batched_full_rank #endif #endif end interface interface rocsolver_zhegst_strided_batched function rocsolver_zhegst_strided_batched_(handle,itype,uplo,n,A,lda,strideA,B,ldb,strideB, & batch_count) & bind(c, name="rocsolver_zhegst_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegst_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zhegst_strided_batched_assumed_rank #else module procedure & rocsolver_zhegst_strided_batched_rank_0,& rocsolver_zhegst_strided_batched_rank_1,& rocsolver_zhegst_strided_batched_full_rank #endif #endif end interface !> \brief The SYEV functions compute the eigenvalues and optionally the eigenvectors of a real !> symmetric !> matrix ``A``. !> !> \note !> The ``_64`` interface accepts ``int64_t`` arguments, but the matrix dimensions ``n`` and !> ``lda`` must still fit within a 32-bit integer (less than 2^31). The internal tridiagonal !> reduction and back-transformation steps remain 32-bit, which bounds the supported size. !> !> \details !> The eigenvalues are returned in ascending order. The eigenvectors are computed depending !> on the value of ``evect``. The computed eigenvectors are orthonormal. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the eigenvectors of A if they were computed !> and !> the algorithm converged. Otherwise, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrix A. !> @param[out] D - pointer to type. Array on the GPU of dimension n. !> The eigenvalues of A in increasing order. !> @param[out] E - pointer to type. Array on the GPU of dimension n. !> This array is used to work internally with the tridiagonal matrix T associated !> with A. !> On exit, if info > 0, it contains the unconverged off-diagonal elements of T !> (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal !> elements !> of this matrix are in D. Those that converged correspond to a subset of the !> eigenvalues of A (not necessarily ordered). !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. If info = i > 0, the algorithm did not converge. !> i elements of E did not converge to zero. interface rocsolver_ssyev function rocsolver_ssyev_(handle,evect,uplo,n,A,lda,D,E,myInfo) bind(c, name="rocsolver_ssyev") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyev_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssyev_assumed_rank #else module procedure & rocsolver_ssyev_rank_0,& rocsolver_ssyev_rank_1,& rocsolver_ssyev_full_rank #endif #endif end interface interface rocsolver_dsyev function rocsolver_dsyev_(handle,evect,uplo,n,A,lda,D,E,myInfo) bind(c, name="rocsolver_dsyev") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyev_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsyev_assumed_rank #else module procedure & rocsolver_dsyev_rank_0,& rocsolver_dsyev_rank_1,& rocsolver_dsyev_full_rank #endif #endif end interface interface rocsolver_ssyev_64 function rocsolver_ssyev_64_(handle,evect,uplo,n,A,lda,D,E,myInfo) & bind(c, name="rocsolver_ssyev_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyev_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function end interface interface rocsolver_dsyev_64 function rocsolver_dsyev_64_(handle,evect,uplo,n,A,lda,D,E,myInfo) & bind(c, name="rocsolver_dsyev_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyev_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function end interface !> \brief The HEEV functions compute the eigenvalues and optionally the eigenvectors of a !> Hermitian matrix A. !> !> \note !> The ``_64`` interface accepts ``int64_t`` arguments, but the matrix dimensions ``n`` and !> ``lda`` must still fit within a 32-bit integer (less than 2^31). The internal tridiagonal !> reduction and back-transformation steps remain 32-bit, which bounds the supported size. !> !> \details !> The eigenvalues are returned in ascending order. The eigenvectors are computed depending !> on the value of ``evect``. The computed eigenvectors are orthonormal. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the Hermitian matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the eigenvectors of A if they were computed !> and !> the algorithm converged. Otherwise, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrix A. !> @param[out] D - pointer to real type. Array on the GPU of dimension n. !> The eigenvalues of A in increasing order. !> @param[out] E - pointer to real type. Array on the GPU of dimension n. !> This array is used to work internally with the tridiagonal matrix T associated !> with A. !> On exit, if info > 0, it contains the unconverged off-diagonal elements of T !> (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal !> elements !> of this matrix are in D. Those that converged correspond to a subset of the !> eigenvalues of A (not necessarily ordered). !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. If info = i > 0, the algorithm did not converge. !> i elements of E did not converge to zero. interface rocsolver_cheev function rocsolver_cheev_(handle,evect,uplo,n,A,lda,D,E,myInfo) bind(c, name="rocsolver_cheev") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheev_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cheev_assumed_rank #else module procedure & rocsolver_cheev_rank_0,& rocsolver_cheev_rank_1,& rocsolver_cheev_full_rank #endif #endif end interface interface rocsolver_zheev function rocsolver_zheev_(handle,evect,uplo,n,A,lda,D,E,myInfo) bind(c, name="rocsolver_zheev") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheev_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zheev_assumed_rank #else module procedure & rocsolver_zheev_rank_0,& rocsolver_zheev_rank_1,& rocsolver_zheev_full_rank #endif #endif end interface interface rocsolver_cheev_64 function rocsolver_cheev_64_(handle,evect,uplo,n,A,lda,D,E,myInfo) & bind(c, name="rocsolver_cheev_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheev_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function end interface interface rocsolver_zheev_64 function rocsolver_zheev_64_(handle,evect,uplo,n,A,lda,D,E,myInfo) & bind(c, name="rocsolver_zheev_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheev_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function end interface !> \brief The SYEV_BATCHED functions compute the eigenvalues and optionally the eigenvectors !> of a batch of !> real symmetric matrices A_l. !> !> \note !> The ``_64`` interface accepts ``int64_t`` arguments, but the matrix dimensions ``n`` and !> ``lda`` must still fit within a 32-bit integer (less than 2^31). The internal tridiagonal !> reduction and back-transformation steps remain 32-bit, which bounds the supported size. !> !> \details !> The eigenvalues are returned in ascending order. The eigenvectors are computed depending !> on the value of ``evect``. The computed eigenvectors are orthonormal. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the eigenvectors of A_l if they were !> computed and !> the algorithm converged. Otherwise, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[out] D - pointer to type. Array on the GPU (the size depends on the value of !> strideD). !> The eigenvalues of A_l in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] E - pointer to type. Array on the GPU (the size depends on the value of !> strideE). !> This array is used to work internally with the tridiagonal matrix T_l !> associated with A_l. !> On exit, if info[l] > 0, E_l contains the unconverged off-diagonal elements of !> T_l !> (or properly speaking, a tridiagonal matrix equivalent to T_l). The diagonal !> elements !> of this matrix are in D_l. Those that converged correspond to a subset of the !> eigenvalues of A_l (not necessarily ordered). !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. If info[l] = i > 0, the !> algorithm did not converge. !> i elements of E_l did not converge to zero. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssyev_batched function rocsolver_ssyev_batched_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) & bind(c, name="rocsolver_ssyev_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyev_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssyev_batched_assumed_rank #else module procedure & rocsolver_ssyev_batched_rank_0,& rocsolver_ssyev_batched_rank_1 #endif #endif end interface interface rocsolver_dsyev_batched function rocsolver_dsyev_batched_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) & bind(c, name="rocsolver_dsyev_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyev_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsyev_batched_assumed_rank #else module procedure & rocsolver_dsyev_batched_rank_0,& rocsolver_dsyev_batched_rank_1 #endif #endif end interface interface rocsolver_ssyev_batched_64 function rocsolver_ssyev_batched_64_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) & bind(c, name="rocsolver_ssyev_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyev_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dsyev_batched_64 function rocsolver_dsyev_batched_64_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) & bind(c, name="rocsolver_dsyev_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyev_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The HEEV_BATCHED functions compute the eigenvalues and optionally the eigenvectors !> of a batch of !> Hermitian matrices A_l. !> !> \note !> The ``_64`` interface accepts ``int64_t`` arguments, but the matrix dimensions ``n`` and !> ``lda`` must still fit within a 32-bit integer (less than 2^31). The internal tridiagonal !> reduction and back-transformation steps remain 32-bit, which bounds the supported size. !> !> \details !> The eigenvalues are returned in ascending order. The eigenvectors are computed depending !> on the value of ``evect``. The computed eigenvectors are orthonormal. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the Hermitian matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the eigenvectors of A_l if they were !> computed and !> the algorithm converged. Otherwise, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> The eigenvalues of A_l in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] E - pointer to real type. Array on the GPU (the size depends on the value of !> strideE). !> This array is used to work internally with the tridiagonal matrix T_l !> associated with A_l. !> On exit, if info[l] > 0, E_l contains the unconverged off-diagonal elements of !> T_l !> (or properly speaking, a tridiagonal matrix equivalent to T_l). The diagonal !> elements !> of this matrix are in D_l. Those that converged correspond to a subset of the !> eigenvalues of A_l (not necessarily ordered). !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. If info[l] = i > 0, the !> algorithm did not converge. !> i elements of E_l did not converge to zero. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_cheev_batched function rocsolver_cheev_batched_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) & bind(c, name="rocsolver_cheev_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheev_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cheev_batched_assumed_rank #else module procedure & rocsolver_cheev_batched_rank_0,& rocsolver_cheev_batched_rank_1 #endif #endif end interface interface rocsolver_zheev_batched function rocsolver_zheev_batched_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) & bind(c, name="rocsolver_zheev_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheev_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zheev_batched_assumed_rank #else module procedure & rocsolver_zheev_batched_rank_0,& rocsolver_zheev_batched_rank_1 #endif #endif end interface interface rocsolver_cheev_batched_64 function rocsolver_cheev_batched_64_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) & bind(c, name="rocsolver_cheev_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheev_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zheev_batched_64 function rocsolver_zheev_batched_64_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) & bind(c, name="rocsolver_zheev_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheev_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The SYEV_STRIDED_BATCHED functions compute the eigenvalues and optionally the !> eigenvectors of a batch of !> real symmetric matrices A_l. !> !> \note !> The ``_64`` interface accepts ``int64_t`` arguments, but the matrix dimensions ``n`` and !> ``lda`` must still fit within a 32-bit integer (less than 2^31). The internal tridiagonal !> reduction and back-transformation steps remain 32-bit, which bounds the supported size. !> !> \details !> The eigenvalues are returned in ascending order. The eigenvectors are computed depending !> on the value of ``evect``. The computed eigenvectors are orthonormal. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the eigenvectors of A_l if they were !> computed and !> the algorithm converged. Otherwise, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] D - pointer to type. Array on the GPU (the size depends on the value of !> strideD). !> The eigenvalues of A_l in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] E - pointer to type. Array on the GPU (the size depends on the value of !> strideE). !> This array is used to work internally with the tridiagonal matrix T_l !> associated with A_l. !> On exit, if info[l] > 0, E_l contains the unconverged off-diagonal elements of !> T_l !> (or properly speaking, a tridiagonal matrix equivalent to T_l). The diagonal !> elements !> of this matrix are in D_l. Those that converged correspond to a subset of the !> eigenvalues of A_l (not necessarily ordered). !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. If info[l] = i > 0, the !> algorithm did not converge. !> i elements of E_l did not converge to zero. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssyev_strided_batched function rocsolver_ssyev_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) & bind(c, name="rocsolver_ssyev_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyev_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssyev_strided_batched_assumed_rank #else module procedure & rocsolver_ssyev_strided_batched_rank_0,& rocsolver_ssyev_strided_batched_rank_1,& rocsolver_ssyev_strided_batched_full_rank #endif #endif end interface interface rocsolver_dsyev_strided_batched function rocsolver_dsyev_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) & bind(c, name="rocsolver_dsyev_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyev_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsyev_strided_batched_assumed_rank #else module procedure & rocsolver_dsyev_strided_batched_rank_0,& rocsolver_dsyev_strided_batched_rank_1,& rocsolver_dsyev_strided_batched_full_rank #endif #endif end interface interface rocsolver_ssyev_strided_batched_64 function rocsolver_ssyev_strided_batched_64_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) & bind(c, name="rocsolver_ssyev_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyev_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dsyev_strided_batched_64 function rocsolver_dsyev_strided_batched_64_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) & bind(c, name="rocsolver_dsyev_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyev_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The HEEV_STRIDED_BATCHED functions compute the eigenvalues and optionally the !> eigenvectors of a batch of !> Hermitian matrices A_l. !> !> \note !> The ``_64`` interface accepts ``int64_t`` arguments, but the matrix dimensions ``n`` and !> ``lda`` must still fit within a 32-bit integer (less than 2^31). The internal tridiagonal !> reduction and back-transformation steps remain 32-bit, which bounds the supported size. !> !> \details !> The eigenvalues are returned in ascending order. The eigenvectors are computed depending !> on the value of ``evect``. The computed eigenvectors are orthonormal. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the Hermitian matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the eigenvectors of A_l if they were !> computed and !> the algorithm converged. Otherwise, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> The eigenvalues of A_l in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] E - pointer to real type. Array on the GPU (the size depends on the value of !> strideE). !> This array is used to work internally with the tridiagonal matrix T_l !> associated with A_l. !> On exit, if info[l] > 0, E_l contains the unconverged off-diagonal elements of !> T_l !> (or properly speaking, a tridiagonal matrix equivalent to T_l). The diagonal !> elements !> of this matrix are in D_l. Those that converged correspond to a subset of the !> eigenvalues of A_l (not necessarily ordered). !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. If info[l] = i > 0, the !> algorithm did not converge. !> i elements of E_l did not converge to zero. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_cheev_strided_batched function rocsolver_cheev_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) & bind(c, name="rocsolver_cheev_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheev_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cheev_strided_batched_assumed_rank #else module procedure & rocsolver_cheev_strided_batched_rank_0,& rocsolver_cheev_strided_batched_rank_1,& rocsolver_cheev_strided_batched_full_rank #endif #endif end interface interface rocsolver_zheev_strided_batched function rocsolver_zheev_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) & bind(c, name="rocsolver_zheev_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheev_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zheev_strided_batched_assumed_rank #else module procedure & rocsolver_zheev_strided_batched_rank_0,& rocsolver_zheev_strided_batched_rank_1,& rocsolver_zheev_strided_batched_full_rank #endif #endif end interface interface rocsolver_cheev_strided_batched_64 function rocsolver_cheev_strided_batched_64_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) & bind(c, name="rocsolver_cheev_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheev_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zheev_strided_batched_64 function rocsolver_zheev_strided_batched_64_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) & bind(c, name="rocsolver_zheev_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheev_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The SYEVD functions compute the eigenvalues and optionally the eigenvectors of a !> real symmetric !> matrix ``A``. !> !> \note !> The ``_64`` interface accepts ``int64_t`` arguments, but the matrix dimensions ``n`` and !> ``lda`` must still fit within a 32-bit integer (less than 2^31). The internal tridiagonal !> reduction and back-transformation steps remain 32-bit, which bounds the supported size. !> !> \details !> The eigenvalues are returned in ascending order. The eigenvectors are computed using a !> divide-and-conquer algorithm, depending on the value of ``evect``. The computed !> eigenvectors !> are orthonormal. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the eigenvectors of A if they were computed !> and !> the algorithm converged. Otherwise, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrix A. !> @param[out] D - pointer to type. Array on the GPU of dimension n. !> The eigenvalues of A in increasing order. !> @param[out] E - pointer to type. Array on the GPU of dimension n. !> This array is used to work internally with the tridiagonal matrix T associated !> with A. !> On exit, if info > 0, it contains the unconverged off-diagonal elements of T !> (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal !> elements !> of this matrix are in D. Those that converged correspond to a subset of the !> eigenvalues of A (not necessarily ordered). !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0 and evect is rocblas_evect_none, the algorithm did not !> converge. !> i elements of E did not converge to zero. !> If info = i > 0 and evect is rocblas_evect_original, the algorithm failed to !> compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), !> i%(n+1)]. interface rocsolver_ssyevd function rocsolver_ssyevd_(handle,evect,uplo,n,A,lda,D,E,myInfo) & bind(c, name="rocsolver_ssyevd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssyevd_assumed_rank #else module procedure & rocsolver_ssyevd_rank_0,& rocsolver_ssyevd_rank_1,& rocsolver_ssyevd_full_rank #endif #endif end interface interface rocsolver_dsyevd function rocsolver_dsyevd_(handle,evect,uplo,n,A,lda,D,E,myInfo) & bind(c, name="rocsolver_dsyevd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsyevd_assumed_rank #else module procedure & rocsolver_dsyevd_rank_0,& rocsolver_dsyevd_rank_1,& rocsolver_dsyevd_full_rank #endif #endif end interface interface rocsolver_ssyevd_64 function rocsolver_ssyevd_64_(handle,evect,uplo,n,A,lda,D,E,myInfo) & bind(c, name="rocsolver_ssyevd_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function end interface interface rocsolver_dsyevd_64 function rocsolver_dsyevd_64_(handle,evect,uplo,n,A,lda,D,E,myInfo) & bind(c, name="rocsolver_dsyevd_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function end interface !> \brief The HEEVD functions compute the eigenvalues and optionally the eigenvectors of a !> Hermitian matrix ``A``. !> !> \note !> The ``_64`` interface accepts ``int64_t`` arguments, but the matrix dimensions ``n`` and !> ``lda`` must still fit within a 32-bit integer (less than 2^31). The internal tridiagonal !> reduction and back-transformation steps remain 32-bit, which bounds the supported size. !> !> \details !> The eigenvalues are returned in ascending order. The eigenvectors are computed using a !> divide-and-conquer algorithm, depending on the value of ``evect``. The computed !> eigenvectors !> are orthonormal. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the Hermitian matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the eigenvectors of A if they were computed !> and !> the algorithm converged. Otherwise, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrix A. !> @param[out] D - pointer to real type. Array on the GPU of dimension n. !> The eigenvalues of A in increasing order. !> @param[out] E - pointer to real type. Array on the GPU of dimension n. !> This array is used to work internally with the tridiagonal matrix T associated !> with A. !> On exit, if info > 0, it contains the unconverged off-diagonal elements of T !> (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal !> elements !> of this matrix are in D. Those that converged correspond to a subset of the !> eigenvalues of A (not necessarily ordered). !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0 and evect is rocblas_evect_none, the algorithm did not !> converge. !> i elements of E did not converge to zero. !> If info = i > 0 and evect is rocblas_evect_original, the algorithm failed to !> compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), !> i%(n+1)]. interface rocsolver_cheevd function rocsolver_cheevd_(handle,evect,uplo,n,A,lda,D,E,myInfo) & bind(c, name="rocsolver_cheevd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevd_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cheevd_assumed_rank #else module procedure & rocsolver_cheevd_rank_0,& rocsolver_cheevd_rank_1,& rocsolver_cheevd_full_rank #endif #endif end interface interface rocsolver_zheevd function rocsolver_zheevd_(handle,evect,uplo,n,A,lda,D,E,myInfo) & bind(c, name="rocsolver_zheevd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevd_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zheevd_assumed_rank #else module procedure & rocsolver_zheevd_rank_0,& rocsolver_zheevd_rank_1,& rocsolver_zheevd_full_rank #endif #endif end interface interface rocsolver_cheevd_64 function rocsolver_cheevd_64_(handle,evect,uplo,n,A,lda,D,E,myInfo) & bind(c, name="rocsolver_cheevd_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevd_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function end interface interface rocsolver_zheevd_64 function rocsolver_zheevd_64_(handle,evect,uplo,n,A,lda,D,E,myInfo) & bind(c, name="rocsolver_zheevd_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevd_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function end interface !> \brief The SYEVD_BATCHED functions compute the eigenvalues and optionally the eigenvectors !> of a batch of !> real symmetric matrices A_l. !> !> \note !> The ``_64`` interface accepts ``int64_t`` arguments, but the matrix dimensions ``n`` and !> ``lda`` must still fit within a 32-bit integer (less than 2^31). The internal tridiagonal !> reduction and back-transformation steps remain 32-bit, which bounds the supported size. !> !> \details !> The eigenvalues are returned in ascending order. The eigenvectors are computed using a !> divide-and-conquer algorithm, depending on the value of ``evect``. The computed !> eigenvectors !> are orthonormal. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the eigenvectors of A_l if they were !> computed and !> the algorithm converged. Otherwise, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[out] D - pointer to type. Array on the GPU (the size depends on the value of !> strideD). !> The eigenvalues of A_l in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] E - pointer to type. Array on the GPU (the size depends on the value of !> strideE). !> This array is used to work internally with the tridiagonal matrix T_l !> associated with A_l. !> On exit, if info[l] > 0, E_l contains the unconverged off-diagonal elements of !> T_l !> (or properly speaking, a tridiagonal matrix equivalent to T_l). The diagonal !> elements !> of this matrix are in D_l. Those that converged correspond to a subset of the !> eigenvalues of A_l (not necessarily ordered). !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. !> If info[l] = i > 0 and evect is rocblas_evect_none, the algorithm did not !> converge. !> i elements of E_l did not converge to zero. !> If info[l] = i > 0 and evect is rocblas_evect_original, the algorithm failed to !> compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), !> i%(n+1)]. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssyevd_batched function rocsolver_ssyevd_batched_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) & bind(c, name="rocsolver_ssyevd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssyevd_batched_assumed_rank #else module procedure & rocsolver_ssyevd_batched_rank_0,& rocsolver_ssyevd_batched_rank_1 #endif #endif end interface interface rocsolver_dsyevd_batched function rocsolver_dsyevd_batched_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) & bind(c, name="rocsolver_dsyevd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsyevd_batched_assumed_rank #else module procedure & rocsolver_dsyevd_batched_rank_0,& rocsolver_dsyevd_batched_rank_1 #endif #endif end interface interface rocsolver_ssyevd_batched_64 function rocsolver_ssyevd_batched_64_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) & bind(c, name="rocsolver_ssyevd_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dsyevd_batched_64 function rocsolver_dsyevd_batched_64_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) & bind(c, name="rocsolver_dsyevd_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The HEEVD_BATCHED functions compute the eigenvalues and optionally the eigenvectors !> of a batch of !> Hermitian matrices A_l. !> !> \note !> The ``_64`` interface accepts ``int64_t`` arguments, but the matrix dimensions ``n`` and !> ``lda`` must still fit within a 32-bit integer (less than 2^31). The internal tridiagonal !> reduction and back-transformation steps remain 32-bit, which bounds the supported size. !> !> \details !> The eigenvalues are returned in ascending order. The eigenvectors are computed using a !> divide-and-conquer algorithm, depending on the value of ``evect``. The computed !> eigenvectors !> are orthonormal. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the Hermitian matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the eigenvectors of A_l if they were !> computed and !> the algorithm converged. Otherwise, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> The eigenvalues of A_l in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] E - pointer to real type. Array on the GPU (the size depends on the value of !> strideE). !> This array is used to work internally with the tridiagonal matrix T_l !> associated with A_l. !> On exit, if info[l] > 0, E_l contains the unconverged off-diagonal elements of !> T_l !> (or properly speaking, a tridiagonal matrix equivalent to T_l). The diagonal !> elements !> of this matrix are in D_l. Those that converged correspond to a subset of the !> eigenvalues of A_l (not necessarily ordered). !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. !> If info[l] = i > 0 and evect is rocblas_evect_none, the algorithm did not !> converge. !> i elements of E_l did not converge to zero. !> If info[l] = i > 0 and evect is rocblas_evect_original, the algorithm failed to !> compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), !> i%(n+1)]. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_cheevd_batched function rocsolver_cheevd_batched_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) & bind(c, name="rocsolver_cheevd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cheevd_batched_assumed_rank #else module procedure & rocsolver_cheevd_batched_rank_0,& rocsolver_cheevd_batched_rank_1 #endif #endif end interface interface rocsolver_zheevd_batched function rocsolver_zheevd_batched_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) & bind(c, name="rocsolver_zheevd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zheevd_batched_assumed_rank #else module procedure & rocsolver_zheevd_batched_rank_0,& rocsolver_zheevd_batched_rank_1 #endif #endif end interface interface rocsolver_cheevd_batched_64 function rocsolver_cheevd_batched_64_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) & bind(c, name="rocsolver_cheevd_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevd_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zheevd_batched_64 function rocsolver_zheevd_batched_64_(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) & bind(c, name="rocsolver_zheevd_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevd_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The SYEVD_STRIDED_BATCHED functions compute the eigenvalues and optionally the !> eigenvectors of a batch of !> real symmetric matrices A_l. !> !> \note !> The ``_64`` interface accepts ``int64_t`` arguments, but the matrix dimensions ``n`` and !> ``lda`` must still fit within a 32-bit integer (less than 2^31). The internal tridiagonal !> reduction and back-transformation steps remain 32-bit, which bounds the supported size. !> !> \details !> The eigenvalues are returned in ascending order. The eigenvectors are computed using a !> divide-and-conquer algorithm, depending on the value of ``evect``. The computed !> eigenvectors !> are orthonormal. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the eigenvectors of A_l if they were !> computed and !> the algorithm converged. Otherwise, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] D - pointer to type. Array on the GPU (the size depends on the value of !> strideD). !> The eigenvalues of A_l in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] E - pointer to type. Array on the GPU (the size depends on the value of !> strideE). !> This array is used to work internally with the tridiagonal matrix T_l !> associated with A_l. !> On exit, if info[l] > 0, E_l contains the unconverged off-diagonal elements of !> T_l !> (or properly speaking, a tridiagonal matrix equivalent to T_l). The diagonal !> elements !> of this matrix are in D_l. Those that converged correspond to a subset of the !> eigenvalues of A_l (not necessarily ordered). !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. !> If info[l] = i > 0 and evect is rocblas_evect_none, the algorithm did not !> converge. !> i elements of E_l did not converge to zero. !> If info[l] = i > 0 and evect is rocblas_evect_original, the algorithm failed to !> compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), !> i%(n+1)]. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssyevd_strided_batched function rocsolver_ssyevd_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) & bind(c, name="rocsolver_ssyevd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssyevd_strided_batched_assumed_rank #else module procedure & rocsolver_ssyevd_strided_batched_rank_0,& rocsolver_ssyevd_strided_batched_rank_1,& rocsolver_ssyevd_strided_batched_full_rank #endif #endif end interface interface rocsolver_dsyevd_strided_batched function rocsolver_dsyevd_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) & bind(c, name="rocsolver_dsyevd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsyevd_strided_batched_assumed_rank #else module procedure & rocsolver_dsyevd_strided_batched_rank_0,& rocsolver_dsyevd_strided_batched_rank_1,& rocsolver_dsyevd_strided_batched_full_rank #endif #endif end interface interface rocsolver_ssyevd_strided_batched_64 function rocsolver_ssyevd_strided_batched_64_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) & bind(c, name="rocsolver_ssyevd_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_dsyevd_strided_batched_64 function rocsolver_dsyevd_strided_batched_64_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) & bind(c, name="rocsolver_dsyevd_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The HEEVD_STRIDED_BATCHED functions compute the eigenvalues and optionally the !> eigenvectors of a batch of !> Hermitian matrices A_l. !> !> \note !> The ``_64`` interface accepts ``int64_t`` arguments, but the matrix dimensions ``n`` and !> ``lda`` must still fit within a 32-bit integer (less than 2^31). The internal tridiagonal !> reduction and back-transformation steps remain 32-bit, which bounds the supported size. !> !> \details !> The eigenvalues are returned in ascending order. The eigenvectors are computed using a !> divide-and-conquer algorithm, depending on the value of ``evect``. The computed !> eigenvectors !> are orthonormal. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the Hermitian matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the eigenvectors of A_l if they were !> computed and !> the algorithm converged. Otherwise, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> The eigenvalues of A_l in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] E - pointer to real type. Array on the GPU (the size depends on the value of !> strideE). !> This array is used to work internally with the tridiagonal matrix T_l !> associated with A_l. !> On exit, if info[l] > 0, E_l contains the unconverged off-diagonal elements of !> T_l !> (or properly speaking, a tridiagonal matrix equivalent to T_l). The diagonal !> elements !> of this matrix are in D_l. Those that converged correspond to a subset of the !> eigenvalues of A_l (not necessarily ordered). !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. The normal use case is !> strideE >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. !> If info[l] = i > 0 and evect is rocblas_evect_none, the algorithm did not !> converge. !> i elements of E_l did not converge to zero. !> If info[l] = i > 0 and evect is rocblas_evect_original, the algorithm failed to !> compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), !> i%(n+1)]. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_cheevd_strided_batched function rocsolver_cheevd_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) & bind(c, name="rocsolver_cheevd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cheevd_strided_batched_assumed_rank #else module procedure & rocsolver_cheevd_strided_batched_rank_0,& rocsolver_cheevd_strided_batched_rank_1,& rocsolver_cheevd_strided_batched_full_rank #endif #endif end interface interface rocsolver_zheevd_strided_batched function rocsolver_zheevd_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) & bind(c, name="rocsolver_zheevd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zheevd_strided_batched_assumed_rank #else module procedure & rocsolver_zheevd_strided_batched_rank_0,& rocsolver_zheevd_strided_batched_rank_1,& rocsolver_zheevd_strided_batched_full_rank #endif #endif end interface interface rocsolver_cheevd_strided_batched_64 function rocsolver_cheevd_strided_batched_64_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) & bind(c, name="rocsolver_cheevd_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevd_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface interface rocsolver_zheevd_strided_batched_64 function rocsolver_zheevd_strided_batched_64_(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) & bind(c, name="rocsolver_zheevd_strided_batched_64") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevd_strided_batched_64_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int64_t),value :: n type(c_ptr),value :: A integer(c_int64_t),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int64_t),value :: batch_count end function end interface !> \brief The SYEVDJ functions compute the eigenvalues and optionally the eigenvectors of a !> real symmetric !> matrix ``A``. !> !> \details !> The eigenvalues are found using the iterative Jacobi algorithm and are returned in !> ascending order. !> The eigenvectors are computed using a divide-and-conquer approach depending on the value of !> ``evect``. !> The computed eigenvectors are orthonormal. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the eigenvectors of A if they were computed !> and !> the algorithm converged. Otherwise, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrix A. !> @param[out] D - pointer to type. Array on the GPU of dimension n. !> The eigenvalues of A in increasing order. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. If info = 1, the algorithm did not converge. interface rocsolver_ssyevdj function rocsolver_ssyevdj_(handle,evect,uplo,n,A,lda,D,myInfo) & bind(c, name="rocsolver_ssyevdj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevdj_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: myInfo end function end interface interface rocsolver_dsyevdj function rocsolver_dsyevdj_(handle,evect,uplo,n,A,lda,D,myInfo) & bind(c, name="rocsolver_dsyevdj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevdj_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: myInfo end function end interface !> \brief The HEEVDJ functions compute the eigenvalues and optionally the eigenvectors of a !> complex Hermitian !> matrix A. !> !> \details !> The eigenvalues are found using the iterative Jacobi algorithm and are returned in !> ascending order. !> The eigenvectors are computed using a divide-and-conquer approach depending on the value of !> ``evect``. !> The computed eigenvectors are orthonormal. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the Hermitian matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the eigenvectors of A if they were computed !> and !> the algorithm converged. Otherwise, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrix A. !> @param[out] D - pointer to real type. Array on the GPU of dimension n. !> The eigenvalues of A in increasing order. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. If info = 1, the algorithm did not converge. interface rocsolver_cheevdj function rocsolver_cheevdj_(handle,evect,uplo,n,A,lda,D,myInfo) & bind(c, name="rocsolver_cheevdj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevdj_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: myInfo end function end interface interface rocsolver_zheevdj function rocsolver_zheevdj_(handle,evect,uplo,n,A,lda,D,myInfo) & bind(c, name="rocsolver_zheevdj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevdj_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D type(c_ptr),value :: myInfo end function end interface !> \brief The SYEVDJ_BATCHED functions compute the eigenvalues and optionally the eigenvectors !> of a !> batch of real symmetric matrices A_l. !> !> \details !> The eigenvalues are found using the iterative Jacobi algorithm and are returned in !> ascending order. !> The eigenvectors are computed using a divide-and-conquer approach depending on the value of !> ``evect``. !> The computed eigenvectors are orthonormal. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the eigenvectors of A_l if they were !> computed and !> the algorithm converged. Otherwise, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[out] D - pointer to type. Array on the GPU (the size depends on the value of !> strideD). !> The eigenvalues of A_l in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for A_l. If info[l] = 1, the algorithm did not !> converge for A_l. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssyevdj_batched function rocsolver_ssyevdj_batched_(handle,evect,uplo,n,A,lda,D,strideD,myInfo,batch_count) & bind(c, name="rocsolver_ssyevdj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevdj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dsyevdj_batched function rocsolver_dsyevdj_batched_(handle,evect,uplo,n,A,lda,D,strideD,myInfo,batch_count) & bind(c, name="rocsolver_dsyevdj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevdj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The HEEVDJ_BATCHED functions computes the eigenvalues and optionally the !> eigenvectors of a !> batch of complex Hermitian matrices A_l. !> !> \details !> The eigenvalues are found using the iterative Jacobi algorithm and are returned in !> ascending order. !> The eigenvectors are computed using a divide-and-conquer approach depending on the value of !> ``evect``. !> The computed eigenvectors are orthonormal. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the Hermitian matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the eigenvectors of A_l if they were !> computed and !> the algorithm converged. Otherwise, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> The eigenvalues of A_l in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for A_l. If info[l] = 1, the algorithm did not !> converge for A_l. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_cheevdj_batched function rocsolver_cheevdj_batched_(handle,evect,uplo,n,A,lda,D,strideD,myInfo,batch_count) & bind(c, name="rocsolver_cheevdj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevdj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zheevdj_batched function rocsolver_zheevdj_batched_(handle,evect,uplo,n,A,lda,D,strideD,myInfo,batch_count) & bind(c, name="rocsolver_zheevdj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevdj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The SYEVDJ_STRIDED_BATCHED functions compute the eigenvalues and optionally the !> eigenvectors of a !> batch of real symmetric matrices A_l. !> !> \details !> The eigenvalues are found using the iterative Jacobi algorithm and are returned in !> ascending order. !> The eigenvectors are computed using a divide-and-conquer approach depending on the value of !> ``evect``. !> The computed eigenvectors are orthonormal. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - Pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the eigenvectors of A_l if they were !> computed and !> the algorithm converged. Otherwise, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] D - pointer to type. Array on the GPU (the size depends on the value of !> strideD). !> The eigenvalues of A_l in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for A_l. If info[l] = 1, the algorithm did not !> converge for A_l. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssyevdj_strided_batched function rocsolver_ssyevdj_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD, & myInfo,batch_count) & bind(c, name="rocsolver_ssyevdj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevdj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dsyevdj_strided_batched function rocsolver_dsyevdj_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD, & myInfo,batch_count) & bind(c, name="rocsolver_dsyevdj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevdj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The HEEVDJ_STRIDED_BATCHED functions compute the eigenvalues and optionally the !> eigenvectors of a !> batch of complex Hermitian matrices A_l. !> !> \details !> The eigenvalues are found using the iterative Jacobi algorithm and are returned in !> ascending order. !> The eigenvectors are computed using a divide-and-conquer approach depending on the value of !> ``evect``. !> The computed eigenvectors are orthonormal. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the Hermitian matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - Pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the eigenvectors of A_l if they were !> computed and !> the algorithm converged. Otherwise, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> The eigenvalues of A_l in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. The normal use case is !> strideD >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for A_l. If info[l] = 1, the algorithm did not !> converge for A_l. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_cheevdj_strided_batched function rocsolver_cheevdj_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD, & myInfo,batch_count) & bind(c, name="rocsolver_cheevdj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevdj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zheevdj_strided_batched function rocsolver_zheevdj_strided_batched_(handle,evect,uplo,n,A,lda,strideA,D,strideD, & myInfo,batch_count) & bind(c, name="rocsolver_zheevdj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevdj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The SYGVDJ functions compute the eigenvalues and (optionally) eigenvectors of !> a real generalized symmetric-definite eigenproblem. !> !> \details !> The problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A X = \lambda B X & \: \text{1st form,}\\% !> A B X = \lambda X & \: \text{2nd form, or}\\% !> B A X = \lambda X & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvalues are found using the iterative Jacobi !> algorithm !> and returned in ascending order. The eigenvectors are computed using a divide-and-conquer !> algorithm, !> depending on the value of ``evect``. !> !> When computed, the matrix Z of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z^T B Z=I & \: \text{if 1st or 2nd form, or}\\% !> Z^T B^{-1} Z=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblem. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices A and B are stored. !> If uplo indicates lower (or upper), then the upper (or lower) parts of A and B !> are not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the normalized matrix Z of eigenvectors if !> they were computed !> and the algorithm converged. Otherwise, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrix A. !> @param[inout] B - pointer to type. Array on the GPU of dimension ldb*n. !> On entry, the symmetric positive definite matrix B. On exit, !> the triangular factor of B as returned by \ref rocsolver_spotrf "POTRF". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of matrix B. !> @param[out] D - pointer to type. Array on the GPU of dimension n. !> The eigenvalues in increasing order. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. If info = 1, the algorithm did not converge. !> If info = n + i, the leading minor of order i of B is not positive definite. interface rocsolver_ssygvdj function rocsolver_ssygvdj_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,myInfo) & bind(c, name="rocsolver_ssygvdj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvdj_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D type(c_ptr),value :: myInfo end function end interface interface rocsolver_dsygvdj function rocsolver_dsygvdj_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,myInfo) & bind(c, name="rocsolver_dsygvdj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvdj_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D type(c_ptr),value :: myInfo end function end interface !> \brief The HEGVDJ functions compute the eigenvalues and (optionally) eigenvectors of !> a complex generalized Hermitian-definite eigenproblem. !> !> \details !> The problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A X = \lambda B X & \: \text{1st form,}\\% !> A B X = \lambda X & \: \text{2nd form, or}\\% !> B A X = \lambda X & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvalues are found using the iterative Jacobi !> algorithm !> and returned in ascending order. The eigenvectors are computed using a divide-and-conquer !> algorithm, !> depending on the value of ``evect``. !> !> When computed, the matrix Z of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z^H B Z=I & \: \text{if 1st or 2nd form, or}\\% !> Z^H B^{-1} Z=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblem. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices A and B are stored. !> If uplo indicates lower (or upper), then the upper (or lower) parts of A and B !> are not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the normalized matrix Z of eigenvectors if !> they were computed !> and the algorithm converged. Otherwise, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrix A. !> @param[inout] B - pointer to type. Array on the GPU of dimension ldb*n. !> On entry, the Hermitian positive definite matrix B. On exit, !> the triangular factor of B as returned by \ref rocsolver_spotrf "POTRF". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of matrix B. !> @param[out] D - pointer to real type. Array on the GPU of dimension n. !> The eigenvalues in increasing order. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. If info = 1, the algorithm did not converge. !> If info = n + i, the leading minor of order i of B is not positive definite. interface rocsolver_chegvdj function rocsolver_chegvdj_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,myInfo) & bind(c, name="rocsolver_chegvdj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvdj_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D type(c_ptr),value :: myInfo end function end interface interface rocsolver_zhegvdj function rocsolver_zhegvdj_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,myInfo) & bind(c, name="rocsolver_zhegvdj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvdj_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D type(c_ptr),value :: myInfo end function end interface !> \brief The SYGVDJ_BATCHED functions compute the eigenvalues and (optionally) eigenvectors !> of a !> batch of real generalized symmetric-definite eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvalues are found using the iterative Jacobi !> algorithm !> and returned in ascending order. The eigenvectors are computed using a divide-and-conquer !> algorithm, !> depending on the value of ``evect``. !> !> When computed, the matrix Z_l of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z^T_l B_l Z_l=I & \: \text{if 1st or 2nd form, or}\\% !> Z^T_l B^{-1}_l Z_l=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices A_l and B_l are !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) parts of A_l and !> B_l !> are not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrix A_l. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the normalized matrices Z_l of !> eigenvectors if they were computed !> and the algorithm converged. Otherwise, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[inout] B - array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*n. !> On entry, the symmetric positive definite matrices B_l. On exit, !> the triangular factor of B_l as returned by \ref rocsolver_spotrf_batched !> "POTRF_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of matrices B_l. !> @param[out] D - pointer to type. Array on the GPU (the size depends on the value of !> strideD). !> The eigenvalues in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. Normal usage is strideD >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit. If info[l] = 1, the algorithm did not converge !> for matrix A_l. !> If info[l] = n + i, the leading minor of order i of B_l is not positive !> definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of eigenproblems in the batch. interface rocsolver_ssygvdj_batched function rocsolver_ssygvdj_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,myInfo, & batch_count) & bind(c, name="rocsolver_ssygvdj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvdj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dsygvdj_batched function rocsolver_dsygvdj_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,myInfo, & batch_count) & bind(c, name="rocsolver_dsygvdj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvdj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The HEGVDJ_BATCHED functions compute the eigenvalues and (optionally) eigenvectors !> of a !> batch of complex generalized Hermitian-definite eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvalues are found using the iterative Jacobi !> algorithm !> and returned in ascending order. The eigenvectors are computed using a divide-and-conquer !> algorithm, !> depending on the value of ``evect``. !> !> When computed, the matrix Z_l of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z^H_l B_l Z_l=I & \: \text{if 1st or 2nd form, or}\\% !> Z^H_l B^{-1}_l Z_l=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices A_l and B_l are !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) parts of A_l and !> B_l !> are not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrix A_l. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the normalized matrices Z_l of !> eigenvectors if they were computed !> and the algorithm converged. Otherwise, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[inout] B - array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*n. !> On entry, the Hermitian positive definite matrices B_l. On exit, !> the triangular factor of B_l as returned by \ref rocsolver_spotrf_batched !> "POTRF_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of matrices B_l. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> The eigenvalues in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. Normal usage is strideD >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit. If info[l] = 1, the algorithm did not converge !> for matrix A_l. !> If info[l] = n + i, the leading minor of order i of B_l is not positive !> definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of eigenproblems in the batch. interface rocsolver_chegvdj_batched function rocsolver_chegvdj_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,myInfo, & batch_count) & bind(c, name="rocsolver_chegvdj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvdj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zhegvdj_batched function rocsolver_zhegvdj_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,myInfo, & batch_count) & bind(c, name="rocsolver_zhegvdj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvdj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The SYGVDJ_STRIDED_BATCHED functions compute the eigenvalues and (optionally) !> eigenvectors of a !> batch of real generalized symmetric-definite eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvalues are found using the iterative Jacobi !> algorithm !> and returned in ascending order. The eigenvectors are computed using a divide-and-conquer !> algorithm, !> depending on the value of ``evect``. !> !> When computed, the matrix Z_l of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z^T_l B_l Z_l=I & \: \text{if 1st or 2nd form, or}\\% !> Z^T_l B^{-1}_l Z_l=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices A_l and B_l are !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) parts of A_l and !> B_l !> are not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrix A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the normalized matrices Z_l of !> eigenvectors if they were computed !> and the algorithm converged. Otherwise, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. Normal usage is strideA >= !> lda*n. !> @param[inout] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> On entry, the symmetric positive definite matrices B_l. On exit, !> the triangular factor of B_l as returned by \ref !> rocsolver_spotrf_strided_batched "POTRF_STRIDED_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of matrices B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. Normal usage is strideB >= !> ldb*n. !> @param[out] D - pointer to type. Array on the GPU (the size depends on the value of !> strideD). !> The eigenvalues in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. Normal usage is strideD >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit. If info[l] = 1, the algorithm did not converge !> for matrix A_l. !> If info[l] = n + i, the leading minor of order i of B_l is not positive !> definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of eigenproblems in the batch. interface rocsolver_ssygvdj_strided_batched function rocsolver_ssygvdj_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,myInfo,batch_count) & bind(c, name="rocsolver_ssygvdj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvdj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dsygvdj_strided_batched function rocsolver_dsygvdj_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,myInfo,batch_count) & bind(c, name="rocsolver_dsygvdj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvdj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The HEGVDJ_STRIDED_BATCHED functions compute the eigenvalues and (optionally) !> eigenvectors of a !> batch of complex generalized Hermitian-definite eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvalues are found using the iterative Jacobi !> algorithm !> and returned in ascending order. The eigenvectors are computed using a divide-and-conquer !> algorithm, !> depending on the value of ``evect``. !> !> When computed, the matrix Z_l of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z^H_l B_l Z_l=I & \: \text{if 1st or 2nd form, or}\\% !> Z^H_l B^{-1}_l Z_l=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices A_l and B_l are !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) parts of A_l and !> B_l !> are not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrix A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the normalized matrices Z_l of !> eigenvectors if they were computed !> and the algorithm converged. Otherwise, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. Normal usage is strideA >= !> lda*n. !> @param[inout] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> On entry, the Hermitian positive definite matrices B_l. On exit, !> the triangular factor of B_l as returned by \ref rocsolver_spotrf_batched !> "POTRF_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of matrices B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. Normal usage is strideB >= !> ldb*n. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> The eigenvalues in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. Normal usage is strideD >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit. If info[l] = 1, the algorithm did not converge !> for matrix A_l. !> If info[l] = n + i, the leading minor of order i of B_l is not positive !> definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of eigenproblems in the batch. interface rocsolver_chegvdj_strided_batched function rocsolver_chegvdj_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,myInfo,batch_count) & bind(c, name="rocsolver_chegvdj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvdj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zhegvdj_strided_batched function rocsolver_zhegvdj_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,myInfo,batch_count) & bind(c, name="rocsolver_zhegvdj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvdj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The SYEVJ functions compute the eigenvalues and optionally the eigenvectors of a !> real symmetric !> matrix ``A``. !> !> \details !> The eigenvalues are found using the iterative Jacobi algorithm and returned in an order !> that !> depends on the value of ``esort``. !> The eigenvectors are computed depending on the value of ``evect``. The computed !> eigenvectors are orthonormal. !> !> At the \f$k\f$-th iteration (or "sweep"), \f$A\f$ is transformed by a product of Jacobi !> rotations \f$V\f$ as !> !> \f[ !> A^{(k)} = V^H A^{(k-1)} V !> \f] !> !> such that \f$off(A^{(k)}) < off(A^{(k-1)})\f$, where \f$A^{(0)} = A\f$ and !> \f$off(A^{(k)})\f$ is the !> Frobenius norm of the off-diagonal elements of \f$A^{(k)}\f$. As \f$off(A^{(k)}) !> \rightarrow 0\f$, the !> diagonal elements of \f$A^{(k)}\f$ increasingly resemble the eigenvalues of \f$A\f$. !> !> \note !> In order to carry out calculations, this method could potentially synchronize the stream !> contained within the !> ``rocblas_handle``. !> !> @param[in] handle - rocblas_handle. !> @param[in] esort - `rocblas_esort`. !> Specifies the order of the returned eigenvalues. If esort is !> rocblas_esort_ascending, then the eigenvalues are sorted and returned in !> ascending order. !> If esort is rocblas_esort_none, then the order of the returned eigenvalues is !> unspecified. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the eigenvectors of A if they were computed !> and !> the algorithm converged. Otherwise, the contents of A are unchanged. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrix A. !> @param[in] abstol - type. !> The absolute tolerance. The algorithm is considered to have converged once !> off(A) !> is <= abstol. If abstol <= 0, then the tolerance will be set to machine !> precision. !> @param[out] residual - pointer to type on the GPU. !> The Frobenius norm of the off-diagonal elements of A (that is, off(A)) at the !> final iteration. !> @param[in] max_sweeps - rocblas_int. max_sweeps > 0. !> Maximum number of sweeps (iterations) to be used by the algorithm. !> @param[out] n_sweeps - pointer to a rocblas_int on the GPU. !> The actual number of sweeps (iterations) used by the algorithm. !> @param[out] W - pointer to type. Array on the GPU of dimension n. !> The eigenvalues of A in increasing order. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. If info = 1, the algorithm did not converge. interface rocsolver_ssyevj function rocsolver_ssyevj_(handle,esort,evect,uplo,n,A,lda,abstol,residual,max_sweeps, & n_sweeps,W,myInfo) & bind(c, name="rocsolver_ssyevj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevj_ type(c_ptr),value :: handle integer(kind(rocblas_esort_none)),value :: esort integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W type(c_ptr),value :: myInfo end function end interface interface rocsolver_dsyevj function rocsolver_dsyevj_(handle,esort,evect,uplo,n,A,lda,abstol,residual,max_sweeps, & n_sweeps,W,myInfo) & bind(c, name="rocsolver_dsyevj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevj_ type(c_ptr),value :: handle integer(kind(rocblas_esort_none)),value :: esort integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W type(c_ptr),value :: myInfo end function end interface !> \brief The HEEVJ functions compute the eigenvalues and optionally the eigenvectors of a !> complex Hermitian !> matrix ``A``. !> !> \details !> The eigenvalues are found using the iterative Jacobi algorithm and returned in an order !> that !> depends on the value of ``esort``. !> The eigenvectors are computed depending on the value of ``evect``. The computed !> eigenvectors are orthonormal. !> !> At the \f$k\f$-th iteration (or "sweep"), \f$A\f$ is transformed by a product of Jacobi !> rotations \f$V\f$ as !> !> \f[ !> A^{(k)} = V^H A^{(k-1)} V !> \f] !> !> such that \f$off(A^{(k)}) < off(A^{(k-1)})\f$, where \f$A^{(0)} = A\f$ and !> \f$off(A^{(k)})\f$ is the !> Frobenius norm of the off-diagonal elements of \f$A^{(k)}\f$. As \f$off(A^{(k)}) !> \rightarrow 0\f$, the !> diagonal elements of \f$A^{(k)}\f$ increasingly resemble the eigenvalues of \f$A\f$. !> !> \note !> In order to carry out calculations, this method could potentially synchronize the stream !> contained within the !> ``rocblas_handle``. !> !> @param[in] handle - rocblas_handle. !> @param[in] esort - `rocblas_esort`. !> Specifies the order of the returned eigenvalues. If esort is !> rocblas_esort_ascending, then the eigenvalues are sorted and returned in !> ascending order. !> If esort is rocblas_esort_none, then the order of the returned eigenvalues is !> unspecified. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the Hermitian matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the eigenvectors of A if they were computed !> and !> the algorithm converged. Otherwise, the contents of A are unchanged. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrix A. !> @param[in] abstol - real type. !> The absolute tolerance. The algorithm is considered to have converged once !> off(A) !> is <= abstol. If abstol <= 0, then the tolerance will be set to machine !> precision. !> @param[out] residual - pointer to real type on the GPU. !> The Frobenius norm of the off-diagonal elements of A (that is, off(A)) at the !> final iteration. !> @param[in] max_sweeps - rocblas_int. max_sweeps > 0. !> Maximum number of sweeps (iterations) to be used by the algorithm. !> @param[out] n_sweeps - pointer to a rocblas_int on the GPU. !> The actual number of sweeps (iterations) used by the algorithm. !> @param[out] W - pointer to real type. Array on the GPU of dimension n. !> The eigenvalues of A in increasing order. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. If info = 1, the algorithm did not converge. interface rocsolver_cheevj function rocsolver_cheevj_(handle,esort,evect,uplo,n,A,lda,abstol,residual,max_sweeps, & n_sweeps,W,myInfo) & bind(c, name="rocsolver_cheevj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevj_ type(c_ptr),value :: handle integer(kind(rocblas_esort_none)),value :: esort integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W type(c_ptr),value :: myInfo end function end interface interface rocsolver_zheevj function rocsolver_zheevj_(handle,esort,evect,uplo,n,A,lda,abstol,residual,max_sweeps, & n_sweeps,W,myInfo) & bind(c, name="rocsolver_zheevj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevj_ type(c_ptr),value :: handle integer(kind(rocblas_esort_none)),value :: esort integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W type(c_ptr),value :: myInfo end function end interface !> \brief The SYEVJ_BATCHED functions compute the eigenvalues and optionally the eigenvectors !> of a batch of !> real symmetric matrices A_l. !> !> \details !> The eigenvalues are found using the iterative Jacobi algorithm and returned in an order !> that !> depends on the value of ``esort``. !> The eigenvectors are computed depending on the value of ``evect``. The computed !> eigenvectors are orthonormal. !> !> At the \f$k\f$-th iteration (or "sweep"), \f$A_l\f$ is transformed by a product of Jacobi !> rotations \f$V_l\f$ as !> !> \f[ !> A_l^{(k)} = V_l^H A_l^{(k-1)} V_l^{} !> \f] !> !> such that \f$off(A_l^{(k)}) < off(A_l^{(k-1)})\f$, where \f$A_l^{(0)} = A_l\f$ and !> \f$off(A_l^{(k)})\f$ is the !> Frobenius norm of the off-diagonal elements of \f$A_l^{(k)}\f$. As \f$off(A_l^{(k)}) !> \rightarrow 0\f$, the !> diagonal elements of \f$A_l^{(k)}\f$ increasingly resemble the eigenvalues of \f$A_l\f$. !> !> \note !> In order to carry out calculations, this method could potentially synchronize the stream !> contained within the !> ``rocblas_handle``. !> !> @param[in] handle - rocblas_handle. !> @param[in] esort - `rocblas_esort`. !> Specifies the order of the returned eigenvalues. If esort is !> rocblas_esort_ascending, then the eigenvalues are sorted and returned in !> ascending order. !> If esort is rocblas_esort_none, then the order of the returned eigenvalues is !> unspecified. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the eigenvectors of A_l if they were !> computed and !> the algorithm converged. Otherwise, the contents of A_l are unchanged. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] abstol - type. !> The absolute tolerance. The algorithm is considered to have converged once !> off(A_l) !> is <= abstol. If abstol <= 0, then the tolerance will be set to machine !> precision. !> @param[out] residual - pointer to type. Array of batch_count scalars on the GPU. !> The Frobenius norm of the off-diagonal elements of A_l (that is, off(A_l)) at !> the final iteration. !> @param[in] max_sweeps - rocblas_int. max_sweeps > 0. !> Maximum number of sweeps (iterations) to be used by the algorithm. !> @param[out] n_sweeps - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The actual number of sweeps (iterations) used by the algorithm for each batch !> instance. !> @param[out] W - pointer to type. Array on the GPU (the size depends on the value of !> strideW). !> The eigenvalues of A_l in increasing order. !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. If info[l] = 1, the algorithm !> did not converge. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssyevj_batched function rocsolver_ssyevj_batched_(handle,esort,evect,uplo,n,A,lda,abstol,residual,max_sweeps, & n_sweeps,W,strideW,myInfo,batch_count) & bind(c, name="rocsolver_ssyevj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_esort_none)),value :: esort integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dsyevj_batched function rocsolver_dsyevj_batched_(handle,esort,evect,uplo,n,A,lda,abstol,residual,max_sweeps, & n_sweeps,W,strideW,myInfo,batch_count) & bind(c, name="rocsolver_dsyevj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_esort_none)),value :: esort integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The HEEVJ_BATCHED functions compute the eigenvalues and optionally the eigenvectors !> of a batch of !> complex Hermitian matrices A_l. !> !> \details !> The eigenvalues are found using the iterative Jacobi algorithm and returned in an order !> that !> depends on the value of ``esort``. !> The eigenvectors are computed depending on the value of ``evect``. The computed !> eigenvectors are orthonormal. !> !> At the \f$k\f$-th iteration (or "sweep"), \f$A_l\f$ is transformed by a product of Jacobi !> rotations \f$V_l\f$ as !> !> \f[ !> A_l^{(k)} = V_l^H A_l^{(k-1)} V_l^{} !> \f] !> !> such that \f$off(A_l^{(k)}) < off(A_l^{(k-1)})\f$, where \f$A_l^{(0)} = A_l\f$ and !> \f$off(A_l^{(k)})\f$ is the !> Frobenius norm of the off-diagonal elements of \f$A_l^{(k)}\f$. As \f$off(A_l^{(k)}) !> \rightarrow 0\f$, the !> diagonal elements of \f$A_l^{(k)}\f$ increasingly resemble the eigenvalues of \f$A_l\f$. !> !> \note !> In order to carry out calculations, this method could potentially synchronize the stream !> contained within the !> ``rocblas_handle``. !> !> @param[in] handle - rocblas_handle. !> @param[in] esort - `rocblas_esort`. !> Specifies the order of the returned eigenvalues. If esort is !> rocblas_esort_ascending, then the eigenvalues are sorted and returned in !> ascending order. !> If esort is rocblas_esort_none, then the order of the returned eigenvalues is !> unspecified. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the Hermitian matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the eigenvectors of A_l if they were !> computed and !> the algorithm converged. Otherwise, the contents of A_l are unchanged. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] abstol - real type. !> The absolute tolerance. The algorithm is considered to have converged once !> off(A_l) !> is <= abstol. If abstol <= 0, then the tolerance will be set to machine !> precision. !> @param[out] residual - pointer to real type. Array of batch_count scalars on the GPU. !> The Frobenius norm of the off-diagonal elements of A_l (that is, off(A_l)) at !> the final iteration. !> @param[in] max_sweeps - rocblas_int. max_sweeps > 0. !> Maximum number of sweeps (iterations) to be used by the algorithm. !> @param[out] n_sweeps - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The actual number of sweeps (iterations) used by the algorithm for each batch !> instance. !> @param[out] W - pointer to real type. Array on the GPU (the size depends on the value of !> strideW). !> The eigenvalues of A_l in increasing order. !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. If info[l] = 1, the algorithm !> did not converge. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_cheevj_batched function rocsolver_cheevj_batched_(handle,esort,evect,uplo,n,A,lda,abstol,residual,max_sweeps, & n_sweeps,W,strideW,myInfo,batch_count) & bind(c, name="rocsolver_cheevj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_esort_none)),value :: esort integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zheevj_batched function rocsolver_zheevj_batched_(handle,esort,evect,uplo,n,A,lda,abstol,residual,max_sweeps, & n_sweeps,W,strideW,myInfo,batch_count) & bind(c, name="rocsolver_zheevj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_esort_none)),value :: esort integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The SYEVJ_STRIDED_BATCHED functions compute the eigenvalues and optionally the !> eigenvectors of a batch of !> real symmetric matrices A_l. !> !> \details !> The eigenvalues are found using the iterative Jacobi algorithm and returned in an order !> that !> depends on the value of ``esort``. !> The eigenvectors are computed depending on the value of ``evect``. The computed !> eigenvectors are orthonormal. !> !> At the \f$k\f$-th iteration (or "sweep"), \f$A_l\f$ is transformed by a product of Jacobi !> rotations \f$V_l\f$ as !> !> \f[ !> A_l^{(k)} = V_l^H A_l^{(k-1)} V_l^{} !> \f] !> !> such that \f$off(A_l^{(k)}) < off(A_l^{(k-1)})\f$, where \f$A_l^{(0)} = A_l\f$ and !> \f$off(A_l^{(k)})\f$ is the !> Frobenius norm of the off-diagonal elements of \f$A_l^{(k)}\f$. As \f$off(A_l^{(k)}) !> \rightarrow 0\f$, the !> diagonal elements of \f$A_l^{(k)}\f$ increasingly resemble the eigenvalues of \f$A_l\f$. !> !> \note !> In order to carry out calculations, this method could potentially synchronize the stream !> contained within the !> ``rocblas_handle``. !> !> @param[in] handle - rocblas_handle. !> @param[in] esort - `rocblas_esort`. !> Specifies the order of the returned eigenvalues. If esort is !> rocblas_esort_ascending, then the eigenvalues are sorted and returned in !> ascending order. !> If esort is rocblas_esort_none, then the order of the returned eigenvalues is !> unspecified. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the eigenvectors of A_l if they were !> computed and !> the algorithm converged. Otherwise, the contents of A_l are unchanged. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[in] abstol - type. !> The absolute tolerance. The algorithm is considered to have converged once !> off(A_l) !> is <= abstol. If abstol <= 0, then the tolerance will be set to machine !> precision. !> @param[out] residual - pointer to type. Array of batch_count scalars on the GPU. !> The Frobenius norm of the off-diagonal elements of A_l (that is, off(A_l)) at !> the final iteration. !> @param[in] max_sweeps - rocblas_int. max_sweeps > 0. !> Maximum number of sweeps (iterations) to be used by the algorithm. !> @param[out] n_sweeps - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The actual number of sweeps (iterations) used by the algorithm for each batch !> instance. !> @param[out] W - pointer to type. Array on the GPU (the size depends on the value of !> strideW). !> The eigenvalues of A_l in increasing order. !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. If info[l] = 1, the algorithm !> did not converge. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssyevj_strided_batched function rocsolver_ssyevj_strided_batched_(handle,esort,evect,uplo,n,A,lda,strideA,abstol, & residual,max_sweeps,n_sweeps,W,strideW,myInfo,batch_count) & bind(c, name="rocsolver_ssyevj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_esort_none)),value :: esort integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_float),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dsyevj_strided_batched function rocsolver_dsyevj_strided_batched_(handle,esort,evect,uplo,n,A,lda,strideA,abstol, & residual,max_sweeps,n_sweeps,W,strideW,myInfo,batch_count) & bind(c, name="rocsolver_dsyevj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_esort_none)),value :: esort integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_double),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The HEEVJ_STRIDED_BATCHED functions compute the eigenvalues and optionally the !> eigenvectors of a batch of !> complex Hermitian matrices A_l. !> !> \details !> The eigenvalues are found using the iterative Jacobi algorithm and returned in an order !> that !> depends on the value of ``esort``. !> The eigenvectors are computed depending on the value of ``evect``. The computed !> eigenvectors are orthonormal. !> !> At the \f$k\f$-th iteration (or "sweep"), \f$A_l\f$ is transformed by a product of Jacobi !> rotations \f$V_l\f$ as !> !> \f[ !> A_l^{(k)} = V_l^H A_l^{(k-1)} V_l^{} !> \f] !> !> such that \f$off(A_l^{(k)}) < off(A_l^{(k-1)})\f$, where \f$A_l^{(0)} = A_l\f$ and !> \f$off(A_l^{(k)})\f$ is the !> Frobenius norm of the off-diagonal elements of \f$A_l^{(k)}\f$. As \f$off(A_l^{(k)}) !> \rightarrow 0\f$, the !> diagonal elements of \f$A_l^{(k)}\f$ increasingly resemble the eigenvalues of \f$A_l\f$. !> !> \note !> In order to carry out calculations, this method could potentially synchronize the stream !> contained within the !> ``rocblas_handle``. !> !> @param[in] handle - rocblas_handle. !> @param[in] esort - `rocblas_esort`. !> Specifies the order of the returned eigenvalues. If esort is !> rocblas_esort_ascending, then the eigenvalues are sorted and returned in !> ascending order. !> If esort is rocblas_esort_none, then the order of the returned eigenvalues is !> unspecified. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the Hermitian matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the eigenvectors of A_l if they were !> computed and !> the algorithm converged. Otherwise, the contents of A_l are unchanged. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[in] abstol - real type. !> The absolute tolerance. The algorithm is considered to have converged once !> off(A_l) !> is <= abstol. If abstol <= 0, then the tolerance will be set to machine !> precision. !> @param[out] residual - pointer to real type. Array of batch_count scalars on the GPU. !> The Frobenius norm of the off-diagonal elements of A_l (that is, off(A_l)) at !> the final iteration. !> @param[in] max_sweeps - rocblas_int. max_sweeps > 0. !> Maximum number of sweeps (iterations) to be used by the algorithm. !> @param[out] n_sweeps - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The actual number of sweeps (iterations) used by the algorithm for each batch !> instance. !> @param[out] W - pointer to real type. Array on the GPU (the size depends on the value of !> strideW). !> The eigenvalues of A_l in increasing order. !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. If info[l] = 1, the algorithm !> did not converge. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_cheevj_strided_batched function rocsolver_cheevj_strided_batched_(handle,esort,evect,uplo,n,A,lda,strideA,abstol, & residual,max_sweeps,n_sweeps,W,strideW,myInfo,batch_count) & bind(c, name="rocsolver_cheevj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_esort_none)),value :: esort integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_float),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zheevj_strided_batched function rocsolver_zheevj_strided_batched_(handle,esort,evect,uplo,n,A,lda,strideA,abstol, & residual,max_sweeps,n_sweeps,W,strideW,myInfo,batch_count) & bind(c, name="rocsolver_zheevj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_esort_none)),value :: esort integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_double),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The SYEVX functions compute a set of the eigenvalues and optionally the !> corresponding eigenvectors of a !> real symmetric matrix ``A``. !> !> \details !> This function computes all the eigenvalues of ``A``, all the eigenvalues in the half-open !> interval \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is rocblas_evect_original, !> the eigenvectors for these eigenvalues will be computed as well. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrix A. !> @param[in] vl - type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A or the eigenvalues within a set of indices. !> @param[in] vu - type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A or the eigenvalues in a half-open interval. !> @param[in] abstol - type. !> The absolute tolerance. An eigenvalue is considered to be located if it lies !> in an interval whose width is <= abstol. If abstol is negative, then !> machine-epsilon times !> the 1-norm of the tridiagonal form of A will be used as the tolerance. If !> abstol=0, then the tolerance will be set !> to twice the underflow threshold. This is the tolerance that could get the most !> accurate results. !> @param[out] nev - pointer to a rocblas_int on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev = !> n. !> If erange is rocblas_erange_index, nev = iu - il + 1. Otherwise, 0 <= nev <= n. !> @param[out] W - pointer to type. Array on the GPU of dimension n. !> The first nev elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[out] Z - pointer to type. Array on the GPU of dimension ldz*nev. !> On exit, if evect is not rocblas_evect_none and info = 0, the first nev columns !> contain !> the eigenvectors of A corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> - Note: If erange is rocblas_range_value, then the values of nev are not known !> in advance. !> The user should ensure that Z is large enough to hold n columns, as all n !> columns !> can be used as workspace for internal computations. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrix Z. !> @param[out] ifail - pointer to rocblas_int. Array on the GPU of dimension n. !> If info = 0, the first nev elements of ifail are zero. !> Otherwise, contains the indices of those eigenvectors that failed !> to converge. Not referenced if evect is rocblas_evect_none. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, the algorithm did not converge. i columns of Z did not !> converge. interface rocsolver_ssyevx function rocsolver_ssyevx_(handle,evect,erange,uplo,n,A,lda,vl,vu,il,iu,abstol,nev,W,Z,ldz, & ifail,myInfo) & bind(c, name="rocsolver_ssyevx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevx_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_float),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail type(c_ptr),value :: myInfo end function end interface interface rocsolver_dsyevx function rocsolver_dsyevx_(handle,evect,erange,uplo,n,A,lda,vl,vu,il,iu,abstol,nev,W,Z,ldz, & ifail,myInfo) & bind(c, name="rocsolver_dsyevx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevx_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_double),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail type(c_ptr),value :: myInfo end function end interface !> \brief The HEEVX functions compute a set of the eigenvalues and optionally the !> corresponding eigenvectors of a !> Hermitian matrix ``A``. !> !> \details !> This function computes all the eigenvalues of ``A``, all the eigenvalues in the half-open !> interval \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is rocblas_evect_original, !> the eigenvectors for these eigenvalues will be computed as well. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrix A. !> @param[in] vl - real type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A or the eigenvalues within a set of indices. !> @param[in] vu - real type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A or the eigenvalues in a half-open interval. !> @param[in] abstol - real type. !> The absolute tolerance. An eigenvalue is considered to be located if it lies !> in an interval whose width is <= abstol. If abstol is negative, then !> machine-epsilon times !> the 1-norm of the tridiagonal form of A will be used as the tolerance. If !> abstol=0, then the tolerance will be set !> to twice the underflow threshold. This is the tolerance that could get the most !> accurate results. !> @param[out] nev - pointer to a rocblas_int on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev = !> n. !> If erange is rocblas_erange_index, nev = iu - il + 1. Otherwise, 0 <= nev <= n. !> @param[out] W - pointer to real type. Array on the GPU of dimension n. !> The first nev elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[out] Z - pointer to type. Array on the GPU of dimension ldz*nev. !> On exit, if evect is not rocblas_evect_none and info = 0, the first nev columns !> contain !> the eigenvectors of A corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> - Note: If erange is rocblas_range_value, then the values of nev are not known !> in advance. !> The user should ensure that Z is large enough to hold n columns, as all n !> columns !> can be used as workspace for internal computations. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrix Z. !> @param[out] ifail - pointer to rocblas_int. Array on the GPU of dimension n. !> If info = 0, the first nev elements of ifail are zero. !> Otherwise, contains the indices of those eigenvectors that failed !> to converge. Not referenced if evect is rocblas_evect_none. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, the algorithm did not converge. i columns of Z did not !> converge. interface rocsolver_cheevx function rocsolver_cheevx_(handle,evect,erange,uplo,n,A,lda,vl,vu,il,iu,abstol,nev,W,Z,ldz, & ifail,myInfo) & bind(c, name="rocsolver_cheevx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevx_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_float),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail type(c_ptr),value :: myInfo end function end interface interface rocsolver_zheevx function rocsolver_zheevx_(handle,evect,erange,uplo,n,A,lda,vl,vu,il,iu,abstol,nev,W,Z,ldz, & ifail,myInfo) & bind(c, name="rocsolver_zheevx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevx_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_double),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail type(c_ptr),value :: myInfo end function end interface !> \brief The SYEVX_BATCHED functions compute a set of the eigenvalues and optionally the !> corresponding eigenvectors !> of a batch of real symmetric matrices A_l. !> !> \details !> This function computes all the eigenvalues of A_l, all the eigenvalues in the half-open !> interval \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is rocblas_evect_original, !> the eigenvectors for these eigenvalues will be computed as well. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] vl - type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] vu - type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] abstol - type. !> The absolute tolerance. An eigenvalue is considered to be located if it lies !> in an interval whose width is <= abstol. If abstol is negative, then !> machine-epsilon times !> the 1-norm of the tridiagonal form of A_l will be used as the tolerance. If !> abstol=0, then the tolerance will be set !> to twice the underflow threshold. This is the tolerance that could get the most !> accurate results. !> @param[out] nev - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev[l] !> = n. !> If erange is rocblas_erange_index, nev[l] = iu - il + 1. Otherwise, 0 <= nev[l] !> <= n. !> @param[out] W - pointer to type. Array on the GPU (the size depends on the value of !> strideW). !> The first nev[l] elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] Z - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldz*nev[l]. !> On exit, if evect is not rocblas_evect_none and info[l] = 0, the first nev[l] !> columns contain !> the eigenvectors of A_l corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> - Note: If erange is rocblas_range_value, then the values of nev[l] are not !> known in advance. !> The user should ensure that Z_l is large enough to hold n columns, as all n !> columns !> can be used as workspace for internal computations. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrices Z_l. !> @param[out] ifail - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideF). !> If info[l] = 0, the first nev[l] elements of ifail_l are zero. !> Otherwise, contains the indices of those eigenvectors that failed !> to converge. Not referenced if evect is rocblas_evect_none. !> @param[in] strideF - rocblas_stride. !> Stride from the start of one vector ifail_l to the next one ifail_(l+1). !> There is no restriction for the value of strideF. The normal use case is !> strideF >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. !> If info[l] = i > 0, the algorithm did not converge. i columns of Z_l did not !> converge. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssyevx_batched function rocsolver_ssyevx_batched_(handle,evect,erange,uplo,n,A,lda,vl,vu,il,iu,abstol,nev,W, & strideW,Z,ldz,ifail,strideF,myInfo,batch_count) & bind(c, name="rocsolver_ssyevx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_float),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dsyevx_batched function rocsolver_dsyevx_batched_(handle,evect,erange,uplo,n,A,lda,vl,vu,il,iu,abstol,nev,W, & strideW,Z,ldz,ifail,strideF,myInfo,batch_count) & bind(c, name="rocsolver_dsyevx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_double),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The HEEVX_BATCHED functions compute a set of the eigenvalues and optionally the !> corresponding eigenvectors !> of a batch of Hermitian matrices A_l. !> !> \details !> This function computes all the eigenvalues of A_l, all the eigenvalues in the half-open !> interval \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is rocblas_evect_original, !> the eigenvectors for these eigenvalues will be computed as well. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] vl - real type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] vu - real type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] abstol - real type. !> The absolute tolerance. An eigenvalue is considered to be located if it lies !> in an interval whose width is <= abstol. If abstol is negative, then !> machine-epsilon times !> the 1-norm of the tridiagonal form of A_l will be used as the tolerance. If !> abstol=0, then the tolerance will be set !> to twice the underflow threshold. This is the tolerance that could get the most !> accurate results. !> @param[out] nev - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev[l] !> = n. !> If erange is rocblas_erange_index, nev[l] = iu - il + 1. Otherwise, 0 <= nev[l] !> <= n. !> @param[out] W - pointer to real type. Array on the GPU (the size depends on the value of !> strideW). !> The first nev[l] elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] Z - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldz*nev[l]. !> On exit, if evect is not rocblas_evect_none and info[l] = 0, the first nev[l] !> columns contain !> the eigenvectors of A_l corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> - Note: If erange is rocblas_range_value, then the values of nev[l] are not !> known in advance. !> The user should ensure that Z_l is large enough to hold n columns, as all n !> columns !> can be used as workspace for internal computations. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrices Z_l. !> @param[out] ifail - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideF). !> If info[l] = 0, the first nev[l] elements of ifail_l are zero. !> Otherwise, contains the indices of those eigenvectors that failed !> to converge. Not referenced if evect is rocblas_evect_none. !> @param[in] strideF - rocblas_stride. !> Stride from the start of one vector ifail_l to the next one ifail_(l+1). !> There is no restriction for the value of strideF. The normal use case is !> strideF >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. !> If info[l] = i > 0, the algorithm did not converge. i columns of Z_l did not !> converge. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_cheevx_batched function rocsolver_cheevx_batched_(handle,evect,erange,uplo,n,A,lda,vl,vu,il,iu,abstol,nev,W, & strideW,Z,ldz,ifail,strideF,myInfo,batch_count) & bind(c, name="rocsolver_cheevx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_float),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zheevx_batched function rocsolver_zheevx_batched_(handle,evect,erange,uplo,n,A,lda,vl,vu,il,iu,abstol,nev,W, & strideW,Z,ldz,ifail,strideF,myInfo,batch_count) & bind(c, name="rocsolver_zheevx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_double),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The SYEVX_STRIDED_BATCHED functions compute a set of the eigenvalues and optionally !> the corresponding eigenvectors !> of a batch of real symmetric matrices A_l. !> !> \details !> This function computes all the eigenvalues of A_l, all the eigenvalues in the half-open !> interval \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is rocblas_evect_original, !> the eigenvectors for these eigenvalues will be computed as well. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[in] vl - type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] vu - type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] abstol - type. !> The absolute tolerance. An eigenvalue is considered to be located if it lies !> in an interval whose width is <= abstol. If abstol is negative, then !> machine-epsilon times !> the 1-norm of the tridiagonal form of A_l will be used as the tolerance. If !> abstol=0, then the tolerance will be set !> to twice the underflow threshold. This is the tolerance that could get the most !> accurate results. !> @param[out] nev - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev[l] !> = n. !> If erange is rocblas_erange_index, nev[l] = iu - il + 1. Otherwise, 0 <= nev[l] !> <= n. !> @param[out] W - pointer to type. Array on the GPU (the size depends on the value of !> strideW). !> The first nev[l] elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] Z - pointer to type. Array on the GPU (the size depends on the value of !> strideZ). !> On exit, if evect is not rocblas_evect_none and info[l] = 0, the first nev[l] !> columns contain !> the eigenvectors of A_l corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrices Z_l. !> @param[in] strideZ - rocblas_stride. !> Stride from the start of one matrix Z_l to the next one Z_(l+1). !> There is no restriction for the value of strideZ. The normal use case is !> strideZ >= ldz*nev[l]. !> - Note: If erange is rocblas_range_value, then the values of nev[l] are not !> known in advance. !> The user should ensure that Z_l is large enough to hold n columns, as all n !> columns !> can be used as workspace for internal computations. !> @param[out] ifail - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideF). !> If info[l] = 0, the first nev[l] elements of ifail_l are zero. !> Otherwise, contains the indices of those eigenvectors that failed !> to converge. Not referenced if evect is rocblas_evect_none. !> @param[in] strideF - rocblas_stride. !> Stride from the start of one vector ifail_l to the next one ifail_(l+1). !> There is no restriction for the value of strideF. The normal use case is !> strideF >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. !> If info[l] = i > 0, the algorithm did not converge. i columns of Z_l did not !> converge. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssyevx_strided_batched function rocsolver_ssyevx_strided_batched_(handle,evect,erange,uplo,n,A,lda,strideA,vl,vu,il, & iu,abstol,nev,W,strideW,Z,ldz,strideZ,ifail,strideF,myInfo,batch_count) & bind(c, name="rocsolver_ssyevx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_float),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz integer(c_int64_t),value :: strideZ type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dsyevx_strided_batched function rocsolver_dsyevx_strided_batched_(handle,evect,erange,uplo,n,A,lda,strideA,vl,vu,il, & iu,abstol,nev,W,strideW,Z,ldz,strideZ,ifail,strideF,myInfo,batch_count) & bind(c, name="rocsolver_dsyevx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_double),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz integer(c_int64_t),value :: strideZ type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The HEEVX_STRIDED_BATCHED functions compute a set of the eigenvalues and optionally !> the corresponding eigenvectors !> of a batch of Hermitian matrices A_l. !> !> \details !> This function computes all the eigenvalues of A_l, all the eigenvalues in the half-open !> interval \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is rocblas_evect_original, !> the eigenvectors for these eigenvalues will be computed as well. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[in] vl - real type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] vu - real type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] abstol - real type. !> The absolute tolerance. An eigenvalue is considered to be located if it lies !> in an interval whose width is <= abstol. If abstol is negative, then !> machine-epsilon times !> the 1-norm of the tridiagonal form of A_l will be used as the tolerance. If !> abstol=0, then the tolerance will be set !> to twice the underflow threshold. This is the tolerance that could get the most !> accurate results. !> @param[out] nev - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev[l] !> = n. !> If erange is rocblas_erange_index, nev[l] = iu - il + 1. Otherwise, 0 <= nev[l] !> <= n. !> @param[out] W - pointer to real type. Array on the GPU (the size depends on the value of !> strideW). !> The first nev[l] elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] Z - pointer to type. Array on the GPU (the size depends on the value of !> strideZ). !> On exit, if evect is not rocblas_evect_none and info[l] = 0, the first nev[l] !> columns contain !> the eigenvectors of A_l corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrices Z_l. !> @param[in] strideZ - rocblas_stride. !> Stride from the start of one matrix Z_l to the next one Z_(l+1). !> There is no restriction for the value of strideZ. The normal use case is !> strideZ >= ldz*nev[l]. !> - Note: If erange is rocblas_range_value, then the values of nev[l] are not !> known in advance. !> The user should ensure that Z_l is large enough to hold n columns, as all n !> columns !> can be used as workspace for internal computations. !> @param[out] ifail - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideF). !> If info[l] = 0, the first nev[l] elements of ifail_l are zero. !> Otherwise, contains the indices of those eigenvectors that failed !> to converge. Not referenced if evect is rocblas_evect_none. !> @param[in] strideF - rocblas_stride. !> Stride from the start of one vector ifail_l to the next one ifail_(l+1). !> There is no restriction for the value of strideF. The normal use case is !> strideF >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. !> If info[l] = i > 0, the algorithm did not converge. i columns of Z_l did not !> converge. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_cheevx_strided_batched function rocsolver_cheevx_strided_batched_(handle,evect,erange,uplo,n,A,lda,strideA,vl,vu,il, & iu,abstol,nev,W,strideW,Z,ldz,strideZ,ifail,strideF,myInfo,batch_count) & bind(c, name="rocsolver_cheevx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_float),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz integer(c_int64_t),value :: strideZ type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zheevx_strided_batched function rocsolver_zheevx_strided_batched_(handle,evect,erange,uplo,n,A,lda,strideA,vl,vu,il, & iu,abstol,nev,W,strideW,Z,ldz,strideZ,ifail,strideF,myInfo,batch_count) & bind(c, name="rocsolver_zheevx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_double),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz integer(c_int64_t),value :: strideZ type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The SYGV functions compute the eigenvalues and (optionally) eigenvectors of !> a real generalized symmetric-definite eigenproblem. !> !> \details !> The problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A X = \lambda B X & \: \text{1st form,}\\% !> A B X = \lambda X & \: \text{2nd form, or}\\% !> B A X = \lambda X & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed depending on the !> value of ``evect``. !> !> When computed, the matrix Z of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z^T B Z=I & \: \text{if 1st or 2nd form, or}\\% !> Z^T B^{-1} Z=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblem. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A and B are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A and B are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the symmetric matrix A. On exit, if evect is original, !> the normalized matrix Z of eigenvectors. If evect is none, then the upper or !> lower triangular !> part of the matrix A (including the diagonal) is destroyed, !> depending on the value of uplo. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] B - pointer to type. Array on the GPU of dimension ldb*n. !> On entry, the symmetric positive definite matrix B. On exit, the !> triangular factor of B as returned by \ref rocsolver_spotrf "POTRF". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B. !> @param[out] D - pointer to type. Array on the GPU of dimension n. !> On exit, the eigenvalues in increasing order. !> @param[out] E - pointer to type. Array on the GPU of dimension n. !> This array is used to work internally with the tridiagonal matrix T associated !> with !> the reduced eigenvalue problem. !> On exit, if 0 < info <= n, it contains the unconverged off-diagonal elements of !> T !> (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal !> elements !> of this matrix are in D. Those that converged correspond to a subset of the !> eigenvalues (not necessarily ordered). !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i <= n, i off-diagonal elements of an intermediate !> tridiagonal form did not converge to zero. !> If info = n + i, the leading minor of order i of B is not !> positive definite. interface rocsolver_ssygv function rocsolver_ssygv_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) & bind(c, name="rocsolver_ssygv") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygv_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssygv_assumed_rank #else module procedure & rocsolver_ssygv_rank_0,& rocsolver_ssygv_rank_1,& rocsolver_ssygv_full_rank #endif #endif end interface interface rocsolver_dsygv function rocsolver_dsygv_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) & bind(c, name="rocsolver_dsygv") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygv_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsygv_assumed_rank #else module procedure & rocsolver_dsygv_rank_0,& rocsolver_dsygv_rank_1,& rocsolver_dsygv_full_rank #endif #endif end interface !> \brief The HEGV functions compute the eigenvalues and (optionally) eigenvectors of !> a complex generalized Hermitian-definite eigenproblem. !> !> \details !> The problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A X = \lambda B X & \: \text{1st form,}\\% !> A B X = \lambda X & \: \text{2nd form, or}\\% !> B A X = \lambda X & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed depending on the !> value of ``evect``. !> !> When computed, the matrix Z of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z^H B Z=I & \: \text{if 1st or 2nd form, or}\\% !> Z^H B^{-1} Z=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblem. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A and B are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A and B are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the Hermitian matrix A. On exit, if evect is original, !> the normalized matrix Z of eigenvectors. If evect is none, then the upper or !> lower triangular !> part of the matrix A (including the diagonal) is destroyed, !> depending on the value of uplo. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] B - pointer to type. Array on the GPU of dimension ldb*n. !> On entry, the Hermitian positive definite matrix B. On exit, the !> triangular factor of B as returned by \ref rocsolver_spotrf "POTRF". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B. !> @param[out] D - pointer to real type. Array on the GPU of dimension n. !> On exit, the eigenvalues in increasing order. !> @param[out] E - pointer to real type. Array on the GPU of dimension n. !> This array is used to work internally with the tridiagonal matrix T associated !> with !> the reduced eigenvalue problem. !> On exit, if 0 < info <= n, it contains the unconverged off-diagonal elements of !> T !> (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal !> elements !> of this matrix are in D. Those that converged correspond to a subset of the !> eigenvalues (not necessarily ordered). !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i <= n, i off-diagonal elements of an intermediate !> tridiagonal form did not converge to zero. !> If info = n + i, the leading minor of order i of B is not !> positive definite. interface rocsolver_chegv function rocsolver_chegv_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) & bind(c, name="rocsolver_chegv") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegv_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_chegv_assumed_rank #else module procedure & rocsolver_chegv_rank_0,& rocsolver_chegv_rank_1,& rocsolver_chegv_full_rank #endif #endif end interface interface rocsolver_zhegv function rocsolver_zhegv_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) & bind(c, name="rocsolver_zhegv") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegv_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zhegv_assumed_rank #else module procedure & rocsolver_zhegv_rank_0,& rocsolver_zhegv_rank_1,& rocsolver_zhegv_full_rank #endif #endif end interface !> \brief The SYGV_BATCHED functions compute the eigenvalues and (optionally) !> eigenvectors of a batch of real generalized symmetric-definite eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed depending on the !> value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^T B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^T B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the symmetric matrices A_l. On exit, if evect is original, !> the normalized matrix Z_l of eigenvectors. If evect is none, then the upper or !> lower triangular !> part of the matrices A_l (including the diagonal) are destroyed, !> depending on the value of uplo. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[out] B - array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*n. !> On entry, the symmetric positive definite matrices B_l. On exit, the !> triangular factor of B_l as returned by \ref rocsolver_spotrf_batched !> "POTRF_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[out] D - pointer to type. Array on the GPU (the size depends on the value of !> strideD). !> On exit, the eigenvalues in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. Normal usage is strideD >= n. !> @param[out] E - pointer to type. Array on the GPU (the size depends on the value of !> strideE). !> This array is used to work internally with the tridiagonal matrix T_l !> associated with !> the l-th reduced eigenvalue problem. !> On exit, if 0 < info[l] <= n, E_l contains the unconverged off-diagonal !> elements of T_l !> (or properly speaking, a tridiagonal matrix equivalent to T_l). The diagonal !> elements !> of this matrix are in D_l. Those that converged correspond to a subset of the !> eigenvalues (not necessarily ordered). !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. Normal usage is strideE >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit of batch instance l. !> If info[l] = i <= n, i off-diagonal elements of an intermediate !> tridiagonal form did not converge to zero. !> If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssygv_batched function rocsolver_ssygv_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE, & myInfo,batch_count) & bind(c, name="rocsolver_ssygv_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssygv_batched_assumed_rank #else module procedure & rocsolver_ssygv_batched_rank_0,& rocsolver_ssygv_batched_rank_1 #endif #endif end interface interface rocsolver_dsygv_batched function rocsolver_dsygv_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE, & myInfo,batch_count) & bind(c, name="rocsolver_dsygv_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsygv_batched_assumed_rank #else module procedure & rocsolver_dsygv_batched_rank_0,& rocsolver_dsygv_batched_rank_1 #endif #endif end interface !> \brief The HEGV_BATCHED functions compute the eigenvalues and (optionally) !> eigenvectors of a batch of complex generalized Hermitian-definite eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed depending on the !> value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^H B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^H B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the Hermitian matrices A_l. On exit, if evect is original, !> the normalized matrix Z_l of eigenvectors. If evect is none, then the upper or !> lower triangular !> part of the matrices A_l (including the diagonal) are destroyed, !> depending on the value of uplo. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[out] B - array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*n. !> On entry, the Hermitian positive definite matrices B_l. On exit, the !> triangular factor of B_l as returned by \ref rocsolver_spotrf_batched !> "POTRF_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> On exit, the eigenvalues in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. Normal usage is strideD >= n. !> @param[out] E - pointer to real type. Array on the GPU (the size depends on the value of !> strideE). !> This array is used to work internally with the tridiagonal matrix T_l !> associated with !> the l-th reduced eigenvalue problem. !> On exit, if 0 < info[l] <= n, it contains the unconverged off-diagonal elements !> of T_l !> (or properly speaking, a tridiagonal matrix equivalent to T_l). The diagonal !> elements !> of this matrix are in D_l. Those that converged correspond to a subset of the !> eigenvalues (not necessarily ordered). !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. Normal usage is strideE >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit of batch l. !> If info[l] = i <= n, i off-diagonal elements of an intermediate !> tridiagonal form did not converge to zero. !> If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_chegv_batched function rocsolver_chegv_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE, & myInfo,batch_count) & bind(c, name="rocsolver_chegv_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_chegv_batched_assumed_rank #else module procedure & rocsolver_chegv_batched_rank_0,& rocsolver_chegv_batched_rank_1 #endif #endif end interface interface rocsolver_zhegv_batched function rocsolver_zhegv_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE, & myInfo,batch_count) & bind(c, name="rocsolver_zhegv_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegv_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zhegv_batched_assumed_rank #else module procedure & rocsolver_zhegv_batched_rank_0,& rocsolver_zhegv_batched_rank_1 #endif #endif end interface !> \brief The SYGV_STRIDED_BATCHED functions compute the eigenvalues and (optionally) !> eigenvectors of a batch of real generalized symmetric-definite eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed depending on the !> value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^T B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^T B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the symmetric matrices A_l. On exit, if evect is original, !> the normalized matrix Z_l of eigenvectors. If evect is none, then the upper or !> lower triangular !> part of the matrices A_l (including the diagonal) are destroyed, !> depending on the value of uplo. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. Normal usage is strideA >= !> lda*n. !> @param[out] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> On entry, the symmetric positive definite matrices B_l. On exit, the !> triangular factor of B_l as returned by \ref rocsolver_spotrf_strided_batched !> "POTRF_STRIDED_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. Normal usage is strideB >= !> ldb*n. !> @param[out] D - pointer to type. Array on the GPU (the size depends on the value of !> strideD). !> On exit, the eigenvalues in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. Normal usage is strideD >= n. !> @param[out] E - pointer to type. Array on the GPU (the size depends on the value of !> strideE). !> This array is used to work internally with the tridiagonal matrix T_l !> associated with !> the l-th reduced eigenvalue problem. !> On exit, if 0 < info[l] <= n, it contains the unconverged off-diagonal elements !> of T_l !> (or properly speaking, a tridiagonal matrix equivalent to T_l). The diagonal !> elements !> of this matrix are in D_l. Those that converged correspond to a subset of the !> eigenvalues (not necessarily ordered). !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. Normal usage is strideE >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit of batch j. !> If info[l] = i <= n, i off-diagonal elements of an intermediate !> tridiagonal form did not converge to zero. !> If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssygv_strided_batched function rocsolver_ssygv_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,E,strideE,myInfo,batch_count) & bind(c, name="rocsolver_ssygv_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssygv_strided_batched_assumed_rank #else module procedure & rocsolver_ssygv_strided_batched_rank_0,& rocsolver_ssygv_strided_batched_rank_1,& rocsolver_ssygv_strided_batched_full_rank #endif #endif end interface interface rocsolver_dsygv_strided_batched function rocsolver_dsygv_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,E,strideE,myInfo,batch_count) & bind(c, name="rocsolver_dsygv_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsygv_strided_batched_assumed_rank #else module procedure & rocsolver_dsygv_strided_batched_rank_0,& rocsolver_dsygv_strided_batched_rank_1,& rocsolver_dsygv_strided_batched_full_rank #endif #endif end interface !> \brief The HEGV_STRIDED_BATCHED functions compute the eigenvalues and (optionally) !> eigenvectors of a batch of complex generalized Hermitian-definite eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed depending on the !> value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^H B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^H B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the Hermitian matrices A_l. On exit, if evect is original, !> the normalized matrix Z_l of eigenvectors. If evect is none, then the upper or !> lower triangular !> part of the matrices A_l (including the diagonal) are destroyed, !> depending on the value of uplo. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. Normal usage is strideA >= !> lda*n. !> @param[out] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> On entry, the Hermitian positive definite matrices B_l. On exit, the !> triangular factor of B_l as returned by \ref rocsolver_spotrf_strided_batched !> "POTRF_STRIDED_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. Normal usage is strideB >= !> ldb*n. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> On exit, the eigenvalues in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. Normal usage is strideD >= n. !> @param[out] E - pointer to real type. Array on the GPU (the size depends on the value of !> strideE). !> This array is used to work internally with the tridiagonal matrix T_l !> associated with !> the l-th reduced eigenvalue problem. !> On exit, if 0 < info[l] <= n, it contains the unconverged off-diagonal elements !> of T_l !> (or properly speaking, a tridiagonal matrix equivalent to T_l). The diagonal !> elements !> of this matrix are in D_l. Those that converged correspond to a subset of the !> eigenvalues (not necessarily ordered). !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. Normal usage is strideE >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit of batch l. !> If info[l] = i <= n, i off-diagonal elements of an intermediate !> tridiagonal form did not converge to zero. !> If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_chegv_strided_batched function rocsolver_chegv_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,E,strideE,myInfo,batch_count) & bind(c, name="rocsolver_chegv_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_chegv_strided_batched_assumed_rank #else module procedure & rocsolver_chegv_strided_batched_rank_0,& rocsolver_chegv_strided_batched_rank_1,& rocsolver_chegv_strided_batched_full_rank #endif #endif end interface interface rocsolver_zhegv_strided_batched function rocsolver_zhegv_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,E,strideE,myInfo,batch_count) & bind(c, name="rocsolver_zhegv_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegv_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zhegv_strided_batched_assumed_rank #else module procedure & rocsolver_zhegv_strided_batched_rank_0,& rocsolver_zhegv_strided_batched_rank_1,& rocsolver_zhegv_strided_batched_full_rank #endif #endif end interface !> \brief The SYGVD functions compute the eigenvalues and (optionally) eigenvectors of !> a real generalized symmetric-definite eigenproblem. !> !> \details !> The problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A X = \lambda B X & \: \text{1st form,}\\% !> A B X = \lambda X & \: \text{2nd form, or}\\% !> B A X = \lambda X & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed using a !> divide-and-conquer algorithm, depending on the !> value of ``evect``. !> !> When computed, the matrix Z of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z^T B Z=I & \: \text{if 1st or 2nd form, or}\\% !> Z^T B^{-1} Z=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblem. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A and B are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A and B are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the symmetric matrix A. On exit, if evect is original, !> the normalized matrix Z of eigenvectors. If evect is none, then the upper or !> lower triangular !> part of the matrix A (including the diagonal) is destroyed, !> depending on the value of uplo. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] B - pointer to type. Array on the GPU of dimension ldb*n. !> On entry, the symmetric positive definite matrix B. On exit, the !> triangular factor of B, as returned by \ref rocsolver_spotrf "POTRF". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B. !> @param[out] D - pointer to type. Array on the GPU of dimension n. !> On exit, the eigenvalues in increasing order. !> @param[out] E - pointer to type. Array on the GPU of dimension n. !> This array is used to work internally with the tridiagonal matrix T associated !> with !> the reduced eigenvalue problem. !> On exit, if 0 < info <= n, it contains the unconverged off-diagonal elements of !> T !> (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal !> elements !> of this matrix are in D. Those that converged correspond to a subset of the !> eigenvalues (not necessarily ordered). !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> - If info = 0, successful exit. !> - If info = i <= n and evect is rocblas_evect_none, i off-diagonal elements of !> an !> intermediate tridiagonal form did not converge to zero. !> - If info = i <= n and evect is rocblas_evect_original, the algorithm failed to !> compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), !> i%(n+1)]. !> - If info = n + i, the leading minor of order i of B is not !> positive definite. interface rocsolver_ssygvd function rocsolver_ssygvd_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) & bind(c, name="rocsolver_ssygvd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssygvd_assumed_rank #else module procedure & rocsolver_ssygvd_rank_0,& rocsolver_ssygvd_rank_1,& rocsolver_ssygvd_full_rank #endif #endif end interface interface rocsolver_dsygvd function rocsolver_dsygvd_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) & bind(c, name="rocsolver_dsygvd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsygvd_assumed_rank #else module procedure & rocsolver_dsygvd_rank_0,& rocsolver_dsygvd_rank_1,& rocsolver_dsygvd_full_rank #endif #endif end interface !> \brief The HEGVD functions computes the eigenvalues and (optionally) eigenvectors of !> a complex generalized Hermitian-definite eigenproblem. !> !> \details !> The problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A X = \lambda B X & \: \text{1st form,}\\% !> A B X = \lambda X & \: \text{2nd form, or}\\% !> B A X = \lambda X & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed using a !> divide-and-conquer algorithm, depending on the !> value of ``evect``. !> !> When computed, the matrix Z of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z^H B Z=I & \: \text{if 1st or 2nd form, or}\\% !> Z^H B^{-1} Z=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblem. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A and B are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A and B are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the Hermitian matrix A. On exit, if evect is original, !> the normalized matrix Z of eigenvectors. If evect is none, then the upper or !> lower triangular !> part of the matrix A (including the diagonal) is destroyed, !> depending on the value of uplo. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] B - pointer to type. Array on the GPU of dimension ldb*n. !> On entry, the Hermitian positive definite matrix B. On exit, the !> triangular factor of B as returned by \ref rocsolver_spotrf "POTRF". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B. !> @param[out] D - pointer to real type. Array on the GPU of dimension n. !> On exit, the eigenvalues in increasing order. !> @param[out] E - pointer to real type. Array on the GPU of dimension n. !> This array is used to work internally with the tridiagonal matrix T associated !> with !> the reduced eigenvalue problem. !> On exit, if 0 < info <= n, it contains the unconverged off-diagonal elements of !> T !> (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal !> elements !> of this matrix are in D. Those that converged correspond to a subset of the !> eigenvalues (not necessarily ordered). !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> - If info = 0, successful exit. !> - If info = i <= n and evect is rocblas_evect_none, i off-diagonal elements of !> an !> intermediate tridiagonal form did not converge to zero. !> - If info = i <= n and evect is rocblas_evect_original, the algorithm failed to !> compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), !> i%(n+1)]. !> - If info = n + i, the leading minor of order i of B is not !> positive definite. interface rocsolver_chegvd function rocsolver_chegvd_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) & bind(c, name="rocsolver_chegvd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvd_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_chegvd_assumed_rank #else module procedure & rocsolver_chegvd_rank_0,& rocsolver_chegvd_rank_1,& rocsolver_chegvd_full_rank #endif #endif end interface interface rocsolver_zhegvd function rocsolver_zhegvd_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) & bind(c, name="rocsolver_zhegvd") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D type(c_ptr),value :: E type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zhegvd_assumed_rank #else module procedure & rocsolver_zhegvd_rank_0,& rocsolver_zhegvd_rank_1,& rocsolver_zhegvd_full_rank #endif #endif end interface !> \brief The SYGVD_BATCHED functions compute the eigenvalues and (optionally) !> eigenvectors of a batch of real generalized symmetric-definite eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed using a !> divide-and-conquer algorithm, depending on the !> value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^T B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^T B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> \note !> In order to carry out calculations, this method could potentially synchronize the stream !> contained within the !> ``rocblas_handle``. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the symmetric matrices A_l. On exit, if evect is original, !> the normalized matrix Z_l of eigenvectors. If evect is none, then the upper or !> lower triangular !> part of the matrices A_l (including the diagonal) are destroyed, !> depending on the value of uplo. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[out] B - array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*n. !> On entry, the symmetric positive definite matrices B_l. On exit, the !> triangular factor of B_l, as returned by \ref rocsolver_spotrf_batched !> "POTRF_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[out] D - pointer to type. Array on the GPU (the size depends on the value of !> strideD). !> On exit, the eigenvalues in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. Normal usage is strideD >= n. !> @param[out] E - pointer to type. Array on the GPU (the size depends on the value of !> strideE). !> This array is used to work internally with the tridiagonal matrix T_l !> associated with !> the l-th reduced eigenvalue problem. !> On exit, if 0 < info[l] <= n, it contains the unconverged off-diagonal elements !> of T_l !> (or properly speaking, a tridiagonal matrix equivalent to T_l). The diagonal !> elements !> of this matrix are in D_l. Those that converged correspond to a subset of the !> eigenvalues (not necessarily ordered). !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. Normal usage is strideE >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> - If info[l] = 0, successful exit of batch l. !> - If info[l] = i <= n and evect is rocblas_evect_none, i off-diagonal elements !> of an !> intermediate tridiagonal form did not converge to zero. !> - If info[l] = i <= n and evect is rocblas_evect_original, the algorithm failed !> to !> compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), !> i%(n+1)]. !> - If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssygvd_batched function rocsolver_ssygvd_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE, & myInfo,batch_count) & bind(c, name="rocsolver_ssygvd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssygvd_batched_assumed_rank #else module procedure & rocsolver_ssygvd_batched_rank_0,& rocsolver_ssygvd_batched_rank_1 #endif #endif end interface interface rocsolver_dsygvd_batched function rocsolver_dsygvd_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE, & myInfo,batch_count) & bind(c, name="rocsolver_dsygvd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsygvd_batched_assumed_rank #else module procedure & rocsolver_dsygvd_batched_rank_0,& rocsolver_dsygvd_batched_rank_1 #endif #endif end interface !> \brief The HEGVD_BATCHED functions compute the eigenvalues and (optionally) !> eigenvectors of a batch of complex generalized Hermitian-definite eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed using a !> divide-and-conquer algorithm, depending on the !> value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^H B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^H B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> \note !> In order to carry out calculations, this method could potentially synchronize the stream !> contained within the !> ``rocblas_handle``. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the Hermitian matrices A_l. On exit, if evect is original, !> the normalized matrix Z_l of eigenvectors. If evect is none, then the upper or !> lower triangular !> part of the matrices A_l (including the diagonal) are destroyed, !> depending on the value of uplo. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[out] B - array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*n. !> On entry, the Hermitian positive definite matrices B_l. On exit, the !> triangular factor of B_l as returned by \ref rocsolver_spotrf_batched !> "POTRF_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> On exit, the eigenvalues in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. Normal usage is strideD >= n. !> @param[out] E - pointer to real type. Array on the GPU (the size depends on the value of !> strideE). !> This array is used to work internally with the tridiagonal matrix T_l !> associated with !> the l-th reduced eigenvalue problem. !> On exit, if 0 < info[l] <= n, it contains the unconverged off-diagonal elements !> of T_l !> (or properly speaking, a tridiagonal matrix equivalent to T_l). The diagonal !> elements !> of this matrix are in D_l. Those that converged correspond to a subset of the !> eigenvalues (not necessarily ordered). !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. Normal usage is strideE >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> - If info[l] = 0, successful exit of batch l. !> - If info[l] = i <= n and evect is rocblas_evect_none, i off-diagonal elements !> of an !> intermediate tridiagonal form did not converge to zero. !> - If info[l] = i <= n and evect is rocblas_evect_original, the algorithm failed !> to !> compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), !> i%(n+1)]. !> - If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_chegvd_batched function rocsolver_chegvd_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE, & myInfo,batch_count) & bind(c, name="rocsolver_chegvd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_chegvd_batched_assumed_rank #else module procedure & rocsolver_chegvd_batched_rank_0,& rocsolver_chegvd_batched_rank_1 #endif #endif end interface interface rocsolver_zhegvd_batched function rocsolver_zhegvd_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E,strideE, & myInfo,batch_count) & bind(c, name="rocsolver_zhegvd_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zhegvd_batched_assumed_rank #else module procedure & rocsolver_zhegvd_batched_rank_0,& rocsolver_zhegvd_batched_rank_1 #endif #endif end interface !> \brief The SYGVD_STRIDED_BATCHED functions compute the eigenvalues and (optionally) !> eigenvectors of a batch of real generalized symmetric-definite eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed using a !> divide-and-conquer algorithm, depending on the !> value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^T B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^T B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> \note !> In order to carry out calculations, this method could potentially synchronize the stream !> contained within the !> ``rocblas_handle``. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the symmetric matrices A_l. On exit, if evect is original, !> the normalized matrix Z_l of eigenvectors. If evect is none, then the upper or !> lower triangular !> part of the matrices A_l (including the diagonal) are destroyed, !> depending on the value of uplo. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. Normal usage is strideA >= !> lda*n. !> @param[out] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> On entry, the symmetric positive definite matrices B_l. On exit, the !> triangular factor of B_l as returned by \ref rocsolver_spotrf_strided_batched !> "POTRF_STRIDED_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. Normal usage is strideB >= !> ldb*n. !> @param[out] D - pointer to type. Array on the GPU (the size depends on the value of !> strideD). !> On exit, the eigenvalues in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. Normal usage is strideD >= n. !> @param[out] E - pointer to type. Array on the GPU (the size depends on the value of !> strideE). !> This array is used to work internally with the tridiagonal matrix T_l !> associated with !> the l-th reduced eigenvalue problem. !> On exit, if 0 < info[l] <= n, it contains the unconverged off-diagonal elements !> of T_l !> (or properly speaking, a tridiagonal matrix equivalent to T_l). The diagonal !> elements !> of this matrix are in D_l. Those that converged correspond to a subset of the !> eigenvalues (not necessarily ordered). !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. Normal usage is strideE >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> - If info[l] = 0, successful exit of batch l. !> - If info[l] = i <= n and evect is rocblas_evect_none, i off-diagonal elements !> of an !> intermediate tridiagonal form did not converge to zero. !> - If info[l] = i <= n and evect is rocblas_evect_original, the algorithm failed !> to !> compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), !> i%(n+1)]. !> - If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssygvd_strided_batched function rocsolver_ssygvd_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,E,strideE,myInfo,batch_count) & bind(c, name="rocsolver_ssygvd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssygvd_strided_batched_assumed_rank #else module procedure & rocsolver_ssygvd_strided_batched_rank_0,& rocsolver_ssygvd_strided_batched_rank_1,& rocsolver_ssygvd_strided_batched_full_rank #endif #endif end interface interface rocsolver_dsygvd_strided_batched function rocsolver_dsygvd_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,E,strideE,myInfo,batch_count) & bind(c, name="rocsolver_dsygvd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsygvd_strided_batched_assumed_rank #else module procedure & rocsolver_dsygvd_strided_batched_rank_0,& rocsolver_dsygvd_strided_batched_rank_1,& rocsolver_dsygvd_strided_batched_full_rank #endif #endif end interface !> \brief The HEGVD_STRIDED_BATCHED functions compute the eigenvalues and (optionally) !> eigenvectors of a batch of complex generalized Hermitian-definite eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed using a !> divide-and-conquer algorithm, depending on the !> value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^H B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^H B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> \note !> In order to carry out calculations, this method could potentially synchronize the stream !> contained within the !> ``rocblas_handle``. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the Hermitian matrices A_l. On exit, if evect is original, !> the normalized matrix Z_l of eigenvectors. If evect is none, then the upper or !> lower triangular !> part of the matrices A_l (including the diagonal) are destroyed, !> depending on the value of uplo. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. Normal usage is strideA >= !> lda*n. !> @param[out] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> On entry, the Hermitian positive definite matrices B_l. On exit, the !> triangular factor of B_l as returned by \ref rocsolver_spotrf_strided_batched !> "POTRF_STRIDED_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. Normal usage is strideB >= !> ldb*n. !> @param[out] D - pointer to real type. Array on the GPU (the size depends on the value of !> strideD). !> On exit, the eigenvalues in increasing order. !> @param[in] strideD - rocblas_stride. !> Stride from the start of one vector D_l to the next one D_(l+1). !> There is no restriction for the value of strideD. Normal usage is strideD >= n. !> @param[out] E - pointer to real type. Array on the GPU (the size depends on the value of !> strideE). !> This array is used to work internally with the tridiagonal matrix T_l !> associated with !> the l-th reduced eigenvalue problem. !> On exit, if 0 < info[l] <= n, it contains the unconverged off-diagonal elements !> of T_l !> (or properly speaking, a tridiagonal matrix equivalent to T_l). The diagonal !> elements !> of this matrix are in D_l. Those that converged correspond to a subset of the !> eigenvalues (not necessarily ordered). !> @param[in] strideE - rocblas_stride. !> Stride from the start of one vector E_l to the next one E_(l+1). !> There is no restriction for the value of strideE. Normal usage is strideE >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> - If info[l] = 0, successful exit of batch l. !> - If info[l] = i <= n and evect is rocblas_evect_none, i off-diagonal elements !> of an !> intermediate tridiagonal form did not converge to zero. !> - If info[l] = i <= n and evect is rocblas_evect_original, the algorithm failed !> to !> compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), !> i%(n+1)]. !> - If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_chegvd_strided_batched function rocsolver_chegvd_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,E,strideE,myInfo,batch_count) & bind(c, name="rocsolver_chegvd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_chegvd_strided_batched_assumed_rank #else module procedure & rocsolver_chegvd_strided_batched_rank_0,& rocsolver_chegvd_strided_batched_rank_1,& rocsolver_chegvd_strided_batched_full_rank #endif #endif end interface interface rocsolver_zhegvd_strided_batched function rocsolver_zhegvd_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,E,strideE,myInfo,batch_count) & bind(c, name="rocsolver_zhegvd_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 :: D integer(c_int64_t),value :: strideD type(c_ptr),value :: E integer(c_int64_t),value :: strideE type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zhegvd_strided_batched_assumed_rank #else module procedure & rocsolver_zhegvd_strided_batched_rank_0,& rocsolver_zhegvd_strided_batched_rank_1,& rocsolver_zhegvd_strided_batched_full_rank #endif #endif end interface !> \brief The SYGVJ functions compute the eigenvalues and (optionally) eigenvectors of !> a real generalized symmetric-definite eigenproblem. !> !> \details !> The problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A X = \lambda B X & \: \text{1st form,}\\% !> A B X = \lambda X & \: \text{2nd form, or}\\% !> B A X = \lambda X & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvalues are found using the iterative !> Jacobi algorithm and returned in ascending order. The eigenvectors are computed !> depending on the value of ``evect``. !> !> When computed, the matrix Z of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z^T B Z=I & \: \text{if 1st or 2nd form, or}\\% !> Z^T B^{-1} Z=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> \note !> In order to carry out calculations, this method could potentially synchronize the stream !> contained within the !> ``rocblas_handle``. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblem. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A and B are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A and B are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the symmetric matrix A. On exit, if evect is original, !> the normalized matrix Z of eigenvectors. If evect is none, then the upper or !> lower triangular !> part of the matrix A (including the diagonal) is destroyed, !> depending on the value of uplo. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] B - pointer to type. Array on the GPU of dimension ldb*n. !> On entry, the symmetric positive definite matrix B. On exit, the !> triangular factor of B, as returned by \ref rocsolver_spotrf "POTRF". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B. !> @param[in] abstol - type. !> The absolute tolerance. The algorithm is considered to have converged once the !> residual !> is <= abstol. If abstol <= 0, then the tolerance will be set to machine !> precision. !> @param[out] residual - pointer to type on the GPU. !> The Frobenius norm of the off-diagonal elements at the final iteration. !> @param[in] max_sweeps - rocblas_int. max_sweeps > 0. !> Maximum number of sweeps (iterations) to be used by the algorithm. !> @param[out] n_sweeps - pointer to a rocblas_int on the GPU. !> The actual number of sweeps (iterations) used by the algorithm. !> @param[out] W - pointer to type. Array on the GPU of dimension n. !> On exit, the eigenvalues in increasing order. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = 1, the algorithm did not converge. !> If info = n + i, the leading minor of order i of B is not !> positive definite. interface rocsolver_ssygvj function rocsolver_ssygvj_(handle,itype,evect,uplo,n,A,lda,B,ldb,abstol,residual,max_sweeps, & n_sweeps,W,myInfo) & bind(c, name="rocsolver_ssygvj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvj_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W type(c_ptr),value :: myInfo end function end interface interface rocsolver_dsygvj function rocsolver_dsygvj_(handle,itype,evect,uplo,n,A,lda,B,ldb,abstol,residual,max_sweeps, & n_sweeps,W,myInfo) & bind(c, name="rocsolver_dsygvj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvj_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W type(c_ptr),value :: myInfo end function end interface !> \brief The HEGVJ functions compute the eigenvalues and (optionally) eigenvectors of !> a complex generalized Hermitian-definite eigenproblem. !> !> \details !> The problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A X = \lambda B X & \: \text{1st form,}\\% !> A B X = \lambda X & \: \text{2nd form, or}\\% !> B A X = \lambda X & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvalues are found using the iterative !> Jacobi algorithm and returned in ascending order. The eigenvectors are computed !> depending on the value of ``evect``. !> !> When computed, the matrix Z of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z^H B Z=I & \: \text{if 1st or 2nd form, or}\\% !> Z^H B^{-1} Z=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> \note !> In order to carry out calculations, this method could potentially synchronize the stream !> contained within the !> ``rocblas_handle``. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblem. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A and B are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A and B are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the Hermitian matrix A. On exit, if evect is original, !> the normalized matrix Z of eigenvectors. If evect is none, then the upper or !> lower triangular !> part of the matrix A (including the diagonal) is destroyed, !> depending on the value of uplo. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] B - pointer to type. Array on the GPU of dimension ldb*n. !> On entry, the Hermitian positive definite matrix B. On exit, the !> triangular factor of B, as returned by \ref rocsolver_spotrf "POTRF". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B. !> @param[in] abstol - real type. !> The absolute tolerance. The algorithm is considered to have converged once the !> residual !> is <= abstol. If abstol <= 0, then the tolerance will be set to machine !> precision. !> @param[out] residual - pointer to real type on the GPU. !> The Frobenius norm of the off-diagonal elements at the final iteration. !> @param[in] max_sweeps - rocblas_int. max_sweeps > 0. !> Maximum number of sweeps (iterations) to be used by the algorithm. !> @param[out] n_sweeps - pointer to a rocblas_int on the GPU. !> The actual number of sweeps (iterations) used by the algorithm. !> @param[out] W - pointer to real type. Array on the GPU of dimension n. !> On exit, the eigenvalues in increasing order. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = 1, the algorithm did not converge. !> If info = n + i, the leading minor of order i of B is not !> positive definite. interface rocsolver_chegvj function rocsolver_chegvj_(handle,itype,evect,uplo,n,A,lda,B,ldb,abstol,residual,max_sweeps, & n_sweeps,W,myInfo) & bind(c, name="rocsolver_chegvj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvj_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W type(c_ptr),value :: myInfo end function end interface interface rocsolver_zhegvj function rocsolver_zhegvj_(handle,itype,evect,uplo,n,A,lda,B,ldb,abstol,residual,max_sweeps, & n_sweeps,W,myInfo) & bind(c, name="rocsolver_zhegvj") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvj_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W type(c_ptr),value :: myInfo end function end interface !> \brief The SYGVJ_BATCHED functions compute the eigenvalues and (optionally) !> eigenvectors of a batch of real generalized symmetric-definite eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvalues are found using the iterative !> Jacobi algorithm and returned in ascending order. The eigenvectors are computed !> depending on the value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^T B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^T B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the symmetric matrices A_l. On exit, if evect is original, !> the normalized matrix Z_l of eigenvectors. If evect is none, then the upper or !> lower triangular !> part of the matrices A_l (including the diagonal) are destroyed, !> depending on the value of uplo. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[out] B - array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*n. !> On entry, the symmetric positive definite matrices B_l. On exit, the !> triangular factor of B_l, as returned by \ref rocsolver_spotrf_batched !> "POTRF_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] abstol - type. !> The absolute tolerance. The algorithm is considered to have converged once the !> residual !> is <= abstol. If abstol <= 0, then the tolerance will be set to machine !> precision. !> @param[out] residual - pointer to type. Array of batch_count scalars on the GPU. !> The Frobenius norm of the off-diagonal elements at the final iteration for each !> batch instance. !> @param[in] max_sweeps - rocblas_int. max_sweeps > 0. !> Maximum number of sweeps (iterations) to be used by the algorithm. !> @param[out] n_sweeps - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The actual number of sweeps (iterations) used by the algorithm for each batch !> instance. !> @param[out] W - pointer to type. Array on the GPU (the size depends on the value of !> strideW). !> On exit, the eigenvalues in increasing order. !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. Normal usage is strideW >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit of batch instance l. !> If info[l] = 1, the algorithm did not converge. !> If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssygvj_batched function rocsolver_ssygvj_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,abstol,residual, & max_sweeps,n_sweeps,W,strideW,myInfo,batch_count) & bind(c, name="rocsolver_ssygvj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dsygvj_batched function rocsolver_dsygvj_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,abstol,residual, & max_sweeps,n_sweeps,W,strideW,myInfo,batch_count) & bind(c, name="rocsolver_dsygvj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The HEGVJ_BATCHED functions compute the eigenvalues and (optionally) !> eigenvectors of a batch of complex generalized Hermitian-definite eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvalues are found using the iterative !> Jacobi algorithm and returned in ascending order. The eigenvectors are computed !> depending on the value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^H B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^H B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the Hermitian matrices A_l. On exit, if evect is original, !> the normalized matrix Z_l of eigenvectors. If evect is none, then the upper or !> lower triangular !> part of the matrices A_l (including the diagonal) are destroyed, !> depending on the value of uplo. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[out] B - array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*n. !> On entry, the Hermitian positive definite matrices B_l. On exit, the !> triangular factor of B_l, as returned by \ref rocsolver_spotrf_batched !> "POTRF_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] abstol - real type. !> The absolute tolerance. The algorithm is considered to have converged once the !> residual !> is <= abstol. If abstol <= 0, then the tolerance will be set to machine !> precision. !> @param[out] residual - pointer to real type. Array of batch_count scalars on the GPU. !> The Frobenius norm of the off-diagonal elements at the final iteration for each !> batch instance. !> @param[in] max_sweeps - rocblas_int. max_sweeps > 0. !> Maximum number of sweeps (iterations) to be used by the algorithm. !> @param[out] n_sweeps - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The actual number of sweeps (iterations) used by the algorithm for each batch !> instance. !> @param[out] W - pointer to real type. Array on the GPU (the size depends on the value of !> strideW). !> On exit, the eigenvalues in increasing order. !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. Normal usage is strideW >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit of batch l. !> If info[l] = 1, the algorithm did not converge. !> If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_chegvj_batched function rocsolver_chegvj_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,abstol,residual, & max_sweeps,n_sweeps,W,strideW,myInfo,batch_count) & bind(c, name="rocsolver_chegvj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zhegvj_batched function rocsolver_zhegvj_batched_(handle,itype,evect,uplo,n,A,lda,B,ldb,abstol,residual, & max_sweeps,n_sweeps,W,strideW,myInfo,batch_count) & bind(c, name="rocsolver_zhegvj_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvj_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The SYGVJ_STRIDED_BATCHED functions compute the eigenvalues and (optionally) !> eigenvectors of a batch of real generalized symmetric-definite eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvalues are found using the iterative !> Jacobi algorithm and returned in ascending order. The eigenvectors are computed !> depending on the value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^T B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^T B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the symmetric matrices A_l. On exit, if evect is original, !> the normalized matrix Z_l of eigenvectors. If evect is none, then the upper or !> lower triangular !> part of the matrices A_l (including the diagonal) are destroyed, !> depending on the value of uplo. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. Normal use is strideA >= !> lda*n. !> @param[out] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> On entry, the symmetric positive definite matrices B_l. On exit, the !> triangular factor of B_l, as returned by \ref rocsolver_spotrf_strided_batched !> "POTRF_STRIDED_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. Normal usage is strideB >= !> ldb*n. !> @param[in] abstol - type. !> The absolute tolerance. The algorithm is considered to have converged once the !> residual !> is <= abstol. If abstol <= 0, then the tolerance will be set to machine !> precision. !> @param[out] residual - pointer to type. Array of batch_count scalars on the GPU. !> The Frobenius norm of the off-diagonal elements at the final iteration for each !> batch instance. !> @param[in] max_sweeps - rocblas_int. max_sweeps > 0. !> Maximum number of sweeps (iterations) to be used by the algorithm. !> @param[out] n_sweeps - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The actual number of sweeps (iterations) used by the algorithm for each batch !> instance. !> @param[out] W - pointer to type. Array on the GPU (the size depends on the value of !> strideW). !> On exit, the eigenvalues in increasing order. !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. Normal usage is strideW >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit of batch l. !> If info[l] = 1, the algorithm did not converge. !> If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssygvj_strided_batched function rocsolver_ssygvj_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,abstol,residual,max_sweeps,n_sweeps,W,strideW,myInfo,batch_count) & bind(c, name="rocsolver_ssygvj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 real(c_float),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dsygvj_strided_batched function rocsolver_dsygvj_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,abstol,residual,max_sweeps,n_sweeps,W,strideW,myInfo,batch_count) & bind(c, name="rocsolver_dsygvj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 real(c_double),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The HEGVJ_STRIDED_BATCHED functions compute the eigenvalues and (optionally) !> eigenvectors of a batch of complex generalized Hermitian-definite eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvalues are found using the iterative !> Jacobi algorithm and returned in ascending order. The eigenvectors are computed !> depending on the value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^H B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^H B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the Hermitian matrices A_l. On exit, if evect is original, !> the normalized matrix Z_l of eigenvectors. If evect is none, then the upper or !> lower triangular !> part of the matrices A_l (including the diagonal) are destroyed, !> depending on the value of uplo. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. Normal usage is strideA >= !> lda*n. !> @param[out] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> On entry, the Hermitian positive definite matrices B_l. On exit, the !> triangular factor of B_l, as returned by \ref rocsolver_spotrf_strided_batched !> "POTRF_STRIDED_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. Normal usage is strideB >= !> ldb*n. !> @param[in] abstol - real type. !> The absolute tolerance. The algorithm is considered to have converged once the !> residual !> is <= abstol. If abstol <= 0, then the tolerance will be set to machine !> precision. !> @param[out] residual - pointer to real type. Array of batch_count scalars on the GPU. !> The Frobenius norm of the off-diagonal elements at the final iteration for each !> batch instance. !> @param[in] max_sweeps - rocblas_int. max_sweeps > 0. !> Maximum number of sweeps (iterations) to be used by the algorithm. !> @param[out] n_sweeps - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The actual number of sweeps (iterations) used by the algorithm for each batch !> instance. !> @param[out] W - pointer to real type. Array on the GPU (the size depends on the value of !> strideW). !> On exit, the eigenvalues in increasing order. !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. Normal usage is strideW >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit of batch l. !> If info[l] = 1, the algorithm did not converge. !> If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_chegvj_strided_batched function rocsolver_chegvj_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,abstol,residual,max_sweeps,n_sweeps,W,strideW,myInfo,batch_count) & bind(c, name="rocsolver_chegvj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 real(c_float),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zhegvj_strided_batched function rocsolver_zhegvj_strided_batched_(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,abstol,residual,max_sweeps,n_sweeps,W,strideW,myInfo,batch_count) & bind(c, name="rocsolver_zhegvj_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvj_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 real(c_double),value :: abstol type(c_ptr),value :: residual integer(c_int),value :: max_sweeps type(c_ptr),value :: n_sweeps type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The SYGVX functions compute a set of the eigenvalues and optionally the !> corresponding eigenvectors of !> a real generalized symmetric-definite eigenproblem. !> !> \details !> The problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A X = \lambda B X & \: \text{1st form,}\\% !> A B X = \lambda X & \: \text{2nd form, or}\\% !> B A X = \lambda X & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed depending on the !> value of ``evect``. !> !> When computed, the matrix Z of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z^T B Z=I & \: \text{if 1st or 2nd form, or}\\% !> Z^T B^{-1} Z=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> This function computes all the eigenvalues, all the eigenvalues in the half-open interval !> \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is ``rocblas_evect_original``, !> the eigenvectors for these eigenvalues will be computed as well. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblem. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A and B are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A and B are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrix A. !> @param[out] B - pointer to type. Array on the GPU of dimension ldb*n. !> On entry, the symmetric positive definite matrix B. On exit, the !> triangular factor of B as returned by \ref rocsolver_spotrf "POTRF". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B. !> @param[in] vl - type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A or the eigenvalues within a set of indices. !> @param[in] vu - type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A or the eigenvalues in a half-open interval. !> @param[in] abstol - type. !> The absolute tolerance. An eigenvalue is considered to be located if it lies !> in an interval whose width is <= abstol. If abstol is negative, then !> machine-epsilon times !> the 1-norm of the tridiagonal form of A will be used as the tolerance. If !> abstol=0, then the tolerance will be set !> to twice the underflow threshold. This is the tolerance that could get the most !> accurate results. !> @param[out] nev - pointer to a rocblas_int on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev = !> n. !> If erange is rocblas_erange_index, nev = iu - il + 1. Otherwise, 0 <= nev <= n. !> @param[out] W - pointer to type. Array on the GPU of dimension n. !> The first nev elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[out] Z - pointer to type. Array on the GPU of dimension ldz*nev. !> On exit, if evect is not rocblas_evect_none and info = 0, the first nev columns !> contain !> the eigenvectors of A corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> - Note: If erange is rocblas_range_value, then the values of nev are not known !> in advance. !> The user should ensure that Z is large enough to hold n columns, as all n !> columns !> can be used as workspace for internal computations. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrix Z. !> @param[out] ifail - pointer to rocblas_int. Array on the GPU of dimension n. !> If info = 0, the first nev elements of ifail are zero. !> If info = i <= n, ifail contains the indices of the i eigenvectors that failed !> to converge. !> Not referenced if evect is rocblas_evect_none. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i <= n, i columns of Z did not converge. !> If info = n + i, the leading minor of order i of B is not !> positive definite. interface rocsolver_ssygvx function rocsolver_ssygvx_(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu,abstol, & nev,W,Z,ldz,ifail,myInfo) & bind(c, name="rocsolver_ssygvx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvx_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_float),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail type(c_ptr),value :: myInfo end function end interface interface rocsolver_dsygvx function rocsolver_dsygvx_(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu,abstol, & nev,W,Z,ldz,ifail,myInfo) & bind(c, name="rocsolver_dsygvx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvx_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_double),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail type(c_ptr),value :: myInfo end function end interface !> \brief The HEGVX functions compute a set of the eigenvalues and optionally the !> corresponding eigenvectors of !> a complex generalized Hermitian-definite eigenproblem. !> !> \details !> The problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A X = \lambda B X & \: \text{1st form,}\\% !> A B X = \lambda X & \: \text{2nd form, or}\\% !> B A X = \lambda X & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed depending on the !> value of ``evect``. !> !> When computed, the matrix Z of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z^H B Z=I & \: \text{if 1st or 2nd form, or}\\% !> Z^H B^{-1} Z=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> This function computes all the eigenvalues, all the eigenvalues in the half-open interval !> \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is ``rocblas_evect_original``, !> the eigenvectors for these eigenvalues will be computed as well. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblem. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A and B are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A and B are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrix A. !> @param[out] B - pointer to type. Array on the GPU of dimension ldb*n. !> On entry, the Hermitian positive definite matrix B. On exit, the !> triangular factor of B, as returned by \ref rocsolver_spotrf "POTRF". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B. !> @param[in] vl - real type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A or the eigenvalues within a set of indices. !> @param[in] vu - real type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A or the eigenvalues in a half-open interval. !> @param[in] abstol - real type. !> The absolute tolerance. An eigenvalue is considered to be located if it lies !> in an interval whose width is <= abstol. If abstol is negative, then !> machine-epsilon times !> the 1-norm of the tridiagonal form of A will be used as the tolerance. If !> abstol=0, then the tolerance will be set !> to twice the underflow threshold. This is the tolerance that could get the most !> accurate results. !> @param[out] nev - pointer to a rocblas_int on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev = !> n. !> If erange is rocblas_erange_index, nev = iu - il + 1. Otherwise, 0 <= nev <= n. !> @param[out] W - pointer to real type. Array on the GPU of dimension n. !> The first nev elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[out] Z - pointer to type. Array on the GPU of dimension ldz*nev. !> On exit, if evect is not rocblas_evect_none and info = 0, the first nev columns !> contain !> the eigenvectors of A corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> - Note: If erange is rocblas_range_value, then the values of nev are not known !> in advance. !> The user should ensure that Z is large enough to hold n columns, as all n !> columns !> can be used as workspace for internal computations. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrix Z. !> @param[out] ifail - pointer to rocblas_int. Array on the GPU of dimension n. !> If info = 0, the first nev elements of ifail are zero. !> If info = i <= n, ifail contains the indices of the i eigenvectors that failed !> to converge. !> Not referenced if evect is rocblas_evect_none. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i <= n, i columns of Z did not converge. !> If info = n + i, the leading minor of order i of B is not !> positive definite. interface rocsolver_chegvx function rocsolver_chegvx_(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu,abstol, & nev,W,Z,ldz,ifail,myInfo) & bind(c, name="rocsolver_chegvx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvx_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_float),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail type(c_ptr),value :: myInfo end function end interface interface rocsolver_zhegvx function rocsolver_zhegvx_(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu,abstol, & nev,W,Z,ldz,ifail,myInfo) & bind(c, name="rocsolver_zhegvx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvx_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_double),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail type(c_ptr),value :: myInfo end function end interface !> \brief The SYGVX_BATCHED functions compute a set of the eigenvalues and optionally !> the corresponding eigenvectors of a batch of real generalized symmetric-definite !> eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed depending on the !> value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^T B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^T B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> This function computes all the eigenvalues, all the eigenvalues in the half-open interval !> \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is ``rocblas_evect_original``, !> the eigenvectors for these eigenvalues will be computed as well. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[out] B - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*n. !> On entry, the symmetric positive definite matrices B_l. On exit, the !> triangular factor of B_l as returned by \ref rocsolver_spotrf_batched !> "POTRF_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] vl - type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] vu - type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] abstol - type. !> The absolute tolerance. An eigenvalue is considered to be located if it lies !> in an interval whose width is <= abstol. If abstol is negative, then !> machine-epsilon times !> the 1-norm of the tridiagonal form of A_l will be used as the tolerance. If !> abstol=0, then the tolerance will be set !> to twice the underflow threshold. This is the tolerance that could get the most !> accurate results. !> @param[out] nev - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev[l] !> = n. !> If erange is rocblas_erange_index, nev[l] = iu - il + 1. Otherwise, 0 <= nev[l] !> <= n. !> @param[out] W - pointer to type. Array on the GPU (the size depends on the value of !> strideW). !> The first nev[l] elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] Z - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldz*nev[l]. !> On exit, if evect is not rocblas_evect_none and info[l] = 0, the first nev[l] !> columns contain !> the eigenvectors of A_l corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> - Note: If erange is rocblas_range_value, then the values of nev[l] are not !> known in advance. !> The user should ensure that Z_l is large enough to hold n columns, as all n !> columns !> can be used as workspace for internal computations. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrices Z_l. !> @param[out] ifail - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideF). !> If info[l] = 0, the first nev[l] elements of ifail_l are zero. !> If info[l] = i <= n, ifail_l contains the indices of the i eigenvectors that !> failed !> to converge. !> Not referenced if evect is rocblas_evect_none. !> @param[in] strideF - rocblas_stride. !> Stride from the start of one vector ifail_l to the next one ifail_(l+1). !> There is no restriction for the value of strideF. The normal use case is !> strideF >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit of batch instance l. !> If info[l] = i <= n, i columns of Z_l did not converge. !> If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssygvx_batched function rocsolver_ssygvx_batched_(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu, & abstol,nev,W,strideW,Z,ldz,ifail,strideF,myInfo,batch_count) & bind(c, name="rocsolver_ssygvx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_float),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dsygvx_batched function rocsolver_dsygvx_batched_(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu, & abstol,nev,W,strideW,Z,ldz,ifail,strideF,myInfo,batch_count) & bind(c, name="rocsolver_dsygvx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_double),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The HEGVX_BATCHED functions compute a set of the eigenvalues and optionally !> the corresponding eigenvectors of a batch of complex generalized Hermitian-definite !> eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed depending on the !> value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^H B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^H B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> This function computes all the eigenvalues, all the eigenvalues in the half-open interval !> \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is ``rocblas_evect_original``, !> the eigenvectors for these eigenvalues will be computed as well. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[out] B - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*n. !> On entry, the Hermitian positive definite matrices B_l. On exit, the !> triangular factor of B_l as returned by \ref rocsolver_spotrf_batched !> "POTRF_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] vl - real type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] vu - real type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] abstol - real type. !> The absolute tolerance. An eigenvalue is considered to be located if it lies !> in an interval whose width is <= abstol. If abstol is negative, then !> machine-epsilon times !> the 1-norm of the tridiagonal form of A_l will be used as the tolerance. If !> abstol=0, then the tolerance will be set !> to twice the underflow threshold. This is the tolerance that could get the most !> accurate results. !> @param[out] nev - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev[l] !> = n. !> If erange is rocblas_erange_index, nev[l] = iu - il + 1. Otherwise, 0 <= nev[l] !> <= n. !> @param[out] W - pointer to real type. Array on the GPU (the size depends on the value of !> strideW). !> The first nev[l] elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] Z - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldz*nev[l]. !> On exit, if evect is not rocblas_evect_none and info[l] = 0, the first nev[l] !> columns contain !> the eigenvectors of A_l corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> - Note: If erange is rocblas_range_value, then the values of nev[l] are not !> known in advance. !> The user should ensure that Z_l is large enough to hold n columns, as all n !> columns !> can be used as workspace for internal computations. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrices Z_l. !> @param[out] ifail - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideF). !> If info[l] = 0, the first nev[l] elements of ifail_l are zero. !> If info[l] = i <= n, ifail_l contains the indices of the i eigenvectors that !> failed !> to converge. !> Not referenced if evect is rocblas_evect_none. !> @param[in] strideF - rocblas_stride. !> Stride from the start of one vector ifail_l to the next one ifail_(l+1). !> There is no restriction for the value of strideF. The normal use case is !> strideF >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit of batch instance l. !> If info[l] = i <= n, i columns of Z_l did not converge. !> If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_chegvx_batched function rocsolver_chegvx_batched_(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu, & abstol,nev,W,strideW,Z,ldz,ifail,strideF,myInfo,batch_count) & bind(c, name="rocsolver_chegvx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_float),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zhegvx_batched function rocsolver_zhegvx_batched_(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu, & abstol,nev,W,strideW,Z,ldz,ifail,strideF,myInfo,batch_count) & bind(c, name="rocsolver_zhegvx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_double),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The SYGVX_STRIDED_BATCHED functions compute a set of the eigenvalues and optionally !> the corresponding eigenvectors of a batch of real generalized symmetric-definite !> eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed depending on the !> value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^T B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^T B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> This function computes all the eigenvalues, all the eigenvalues in the half-open interval !> \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is ``rocblas_evect_original``, !> the eigenvectors for these eigenvalues will be computed as well. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> On entry, the symmetric positive definite matrices B_l. On exit, the !> triangular factor of B_l as returned by \ref rocsolver_spotrf_strided_batched !> "POTRF_STRIDED_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. The normal use case is !> strideB >= ldb*n. !> @param[in] vl - type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] vu - type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] abstol - type. !> The absolute tolerance. An eigenvalue is considered to be located if it lies !> in an interval whose width is <= abstol. If abstol is negative, then !> machine-epsilon times !> the 1-norm of the tridiagonal form of A_l will be used as the tolerance. If !> abstol=0, then the tolerance will be set !> to twice the underflow threshold. This is the tolerance that could get the most !> accurate results. !> @param[out] nev - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev[l] !> = n. !> If erange is rocblas_erange_index, nev[l] = iu - il + 1. Otherwise, 0 <= nev[l] !> <= n. !> @param[out] W - pointer to type. Array on the GPU (the size depends on the value of !> strideW). !> The first nev[l] elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] Z - pointer to type. Array on the GPU (the size depends on the value of !> strideZ). !> On exit, if evect is not rocblas_evect_none and info[l] = 0, the first nev[l] !> columns contain !> the eigenvectors of A_l corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrices Z_l. !> @param[in] strideZ - rocblas_stride. !> Stride from the start of one matrix Z_l to the next one Z_(l+1). !> There is no restriction for the value of strideZ. The normal use case is !> strideZ >= ldz*nev[l]. !> - Note: If erange is rocblas_range_value, then the values of nev[l] are not !> known in advance. !> The user should ensure that Z_l is large enough to hold n columns, as all n !> columns !> can be used as workspace for internal computations. !> @param[out] ifail - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideF). !> If info[l] = 0, the first nev[l] elements of ifail_l are zero. !> If info[l] = i <= n, ifail_l contains the indices of the i eigenvectors that !> failed !> to converge. !> Not referenced if evect is rocblas_evect_none. !> @param[in] strideF - rocblas_stride. !> Stride from the start of one vector ifail_l to the next one ifail_(l+1). !> There is no restriction for the value of strideF. The normal use case is !> strideF >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit of batch l. !> If info[l] = i <= n, i columns of Z_l did not converge. !> If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssygvx_strided_batched function rocsolver_ssygvx_strided_batched_(handle,itype,evect,erange,uplo,n,A,lda,strideA,B, & ldb,strideB,vl,vu,il,iu,abstol,nev,W,strideW,Z,ldz,strideZ,ifail,strideF,myInfo, & batch_count) & bind(c, name="rocsolver_ssygvx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_float),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz integer(c_int64_t),value :: strideZ type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dsygvx_strided_batched function rocsolver_dsygvx_strided_batched_(handle,itype,evect,erange,uplo,n,A,lda,strideA,B, & ldb,strideB,vl,vu,il,iu,abstol,nev,W,strideW,Z,ldz,strideZ,ifail,strideF,myInfo, & batch_count) & bind(c, name="rocsolver_dsygvx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_double),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz integer(c_int64_t),value :: strideZ type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The HEGVX_STRIDED_BATCHED functions compute a set of the eigenvalues and optionally !> the corresponding eigenvectors of a batch of complex generalized Hermitian-definite !> eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed depending on the !> value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^H B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^H B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> This function computes all the eigenvalues, all the eigenvalues in the half-open interval !> \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is ``rocblas_evect_original``, !> the eigenvectors for these eigenvalues will be computed as well. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> On entry, the Hermitian positive definite matrices B_l. On exit, the !> triangular factor of B_l as returned by \ref rocsolver_spotrf_strided_batched !> "POTRF_STRIDED_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. The normal use case is !> strideB >= ldb*n. !> @param[in] vl - real type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] vu - real type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] abstol - real type. !> The absolute tolerance. An eigenvalue is considered to be located if it lies !> in an interval whose width is <= abstol. If abstol is negative, then !> machine-epsilon times !> the 1-norm of the tridiagonal form of A_l will be used as the tolerance. If !> abstol=0, then the tolerance will be set !> to twice the underflow threshold. This is the tolerance that could get the most !> accurate results. !> @param[out] nev - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev[l] !> = n. !> If erange is rocblas_erange_index, nev[l] = iu - il + 1. Otherwise, 0 <= nev[l] !> <= n. !> @param[out] W - pointer to real type. Array on the GPU (the size depends on the value of !> strideW). !> The first nev[l] elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] Z - pointer to type. Array on the GPU (the size depends on the value of !> strideZ). !> On exit, if evect is not rocblas_evect_none and info[l] = 0, the first nev[l] !> columns contain !> the eigenvectors of A_l corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrices Z_l. !> @param[in] strideZ - rocblas_stride. !> Stride from the start of one matrix Z_l to the next one Z_(l+1). !> There is no restriction for the value of strideZ. The normal use case is !> strideZ >= ldz*nev[l]. !> - Note: If erange is rocblas_range_value, then the values of nev[l] are not !> known in advance. !> The user should ensure that Z_l is large enough to hold n columns, as all n !> columns !> can be used as workspace for internal computations. !> @param[out] ifail - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideF). !> If info[l] = 0, the first nev[l] elements of ifail_l are zero. !> If info[l] = i <= n, ifail_l contains the indices of the i eigenvectors that !> failed !> to converge. !> Not referenced if evect is rocblas_evect_none. !> @param[in] strideF - rocblas_stride. !> Stride from the start of one vector ifail_l to the next one ifail_(l+1). !> There is no restriction for the value of strideF. The normal use case is !> strideF >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit of batch l. !> If info[l] = i <= n, i columns of Z_l did not converge. !> If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_chegvx_strided_batched function rocsolver_chegvx_strided_batched_(handle,itype,evect,erange,uplo,n,A,lda,strideA,B, & ldb,strideB,vl,vu,il,iu,abstol,nev,W,strideW,Z,ldz,strideZ,ifail,strideF,myInfo, & batch_count) & bind(c, name="rocsolver_chegvx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_float),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz integer(c_int64_t),value :: strideZ type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zhegvx_strided_batched function rocsolver_zhegvx_strided_batched_(handle,itype,evect,erange,uplo,n,A,lda,strideA,B, & ldb,strideB,vl,vu,il,iu,abstol,nev,W,strideW,Z,ldz,strideZ,ifail,strideF,myInfo, & batch_count) & bind(c, name="rocsolver_zhegvx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu real(c_double),value :: abstol type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz integer(c_int64_t),value :: strideZ type(c_ptr),value :: ifail integer(c_int64_t),value :: strideF type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The GETRI_OUTOFPLACE functions compute the inverse \f$C = A^{-1}\f$ of a general !> ``n`` -by-``n`` matrix ``A``. !> !> \details !> The inverse is computed by solving the linear system !> !> \f[ !> AC = I !> \f] !> !> where I is the identity matrix, and ``A`` is factorized as \f$A = PLU\f$, as given by \ref !> rocsolver_sgetrf "GETRF". !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrix A. !> @param[in] A - pointer to type. Array on the GPU of dimension lda*n. !> The factors L and U of the factorization \f$A = PLU\f$ returned by \ref !> rocsolver_sgetrf "GETRF". !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[in] ipiv - pointer to rocblas_int. Array on the GPU of dimension n. !> The pivot indices returned by \ref rocsolver_sgetrf "GETRF". !> @param[out] C - pointer to type. Array on the GPU of dimension ldc*n. !> If info = 0, the inverse of A, and otherwise undefined. !> @param[in] ldc - rocblas_int. ldc >= n. !> Specifies the leading dimension of C. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, U is singular. U[i,i] is the first zero pivot. interface rocsolver_sgetri_outofplace function rocsolver_sgetri_outofplace_(handle,n,A,lda,ipiv,C,ldc,myInfo) & bind(c, name="rocsolver_sgetri_outofplace") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_ 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 :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetri_outofplace_assumed_rank #else module procedure & rocsolver_sgetri_outofplace_rank_0,& rocsolver_sgetri_outofplace_rank_1,& rocsolver_sgetri_outofplace_full_rank #endif #endif end interface interface rocsolver_dgetri_outofplace function rocsolver_dgetri_outofplace_(handle,n,A,lda,ipiv,C,ldc,myInfo) & bind(c, name="rocsolver_dgetri_outofplace") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_ 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 :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetri_outofplace_assumed_rank #else module procedure & rocsolver_dgetri_outofplace_rank_0,& rocsolver_dgetri_outofplace_rank_1,& rocsolver_dgetri_outofplace_full_rank #endif #endif end interface interface rocsolver_cgetri_outofplace function rocsolver_cgetri_outofplace_(handle,n,A,lda,ipiv,C,ldc,myInfo) & bind(c, name="rocsolver_cgetri_outofplace") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_ 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 :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetri_outofplace_assumed_rank #else module procedure & rocsolver_cgetri_outofplace_rank_0,& rocsolver_cgetri_outofplace_rank_1,& rocsolver_cgetri_outofplace_full_rank #endif #endif end interface interface rocsolver_zgetri_outofplace function rocsolver_zgetri_outofplace_(handle,n,A,lda,ipiv,C,ldc,myInfo) & bind(c, name="rocsolver_zgetri_outofplace") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_ 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 :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetri_outofplace_assumed_rank #else module procedure & rocsolver_zgetri_outofplace_rank_0,& rocsolver_zgetri_outofplace_rank_1,& rocsolver_zgetri_outofplace_full_rank #endif #endif end interface !> \brief The GETRI_OUTOFPLACE_BATCHED functions compute the inverse \f$C_l = A_l^{-1}\f$ of a !> batch of general ``n`` -by-``n`` matrices \f$A_l\f$. !> !> \details !> The inverse is computed by solving the linear system !> !> \f[ !> A_l C_l = I !> \f] !> !> where I is the identity matrix, and \f$A_l\f$ is factorized as \f$A_l = P_l L_l U_l\f$, as !> given by \ref rocsolver_sgetrf_batched "GETRF_BATCHED". !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of all matrices A_l in the batch. !> @param[in] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> The factors L_l and U_l of the factorization A_l = P_l*L_l*U_l returned by \ref !> rocsolver_sgetrf_batched "GETRF_BATCHED". !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] ipiv - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideP). !> The pivot indices returned by \ref rocsolver_sgetrf_batched "GETRF_BATCHED". !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value of strideP. The normal use case is !> strideP >= n. !> @param[out] C - array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldc*n. !> If info[l] = 0, the inverse of matrices A_l, and otherwise undefined. !> @param[in] ldc - rocblas_int. ldc >= n. !> Specifies the leading dimension of C_l. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for inversion of A_l. !> If info[l] = i > 0, U_l is singular. U_l[i,i] is the first zero pivot. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgetri_outofplace_batched function rocsolver_sgetri_outofplace_batched_(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo, & batch_count) & bind(c, name="rocsolver_sgetri_outofplace_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_batched_ 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 integer(c_int64_t),value :: strideP type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetri_outofplace_batched_assumed_rank #else module procedure & rocsolver_sgetri_outofplace_batched_rank_0,& rocsolver_sgetri_outofplace_batched_rank_1 #endif #endif end interface interface rocsolver_dgetri_outofplace_batched function rocsolver_dgetri_outofplace_batched_(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo, & batch_count) & bind(c, name="rocsolver_dgetri_outofplace_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_batched_ 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 integer(c_int64_t),value :: strideP type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetri_outofplace_batched_assumed_rank #else module procedure & rocsolver_dgetri_outofplace_batched_rank_0,& rocsolver_dgetri_outofplace_batched_rank_1 #endif #endif end interface interface rocsolver_cgetri_outofplace_batched function rocsolver_cgetri_outofplace_batched_(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo, & batch_count) & bind(c, name="rocsolver_cgetri_outofplace_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_batched_ 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 integer(c_int64_t),value :: strideP type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetri_outofplace_batched_assumed_rank #else module procedure & rocsolver_cgetri_outofplace_batched_rank_0,& rocsolver_cgetri_outofplace_batched_rank_1 #endif #endif end interface interface rocsolver_zgetri_outofplace_batched function rocsolver_zgetri_outofplace_batched_(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo, & batch_count) & bind(c, name="rocsolver_zgetri_outofplace_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_batched_ 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 integer(c_int64_t),value :: strideP type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetri_outofplace_batched_assumed_rank #else module procedure & rocsolver_zgetri_outofplace_batched_rank_0,& rocsolver_zgetri_outofplace_batched_rank_1 #endif #endif end interface !> \brief The GETRI_OUTOFPLACE_STRIDED_BATCHED functions compute the inverse \f$C_l = !> A_l^{-1}\f$ of a batch of general ``n`` -by-``n`` matrices \f$A_l\f$. !> !> \details !> The inverse is computed by solving the linear system !> !> \f[ !> A_l C_l = I !> \f] !> !> where I is the identity matrix, and \f$A_l\f$ is factorized as \f$A_l = P_l L_l U_l\f$, as !> given by \ref rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED". !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of all matrices A_l in the batch. !> @param[in] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> The factors L_l and U_l of the factorization A_l = P_l*L_l*U_l returned by !> \ref rocsolver_sgetrf_strided_batched "GETRF_STRIDED_BATCHED". !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[in] ipiv - pointer to rocblas_int. Array on the GPU (the size depends on the value !> of strideP). !> The pivot indices returned by \ref rocsolver_sgetrf_strided_batched !> "GETRF_STRIDED_BATCHED". !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value of strideP. The normal use case is !> strideP >= n. !> @param[out] C - pointer to type. Array on the GPU (the size depends on the value of !> strideC). !> If info[l] = 0, the inverse of matrices A_l, and otherwise undefined. !> @param[in] ldc - rocblas_int. ldc >= n. !> Specifies the leading dimension of C_l. !> @param[in] strideC - rocblas_stride. !> Stride from the start of one matrix C_l to the next one C_(l+1). !> There is no restriction for the value of strideC. The normal use case is !> strideC >= ldc*n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for inversion of A_l. !> If info[l] = i > 0, U_l is singular. U_l[i,i] is the first zero pivot. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgetri_outofplace_strided_batched function rocsolver_sgetri_outofplace_strided_batched_(handle,n,A,lda,strideA,ipiv,strideP,C, & ldc,strideC,myInfo,batch_count) & bind(c, name="rocsolver_sgetri_outofplace_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetri_outofplace_strided_batched_assumed_rank #else module procedure & rocsolver_sgetri_outofplace_strided_batched_rank_0,& rocsolver_sgetri_outofplace_strided_batched_rank_1,& rocsolver_sgetri_outofplace_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgetri_outofplace_strided_batched function rocsolver_dgetri_outofplace_strided_batched_(handle,n,A,lda,strideA,ipiv,strideP,C, & ldc,strideC,myInfo,batch_count) & bind(c, name="rocsolver_dgetri_outofplace_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetri_outofplace_strided_batched_assumed_rank #else module procedure & rocsolver_dgetri_outofplace_strided_batched_rank_0,& rocsolver_dgetri_outofplace_strided_batched_rank_1,& rocsolver_dgetri_outofplace_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgetri_outofplace_strided_batched function rocsolver_cgetri_outofplace_strided_batched_(handle,n,A,lda,strideA,ipiv,strideP,C, & ldc,strideC,myInfo,batch_count) & bind(c, name="rocsolver_cgetri_outofplace_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetri_outofplace_strided_batched_assumed_rank #else module procedure & rocsolver_cgetri_outofplace_strided_batched_rank_0,& rocsolver_cgetri_outofplace_strided_batched_rank_1,& rocsolver_cgetri_outofplace_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgetri_outofplace_strided_batched function rocsolver_zgetri_outofplace_strided_batched_(handle,n,A,lda,strideA,ipiv,strideP,C, & ldc,strideC,myInfo,batch_count) & bind(c, name="rocsolver_zgetri_outofplace_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetri_outofplace_strided_batched_assumed_rank #else module procedure & rocsolver_zgetri_outofplace_strided_batched_rank_0,& rocsolver_zgetri_outofplace_strided_batched_rank_1,& rocsolver_zgetri_outofplace_strided_batched_full_rank #endif #endif end interface !> \brief The GETRI_NPVT_OUTOFPLACE functions compute the inverse \f$C = A^{-1}\f$ of a !> general ``n`` -by-``n`` matrix ``A`` without partial pivoting. !> !> \details !> The inverse is computed by solving the linear system !> !> \f[ !> AC = I !> \f] !> !> where I is the identity matrix, and ``A`` is factorized as \f$A = LU\f$, as given by \ref !> rocsolver_sgetrf_npvt "GETRF_NPVT". !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrix A. !> @param[in] A - pointer to type. Array on the GPU of dimension lda*n. !> The factors L and U of the factorization \f$A = LU\f$ returned by \ref !> rocsolver_sgetrf_npvt "GETRF_NPVT". !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] C - pointer to type. Array on the GPU of dimension ldc*n. !> If info = 0, the inverse of A, and otherwise undefined. !> @param[in] ldc - rocblas_int. ldc >= n. !> Specifies the leading dimension of C. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, U is singular. U[i,i] is the first zero pivot. interface rocsolver_sgetri_npvt_outofplace function rocsolver_sgetri_npvt_outofplace_(handle,n,A,lda,C,ldc,myInfo) & bind(c, name="rocsolver_sgetri_npvt_outofplace") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetri_npvt_outofplace_assumed_rank #else module procedure & rocsolver_sgetri_npvt_outofplace_rank_0,& rocsolver_sgetri_npvt_outofplace_rank_1,& rocsolver_sgetri_npvt_outofplace_full_rank #endif #endif end interface interface rocsolver_dgetri_npvt_outofplace function rocsolver_dgetri_npvt_outofplace_(handle,n,A,lda,C,ldc,myInfo) & bind(c, name="rocsolver_dgetri_npvt_outofplace") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetri_npvt_outofplace_assumed_rank #else module procedure & rocsolver_dgetri_npvt_outofplace_rank_0,& rocsolver_dgetri_npvt_outofplace_rank_1,& rocsolver_dgetri_npvt_outofplace_full_rank #endif #endif end interface interface rocsolver_cgetri_npvt_outofplace function rocsolver_cgetri_npvt_outofplace_(handle,n,A,lda,C,ldc,myInfo) & bind(c, name="rocsolver_cgetri_npvt_outofplace") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetri_npvt_outofplace_assumed_rank #else module procedure & rocsolver_cgetri_npvt_outofplace_rank_0,& rocsolver_cgetri_npvt_outofplace_rank_1,& rocsolver_cgetri_npvt_outofplace_full_rank #endif #endif end interface interface rocsolver_zgetri_npvt_outofplace function rocsolver_zgetri_npvt_outofplace_(handle,n,A,lda,C,ldc,myInfo) & bind(c, name="rocsolver_zgetri_npvt_outofplace") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetri_npvt_outofplace_assumed_rank #else module procedure & rocsolver_zgetri_npvt_outofplace_rank_0,& rocsolver_zgetri_npvt_outofplace_rank_1,& rocsolver_zgetri_npvt_outofplace_full_rank #endif #endif end interface !> \brief The GETRI_NPVT_OUTOFPLACE_BATCHED functions compute the inverse \f$C_l^{} = !> A_l^{-1}\f$ of a batch of general ``n`` -by-``n`` matrices \f$A_l\f$ !> without partial pivoting. !> !> \details !> The inverse is computed by solving the linear system !> !> \f[ !> A_l C_l = I !> \f] !> !> where I is the identity matrix, and \f$A_l\f$ is factorized as \f$A_l = L_l U_l\f$, as !> given by \ref rocsolver_sgetrf_npvt_batched "GETRF_NPVT_BATCHED". !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of all matrices A_l in the batch. !> @param[in] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> The factors L_l and U_l of the factorization A_l = L_l*U_l returned by \ref !> rocsolver_sgetrf_npvt_batched "GETRF_NPVT_BATCHED". !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[out] C - array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldc*n. !> If info[l] = 0, the inverse of matrices A_l, and otherwise undefined. !> @param[in] ldc - rocblas_int. ldc >= n. !> Specifies the leading dimension of C_l. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for inversion of A_l. !> If info[l] = i > 0, U_l is singular. U_l[i,i] is the first zero pivot. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgetri_npvt_outofplace_batched function rocsolver_sgetri_npvt_outofplace_batched_(handle,n,A,lda,C,ldc,myInfo,batch_count) & bind(c, name="rocsolver_sgetri_npvt_outofplace_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dgetri_npvt_outofplace_batched function rocsolver_dgetri_npvt_outofplace_batched_(handle,n,A,lda,C,ldc,myInfo,batch_count) & bind(c, name="rocsolver_dgetri_npvt_outofplace_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_cgetri_npvt_outofplace_batched function rocsolver_cgetri_npvt_outofplace_batched_(handle,n,A,lda,C,ldc,myInfo,batch_count) & bind(c, name="rocsolver_cgetri_npvt_outofplace_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zgetri_npvt_outofplace_batched function rocsolver_zgetri_npvt_outofplace_batched_(handle,n,A,lda,C,ldc,myInfo,batch_count) & bind(c, name="rocsolver_zgetri_npvt_outofplace_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The GETRI_NPVT_OUTOFPLACE_STRIDED_BATCHED functions compute the inverse \f$C_l^{} = !> A_l^{-1}\f$ of a batch of general ``n`` -by-``n`` matrices \f$A_l\f$ !> without partial pivoting. !> !> \details !> The inverse is computed by solving the linear system !> !> \f[ !> A_l C_l = I !> \f] !> !> where I is the identity matrix, and \f$A_l\f$ is factorized as \f$A_l = L_l U_l\f$, as !> given by \ref rocsolver_sgetrf_npvt_strided_batched "GETRF_NPVT_STRIDED_BATCHED". !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of all matrices A_l in the batch. !> @param[in] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> The factors L_l and U_l of the factorization A_l = L_l*U_l returned by !> \ref rocsolver_sgetrf_npvt_strided_batched "GETRF_NPVT_STRIDED_BATCHED". !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] C - pointer to type. Array on the GPU (the size depends on the value of !> strideC). !> If info[l] = 0, the inverse of matrices A_l, and otherwise undefined. !> @param[in] ldc - rocblas_int. ldc >= n. !> Specifies the leading dimension of C_l. !> @param[in] strideC - rocblas_stride. !> Stride from the start of one matrix C_l to the next one C_(l+1). !> There is no restriction for the value of strideC. The normal use case is !> strideC >= ldc*n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for inversion of A_l. !> If info[l] = i > 0, U_l is singular. U_l[i,i] is the first zero pivot. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgetri_npvt_outofplace_strided_batched function rocsolver_sgetri_npvt_outofplace_strided_batched_(handle,n,A,lda,strideA,C,ldc, & strideC,myInfo,batch_count) & bind(c, name="rocsolver_sgetri_npvt_outofplace_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_sgetri_npvt_outofplace_strided_batched_assumed_rank #else module procedure & rocsolver_sgetri_npvt_outofplace_strided_batched_rank_0,& rocsolver_sgetri_npvt_outofplace_strided_batched_rank_1,& rocsolver_sgetri_npvt_outofplace_strided_batched_full_rank #endif #endif end interface interface rocsolver_dgetri_npvt_outofplace_strided_batched function rocsolver_dgetri_npvt_outofplace_strided_batched_(handle,n,A,lda,strideA,C,ldc, & strideC,myInfo,batch_count) & bind(c, name="rocsolver_dgetri_npvt_outofplace_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dgetri_npvt_outofplace_strided_batched_assumed_rank #else module procedure & rocsolver_dgetri_npvt_outofplace_strided_batched_rank_0,& rocsolver_dgetri_npvt_outofplace_strided_batched_rank_1,& rocsolver_dgetri_npvt_outofplace_strided_batched_full_rank #endif #endif end interface interface rocsolver_cgetri_npvt_outofplace_strided_batched function rocsolver_cgetri_npvt_outofplace_strided_batched_(handle,n,A,lda,strideA,C,ldc, & strideC,myInfo,batch_count) & bind(c, name="rocsolver_cgetri_npvt_outofplace_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_cgetri_npvt_outofplace_strided_batched_assumed_rank #else module procedure & rocsolver_cgetri_npvt_outofplace_strided_batched_rank_0,& rocsolver_cgetri_npvt_outofplace_strided_batched_rank_1,& rocsolver_cgetri_npvt_outofplace_strided_batched_full_rank #endif #endif end interface interface rocsolver_zgetri_npvt_outofplace_strided_batched function rocsolver_zgetri_npvt_outofplace_strided_batched_(handle,n,A,lda,strideA,C,ldc, & strideC,myInfo,batch_count) & bind(c, name="rocsolver_zgetri_npvt_outofplace_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zgetri_npvt_outofplace_strided_batched_assumed_rank #else module procedure & rocsolver_zgetri_npvt_outofplace_strided_batched_rank_0,& rocsolver_zgetri_npvt_outofplace_strided_batched_rank_1,& rocsolver_zgetri_npvt_outofplace_strided_batched_full_rank #endif #endif end interface !> \brief The TRTRI functions invert a triangular ``n``-by-``n`` matrix ``A``. !> !> \details !> ``A`` can be upper or lower triangular, depending on the value of ``uplo``, and unit or !> non-unit !> triangular, depending on the value of ``diag``. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A is not used. !> @param[in] diag - rocblas_diagonal. !> If diag indicates unit, then the diagonal elements of A are not referenced and !> assumed to equal one. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the triangular matrix. !> On exit, the inverse of A if info = 0. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, A is singular. A[i,i] is the first zero element in the !> diagonal. interface rocsolver_strtri function rocsolver_strtri_(handle,uplo,diag,n,A,lda,myInfo) bind(c, name="rocsolver_strtri") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_strtri_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_strtri_assumed_rank #else module procedure & rocsolver_strtri_rank_0,& rocsolver_strtri_rank_1,& rocsolver_strtri_full_rank #endif #endif end interface interface rocsolver_dtrtri function rocsolver_dtrtri_(handle,uplo,diag,n,A,lda,myInfo) bind(c, name="rocsolver_dtrtri") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dtrtri_assumed_rank #else module procedure & rocsolver_dtrtri_rank_0,& rocsolver_dtrtri_rank_1,& rocsolver_dtrtri_full_rank #endif #endif end interface interface rocsolver_ctrtri function rocsolver_ctrtri_(handle,uplo,diag,n,A,lda,myInfo) bind(c, name="rocsolver_ctrtri") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ctrtri_assumed_rank #else module procedure & rocsolver_ctrtri_rank_0,& rocsolver_ctrtri_rank_1,& rocsolver_ctrtri_full_rank #endif #endif end interface interface rocsolver_ztrtri function rocsolver_ztrtri_(handle,uplo,diag,n,A,lda,myInfo) bind(c, name="rocsolver_ztrtri") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ztrtri_assumed_rank #else module procedure & rocsolver_ztrtri_rank_0,& rocsolver_ztrtri_rank_1,& rocsolver_ztrtri_full_rank #endif #endif end interface !> \brief The TRTRI_BATCHED functions invert a batch of triangular ``n`` -by-``n`` matrices !> \f$A_l\f$. !> !> \details !> \f$A_l\f$ can be upper or lower triangular, depending on the value of ``uplo``, and unit or !> non-unit !> triangular, depending on the value of ``diag``. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrices A_l are stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A_l is not used. !> @param[in] diag - rocblas_diagonal. !> If diag indicates unit, then the diagonal elements of matrices A_l are not !> referenced and !> assumed to equal one. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of all matrices A_l in the batch. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the triangular matrices A_l. !> On exit, the inverses of A_l if info[l] = 0. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for inversion of A_l. !> If info[l] = i > 0, A_l is singular. A_l[i,i] is the first zero element in the !> diagonal. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_strtri_batched function rocsolver_strtri_batched_(handle,uplo,diag,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_strtri_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_strtri_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dtrtri_batched function rocsolver_dtrtri_batched_(handle,uplo,diag,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_dtrtri_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_ctrtri_batched function rocsolver_ctrtri_batched_(handle,uplo,diag,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_ctrtri_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_ztrtri_batched function rocsolver_ztrtri_batched_(handle,uplo,diag,n,A,lda,myInfo,batch_count) & bind(c, name="rocsolver_ztrtri_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The TRTRI_STRIDED_BATCHED functions invert a batch of triangular ``n`` -by-``n`` !> matrices \f$A_l\f$. !> !> \details !> \f$A_l\f$ can be upper or lower triangular, depending on the value of ``uplo``, and unit or !> non-unit !> triangular, depending on the value of ``diag``. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrices A_l are stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A_l is not used. !> @param[in] diag - rocblas_diagonal. !> If diag indicates unit, then the diagonal elements of matrices A_l are not !> referenced and !> assumed to equal one. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of all matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the triangular matrices A_l. !> On exit, the inverses of A_l if info[l] = 0. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for inversion of A_l. !> If info[l] = i > 0, A_l is singular. A_l[i,i] is the first zero element in the !> diagonal. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_strtri_strided_batched function rocsolver_strtri_strided_batched_(handle,uplo,diag,n,A,lda,strideA,myInfo, & batch_count) & bind(c, name="rocsolver_strtri_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_strtri_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_strtri_strided_batched_assumed_rank #else module procedure & rocsolver_strtri_strided_batched_rank_0,& rocsolver_strtri_strided_batched_rank_1,& rocsolver_strtri_strided_batched_full_rank #endif #endif end interface interface rocsolver_dtrtri_strided_batched function rocsolver_dtrtri_strided_batched_(handle,uplo,diag,n,A,lda,strideA,myInfo, & batch_count) & bind(c, name="rocsolver_dtrtri_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dtrtri_strided_batched_assumed_rank #else module procedure & rocsolver_dtrtri_strided_batched_rank_0,& rocsolver_dtrtri_strided_batched_rank_1,& rocsolver_dtrtri_strided_batched_full_rank #endif #endif end interface interface rocsolver_ctrtri_strided_batched function rocsolver_ctrtri_strided_batched_(handle,uplo,diag,n,A,lda,strideA,myInfo, & batch_count) & bind(c, name="rocsolver_ctrtri_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ctrtri_strided_batched_assumed_rank #else module procedure & rocsolver_ctrtri_strided_batched_rank_0,& rocsolver_ctrtri_strided_batched_rank_1,& rocsolver_ctrtri_strided_batched_full_rank #endif #endif end interface interface rocsolver_ztrtri_strided_batched function rocsolver_ztrtri_strided_batched_(handle,uplo,diag,n,A,lda,strideA,myInfo, & batch_count) & bind(c, name="rocsolver_ztrtri_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(kind(rocblas_diagonal_non_unit)),value :: diag integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ztrtri_strided_batched_assumed_rank #else module procedure & rocsolver_ztrtri_strided_batched_rank_0,& rocsolver_ztrtri_strided_batched_rank_1,& rocsolver_ztrtri_strided_batched_full_rank #endif #endif end interface !> \brief The SYTF2 functions compute the factorization of a symmetric and maybe indefinite !> matrix \f$A\f$ !> using Bunch-Kaufman diagonal pivoting. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The factorization has the form !> !> \f[ !> \begin{array}{cl} !> A = U D U^T & \: \text{or}\\% !> A = L D L^T & !> \end{array} !> \f] !> !> where \f$U\f$ or \f$L\f$ is a product of permutation and unit upper/lower !> triangular matrices (depending on the value of ``uplo``), and \f$D\f$ is a symmetric !> block diagonal matrix with 1-by-1 and 2-by-2 diagonal blocks \f$D_k\f$. !> !> Specifically, \f$U\f$ and \f$L\f$ are computed as !> !> \f[ !> \begin{array}{cl} !> U = P(n) U(n) \cdots P(k) U(k) \cdots & \: \text{and}\\% !> L = P(1) L(1) \cdots P(k) L(k) \cdots & !> \end{array} !> \f] !> !> where \f$k\f$ decreases from \f$n\f$ to 1 (increases from 1 to \f$n\f$) in steps of 1 or 2, !> depending on the order of block \f$D_k\f$, and \f$P(k)\f$ is a permutation matrix defined !> by !> \f$ipiv[k]\f$. If \f$s\f$ denotes the order of block \f$D_k\f$, then \f$U(k)\f$ !> and \f$L(k)\f$ are unit upper/lower triangular matrices defined as !> !> \f[ !> U(k) = \left[ \begin{array}{ccc} !> I_{k-s} & v & 0 \\% !> 0 & I_s & 0 \\% !> 0 & 0 & I_{n-k} !> \end{array} \right] !> \f] !> !> and !> !> \f[ !> L(k) = \left[ \begin{array}{ccc} !> I_{k-1} & 0 & 0 \\% !> 0 & I_s & 0 \\% !> 0 & v & I_{n-k-s+1} !> \end{array} \right]. !> \f] !> !> If \f$s = 1\f$, then \f$D_k\f$ is stored in \f$A[k,k]\f$, and \f$v\f$ is stored in the !> upper/lower !> part of column \f$k\f$ of \f$A\f$. !> If \f$s = 2\f$ and ``uplo`` is ``upper``, then \f$D_k\f$ is stored in \f$A[k-1,k-1]\f$, !> \f$A[k-1,k]\f$, !> and \f$A[k,k]\f$, and \f$v\f$ is stored in the upper parts of columns \f$k-1\f$ and \f$k\f$ !> of \f$A\f$. !> If \f$s = 2\f$ and ``uplo`` is ``lower``, then \f$D_k\f$ is stored in \f$A[k,k]\f$, !> \f$A[k+1,k]\f$, !> and \f$A[k+1,k+1]\f$, and \f$v\f$ is stored in the lower parts of columns \f$k\f$ and !> \f$k+1\f$ of \f$A\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the symmetric matrix A to be factored. !> On exit, the block diagonal matrix D and the multipliers needed to !> compute U or L. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] ipiv - pointer to rocblas_int. Array on the GPU of dimension n. !> The vector of pivot indices. Elements of ipiv are 1-based indices. !> For 1 <= k <= n, if ipiv[k] > 0, then rows and columns k and ipiv[k] !> were interchanged, and D[k,k] is a 1-by-1 diagonal block. !> If, instead, ipiv[k] = ipiv[k-1] < 0 and uplo is upper (or ipiv[k] !> = ipiv[k+1] < 0 and uplo is lower), then rows and columns k-1 and !> -ipiv[k] (or rows and columns k+1 and -ipiv[k]) were interchanged, !> and D[k-1,k-1] to D[k,k] (or D[k,k] to D[k+1,k+1]) is a 2-by-2 !> diagonal block. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, D is singular. D[i,i] is the first diagonal zero. interface rocsolver_ssytf2 function rocsolver_ssytf2_(handle,uplo,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_ssytf2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssytf2_assumed_rank #else module procedure & rocsolver_ssytf2_rank_0,& rocsolver_ssytf2_rank_1,& rocsolver_ssytf2_full_rank #endif #endif end interface interface rocsolver_dsytf2 function rocsolver_dsytf2_(handle,uplo,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_dsytf2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsytf2_assumed_rank #else module procedure & rocsolver_dsytf2_rank_0,& rocsolver_dsytf2_rank_1,& rocsolver_dsytf2_full_rank #endif #endif end interface interface rocsolver_csytf2 function rocsolver_csytf2_(handle,uplo,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_csytf2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytf2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_csytf2_assumed_rank #else module procedure & rocsolver_csytf2_rank_0,& rocsolver_csytf2_rank_1,& rocsolver_csytf2_full_rank #endif #endif end interface interface rocsolver_zsytf2 function rocsolver_zsytf2_(handle,uplo,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_zsytf2") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zsytf2_assumed_rank #else module procedure & rocsolver_zsytf2_rank_0,& rocsolver_zsytf2_rank_1,& rocsolver_zsytf2_full_rank #endif #endif end interface !> \brief The SYTF2_BATCHED functions computes the factorization of a batch of symmetric and !> maybe indefinite !> matrices using Bunch-Kaufman diagonal pivoting. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The factorization has the form !> !> \f[ !> \begin{array}{cl} !> A_l^{} = U_l^{} D_l^{} U_l^T & \: \text{or}\\% !> A_l^{} = L_l^{} D_l^{} L_l^T & !> \end{array} !> \f] !> !> where \f$U_l\f$ or \f$L_l\f$ is a product of permutation and unit upper/lower !> triangular matrices (depending on the value of ``uplo``), and \f$D_l\f$ is a symmetric !> block diagonal matrix with 1-by-1 and 2-by-2 diagonal blocks \f$D_{kl}\f$. !> !> Specifically, \f$U_l\f$ and \f$L_l\f$ are computed as !> !> \f[ !> \begin{array}{cl} !> U_l = P_l(n) U_l(n) \cdots P_l(k) U_l(k) \cdots & \: \text{and}\\% !> L_l = P_l(1) L_l(1) \cdots P_l(k) L_l(k) \cdots & !> \end{array} !> \f] !> !> where \f$k\f$ decreases from \f$n\f$ to 1 (increases from 1 to \f$n\f$) in steps of 1 or 2, !> depending on the order of block \f$D_{kl}\f$, and \f$P_l(k)\f$ is a permutation matrix !> defined by !> \f$ipiv_l[k]\f$. If \f$s\f$ denotes the order of block \f$D_{kl}\f$, then \f$U_l(k)\f$ !> and \f$L_l(k)\f$ are unit upper/lower triangular matrices defined as !> !> \f[ !> U_l(k) = \left[ \begin{array}{ccc} !> I_{k-s} & v & 0 \\% !> 0 & I_s & 0 \\% !> 0 & 0 & I_{n-k} !> \end{array} \right] !> \f] !> !> and !> !> \f[ !> L_l(k) = \left[ \begin{array}{ccc} !> I_{k-1} & 0 & 0 \\% !> 0 & I_s & 0 \\% !> 0 & v & I_{n-k-s+1} !> \end{array} \right]. !> \f] !> !> If \f$s = 1\f$, then \f$D_{kl}\f$ is stored in \f$A_l[k,k]\f$, and \f$v\f$ is stored in the !> upper/lower !> part of column \f$k\f$ of \f$A_l\f$. !> If \f$s = 2\f$ and ``uplo`` is ``upper``, then \f$D_{kl}\f$ is stored in !> \f$A_l[k-1,k-1]\f$, \f$A_l[k-1,k]\f$, !> and \f$A_l[k,k]\f$, and \f$v\f$ is stored in the upper parts of columns \f$k-1\f$ and !> \f$k\f$ of \f$A_l\f$. !> If \f$s = 2\f$ and ``uplo`` is ``lower``, then \f$D_{kl}\f$ is stored in \f$A_l[k,k]\f$, !> \f$A_l[k+1,k]\f$, !> and \f$A_l[k+1,k+1]\f$, and \f$v\f$ is stored in the lower parts of columns \f$k\f$ and !> \f$k+1\f$ of \f$A_l\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrices A_l are stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A_l is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of all matrices A_l in the batch. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the symmetric matrices A_l to be factored. !> On exit, the block diagonal matrices D_l and the multipliers needed to !> compute U_l or L_l. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[out] ipiv - pointer to rocblas_int. Array on the GPU of dimension n. !> The vector of pivot indices. Elements of ipiv are 1-based indices. !> For 1 <= k <= n, if ipiv_l[k] > 0, then rows and columns k and ipiv_l[k] !> were interchanged, and D_l[k,k] is a 1-by-1 diagonal block. !> If, instead, ipiv_l[k] = ipiv_l[k-1] < 0 and uplo is upper (or ipiv_l[k] !> = ipiv_l[k+1] < 0 and uplo is lower), then rows and columns k-1 and !> -ipiv_l[k] (or rows and columns k+1 and -ipiv_l[k]) were interchanged, !> and D_l[k-1,k-1] to D_l[k,k] (or D_l[k,k] to D_l[k+1,k+1]) is a 2-by-2 !> diagonal block. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value of strideP. The normal use case is !> strideP >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for factorization of A_l. !> If info[l] = i > 0, D_l is singular. D_l[i,i] is the first diagonal zero. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssytf2_batched function rocsolver_ssytf2_batched_(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_ssytf2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssytf2_batched_assumed_rank #else module procedure & rocsolver_ssytf2_batched_rank_0,& rocsolver_ssytf2_batched_rank_1 #endif #endif end interface interface rocsolver_dsytf2_batched function rocsolver_dsytf2_batched_(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_dsytf2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsytf2_batched_assumed_rank #else module procedure & rocsolver_dsytf2_batched_rank_0,& rocsolver_dsytf2_batched_rank_1 #endif #endif end interface interface rocsolver_csytf2_batched function rocsolver_csytf2_batched_(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_csytf2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytf2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_csytf2_batched_assumed_rank #else module procedure & rocsolver_csytf2_batched_rank_0,& rocsolver_csytf2_batched_rank_1 #endif #endif end interface interface rocsolver_zsytf2_batched function rocsolver_zsytf2_batched_(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_zsytf2_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zsytf2_batched_assumed_rank #else module procedure & rocsolver_zsytf2_batched_rank_0,& rocsolver_zsytf2_batched_rank_1 #endif #endif end interface !> \brief The SYTF2_STRIDED_BATCHED functions compute the factorization of a batch of !> symmetric and maybe indefinite !> matrices using Bunch-Kaufman diagonal pivoting. !> !> \details !> (This is the unblocked version of the algorithm.) !> !> The factorization has the form !> !> \f[ !> \begin{array}{cl} !> A_l^{} = U_l^{} D_l^{} U_l^T & \: \text{or}\\% !> A_l^{} = L_l^{} D_l^{} L_l^T & !> \end{array} !> \f] !> !> where \f$U_l\f$ or \f$L_l\f$ is a product of permutation and unit upper/lower !> triangular matrices (depending on the value of uplo), and \f$D_l\f$ is a symmetric !> block diagonal matrix with 1-by-1 and 2-by-2 diagonal blocks \f$D_{kl}\f$. !> !> Specifically, \f$U_l\f$ and \f$L_l\f$ are computed as !> !> \f[ !> \begin{array}{cl} !> U_l = P_l(n) U_l(n) \cdots P_l(k) U_l(k) \cdots & \: \text{and}\\% !> L_l = P_l(1) L_l(1) \cdots P_l(k) L_l(k) \cdots & !> \end{array} !> \f] !> !> where \f$k\f$ decreases from \f$n\f$ to 1 (increases from 1 to \f$n\f$) in steps of 1 or 2, !> depending on the order of block \f$D_{kl}\f$, and \f$P_l(k)\f$ is a permutation matrix !> defined by !> \f$ipiv_l[k]\f$. If \f$s\f$ denotes the order of block \f$D_{kl}\f$, then \f$U_l(k)\f$ !> and \f$L_l(k)\f$ are unit upper/lower triangular matrices defined as !> !> \f[ !> U_l(k) = \left[ \begin{array}{ccc} !> I_{k-s} & v & 0 \\% !> 0 & I_s & 0 \\% !> 0 & 0 & I_{n-k} !> \end{array} \right] !> \f] !> !> and !> !> \f[ !> L_l(k) = \left[ \begin{array}{ccc} !> I_{k-1} & 0 & 0 \\% !> 0 & I_s & 0 \\% !> 0 & v & I_{n-k-s+1} !> \end{array} \right]. !> \f] !> !> If \f$s = 1\f$, then \f$D_{kl}\f$ is stored in \f$A_l[k,k]\f$ and \f$v\f$ is stored in the !> upper/lower !> part of column \f$k\f$ of \f$A_l\f$. !> If \f$s = 2\f$ and ``uplo`` is ``upper``, then \f$D_{kl}\f$ is stored in !> \f$A_l[k-1,k-1]\f$, \f$A_l[k-1,k]\f$, !> and \f$A_l[k,k]\f$, and \f$v\f$ is stored in the upper parts of columns \f$k-1\f$ and !> \f$k\f$ of \f$A_l\f$. !> If \f$s = 2\f$ and ``uplo`` is ``lower``, then \f$D_{kl}\f$ is stored in \f$A_l[k,k]\f$, !> \f$A_l[k+1,k]\f$, !> and \f$A_l[k+1,k+1]\f$, and \f$v\f$ is stored in the lower parts of columns \f$k\f$ and !> \f$k+1\f$ of \f$A_l\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrices A_l are stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A_l is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of all matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the symmetric matrices A_l to be factored. !> On exit, the block diagonal matrices D_l and the multipliers needed to !> compute U_l or L_l. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n !> @param[out] ipiv - pointer to rocblas_int. Array on the GPU of dimension n. !> The vector of pivot indices. Elements of ipiv are 1-based indices. !> For 1 <= k <= n, if ipiv_l[k] > 0, then rows and columns k and ipiv_l[k] !> were interchanged, and D_l[k,k] is a 1-by-1 diagonal block. !> If, instead, ipiv_l[k] = ipiv_l[k-1] < 0 and uplo is upper (or ipiv_l[k] !> = ipiv_l[k+1] < 0 and uplo is lower), then rows and columns k-1 and !> -ipiv_l[k] (or rows and columns k+1 and -ipiv_l[k]) were interchanged, !> and D_l[k-1,k-1] to D_l[k,k] (or D_l[k,k] to D_l[k+1,k+1]) is a 2-by-2 !> diagonal block. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value of strideP. The normal use case is !> strideP >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for factorization of A_l. !> If info[l] = i > 0, D_l is singular. D_l[i,i] is the first diagonal zero. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssytf2_strided_batched function rocsolver_ssytf2_strided_batched_(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_ssytf2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssytf2_strided_batched_assumed_rank #else module procedure & rocsolver_ssytf2_strided_batched_rank_0,& rocsolver_ssytf2_strided_batched_rank_1,& rocsolver_ssytf2_strided_batched_full_rank #endif #endif end interface interface rocsolver_dsytf2_strided_batched function rocsolver_dsytf2_strided_batched_(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_dsytf2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsytf2_strided_batched_assumed_rank #else module procedure & rocsolver_dsytf2_strided_batched_rank_0,& rocsolver_dsytf2_strided_batched_rank_1,& rocsolver_dsytf2_strided_batched_full_rank #endif #endif end interface interface rocsolver_csytf2_strided_batched function rocsolver_csytf2_strided_batched_(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_csytf2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytf2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_csytf2_strided_batched_assumed_rank #else module procedure & rocsolver_csytf2_strided_batched_rank_0,& rocsolver_csytf2_strided_batched_rank_1,& rocsolver_csytf2_strided_batched_full_rank #endif #endif end interface interface rocsolver_zsytf2_strided_batched function rocsolver_zsytf2_strided_batched_(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_zsytf2_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zsytf2_strided_batched_assumed_rank #else module procedure & rocsolver_zsytf2_strided_batched_rank_0,& rocsolver_zsytf2_strided_batched_rank_1,& rocsolver_zsytf2_strided_batched_full_rank #endif #endif end interface !> \brief The SYTRF functions compute the factorization of a symmetric and maybe indefinite !> matrix \f$A\f$ !> using Bunch-Kaufman diagonal pivoting. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The factorization has the form !> !> \f[ !> \begin{array}{cl} !> A = U D U^T & \: \text{or}\\% !> A = L D L^T & !> \end{array} !> \f] !> !> where \f$U\f$ or \f$L\f$ is a product of permutation and unit upper/lower !> triangular matrices (depending on the value of uplo), and \f$D\f$ is a symmetric !> block diagonal matrix with 1-by-1 and 2-by-2 diagonal blocks \f$D_k\f$. !> !> Specifically, \f$U\f$ and \f$L\f$ are computed as !> !> \f[ !> \begin{array}{cl} !> U = P(n) U(n) \cdots P(k) U(k) \cdots & \: \text{and}\\% !> L = P(1) L(1) \cdots P(k) L(k) \cdots & !> \end{array} !> \f] !> !> where \f$k\f$ decreases from \f$n\f$ to 1 (increases from 1 to \f$n\f$) in steps of 1 or 2, !> depending on the order of block \f$D_k\f$, and \f$P(k)\f$ is a permutation matrix defined !> by !> \f$ipiv[k]\f$. If \f$s\f$ denotes the order of block \f$D_k\f$, then \f$U(k)\f$ !> and \f$L(k)\f$ are unit upper/lower triangular matrices defined as !> !> \f[ !> U(k) = \left[ \begin{array}{ccc} !> I_{k-s} & v & 0 \\% !> 0 & I_s & 0 \\% !> 0 & 0 & I_{n-k} !> \end{array} \right] !> \f] !> !> and !> !> \f[ !> L(k) = \left[ \begin{array}{ccc} !> I_{k-1} & 0 & 0 \\% !> 0 & I_s & 0 \\% !> 0 & v & I_{n-k-s+1} !> \end{array} \right]. !> \f] !> !> If \f$s = 1\f$, then \f$D_k\f$ is stored in \f$A[k,k]\f$, and \f$v\f$ is stored in the !> upper/lower !> part of column \f$k\f$ of \f$A\f$. !> If \f$s = 2\f$ and ``uplo`` is ``upper``, then \f$D_k\f$ is stored in \f$A[k-1,k-1]\f$, !> \f$A[k-1,k]\f$, !> and \f$A[k,k]\f$, and \f$v\f$ is stored in the upper parts of columns \f$k-1\f$ and \f$k\f$ !> of \f$A\f$. !> If \f$s = 2\f$ and ``uplo`` is ``lower``, then \f$D_k\f$ is stored in \f$A[k,k]\f$, !> \f$A[k+1,k]\f$, !> and \f$A[k+1,k+1]\f$, and \f$v\f$ is stored in the lower parts of columns \f$k\f$ and !> \f$k+1\f$ of \f$A\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of the matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the symmetric matrix A to be factored. !> On exit, the block diagonal matrix D and the multipliers needed to !> compute U or L. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of A. !> @param[out] ipiv - pointer to rocblas_int. Array on the GPU of dimension n. !> The vector of pivot indices. Elements of ipiv are 1-based indices. !> For 1 <= k <= n, if ipiv[k] > 0, then rows and columns k and ipiv[k] !> were interchanged, and D[k,k] is a 1-by-1 diagonal block. !> If, instead, ipiv[k] = ipiv[k-1] < 0 and uplo is upper (or ipiv[k] !> = ipiv[k+1] < 0 and uplo is lower), then rows and columns k-1 and !> -ipiv[k] (or rows and columns k+1 and -ipiv[k]) were interchanged, !> and D[k-1,k-1] to D[k,k] (or D[k,k] to D[k+1,k+1]) is a 2-by-2 !> diagonal block. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, D is singular. D[i,i] is the first diagonal zero. interface rocsolver_ssytrf function rocsolver_ssytrf_(handle,uplo,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_ssytrf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssytrf_assumed_rank #else module procedure & rocsolver_ssytrf_rank_0,& rocsolver_ssytrf_rank_1,& rocsolver_ssytrf_full_rank #endif #endif end interface interface rocsolver_dsytrf function rocsolver_dsytrf_(handle,uplo,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_dsytrf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsytrf_assumed_rank #else module procedure & rocsolver_dsytrf_rank_0,& rocsolver_dsytrf_rank_1,& rocsolver_dsytrf_full_rank #endif #endif end interface interface rocsolver_csytrf function rocsolver_csytrf_(handle,uplo,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_csytrf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrf_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_csytrf_assumed_rank #else module procedure & rocsolver_csytrf_rank_0,& rocsolver_csytrf_rank_1,& rocsolver_csytrf_full_rank #endif #endif end interface interface rocsolver_zsytrf function rocsolver_zsytrf_(handle,uplo,n,A,lda,ipiv,myInfo) bind(c, name="rocsolver_zsytrf") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zsytrf_assumed_rank #else module procedure & rocsolver_zsytrf_rank_0,& rocsolver_zsytrf_rank_1,& rocsolver_zsytrf_full_rank #endif #endif end interface !> \brief The SYTRF_BATCHED functions compute the factorization of a batch of symmetric and !> maybe indefinite !> matrices using Bunch-Kaufman diagonal pivoting. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The factorization has the form !> !> \f[ !> \begin{array}{cl} !> A_l^{} = U_l^{} D_l^{} U_l^T & \: \text{or}\\% !> A_l^{} = L_l^{} D_l^{} L_l^T & !> \end{array} !> \f] !> !> where \f$U_l\f$ or \f$L_l\f$ is a product of permutation and unit upper/lower !> triangular matrices (depending on the value of uplo), and \f$D_l\f$ is a symmetric !> block diagonal matrix with 1-by-1 and 2-by-2 diagonal blocks \f$D_{kl}\f$. !> !> Specifically, \f$U_l\f$ and \f$L_l\f$ are computed as !> !> \f[ !> \begin{array}{cl} !> U_l = P_l(n) U_l(n) \cdots P_l(k) U_l(k) \cdots & \: \text{and}\\% !> L_l = P_l(1) L_l(1) \cdots P_l(k) L_l(k) \cdots & !> \end{array} !> \f] !> !> where \f$k\f$ decreases from \f$n\f$ to 1 (increases from 1 to \f$n\f$) in steps of 1 or 2, !> depending on the order of block \f$D_{kl}\f$, and \f$P_l(k)\f$ is a permutation matrix !> defined by !> \f$ipiv_l[k]\f$. If \f$s\f$ denotes the order of block \f$D_{kl}\f$, then \f$U_l(k)\f$ !> and \f$L_l(k)\f$ are unit upper/lower triangular matrices defined as !> !> \f[ !> U_l(k) = \left[ \begin{array}{ccc} !> I_{k-s} & v & 0 \\% !> 0 & I_s & 0 \\% !> 0 & 0 & I_{n-k} !> \end{array} \right] !> \f] !> !> and !> !> \f[ !> L_l(k) = \left[ \begin{array}{ccc} !> I_{k-1} & 0 & 0 \\% !> 0 & I_s & 0 \\% !> 0 & v & I_{n-k-s+1} !> \end{array} \right]. !> \f] !> !> If \f$s = 1\f$, then \f$D_{kl}\f$ is stored in \f$A_l[k,k]\f$, and \f$v\f$ is stored in the !> upper/lower !> part of column \f$k\f$ of \f$A_l\f$. !> If \f$s = 2\f$ and ``uplo`` is ``upper``, then \f$D_{kl}\f$ is stored in !> \f$A_l[k-1,k-1]\f$, \f$A_l[k-1,k]\f$, !> and \f$A_l[k,k]\f$, and \f$v\f$ is stored in the upper parts of columns \f$k-1\f$ and !> \f$k\f$ of \f$A_l\f$. !> If \f$s = 2\f$ and ``uplo`` is ``lower``, then \f$D_{kl}\f$ is stored in \f$A_l[k,k]\f$, !> \f$A_l[k+1,k]\f$, !> and \f$A_l[k+1,k+1]\f$, and \f$v\f$ is stored in the lower parts of columns \f$k\f$ and !> \f$k+1\f$ of \f$A_l\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrices A_l are stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A_l is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of all matrices A_l in the batch. !> @param[inout] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the symmetric matrices A_l to be factored. !> On exit, the block diagonal matrices D_l and the multipliers needed to !> compute U_l or L_l. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[out] ipiv - pointer to rocblas_int. Array on the GPU of dimension n. !> The vector of pivot indices. Elements of ipiv are 1-based indices. !> For 1 <= k <= n, if ipiv_l[k] > 0, then rows and columns k and ipiv_l[k] !> were interchanged, and D_l[k,k] is a 1-by-1 diagonal block. !> If, instead, ipiv_l[k] = ipiv_l[k-1] < 0 and uplo is upper (or ipiv_l[k] !> = ipiv_l[k+1] < 0 and uplo is lower), then rows and columns k-1 and !> -ipiv_l[k] (or rows and columns k+1 and -ipiv_l[k]) were interchanged, !> and D_l[k-1,k-1] to D_l[k,k] (or D_l[k,k] to D_l[k+1,k+1]) is a 2-by-2 !> diagonal block. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value of strideP. The normal use case is !> strideP >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for factorization of A_l. !> If info[l] = i > 0, D_l is singular. D_l[i,i] is the first diagonal zero. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssytrf_batched function rocsolver_ssytrf_batched_(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_ssytrf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssytrf_batched_assumed_rank #else module procedure & rocsolver_ssytrf_batched_rank_0,& rocsolver_ssytrf_batched_rank_1 #endif #endif end interface interface rocsolver_dsytrf_batched function rocsolver_dsytrf_batched_(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_dsytrf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsytrf_batched_assumed_rank #else module procedure & rocsolver_dsytrf_batched_rank_0,& rocsolver_dsytrf_batched_rank_1 #endif #endif end interface interface rocsolver_csytrf_batched function rocsolver_csytrf_batched_(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_csytrf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrf_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_csytrf_batched_assumed_rank #else module procedure & rocsolver_csytrf_batched_rank_0,& rocsolver_csytrf_batched_rank_1 #endif #endif end interface interface rocsolver_zsytrf_batched function rocsolver_zsytrf_batched_(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) & bind(c, name="rocsolver_zsytrf_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zsytrf_batched_assumed_rank #else module procedure & rocsolver_zsytrf_batched_rank_0,& rocsolver_zsytrf_batched_rank_1 #endif #endif end interface !> \brief The SYTRF_STRIDED_BATCHED functions compute the factorization of a batch of !> symmetric and maybe indefinite !> matrices using Bunch-Kaufman diagonal pivoting. !> !> \details !> (This is the blocked version of the algorithm.) !> !> The factorization has the form !> !> \f[ !> \begin{array}{cl} !> A_l^{} = U_l^{} D_l^{} U_l^T & \: \text{or}\\% !> A_l^{} = L_l^{} D_l^{} L_l^T & !> \end{array} !> \f] !> !> where \f$U_l\f$ or \f$L_l\f$ is a product of permutation and unit upper/lower !> triangular matrices (depending on the value of uplo), and \f$D_l\f$ is a symmetric !> block diagonal matrix with 1-by-1 and 2-by-2 diagonal blocks \f$D_{kl}\f$. !> !> Specifically, \f$U_l\f$ and \f$L_l\f$ are computed as !> !> \f[ !> \begin{array}{cl} !> U_l = P_l(n) U_l(n) \cdots P_l(k) U_l(k) \cdots & \: \text{and}\\% !> L_l = P_l(1) L_l(1) \cdots P_l(k) L_l(k) \cdots & !> \end{array} !> \f] !> !> where \f$k\f$ decreases from \f$n\f$ to 1 (increases from 1 to \f$n\f$) in steps of 1 or 2, !> depending on the order of block \f$D_{kl}\f$, and \f$P_l(k)\f$ is a permutation matrix !> defined by !> \f$ipiv_l[k]\f$. If \f$s\f$ denotes the order of block \f$D_{kl}\f$, then \f$U_l(k)\f$ !> and \f$L_l(k)\f$ are unit upper/lower triangular matrices defined as !> !> \f[ !> U_l(k) = \left[ \begin{array}{ccc} !> I_{k-s} & v & 0 \\% !> 0 & I_s & 0 \\% !> 0 & 0 & I_{n-k} !> \end{array} \right] !> \f] !> !> and !> !> \f[ !> L_l(k) = \left[ \begin{array}{ccc} !> I_{k-1} & 0 & 0 \\% !> 0 & I_s & 0 \\% !> 0 & v & I_{n-k-s+1} !> \end{array} \right]. !> \f] !> !> If \f$s = 1\f$, then \f$D_{kl}\f$ is stored in \f$A_l[k,k]\f$, and \f$v\f$ is stored in the !> upper/lower !> part of column \f$k\f$ of \f$A_l\f$. !> If \f$s = 2\f$ and ``uplo`` is ``upper``, then \f$D_{kl}\f$ is stored in !> \f$A_l[k-1,k-1]\f$, \f$A_l[k-1,k]\f$, !> and \f$A_l[k,k]\f$, and \f$v\f$ is stored in the upper parts of columns \f$k-1\f$ and !> \f$k\f$ of \f$A_l\f$. !> If \f$s = 2\f$ and ``uplo`` is ``lower``, then \f$D_l(k)\f$ is stored in \f$A_l[k,k]\f$, !> \f$A_l[k+1,k]\f$, !> and \f$A_l[k+1,k+1]\f$, and \f$v\f$ is stored in the lower parts of columns \f$k\f$ and !> \f$k+1\f$ of \f$A_l\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the matrices A_l are stored. !> If uplo indicates lower (or upper), then the upper (or lower) !> part of A_l is not used. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows and columns of all matrices A_l in the batch. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the symmetric matrices A_l to be factored. !> On exit, the block diagonal matrices D_l and the multipliers needed to !> compute U_l or L_l. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] ipiv - pointer to rocblas_int. Array on the GPU of dimension n. !> The vector of pivot indices. Elements of ipiv are 1-based indices. !> For 1 <= k <= n, if ipiv_l[k] > 0, then rows and columns k and ipiv_l[k] !> were interchanged, and D_l[k,k] is a 1-by-1 diagonal block. !> If, instead, ipiv_l[k] = ipiv_l[k-1] < 0 and uplo is upper (or ipiv_l[k] !> = ipiv_l[k+1] < 0 and uplo is lower), then rows and columns k-1 and !> -ipiv_l[k] (or rows and columns k+1 and -ipiv_l[k]) were interchanged, !> and D_l[k-1,k-1] to D_l[k,k] (or D_l[k,k] to D_l[k+1,k+1]) is a 2-by-2 !> diagonal block. !> @param[in] strideP - rocblas_stride. !> Stride from the start of one vector ipiv_l to the next one ipiv_(l+1). !> There is no restriction for the value of strideP. The normal use case is !> strideP >= n. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for factorization of A_l. !> If info[l] = i > 0, D_l is singular. D_l[i,i] is the first diagonal zero. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssytrf_strided_batched function rocsolver_ssytrf_strided_batched_(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_ssytrf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_ssytrf_strided_batched_assumed_rank #else module procedure & rocsolver_ssytrf_strided_batched_rank_0,& rocsolver_ssytrf_strided_batched_rank_1,& rocsolver_ssytrf_strided_batched_full_rank #endif #endif end interface interface rocsolver_dsytrf_strided_batched function rocsolver_dsytrf_strided_batched_(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_dsytrf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_dsytrf_strided_batched_assumed_rank #else module procedure & rocsolver_dsytrf_strided_batched_rank_0,& rocsolver_dsytrf_strided_batched_rank_1,& rocsolver_dsytrf_strided_batched_full_rank #endif #endif end interface interface rocsolver_csytrf_strided_batched function rocsolver_csytrf_strided_batched_(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_csytrf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrf_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_csytrf_strided_batched_assumed_rank #else module procedure & rocsolver_csytrf_strided_batched_rank_0,& rocsolver_csytrf_strided_batched_rank_1,& rocsolver_csytrf_strided_batched_full_rank #endif #endif end interface interface rocsolver_zsytrf_strided_batched function rocsolver_zsytrf_strided_batched_(handle,uplo,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) & bind(c, name="rocsolver_zsytrf_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: ipiv integer(c_int64_t),value :: strideP type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zsytrf_strided_batched_assumed_rank #else module procedure & rocsolver_zsytrf_strided_batched_rank_0,& rocsolver_zsytrf_strided_batched_rank_1,& rocsolver_zsytrf_strided_batched_full_rank #endif #endif end interface !> //! !> !> \brief The GEBLTTRF_NPVT functions compute the LU factorization of a block tridiagonal !> matrix without partial pivoting. !> !> \details The LU factorization of a block tridiagonal matrix !> !> \f[ !> M = \left[\begin{array}{ccccc} !> B_1 & C_1 & & & \\% !> A_1 & B_2 & C_2 & & \\% !> & \ddots & \ddots & \ddots & \\% !> & & A_{n-2} & B_{n-1} & C_{n-1}\\% !> & & & A_{n-1} & B_n !> \end{array}\right] !> \f] !> !> with \f$n = \f$ ``nblocks`` diagonal blocks of size ``nb``, can be represented as !> !> \f[ !> M = \left[\begin{array}{cccc} !> E_1 & & & \\% !> A_1 & E_2 & & \\% !> & \ddots & \ddots & \\% !> & & A_{n-1} & E_n !> \end{array}\right] \left[\begin{array}{cccc} !> I & F_1 & & \\% !> & \ddots & \ddots & \\% !> & & I & F_{n-1}\\% !> & & & I !> \end{array}\right] = LU !> \f] !> !> where the blocks \f$E_i\f$ and \f$F_i\f$ are general blocks of size ``nb``. This function !> returns !> diagonal blocks \f$E_i\f$ in factorized form, i.e. \f$E_i=(L_i+I)U_i\f$ where \f$L_i\f$ is !> strictly lower triangular !> and \f$U_i\f$ is upper triangular. !> !> @param[in] handle - rocblas_handle. !> @param[in] nb - rocblas_int. nb >= 0. !> The number of rows and columns of each block. !> @param[in] nblocks - rocblas_int. nblocks >= 0. !> The number of blocks along the diagonal of the matrix. !> @param[in] A - pointer to type. Array on the GPU of dimension lda*nb*(nblocks-1). !> Contains the blocks A_i, arranged one after the other. !> @param[in] lda - rocblas_int. lda >= nb. !> Specifies the leading dimension of blocks A_i. !> @param[inout] B - pointer to type. Array on the GPU of dimension ldb*nb*nblocks. !> On entry, contains the blocks B_i, arranged one after the other. !> On exit, it is overwritten by L_i + U_i, where L_i and U_i are the factors of !> E_i as returned by !> \ref rocsolver_sgetrf_npvt "GETRF_NPVT". !> @param[in] ldb - rocblas_int. ldb >= nb. !> Specifies the leading dimension of blocks B_i. !> @param[inout] C - pointer to type. Array on the GPU of dimension ldc*nb*(nblocks-1). !> On entry, contains the blocks C_i, arranged one after the other. !> On exit, it is overwritten by blocks F_i. !> @param[in] ldc - rocblas_int. ldc >= nb. !> Specifies the leading dimension of blocks C_i. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, the matrix is singular. interface rocsolver_sgeblttrf_npvt function rocsolver_sgeblttrf_npvt_(handle,nb,nblocks,A,lda,B,ldb,C,ldc,myInfo) & bind(c, name="rocsolver_sgeblttrf_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeblttrf_npvt_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function end interface interface rocsolver_dgeblttrf_npvt function rocsolver_dgeblttrf_npvt_(handle,nb,nblocks,A,lda,B,ldb,C,ldc,myInfo) & bind(c, name="rocsolver_dgeblttrf_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeblttrf_npvt_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function end interface interface rocsolver_cgeblttrf_npvt function rocsolver_cgeblttrf_npvt_(handle,nb,nblocks,A,lda,B,ldb,C,ldc,myInfo) & bind(c, name="rocsolver_cgeblttrf_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeblttrf_npvt_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function end interface interface rocsolver_zgeblttrf_npvt function rocsolver_zgeblttrf_npvt_(handle,nb,nblocks,A,lda,B,ldb,C,ldc,myInfo) & bind(c, name="rocsolver_zgeblttrf_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeblttrf_npvt_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo end function end interface !> \brief The GEBLTTRF_NPVT_BATCHED functions compute the LU factorization of a batch of block !> tridiagonal matrices without !> partial pivoting. !> !> \details The LU factorization of a block tridiagonal matrix \f$M_l\f$ in the batch !> !> \f[ !> M_l = \left[\begin{array}{ccccc} !> B_{l1} & C_{l1} & & & \\% !> A_{l1} & B_{l2} & C_{l2} & & \\% !> & \ddots & \ddots & \ddots & \\% !> & & A_{l(n-2)} & B_{l(n-1)} & C_{l(l-1)} \\% !> & & & A_{l(n-1)} & B_{ln} !> \end{array}\right] !> \f] !> !> with \f$n = \f$ ``nblocks`` diagonal blocks of size ``nb``, can be represented as !> !> \f[ !> M_l = \left[\begin{array}{cccc} !> E_{l1} & & & \\% !> A_{l1} & E_{l2} & & \\% !> & \ddots & \ddots & \\% !> & & A_{l(n-1)} & E_{ln} !> \end{array}\right] \left[\begin{array}{cccc} !> I & F_{l1} & & \\% !> & \ddots & \ddots & \\% !> & & I & F_{l(n-1)} \\% !> & & & I !> \end{array}\right] = L_l U_l !> \f] !> !> where the blocks \f$E_{li}\f$ and \f$F_{li}\f$ are general blocks of size ``nb``. This !> function returns !> diagonal blocks \f$E_{li}\f$ in factorized form, i.e. \f$E_{li}=(L_{li}+I)U_{li}\f$ where !> \f$L_{li}\f$ is strictly lower triangular !> and \f$U_{li}\f$ is upper triangular. !> !> @param[in] handle - rocblas_handle. !> @param[in] nb - rocblas_int. nb >= 0. !> The number of rows and columns of each block. !> @param[in] nblocks - rocblas_int. nblocks >= 0. !> The number of blocks along the diagonal of each matrix in the batch. !> @param[in] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension !> lda*nb*(nblocks-1). !> Contains the blocks A_{li}, arranged one after the other. !> @param[in] lda - rocblas_int. lda >= nb. !> Specifies the leading dimension of blocks A_{li}. !> @param[inout] B - array of pointers to type. Each pointer points to an array on the GPU of !> dimension !> ldb*nb*nblocks. !> On entry, contains the blocks B_{li}, arranged one after the other. !> On exit, it is overwritten by L_{li} + U_{li}, where L_{li} and U_{li} are the !> factors of E_{li} as returned by !> \ref rocsolver_sgetrf_npvt "GETRF_NPVT". !> @param[in] ldb - rocblas_int. ldb >= nb. !> Specifies the leading dimension of blocks B_{li}. !> @param[inout] C - array of pointers to type. Each pointer points to an array on the GPU of !> dimension !> ldc*nb*(nblocks-1). !> On entry, contains the blocks C_{li}, arranged one after the other. !> On exit, it is overwritten by blocks F_{li}. !> @param[in] ldc - rocblas_int. ldc >= nb. !> Specifies the leading dimension of blocks C_{li}. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for factorization of l-th batch instance. !> If info[l] = i > 0, the l-th batch instance is singular. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgeblttrf_npvt_batched function rocsolver_sgeblttrf_npvt_batched_(handle,nb,nblocks,A,lda,B,ldb,C,ldc,myInfo, & batch_count) & bind(c, name="rocsolver_sgeblttrf_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeblttrf_npvt_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dgeblttrf_npvt_batched function rocsolver_dgeblttrf_npvt_batched_(handle,nb,nblocks,A,lda,B,ldb,C,ldc,myInfo, & batch_count) & bind(c, name="rocsolver_dgeblttrf_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeblttrf_npvt_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_cgeblttrf_npvt_batched function rocsolver_cgeblttrf_npvt_batched_(handle,nb,nblocks,A,lda,B,ldb,C,ldc,myInfo, & batch_count) & bind(c, name="rocsolver_cgeblttrf_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeblttrf_npvt_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zgeblttrf_npvt_batched function rocsolver_zgeblttrf_npvt_batched_(handle,nb,nblocks,A,lda,B,ldb,C,ldc,myInfo, & batch_count) & bind(c, name="rocsolver_zgeblttrf_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeblttrf_npvt_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: C integer(c_int),value :: ldc type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The GEBLTTRF_NPVT_STRIDED_BATCHED functions compute the LU factorization of a batch !> of block tridiagonal !> matrices without partial pivoting. !> !> \details The LU factorization of a block tridiagonal matrix \f$M_l\f$ in the batch !> !> \f[ !> M_l = \left[\begin{array}{ccccc} !> B_{l1} & C_{l1} & & & \\% !> A_{l1} & B_{l2} & C_{l2} & & \\% !> & \ddots & \ddots & \ddots & \\% !> & & A_{l(n-2)} & B_{l(n-1)} & C_{l(n-1)} \\% !> & & & A_{l(n-1)} & B_{ln} !> \end{array}\right] !> \f] !> !> with \f$n = \f$ ``nblocks`` diagonal blocks of size ``nb``, can be represented as !> !> \f[ !> M_l = \left[\begin{array}{cccc} !> E_{l1} & & & \\% !> A_{l1} & E_{l2} & & \\% !> & \ddots & \ddots & \\% !> & & A_{l(n-1)} & E_{ln} !> \end{array}\right] \left[\begin{array}{cccc} !> I & F_{l1} & & \\% !> & \ddots & \ddots & \\% !> & & I & F_{l(n-1)} \\% !> & & & I !> \end{array}\right] = L_l U_l !> \f] !> !> where the blocks \f$E_{li}\f$ and \f$F_{li}\f$ are general blocks of size ``nb``. This !> function returns !> diagonal blocks \f$E_{li}\f$ in factorized form, i.e. \f$E_{li}=(L_{li}+I)U_{li}\f$ where !> \f$L_{li}\f$ is strictly lower triangular !> and \f$U_{li}\f$ is upper triangular. !> !> @param[in] handle - rocblas_handle. !> @param[in] nb - rocblas_int. nb >= 0. !> The number of rows and columns of each block. !> @param[in] nblocks - rocblas_int. nblocks >= 0. !> The number of blocks along the diagonal of each matrix in the batch. !> @param[in] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> Contains the blocks A_{li}, arranged one after the other. !> @param[in] lda - rocblas_int. lda >= nb. !> Specifies the leading dimension of blocks A_{li}. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one block A_{li} to the same block in the next batch !> instance A_{(l+1)i}. !> There is no restriction for the value of strideA. The normal use case is !> strideA >= !> lda*nb*(nblocks-1). !> @param[inout] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> On entry, contains the blocks B_{li}, arranged one after the other. !> On exit, it is overwritten by L_{li} + U_{li}, where L_{li} and U_{li} are the !> factors of E_{li} as returned by !> \ref rocsolver_sgetrf_npvt "GETRF_NPVT". !> @param[in] ldb - rocblas_int. ldb >= nb. !> Specifies the leading dimension of matrix blocks B_{li}. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one block B_{li} to the same block in the next batch !> instance B_{(l+1)i}. !> There is no restriction for the value of strideB. The normal use case is !> strideB >= !> ldb*nb*nblocks. !> @param[inout] C - pointer to type. Array on the GPU (the size depends on the value of !> strideC). !> On entry, contains the blocks C_{li}, arranged one after the other. !> On exit, it is overwritten by blocks F_{li}. !> @param[in] ldc - rocblas_int. ldc >= nb. !> Specifies the leading dimension of matrix blocks C_{li}. !> @param[in] strideC - rocblas_stride. !> Stride from the start of one block C_{li} to the same block in the next batch !> instance C_{(l+1)i}. !> There is no restriction for the value of strideC. The normal use case is !> strideC >= !> ldc*nb*(nblocks-1). !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for factorization of l-th batch instance. !> If info[l] = i > 0, the l-th batch instance is singular. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgeblttrf_npvt_strided_batched function rocsolver_sgeblttrf_npvt_strided_batched_(handle,nb,nblocks,A,lda,strideA,B,ldb, & strideB,C,ldc,strideC,myInfo,batch_count) & bind(c, name="rocsolver_sgeblttrf_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeblttrf_npvt_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks 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 :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dgeblttrf_npvt_strided_batched function rocsolver_dgeblttrf_npvt_strided_batched_(handle,nb,nblocks,A,lda,strideA,B,ldb, & strideB,C,ldc,strideC,myInfo,batch_count) & bind(c, name="rocsolver_dgeblttrf_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeblttrf_npvt_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks 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 :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_cgeblttrf_npvt_strided_batched function rocsolver_cgeblttrf_npvt_strided_batched_(handle,nb,nblocks,A,lda,strideA,B,ldb, & strideB,C,ldc,strideC,myInfo,batch_count) & bind(c, name="rocsolver_cgeblttrf_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeblttrf_npvt_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks 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 :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zgeblttrf_npvt_strided_batched function rocsolver_zgeblttrf_npvt_strided_batched_(handle,nb,nblocks,A,lda,strideA,B,ldb, & strideB,C,ldc,strideC,myInfo,batch_count) & bind(c, name="rocsolver_zgeblttrf_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeblttrf_npvt_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks 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 :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The GEBLTTRF_NPVT_INTERLEAVED_BATCHED functions compute the LU factorization of a !> batch of block tridiagonal !> matrices without partial pivoting. !> !> \details The LU factorization of a block tridiagonal matrix \f$M_l\f$ in the batch !> !> \f[ !> M_l = \left[\begin{array}{ccccc} !> B_{l1} & C_{l1} & & & \\% !> A_{l1} & B_{l2} & C_{l2} & & \\% !> & \ddots & \ddots & \ddots & \\% !> & & A_{l(n-2)} & B_{l(n-1)} & C_{l(n-1)}\\% !> & & & A_{l(n-1)} & B_{ln} !> \end{array}\right] !> \f] !> !> with \f$n = \f$ ``nblocks`` diagonal blocks of size ``nb``, can be represented as !> !> \f[ !> M_l = \left[\begin{array}{cccc} !> E_{l1} & & & \\% !> A_{l1} & E_{l2} & & \\% !> & \ddots & \ddots & \\% !> & & A_{l(n-1)} & E_{ln} !> \end{array}\right] \left[\begin{array}{cccc} !> I & F_{l1} & & \\% !> & \ddots & \ddots & \\% !> & & I & F_{l(n-1)} \\% !> & & & I !> \end{array}\right] = L_l U_l !> \f] !> !> where the blocks \f$E_{li}\f$ and \f$F_{li}\f$ are general blocks of size ``nb``. This !> function returns !> diagonal blocks \f$E_{li}\f$ in factorized form, i.e. \f$E_{li}=(L_{li}+I)U_{li}\f$ where !> \f$L_{li}\f$ is strictly lower triangular !> and \f$U_{li}\f$ is upper triangular. !> !> @param[in] handle - rocblas_handle. !> @param[in] nb - rocblas_int. nb >= 0. !> The number of rows and columns of each block. !> @param[in] nblocks - rocblas_int. nblocks >= 0. !> The number of blocks along the diagonal of each matrix in the batch. !> @param[in] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> Contains the blocks A_{li}, arranged one after the other. !> @param[in] inca - rocblas_int. inca > 0. !> Stride from the start of one row of A_{li} to the next. The normal use cases !> are !> inca = 1 (equivalent to the strided batched case) or inca = batch_count (for an !> interleaved batched case). !> @param[in] lda - rocblas_int. lda >= inca * nb. !> Specifies the leading dimension of blocks A_{li}, that is, the stride from the !> start !> of one column of A_{li} to the next. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one block A_{li} to the same block in the next batch !> instance A_{(l+1)i}. !> There is no restriction for the value of strideA. The normal use cases are !> strideA >= !> lda*nb*(nblocks-1) (equivalent to the strided batched case) or strideA = 1 (for !> an interleaved batched case). !> @param[inout] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> On entry, contains the blocks B_{li}, arranged one after the other. !> On exit, it is overwritten by L_{li} + U_{li}, where L_{li} and U_{li} are the !> factors of E_{li} as returned by !> \ref rocsolver_sgetrf_npvt "GETRF_NPVT". !> @param[in] incb - rocblas_int. incb > 0. !> Stride from the start of one row of B_{li} to the next. The normal use cases !> are !> incb = 1 (equivalent to the strided batched case) or incb = batch_count (for an !> interleaved batched case). !> @param[in] ldb - rocblas_int. ldb >= incb * nb. !> Specifies the leading dimension of blocks B_{li}, that is, the stride from the !> start !> of one column of B_{li} to the next. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one block B_{li} to the same block in the next batch !> instance B_{(l+1)i}. !> There is no restriction for the value of strideB. The normal use cases are !> strideB >= !> ldb*nb*nblocks (equivalent to the strided batched case) or strideB = 1 (for an !> interleaved batched case). !> @param[inout] C - pointer to type. Array on the GPU (the size depends on the value of !> strideC). !> On entry, contains the blocks C_{li}, arranged one after the other. !> On exit, it is overwritten by blocks F_{li}. !> @param[in] incc - rocblas_int. incc > 0. !> Stride from the start of one row of C_{li} to the next. The normal use cases !> are !> incc = 1 (equivalent to the strided batched case) or incc = batch_count (for an !> interleaved batched case). !> @param[in] ldc - rocblas_int. ldc >= incc * nb. !> Specifies the leading dimension of blocks C_{li}, that is, the stride from the !> start !> of one column of C_{li} to the next. !> @param[in] strideC - rocblas_stride. !> Stride from the start of one block C_{li} to the same block in the next batch !> instance C_{(l+1)i}. !> There is no restriction for the value of strideC. The normal use cases are !> strideC >= !> ldc*nb*(nblocks-1) (equivalent to the strided batched case) or strideC = 1 (for !> an interleaved batched case). !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for factorization of l-th batch instance. !> If info[l] = i > 0, the l-th batch instance is singular. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgeblttrf_npvt_interleaved_batched function rocsolver_sgeblttrf_npvt_interleaved_batched_(handle,nb,nblocks,A,inca,lda,strideA,B, & incb,ldb,strideB,C,incc,ldc,strideC,myInfo,batch_count) & bind(c, name="rocsolver_sgeblttrf_npvt_interleaved_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeblttrf_npvt_interleaved_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks type(c_ptr),value :: A integer(c_int),value :: inca integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int),value :: incb integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: C integer(c_int),value :: incc integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dgeblttrf_npvt_interleaved_batched function rocsolver_dgeblttrf_npvt_interleaved_batched_(handle,nb,nblocks,A,inca,lda,strideA,B, & incb,ldb,strideB,C,incc,ldc,strideC,myInfo,batch_count) & bind(c, name="rocsolver_dgeblttrf_npvt_interleaved_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeblttrf_npvt_interleaved_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks type(c_ptr),value :: A integer(c_int),value :: inca integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int),value :: incb integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: C integer(c_int),value :: incc integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_cgeblttrf_npvt_interleaved_batched function rocsolver_cgeblttrf_npvt_interleaved_batched_(handle,nb,nblocks,A,inca,lda,strideA,B, & incb,ldb,strideB,C,incc,ldc,strideC,myInfo,batch_count) & bind(c, name="rocsolver_cgeblttrf_npvt_interleaved_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeblttrf_npvt_interleaved_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks type(c_ptr),value :: A integer(c_int),value :: inca integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int),value :: incb integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: C integer(c_int),value :: incc integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zgeblttrf_npvt_interleaved_batched function rocsolver_zgeblttrf_npvt_interleaved_batched_(handle,nb,nblocks,A,inca,lda,strideA,B, & incb,ldb,strideB,C,incc,ldc,strideC,myInfo,batch_count) & bind(c, name="rocsolver_zgeblttrf_npvt_interleaved_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeblttrf_npvt_interleaved_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks type(c_ptr),value :: A integer(c_int),value :: inca integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int),value :: incb integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: C integer(c_int),value :: incc integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The GEBLTTRS_NPVT functions solve a system of linear equations given by a block !> tridiagonal matrix !> in its factorized form (without partial pivoting). !> !> \details The linear system has the form !> !> \f[ !> MX = \left[\begin{array}{ccccc} !> B_1 & C_1 & & & \\% !> A_1 & B_2 & C_2 & & \\% !> & \ddots & \ddots & \ddots & \\% !> & & A_{n-2} & B_{n-1} & C_{n-1} \\% !> & & & A_{n-1} & B_n !> \end{array}\right]\left[\begin{array}{c} !> X_1\\% !> X_2\\% !> X_3\\% !> \vdots\\% !> X_n !> \end{array}\right]=\left[\begin{array}{c} !> R_1\\% !> R_2\\% !> R_3\\% !> \vdots\\% !> R_n !> \end{array}\right]=R !> \f] !> !> where matrix M has \f$n = \f$ ``nblocks`` diagonal blocks of size ``nb``, and the !> right-hand-side !> blocks \f$R_i\f$ are general blocks of size ``nb`` -by-``nrhs``. The blocks of matrix M !> should be in !> the factorized form, as returned by \ref rocsolver_sgeblttrf_npvt "GEBLTTRF_NPVT". !> !> @param[in] handle - rocblas_handle. !> @param[in] nb - rocblas_int. nb >= 0. !> The number of rows and columns of each block. !> @param[in] nblocks - rocblas_int. nblocks >= 0. !> The number of blocks along the diagonal of the matrix. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns of blocks R_i. !> @param[in] A - pointer to type. Array on the GPU of dimension lda*nb*(nblocks-1). !> Contains the blocks A_i, as returned by \ref rocsolver_sgeblttrf_npvt !> "GEBLTTRF_NPVT". !> @param[in] lda - rocblas_int. lda >= nb. !> Specifies the leading dimension of blocks A_i. !> @param[in] B - pointer to type. Array on the GPU of dimension ldb*nb*nblocks. !> Contains the blocks B_i, as returned by \ref rocsolver_sgeblttrf_npvt !> "GEBLTTRF_NPVT". !> @param[in] ldb - rocblas_int. ldb >= nb. !> Specifies the leading dimension of blocks B_i. !> @param[in] C - pointer to type. Array on the GPU of dimension ldc*nb*(nblocks-1). !> Contains the blocks C_i, as returned by \ref rocsolver_sgeblttrf_npvt !> "GEBLTTRF_NPVT". !> @param[in] ldc - rocblas_int. ldc >= nb. !> Specifies the leading dimension of blocks C_i. !> @param[inout] X - pointer to type. Array on the GPU of dimension ldx*nblocks*nrhs. !> On entry, X contains the right-hand-side blocks R_i. It is overwritten by !> solution !> vectors X_i on exit. !> @param[in] ldx - rocblas_int. ldx >= nb. !> Specifies the leading dimension of blocks X_i. interface rocsolver_sgeblttrs_npvt function rocsolver_sgeblttrs_npvt_(handle,nb,nblocks,nrhs,A,lda,B,ldb,C,ldc,X,ldx) & bind(c, name="rocsolver_sgeblttrs_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeblttrs_npvt_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks 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 :: C integer(c_int),value :: ldc type(c_ptr),value :: X integer(c_int),value :: ldx end function end interface interface rocsolver_dgeblttrs_npvt function rocsolver_dgeblttrs_npvt_(handle,nb,nblocks,nrhs,A,lda,B,ldb,C,ldc,X,ldx) & bind(c, name="rocsolver_dgeblttrs_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeblttrs_npvt_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks 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 :: C integer(c_int),value :: ldc type(c_ptr),value :: X integer(c_int),value :: ldx end function end interface interface rocsolver_cgeblttrs_npvt function rocsolver_cgeblttrs_npvt_(handle,nb,nblocks,nrhs,A,lda,B,ldb,C,ldc,X,ldx) & bind(c, name="rocsolver_cgeblttrs_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeblttrs_npvt_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks 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 :: C integer(c_int),value :: ldc type(c_ptr),value :: X integer(c_int),value :: ldx end function end interface interface rocsolver_zgeblttrs_npvt function rocsolver_zgeblttrs_npvt_(handle,nb,nblocks,nrhs,A,lda,B,ldb,C,ldc,X,ldx) & bind(c, name="rocsolver_zgeblttrs_npvt") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeblttrs_npvt_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks 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 :: C integer(c_int),value :: ldc type(c_ptr),value :: X integer(c_int),value :: ldx end function end interface !> \brief The GEBLTTRS_NPVT_BATCHED functions solve a batch of system of linear equations !> given by block tridiagonal !> matrices in its factorized form (without partial pivoting). !> !> \details Each linear system has the form !> !> \f[ !> M_l X_l = \left[\begin{array}{ccccc} !> B_{l1} & C_{l1} & & & \\% !> A_{l1} & B_{l2} & C_{l2} & & \\% !> & \ddots & \ddots & \ddots & \\% !> & & A_{l(n-2)} & B_{l(n-1)} & C_{l(n-1)} \\% !> & & & A_{l(n-1)} & B_{ln} !> \end{array}\right]\left[\begin{array}{c} !> X_{l1}\\% !> X_{l2}\\% !> X_{l3}\\% !> \vdots\\% !> X_{ln} !> \end{array}\right]=\left[\begin{array}{c} !> R_{l1}\\% !> R_{l2}\\% !> R_{l3}\\% !> \vdots\\% !> R_{ln} !> \end{array}\right]=R_l !> \f] !> !> where matrix \f$M_l\f$ has \f$n = \f$ ``nblocks`` diagonal blocks of size ``nb``, and the !> right-hand-side !> blocks \f$R_{li}\f$ are general blocks of size ``nb`` -by-``nrhs``. The blocks of matrix !> \f$M_l\f$ should be in !> the factorized form, as returned by \ref rocsolver_sgeblttrf_npvt_batched !> "GEBLTTRF_NPVT_BATCHED". !> !> @param[in] handle - rocblas_handle. !> @param[in] nb - rocblas_int. nb >= 0. !> The number of rows and columns of each block. !> @param[in] nblocks - rocblas_int. nblocks >= 0. !> The number of blocks along the diagonal of each matrix in the batch. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns of blocks !> R_{li}. !> @param[in] A - array of pointers to type. Each pointer points to an array on the GPU of !> dimension !> lda*nb*(nblocks-1). !> Contains the blocks A_{li}, as returned by \ref !> rocsolver_sgeblttrf_npvt_batched "GEBLTTRF_NPVT_BATCHED". !> @param[in] lda - rocblas_int. lda >= nb. !> Specifies the leading dimension of blocks A_{li}. !> @param[in] B - array of pointers to type. Each pointer points to an array on the GPU of !> dimension !> lda*nb*nblocks. !> Contains the blocks B_{li}, as returned by \ref !> rocsolver_sgeblttrf_npvt_batched "GEBLTTRF_NPVT_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= nb. !> Specifies the leading dimension of blocks B_{li}. !> @param[in] C - array of pointers to type. Each pointer points to an array on the GPU of !> dimension !> ldc*nb*(nblocks-1). !> Contains the blocks C_{li}, as returned by \ref !> rocsolver_sgeblttrf_npvt_batched "GEBLTTRF_NPVT_BATCHED". !> @param[in] ldc - rocblas_int. ldc >= nb. !> Specifies the leading dimension of blocks C_{li}. !> @param[inout] X - array of pointers to type. Each pointer points to an array on the GPU of !> dimension !> ldx*nblocks*nrhs. !> On entry, X contains the right-hand-side blocks R_{li}. It is overwritten by !> solution !> vectors X_{li} on exit. !> @param[in] ldx - rocblas_int. ldx >= nb. !> Specifies the leading dimension of blocks X_{li}. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgeblttrs_npvt_batched function rocsolver_sgeblttrs_npvt_batched_(handle,nb,nblocks,nrhs,A,lda,B,ldb,C,ldc,X,ldx, & batch_count) & bind(c, name="rocsolver_sgeblttrs_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeblttrs_npvt_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks 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 :: C integer(c_int),value :: ldc type(c_ptr),value :: X integer(c_int),value :: ldx integer(c_int),value :: batch_count end function end interface interface rocsolver_dgeblttrs_npvt_batched function rocsolver_dgeblttrs_npvt_batched_(handle,nb,nblocks,nrhs,A,lda,B,ldb,C,ldc,X,ldx, & batch_count) & bind(c, name="rocsolver_dgeblttrs_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeblttrs_npvt_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks 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 :: C integer(c_int),value :: ldc type(c_ptr),value :: X integer(c_int),value :: ldx integer(c_int),value :: batch_count end function end interface interface rocsolver_cgeblttrs_npvt_batched function rocsolver_cgeblttrs_npvt_batched_(handle,nb,nblocks,nrhs,A,lda,B,ldb,C,ldc,X,ldx, & batch_count) & bind(c, name="rocsolver_cgeblttrs_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeblttrs_npvt_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks 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 :: C integer(c_int),value :: ldc type(c_ptr),value :: X integer(c_int),value :: ldx integer(c_int),value :: batch_count end function end interface interface rocsolver_zgeblttrs_npvt_batched function rocsolver_zgeblttrs_npvt_batched_(handle,nb,nblocks,nrhs,A,lda,B,ldb,C,ldc,X,ldx, & batch_count) & bind(c, name="rocsolver_zgeblttrs_npvt_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeblttrs_npvt_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks 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 :: C integer(c_int),value :: ldc type(c_ptr),value :: X integer(c_int),value :: ldx integer(c_int),value :: batch_count end function end interface !> \brief The GEBLTTRS_NPVT_STRIDED_BATCHED functions solve a batch of system of linear !> equations given by block !> tridiagonal matrices in its factorized form (without partial pivoting). !> !> \details Each linear system has the form !> !> \f[ !> M_l X_l = \left[\begin{array}{ccccc} !> B_{l1} & C_{l1} & & & \\% !> A_{l1} & B_{l2} & C_{l2} & & \\% !> & \ddots & \ddots & \ddots & \\% !> & & A_{l(n-2)} & B_{l(n-1)} & C_{l(n-1)} \\% !> & & & A_{l(n-1)} & B_{ln} !> \end{array}\right]\left[\begin{array}{c} !> X_{l1}\\% !> X_{l2}\\% !> X_{l3}\\% !> \vdots\\% !> X_{ln} !> \end{array}\right]=\left[\begin{array}{c} !> R_{l1}\\% !> R_{l2}\\% !> R_{l3}\\% !> \vdots\\% !> R_{ln} !> \end{array}\right]=R_l !> \f] !> !> where matrix \f$M_l\f$ has \f$n = \f$ ``nblocks`` diagonal blocks of size ``nb``, and the !> right-hand-side !> blocks \f$R_{li}\f$ are general blocks of size ``nb`` -by-``nrhs``. The blocks of matrix !> \f$M_l\f$ should be in !> the factorized form, as returned by \ref rocsolver_sgeblttrf_npvt_strided_batched !> "GEBLTTRF_NPVT_STRIDED_BATCHED". !> !> @param[in] handle - rocblas_handle. !> @param[in] nb - rocblas_int. nb >= 0. !> The number of rows and columns of each block. !> @param[in] nblocks - rocblas_int. nblocks >= 0. !> The number of blocks along the diagonal of each matrix in the batch. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns of blocks !> R_{li}. !> @param[in] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> Contains the blocks A_{li}, as returned by \ref !> rocsolver_sgeblttrf_npvt_strided_batched "GEBLTTRF_NPVT_STRIDED_BATCHED". !> @param[in] lda - rocblas_int. lda >= nb. !> Specifies the leading dimension of blocks A_{li}. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one block A_{li} to the same block in the next batch !> instance A_{(l+1)i}. !> There is no restriction for the value of strideA. The normal use case is !> strideA >= !> lda*nb*(nblocks-1). !> @param[in] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> Contains the blocks B_{li}, as returned by \ref !> rocsolver_sgeblttrf_npvt_strided_batched "GEBLTTRF_NPVT_STRIDED_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= nb. !> Specifies the leading dimension of blocks B_{li}. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one block B_{li} to the same block in the next batch !> instance B_{(l+1)i}. !> There is no restriction for the value of strideB. The normal use case is !> strideB >= !> ldb*nb*nblocks. !> @param[in] C - pointer to type. Array on the GPU (the size depends on the value of !> strideC). !> Contains the blocks C_{li}, as returned by \ref !> rocsolver_sgeblttrf_npvt_strided_batched "GEBLTTRF_NPVT_STRIDED_BATCHED". !> @param[in] ldc - rocblas_int. ldc >= nb. !> Specifies the leading dimension of blocks C_{li}. !> @param[in] strideC - rocblas_stride. !> Stride from the start of one block C_{li} to the same block in the next batch !> instance C_{(l+1)i}. !> There is no restriction for the value of strideC. The normal use case is !> strideC >= !> ldc*nb*(nblocks-1). !> @param[inout] X - pointer to type. Array on the GPU (the size depends on the value of !> strideX). !> On entry, X contains the right-hand-side blocks R_{li}. It is overwritten by !> solution !> vectors X_{li} on exit. !> @param[in] ldx - rocblas_int. ldx >= nb. !> Specifies the leading dimension of blocks X_{li}. !> @param[in] strideX - rocblas_stride. !> Stride from the start of one block X_{li} to the same block in the next batch !> instance X_{(l+1)i}. !> There is no restriction for the value of strideX. The normal use case is !> strideX >= !> ldx*nblocks*nrhs. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgeblttrs_npvt_strided_batched function rocsolver_sgeblttrs_npvt_strided_batched_(handle,nb,nblocks,nrhs,A,lda,strideA,B,ldb, & strideB,C,ldc,strideC,X,ldx,strideX,batch_count) & bind(c, name="rocsolver_sgeblttrs_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeblttrs_npvt_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks 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 :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: X integer(c_int),value :: ldx integer(c_int64_t),value :: strideX integer(c_int),value :: batch_count end function end interface interface rocsolver_dgeblttrs_npvt_strided_batched function rocsolver_dgeblttrs_npvt_strided_batched_(handle,nb,nblocks,nrhs,A,lda,strideA,B,ldb, & strideB,C,ldc,strideC,X,ldx,strideX,batch_count) & bind(c, name="rocsolver_dgeblttrs_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeblttrs_npvt_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks 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 :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: X integer(c_int),value :: ldx integer(c_int64_t),value :: strideX integer(c_int),value :: batch_count end function end interface interface rocsolver_cgeblttrs_npvt_strided_batched function rocsolver_cgeblttrs_npvt_strided_batched_(handle,nb,nblocks,nrhs,A,lda,strideA,B,ldb, & strideB,C,ldc,strideC,X,ldx,strideX,batch_count) & bind(c, name="rocsolver_cgeblttrs_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeblttrs_npvt_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks 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 :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: X integer(c_int),value :: ldx integer(c_int64_t),value :: strideX integer(c_int),value :: batch_count end function end interface interface rocsolver_zgeblttrs_npvt_strided_batched function rocsolver_zgeblttrs_npvt_strided_batched_(handle,nb,nblocks,nrhs,A,lda,strideA,B,ldb, & strideB,C,ldc,strideC,X,ldx,strideX,batch_count) & bind(c, name="rocsolver_zgeblttrs_npvt_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeblttrs_npvt_strided_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks 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 :: C integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: X integer(c_int),value :: ldx integer(c_int64_t),value :: strideX integer(c_int),value :: batch_count end function end interface !> \brief The GEBLTTRS_NPVT_INTERLEAVED_BATCHED functions solve a batch of system of linear !> equations given by block !> tridiagonal matrices in its factorized form (without partial pivoting). !> !> \details Each linear system has the form !> !> \f[ !> M_l X_l = \left[\begin{array}{ccccc} !> B_{l1} & C_{ll} & & & \\% !> A_{l1} & B_{ll} & C_{ll} & & \\% !> & \ddots & \ddots & \ddots & \\% !> & & A_{l(n-2)} & B_{l(n-1)} & C_{l(n-1)} \\% !> & & & A_{l(n-1)} & B_{ln} !> \end{array}\right]\left[\begin{array}{c} !> X_{l1}\\% !> X_{l2}\\% !> X_{l3}\\% !> \vdots\\% !> X_{ln} !> \end{array}\right]=\left[\begin{array}{c} !> R_{l1}\\% !> R_{l2}\\% !> R_{l3}\\% !> \vdots\\% !> R_{ln} !> \end{array}\right]=R_l !> \f] !> !> where matrix \f$M_l\f$ has \f$n = \f$ ``nblocks`` diagonal blocks of size ``nb``, and the !> right-hand-side !> blocks \f$R_{li}\f$ are general blocks of size ``nb`` -by-``nrhs``. The blocks of matrix !> \f$M_l\f$ should be in !> the factorized form, as returned by \ref rocsolver_sgeblttrf_npvt_interleaved_batched !> "GEBLTTRF_NPVT_INTERLEAVED_BATCHED". !> !> @param[in] handle - rocblas_handle. !> @param[in] nb - rocblas_int. nb >= 0. !> The number of rows and columns of each block. !> @param[in] nblocks - rocblas_int. nblocks >= 0. !> The number of blocks along the diagonal of each matrix in the batch. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns of blocks !> R_{li}. !> @param[in] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> Contains the blocks A_{li}, as returned by \ref !> rocsolver_sgeblttrf_npvt_interleaved_batched !> "GEBLTTRF_NPVT_INTERLEAVED_BATCHED". !> @param[in] inca - rocblas_int. inca > 0. !> Stride from the start of one row of A_{li} to the next. The normal use cases !> are !> inca = 1 (equivalent to the strided batched case) or inca = batch_count (for an !> interleaved batched case). !> @param[in] lda - rocblas_int. lda >= inca * nb. !> Specifies the leading dimension of blocks A_{li}, that is, the stride from the !> start !> of one column of A_{li} to the next. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one block A_{li} to the same block in the next batch !> instance A_{(l+1)i}. !> There is no restriction for the value of strideA. The normal use cases are !> strideA >= !> lda*nb*(nblocks-1) (equivalent to the strided batched case) or strideA = 1 (for !> an interleaved batched case). !> @param[in] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> Contains the blocks B_{li}, as returned by \ref !> rocsolver_sgeblttrf_npvt_interleaved_batched !> "GEBLTTRF_NPVT_INTERLEAVED_BATCHED". !> @param[in] incb - rocblas_int. incb > 0. !> Stride from the start of one row of B_{li} to the next. The normal use cases !> are !> incb = 1 (equivalent to the strided batched case) or incb = batch_count (for an !> interleaved batched case). !> @param[in] ldb - rocblas_int. ldb >= incb * nb. !> Specifies the leading dimension of blocks B_{li}, that is, the stride from the !> start !> of one column of B_{li} to the next. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one block B_{li} to the same block in the next batch !> instance B_{(l+1)i}. !> There is no restriction for the value of strideB. The normal use cases are !> strideB >= !> ldb*nb*nblocks (equivalent to the strided batched case) or strideB = 1 (for an !> interleaved batched case). !> @param[in] C - pointer to type. Array on the GPU (the size depends on the value of !> strideC). !> Contains the blocks C_{li}, as returned by \ref !> rocsolver_sgeblttrf_npvt_interleaved_batched !> "GEBLTTRF_NPVT_INTERLEAVED_BATCHED". !> @param[in] incc - rocblas_int. incc > 0. !> Stride from the start of one row of C_{li} to the next. The normal use cases !> are !> incc = 1 (equivalent to the strided batched case) or incc = batch_count (for an !> interleaved batched case). !> @param[in] ldc - rocblas_int. ldc >= incc * nb. !> Specifies the leading dimension of blocks C_{li}, that is, the stride from the !> start !> of one column of C_{li} to the next. !> @param[in] strideC - rocblas_stride. !> Stride from the start of one block C_{li} to the same block in the next batch !> instance C_{(l+1)i}. !> There is no restriction for the value of strideC. The normal use cases are !> strideC >= !> ldc*nb*(nblocks-1) (equivalent to the strided batched case) or strideC = 1 (for !> an interleaved batched case). !> @param[inout] X - pointer to type. Array on the GPU (the size depends on the value of !> strideX). !> On entry, X contains the right-hand-side blocks R_{li}. It is overwritten by !> solution !> vectors X_{li} on exit. !> @param[in] incx - rocblas_int. incx > 0. !> Stride from the start of one row of X_{li} to the next. The normal use cases !> are !> incx = 1 (equivalent to the strided batched case) or incx = batch_count (for an !> interleaved batched case). !> @param[in] ldx - rocblas_int. ldx >= incx * nb. !> Specifies the leading dimension of blocks X_{li}, that is, the stride from the !> start !> of one column of X_{li} to the next. !> @param[in] strideX - rocblas_stride. !> Stride from the start of one block X_{li} to the same block in the next batch !> instance X_{(l+1)i}. !> There is no restriction for the value of strideX. The normal use cases are !> strideX >= !> ldx*nrhs*nblocks (equivalent to the strided batched case) or strideX = 1 (for !> an interleaved batched case). !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_sgeblttrs_npvt_interleaved_batched function rocsolver_sgeblttrs_npvt_interleaved_batched_(handle,nb,nblocks,nrhs,A,inca,lda, & strideA,B,incb,ldb,strideB,C,incc,ldc,strideC,X,incx,ldx,strideX,batch_count) & bind(c, name="rocsolver_sgeblttrs_npvt_interleaved_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeblttrs_npvt_interleaved_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: inca integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int),value :: incb integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: C integer(c_int),value :: incc integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: X integer(c_int),value :: incx integer(c_int),value :: ldx integer(c_int64_t),value :: strideX integer(c_int),value :: batch_count end function end interface interface rocsolver_dgeblttrs_npvt_interleaved_batched function rocsolver_dgeblttrs_npvt_interleaved_batched_(handle,nb,nblocks,nrhs,A,inca,lda, & strideA,B,incb,ldb,strideB,C,incc,ldc,strideC,X,incx,ldx,strideX,batch_count) & bind(c, name="rocsolver_dgeblttrs_npvt_interleaved_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeblttrs_npvt_interleaved_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: inca integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int),value :: incb integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: C integer(c_int),value :: incc integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: X integer(c_int),value :: incx integer(c_int),value :: ldx integer(c_int64_t),value :: strideX integer(c_int),value :: batch_count end function end interface interface rocsolver_cgeblttrs_npvt_interleaved_batched function rocsolver_cgeblttrs_npvt_interleaved_batched_(handle,nb,nblocks,nrhs,A,inca,lda, & strideA,B,incb,ldb,strideB,C,incc,ldc,strideC,X,incx,ldx,strideX,batch_count) & bind(c, name="rocsolver_cgeblttrs_npvt_interleaved_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeblttrs_npvt_interleaved_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: inca integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int),value :: incb integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: C integer(c_int),value :: incc integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: X integer(c_int),value :: incx integer(c_int),value :: ldx integer(c_int64_t),value :: strideX integer(c_int),value :: batch_count end function end interface interface rocsolver_zgeblttrs_npvt_interleaved_batched function rocsolver_zgeblttrs_npvt_interleaved_batched_(handle,nb,nblocks,nrhs,A,inca,lda, & strideA,B,incb,ldb,strideB,C,incc,ldc,strideC,X,incx,ldx,strideX,batch_count) & bind(c, name="rocsolver_zgeblttrs_npvt_interleaved_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeblttrs_npvt_interleaved_batched_ type(c_ptr),value :: handle integer(c_int),value :: nb integer(c_int),value :: nblocks integer(c_int),value :: nrhs type(c_ptr),value :: A integer(c_int),value :: inca integer(c_int),value :: lda integer(c_int64_t),value :: strideA type(c_ptr),value :: B integer(c_int),value :: incb integer(c_int),value :: ldb integer(c_int64_t),value :: strideB type(c_ptr),value :: C integer(c_int),value :: incc integer(c_int),value :: ldc integer(c_int64_t),value :: strideC type(c_ptr),value :: X integer(c_int),value :: incx integer(c_int),value :: ldx integer(c_int64_t),value :: strideX integer(c_int),value :: batch_count end function end interface !> \brief The CREATE_RFINFO function initializes the structure ``rfinfo`` that contains the meta !> data and descriptors of the specific matrices !> required by the refactorization functions !> \ref rocsolver_scsrrf_refactlu "CSRRF_REFACTLU" and \ref rocsolver_scsrrf_refactchol !> "CSRRF_REFACTCHOL" and !> by the direct solver \ref rocsolver_scsrrf_solve "CSRRF_SOLVE". !> !> \details !> @param[out] rfinfo - `rocsolver_rfinfo`. !> The pointer to the rfinfo struct to be initialized. !> @param[in] handle - rocblas_handle. interface rocsolver_create_rfinfo function rocsolver_create_rfinfo_(rfinfo,handle) bind(c, name="rocsolver_create_rfinfo") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_create_rfinfo_ type(c_ptr) :: rfinfo type(c_ptr),value :: handle end function end interface !> \brief The DESTROY_RFINFO function destroys the structure ``rfinfo`` used by the !> refactorization functions !> \ref rocsolver_scsrrf_refactlu "CSRRF_REFACTLU" and \ref rocsolver_scsrrf_refactchol !> "CSRRF_REFACTCHOL" and !> by the direct solver \ref rocsolver_scsrrf_solve "CSRRF_SOLVE". !> !> \details !> @param[in] rfinfo - `rocsolver_rfinfo`. !> The rfinfo struct to be destroyed. interface rocsolver_destroy_rfinfo function rocsolver_destroy_rfinfo_(rfinfo) bind(c, name="rocsolver_destroy_rfinfo") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_destroy_rfinfo_ type(c_ptr),value :: rfinfo end function end interface !> \brief The SET_RFINFO_MODE function sets the mode of the structure ``rfinfo`` required by the !> refactorization functions !> \ref rocsolver_scsrrf_refactlu "CSRRF_REFACTLU" and \ref rocsolver_scsrrf_refactchol !> "CSRRF_REFACTCHOL" and !> by the direct solver \ref rocsolver_scsrrf_solve "CSRRF_SOLVE". !> !> \details !> @param[in] rfinfo - `rocsolver_rfinfo`. !> The rfinfo struct to be set up. !> @param[in] mode - `rocsolver_rfinfo_mode`. !> Use rocsolver_rfinfo_mode_cholesky when the Cholesky factorization is required. interface rocsolver_set_rfinfo_mode function rocsolver_set_rfinfo_mode_(rfinfo,mode) bind(c, name="rocsolver_set_rfinfo_mode") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_set_rfinfo_mode_ type(c_ptr),value :: rfinfo integer(kind(rocsolver_rfinfo_mode_lu)),value :: mode end function end interface !> \brief The GET_RFINFO_MODE function gets the mode of the structure ``rfinfo`` required by the !> refactorization functions !> \ref rocsolver_scsrrf_refactlu "CSRRF_REFACTLU" and \ref rocsolver_scsrrf_refactchol !> "CSRRF_REFACTCHOL" and !> by the direct solver \ref rocsolver_scsrrf_solve "CSRRF_SOLVE". !> !> \details !> @param[in] rfinfo - `rocsolver_rfinfo`. !> The referenced rfinfo struct. !> @param[out] mode - `rocsolver_rfinfo_mode`. !> The queried mode. interface rocsolver_get_rfinfo_mode function rocsolver_get_rfinfo_mode_(rfinfo,mode) bind(c, name="rocsolver_get_rfinfo_mode") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_get_rfinfo_mode_ type(c_ptr),value :: rfinfo type(c_ptr),value :: mode end function end interface !> \brief The CSRRF_SUMLU functions bundle the factors \f$L\f$ and \f$U\f$, associated with !> the LU factorization !> of a sparse matrix \f$A\f$, into a single sparse matrix \f$T=(L-I)+U\f$. !> !> \details Factor \f$L\f$ is a sparse lower triangular matrix with unit diagonal elements, !> and !> \f$U\f$ is a sparse upper triangular matrix. The resulting sparse matrix \f$T\f$ combines !> both !> sparse factors without storing the unit diagonal. In other words, the number of non-zero !> elements of T, ``nnzT``, is given by ``nnzT`` = ``nnzL`` - ``n`` + ``nnzU``. !> !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows (and columns) of matrix A. !> @param[in] nnzL - rocblas_int. nnzL >= n. !> The number of non-zero elements in L. !> @param[in] ptrL - pointer to rocblas_int. Array on the GPU of dimension n+1. !> It contains the positions of the beginning of each row in indL and valL. !> The last element of ptrL is equal to nnzL. !> @param[in] indL - pointer to rocblas_int. Array on the GPU of dimension nnzL. !> It contains the column indices of the non-zero elements of L. Indices are !> sorted by row and by column within each row. !> @param[in] valL - pointer to type. Array on the GPU of dimension nnzL. !> The values of the non-zero elements of L. !> @param[in] nnzU - rocblas_int. nnzU >= 0. !> The number of non-zero elements in U. !> @param[in] ptrU - pointer to rocblas_int. Array on the GPU of dimension n+1. !> It contains the positions of the beginning of each row in indU and valU. !> The last element of ptrU is equal to nnzU. !> @param[in] indU - pointer to rocblas_int. Array on the GPU of dimension nnzU. !> It contains the column indices of the non-zero elements of U. Indices are !> sorted by row and by column within each row. !> @param[in] valU - pointer to type. Array on the GPU of dimension nnzU. !> The values of the non-zero elements of U. !> @param[out] ptrT - pointer to rocblas_int. Array on the GPU of dimension n+1. !> It contains the positions of the beginning of each row in indT and valT. !> The last element of ptrT is equal to nnzT. !> @param[out] indT - pointer to rocblas_int. Array on the GPU of dimension nnzT. !> It contains the column indices of the non-zero elements of T. Indices are !> sorted by row and by column within each row. !> @param[out] valT - pointer to type. Array on the GPU of dimension nnzT. !> The values of the non-zero elements of T. interface rocsolver_scsrrf_sumlu function rocsolver_scsrrf_sumlu_(handle,n,nnzL,ptrL,indL,valL,nnzU,ptrU,indU,valU,ptrT,indT, & valT) & bind(c, name="rocsolver_scsrrf_sumlu") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_scsrrf_sumlu_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nnzL type(c_ptr),value :: ptrL type(c_ptr),value :: indL type(c_ptr),value :: valL integer(c_int),value :: nnzU type(c_ptr),value :: ptrU type(c_ptr),value :: indU type(c_ptr),value :: valU type(c_ptr),value :: ptrT type(c_ptr),value :: indT type(c_ptr),value :: valT end function end interface interface rocsolver_dcsrrf_sumlu function rocsolver_dcsrrf_sumlu_(handle,n,nnzL,ptrL,indL,valL,nnzU,ptrU,indU,valU,ptrT,indT, & valT) & bind(c, name="rocsolver_dcsrrf_sumlu") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dcsrrf_sumlu_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nnzL type(c_ptr),value :: ptrL type(c_ptr),value :: indL type(c_ptr),value :: valL integer(c_int),value :: nnzU type(c_ptr),value :: ptrU type(c_ptr),value :: indU type(c_ptr),value :: valU type(c_ptr),value :: ptrT type(c_ptr),value :: indT type(c_ptr),value :: valT end function end interface !> \brief The CSRRF_SPLITLU functions split the factors \f$L\f$ and \f$U\f$, associated with !> the LU factorization !> of a sparse matrix \f$A\f$, from a bundled matrix \f$T=(L-I)+U\f$. !> !> \details Factor \f$L\f$ is a sparse lower triangular matrix with unit diagonal elements, !> and !> \f$U\f$ is a sparse upper triangular matrix. Conceptually, on input, U is stored on the !> diagonal !> and upper part of \f$T\f$, while the non-diagonal elements of \f$L\f$ are stored on the !> strictly !> lower part of \f$T\f$. !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows (and columns) of matrix A. !> @param[in] nnzT - rocblas_int. nnzT >= 0. !> The number of non-zero elements in T. !> @param[in] ptrT - pointer to rocblas_int. Array on the GPU of dimension n+1. !> It contains the positions of the beginning of each row in indT and valT. !> The last element of ptrT is equal to nnzT. !> @param[in] indT - pointer to rocblas_int. Array on the GPU of dimension nnzT. !> It contains the column indices of the non-zero elements of T. Indices are !> sorted by row and by column within each row. !> @param[in] valT - pointer to type. Array on the GPU of dimension nnzT. !> The values of the non-zero elements of T. !> @param[out] ptrL - pointer to rocblas_int. Array on the GPU of dimension n+1. !> It contains the positions of the beginning of each row in indL and valL. !> The last element of ptrL is equal to nnzL. !> @param[out] indL - pointer to rocblas_int. Array on the GPU of dimension nnzL. !> It contains the column indices of the non-zero elements of L. Indices are !> sorted by row and by column within each row. (If nnzL is not known in advance, !> the size of this array could be set to nnzT + n as an upper bound.) !> @param[out] valL - pointer to type. Array on the GPU of dimension nnzL. !> The values of the non-zero elements of L. (If nnzL is not known in advance, !> the size of this array could be set to nnzT + n as an upper bound.) !> @param[out] ptrU - pointer to rocblas_int. Array on the GPU of dimension n+1. !> It contains the positions of the beginning of each row in indU and valU. !> The last element of ptrU is equal to nnzU. !> @param[out] indU - pointer to rocblas_int. Array on the GPU of dimension nnzU. !> It contains the column indices of the non-zero elements of U. Indices are !> sorted by row and by column within each row. (If nnzU is not known in advance, !> the size of this array could be set to nnzT as an upper bound.) !> @param[out] valU - pointer to type. Array on the GPU of dimension nnzU. !> The values of the non-zero elements of U. (If nnzU is not known in advance, !> the size of this array could be set to nnzT as an upper bound.) interface rocsolver_scsrrf_splitlu function rocsolver_scsrrf_splitlu_(handle,n,nnzT,ptrT,indT,valT,ptrL,indL,valL,ptrU,indU,valU) & bind(c, name="rocsolver_scsrrf_splitlu") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_scsrrf_splitlu_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nnzT type(c_ptr),value :: ptrT type(c_ptr),value :: indT type(c_ptr),value :: valT type(c_ptr),value :: ptrL type(c_ptr),value :: indL type(c_ptr),value :: valL type(c_ptr),value :: ptrU type(c_ptr),value :: indU type(c_ptr),value :: valU end function end interface interface rocsolver_dcsrrf_splitlu function rocsolver_dcsrrf_splitlu_(handle,n,nnzT,ptrT,indT,valT,ptrL,indL,valL,ptrU,indU,valU) & bind(c, name="rocsolver_dcsrrf_splitlu") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dcsrrf_splitlu_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nnzT type(c_ptr),value :: ptrT type(c_ptr),value :: indT type(c_ptr),value :: valT type(c_ptr),value :: ptrL type(c_ptr),value :: indL type(c_ptr),value :: valL type(c_ptr),value :: ptrU type(c_ptr),value :: indU type(c_ptr),value :: valU end function end interface !> \brief The CSRRF_ANALYSIS functions perform the analysis phase required by the !> refactorization functions !> \ref rocsolver_scsrrf_refactlu "CSRRF_REFACTLU" and \ref rocsolver_scsrrf_refactchol !> "CSRRF_REFACTCHOL" and !> by the direct solver \ref rocsolver_scsrrf_solve "CSRRF_SOLVE". !> !> \details Consider a sparse matrix \f$M\f$ previously factorized as !> !> \f[ !> Q^TMQ = L_ML_M^T !> \f] !> !> (Cholesky factorization for the symmetric positive definite case), or !> !> \f[ !> PMQ = L_MU_M !> \f] !> !> (LU factorization for the general case) !> !> where \f$L_M\f$ is lower triangular (with unit diagonal in the general case), \f$U_M\f$ is !> upper triangular, and \f$P\f$ !> and \f$Q\f$ are permutation matrices associated with pivoting and reordering (to minimize !> fill-in), respectively. The metadata generated by this routine is collected in the output !> parameter !> ``rfinfo``. This information will allow the fast refactorization of another sparse matrix !> \f$A\f$ as !> !> \f[ !> Q^TAQ = L_AL_A^T, \quad \text{or} !> \f] !> !> \f[ !> PAQ = L_AU_A, !> \f] !> !> and, eventually, the computation of the solution vector \f$X\f$ of any linear system of the !> form !> !> \f[ !> AX = B !> \f] !> !> as long as \f$A\f$ has the same sparsity pattern as the previous matrix \f$M\f$. !> !> This function supposes that the ``rfinfo`` struct has been initialized by \ref !> rocsolver_create_rfinfo "RFINFO_CREATE". !> By default, ``rfinfo`` is set up to work with the LU factorization (general matrices). If !> the matrix is symmetric positive definite, !> and the Cholesky factorization is !> desired, then the corresponding mode must be manually set up by \ref !> rocsolver_set_rfinfo_mode "SET_RFINFO_MODE". This function !> does not automatically detect symmetry. !> !> For the LU factorization mode, the LU factors \f$L_M\f$ and \f$U_M\f$ must be passed in a !> bundle !> matrix \f$T=(L_M-I)+U_M\f$, as returned by \ref rocsolver_scsrrf_sumlu "CSRRF_SUMLU". For !> the Cholesky mode, !> the lower triangular part of \f$T\f$ must contain the Cholesky factor \f$L_M\f$, and the !> strictly upper triangular !> part of \f$T\f$ will be ignored. Similarly, the strictly upper triangular part of \f$M\f$ !> is ignored when working !> in Cholesky mode. !> !> \note !> If only a refactorization will be executed (that is, without a solver phase), then ``nrhs`` !> can be set to zero !> and ``B`` can be null. !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows (and columns) of matrix M. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right-hand-sides (columns of matrix B). Set nrhs to zero when !> only the !> refactorization is needed. !> @param[in] nnzM - rocblas_int. nnzM >= 0. !> The number of non-zero elements in M. !> @param[in] ptrM - pointer to rocblas_int. Array on the GPU of dimension n+1. !> It contains the positions of the beginning of each row in indM and valM. !> The last element of ptrM is equal to nnzM. !> @param[in] indM - pointer to rocblas_int. Array on the GPU of dimension nnzM. !> It contains the column indices of the non-zero elements of M. Indices are !> sorted by row and by column within each row. !> @param[in] valM - pointer to type. Array on the GPU of dimension nnzM. !> The values of the non-zero elements of M. The strictly upper triangular entries !> are !> not referenced when working in Cholesky mode. !> @param[in] nnzT - rocblas_int. nnzT >= 0. !> The number of non-zero elements in T. !> @param[in] ptrT - pointer to rocblas_int. Array on the GPU of dimension n+1. !> It contains the positions of the beginning of each row in indT and valT. !> The last element of ptrT is equal to nnzT. !> @param[in] indT - pointer to rocblas_int. Array on the GPU of dimension nnzT. !> It contains the column indices of the non-zero elements of T. Indices are !> sorted by row and by column within each row. !> @param[in] valT - pointer to type. Array on the GPU of dimension nnzT. !> The values of the non-zero elements of T. The strictly upper triangular entries !> are !> not referenced when working in Cholesky mode. !> @param[in] pivP - pointer to rocblas_int. Array on the GPU of dimension n. !> Contains the pivot indices representing the permutation matrix P, that is, the !> order in which the rows of matrix M were rearranged. When working in Cholesky !> mode, !> this array is not referenced and can be null. !> @param[in] pivQ - pointer to rocblas_int. Array on the GPU of dimension n. !> Contains the pivot indices representing the permutation matrix Q, that is, the !> order in which the columns of matrix M were rearranged. !> @param[in] B - pointer to type. Array on the GPU of dimension ldb*nrhs. !> The right hand side matrix B. It can be null if only the refactorization is !> needed. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of B. !> @param[out] rfinfo - rocsolver_rfinfo. !> Structure that holds the meta data generated in the analysis phase. interface rocsolver_scsrrf_analysis function rocsolver_scsrrf_analysis_(handle,n,nrhs,nnzM,ptrM,indM,valM,nnzT,ptrT,indT,valT, & pivP,pivQ,B,ldb,rfinfo) & bind(c, name="rocsolver_scsrrf_analysis") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_scsrrf_analysis_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs integer(c_int),value :: nnzM type(c_ptr),value :: ptrM type(c_ptr),value :: indM type(c_ptr),value :: valM integer(c_int),value :: nnzT type(c_ptr),value :: ptrT type(c_ptr),value :: indT type(c_ptr),value :: valT type(c_ptr),value :: pivP type(c_ptr),value :: pivQ type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: rfinfo end function end interface interface rocsolver_dcsrrf_analysis function rocsolver_dcsrrf_analysis_(handle,n,nrhs,nnzM,ptrM,indM,valM,nnzT,ptrT,indT,valT, & pivP,pivQ,B,ldb,rfinfo) & bind(c, name="rocsolver_dcsrrf_analysis") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dcsrrf_analysis_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs integer(c_int),value :: nnzM type(c_ptr),value :: ptrM type(c_ptr),value :: indM type(c_ptr),value :: valM integer(c_int),value :: nnzT type(c_ptr),value :: ptrT type(c_ptr),value :: indT type(c_ptr),value :: valT type(c_ptr),value :: pivP type(c_ptr),value :: pivQ type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: rfinfo end function end interface !> \brief The CSRRF_REFACTLU functions perform a fast LU factorization of a sparse matrix !> \f$A\f$ based on the !> information from the factorization of a previous matrix \f$M\f$ with the same sparsity !> pattern !> (refactorization). !> !> \details Consider a sparse matrix \f$M\f$ previously factorized as !> !> \f[ !> PMQ = L_MU_M !> \f] !> !> where \f$L_M\f$ is lower triangular with unit diagonal, \f$U_M\f$ is upper triangular, and !> \f$P\f$ !> and \f$Q\f$ are permutation matrices associated with pivoting and reordering (to minimize !> fill-in), respectively. If \f$A\f$ has the same sparsity pattern as \f$M\f$, then the !> refactorization !> !> \f[ !> PAQ = L_AU_A !> \f] !> !> can be computed numerically without a symbolic analysis phase. !> !> This function supposes that ``rfinfo`` has been updated, by function \ref !> rocsolver_scsrrf_analysis "CSRRF_ANALYSIS", !> after the analysis phase of the previous matrix M and its initial factorization. Both !> functions, CSRRF_ANALYSIS and !> CSRRF_REFACTLU must be run with the same ``rfinfo`` mode (LU factorization, the default !> mode), otherwise, the workflow will !> result in an error. !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows (and columns) of matrix A. !> @param[in] nnzA - rocblas_int. nnzA >= 0. !> The number of non-zero elements in A. !> @param[in] ptrA - pointer to rocblas_int. Array on the GPU of dimension n+1. !> It contains the positions of the beginning of each row in indA and valA. !> The last element of ptrM is equal to nnzA. !> @param[in] indA - pointer to rocblas_int. Array on the GPU of dimension nnzA. !> It contains the column indices of the non-zero elements of M. Indices are !> sorted by row and by column within each row. !> @param[in] valA - pointer to type. Array on the GPU of dimension nnzA. !> The values of the non-zero elements of A. !> @param[in] nnzT - rocblas_int. nnzT >= 0. !> The number of non-zero elements in T. !> @param[in] ptrT - pointer to rocblas_int. Array on the GPU of dimension n+1. !> It contains the positions of the beginning of each row in indT and valT. !> The last element of ptrT is equal to nnzT. !> @param[in] indT - pointer to rocblas_int. Array on the GPU of dimension nnzT. !> It contains the column indices of the non-zero elements of T. Indices are !> sorted by row and by column within each row. !> @param[out] valT - pointer to type. Array on the GPU of dimension nnzT. !> The values of the non-zero elements of the new bundle matrix (L_A - I) + U_A. !> @param[in] pivP - pointer to rocblas_int. Array on the GPU of dimension n. !> Contains the pivot indices representing the permutation matrix P, that is, the !> order in which the rows of matrix M were rearranged. !> @param[in] pivQ - pointer to rocblas_int. Array on the GPU of dimension n. !> Contains the pivot indices representing the permutation matrix Q, that is, the !> order in which the columns of matrix M were rearranged. !> @param[in] rfinfo - rocsolver_rfinfo. !> Structure that holds the meta data generated in the analysis phase. interface rocsolver_scsrrf_refactlu function rocsolver_scsrrf_refactlu_(handle,n,nnzA,ptrA,indA,valA,nnzT,ptrT,indT,valT,pivP, & pivQ,rfinfo) & bind(c, name="rocsolver_scsrrf_refactlu") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_scsrrf_refactlu_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: ptrA type(c_ptr),value :: indA type(c_ptr),value :: valA integer(c_int),value :: nnzT type(c_ptr),value :: ptrT type(c_ptr),value :: indT type(c_ptr),value :: valT type(c_ptr),value :: pivP type(c_ptr),value :: pivQ type(c_ptr),value :: rfinfo end function end interface interface rocsolver_dcsrrf_refactlu function rocsolver_dcsrrf_refactlu_(handle,n,nnzA,ptrA,indA,valA,nnzT,ptrT,indT,valT,pivP, & pivQ,rfinfo) & bind(c, name="rocsolver_dcsrrf_refactlu") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dcsrrf_refactlu_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: ptrA type(c_ptr),value :: indA type(c_ptr),value :: valA integer(c_int),value :: nnzT type(c_ptr),value :: ptrT type(c_ptr),value :: indT type(c_ptr),value :: valT type(c_ptr),value :: pivP type(c_ptr),value :: pivQ type(c_ptr),value :: rfinfo end function end interface !> \brief The CSRRF_REFACTCHOL functions perform a fast Cholesky factorization of a sparse !> symmetric positive definite matrix \f$A\f$ !> based on the information from the factorization of a previous matrix \f$M\f$ with the same !> sparsity pattern !> (refactorization). !> !> \details Consider a sparse matrix \f$M\f$ previously factorized as !> !> \f[ !> Q^TMQ = L_ML_M^T !> \f] !> !> where \f$L_M\f$ is lower triangular, and \f$Q\f$ is a permutation matrix associated with !> reordering to minimize !> fill-in. If \f$A\f$ has the same sparsity pattern as \f$M\f$, then the refactorization !> !> \f[ !> Q^TAQ = L_AL_A^T !> \f] !> !> can be computed numerically without a symbolic analysis phase. !> !> This function supposes that ``rfinfo`` has been updated by function \ref !> rocsolver_scsrrf_analysis "CSRRF_ANALYSIS", !> after the analysis phase of the previous matrix M and its initial factorization. Both !> functions, CSRRF_ANALYSIS and !> CSRRF_REFACTCHOL, must be run with the same ``rfinfo`` mode (Cholesky factorization), !> otherwise, the workflow will !> result in an error. !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows (and columns) of matrix A. !> @param[in] nnzA - rocblas_int. nnzA >= 0. !> The number of non-zero elements in A. !> @param[in] ptrA - pointer to rocblas_int. Array on the GPU of dimension n+1. !> It contains the positions of the beginning of each row in indA and valA. !> The last element of ptrM is equal to nnzA. !> @param[in] indA - pointer to rocblas_int. Array on the GPU of dimension nnzA. !> It contains the column indices of the non-zero elements of M. Indices are !> sorted by row and by column within each row. !> @param[in] valA - pointer to type. Array on the GPU of dimension nnzA. !> The values of the non-zero elements of A. The strictly upper triangular entries !> are !> not referenced. !> @param[in] nnzT - rocblas_int. nnzT >= 0. !> The number of non-zero elements in T. !> @param[in] ptrT - pointer to rocblas_int. Array on the GPU of dimension n+1. !> It contains the positions of the beginning of each row in indT and valT. !> The last element of ptrT is equal to nnzT. !> @param[in] indT - pointer to rocblas_int. Array on the GPU of dimension nnzT. !> It contains the column indices of the non-zero elements of T. Indices are !> sorted by row and by column within each row. !> @param[out] valT - pointer to type. Array on the GPU of dimension nnzT. !> The values of the non-zero elements of the new Cholesky factor L_A. !> The strictly upper triangular entries of this array are not referenced. !> @param[in] pivQ - pointer to rocblas_int. Array on the GPU of dimension n. !> Contains the pivot indices representing the permutation matrix Q, that is, the !> order in which the columns of matrix M were rearranged. !> @param[in] rfinfo - `rocsolver_rfinfo`. !> Structure that holds the meta data generated in the analysis phase. interface rocsolver_scsrrf_refactchol function rocsolver_scsrrf_refactchol_(handle,n,nnzA,ptrA,indA,valA,nnzT,ptrT,indT,valT,pivQ, & rfinfo) & bind(c, name="rocsolver_scsrrf_refactchol") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_scsrrf_refactchol_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: ptrA type(c_ptr),value :: indA type(c_ptr),value :: valA integer(c_int),value :: nnzT type(c_ptr),value :: ptrT type(c_ptr),value :: indT type(c_ptr),value :: valT type(c_ptr),value :: pivQ type(c_ptr),value :: rfinfo end function end interface interface rocsolver_dcsrrf_refactchol function rocsolver_dcsrrf_refactchol_(handle,n,nnzA,ptrA,indA,valA,nnzT,ptrT,indT,valT,pivQ, & rfinfo) & bind(c, name="rocsolver_dcsrrf_refactchol") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dcsrrf_refactchol_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nnzA type(c_ptr),value :: ptrA type(c_ptr),value :: indA type(c_ptr),value :: valA integer(c_int),value :: nnzT type(c_ptr),value :: ptrT type(c_ptr),value :: indT type(c_ptr),value :: valT type(c_ptr),value :: pivQ type(c_ptr),value :: rfinfo end function end interface !> \brief The CSRRF_SOLVE functions solve a linear system with sparse coefficient matrix !> \f$A\f$ in its !> factorized form. !> !> \details The linear system is of the form !> !> \f[ !> AX = B !> \f] !> !> where the sparse matrix \f$A\f$ is factorized as !> !> \f[ !> Q^TAQ = L_AL_A^T !> \f] !> !> (Cholesky factorization for the symmetric positive definite case), or !> !> \f[ !> PAQ = L_AU_A !> \f] !> !> (LU factorization for the general case), !> !> and \f$B\f$ is a dense matrix of right hand sides. !> !> This function supposes that ``rfinfo`` has been updated by function \ref !> rocsolver_scsrrf_analysis "CSRRF_ANALYSIS" !> after the analysis phase. Both functions, CSRRF_ANALYSIS and !> CSRRF_SOLVE, must be run with the same ``rfinfo`` mode (LU or Cholesky factorization), !> otherwise, the workflow will !> result in an error. !> !> For the LU factorization mode, the LU factors \f$L_A\f$ and \f$U_A\f$ must be passed in a !> bundle matrix \f$T=(L_A-I)+U_A\f$, !> as returned by \ref rocsolver_scsrrf_refactlu "CSRRF_REFACTLU" or \ref !> rocsolver_scsrrf_sumlu "CSRRF_SUMLU". For the Cholesky mode, !> the lower triangular part of \f$T\f$ must contain the Cholesky factor \f$L_A\f$, and the !> strictly upper triangular !> part of \f$T\f$ will be ignored. !> !> @param[in] handle - rocblas_handle. !> @param[in] n - rocblas_int. n >= 0. !> The number of rows (and columns) of matrix A. !> @param[in] nrhs - rocblas_int. nrhs >= 0. !> The number of right hand sides, that is, the number of columns of matrix B. !> @param[in] nnzT - rocblas_int. nnzT >= 0. !> The number of non-zero elements in T. !> @param[in] ptrT - pointer to rocblas_int. Array on the GPU of dimension n+1. !> It contains the positions of the beginning of each row in indT and valT. !> The last element of ptrT is equal to nnzT. !> @param[in] indT - pointer to rocblas_int. Array on the GPU of dimension nnzT. !> It contains the column indices of the non-zero elements of T. Indices are !> sorted by row and by column within each row. !> @param[in] valT - pointer to type. Array on the GPU of dimension nnzT. !> The values of the non-zero elements of T. The strictly upper triangular entries !> are !> not referenced when working in Cholesky mode. !> @param[in] pivP - pointer to rocblas_int. Array on the GPU of dimension n. !> Contains the pivot indices representing the permutation matrix P, that is, the !> order in which the rows of matrix A were rearranged. When working in Cholesky !> mode, !> this array is not referenced and can be null. !> @param[in] pivQ - pointer to rocblas_int. Array on the GPU of dimension n. !> Contains the pivot indices representing the permutation matrix Q, that is, the !> order in which the columns of matrix A were rearranged. !> @param[inout] B - pointer to type. Array on the GPU of dimension ldb*nrhs. !> On entry the right hand side matrix B. On exit, the solution matrix X. !> @param[in] ldb - rocblas_int. ldb >= n. !> The leading dimension of B. !> @param[in] rfinfo - rocsolver_rfinfo. !> Structure that holds the metadata generated in the analysis phase. interface rocsolver_scsrrf_solve function rocsolver_scsrrf_solve_(handle,n,nrhs,nnzT,ptrT,indT,valT,pivP,pivQ,B,ldb,rfinfo) & bind(c, name="rocsolver_scsrrf_solve") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_scsrrf_solve_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs integer(c_int),value :: nnzT type(c_ptr),value :: ptrT type(c_ptr),value :: indT type(c_ptr),value :: valT type(c_ptr),value :: pivP type(c_ptr),value :: pivQ type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: rfinfo end function end interface interface rocsolver_dcsrrf_solve function rocsolver_dcsrrf_solve_(handle,n,nrhs,nnzT,ptrT,indT,valT,pivP,pivQ,B,ldb,rfinfo) & bind(c, name="rocsolver_dcsrrf_solve") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dcsrrf_solve_ type(c_ptr),value :: handle integer(c_int),value :: n integer(c_int),value :: nrhs integer(c_int),value :: nnzT type(c_ptr),value :: ptrT type(c_ptr),value :: indT type(c_ptr),value :: valT type(c_ptr),value :: pivP type(c_ptr),value :: pivQ type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: rfinfo end function end interface !> \brief The SYEVDX functions compute a set of the eigenvalues and optionally the !> corresponding eigenvectors of a !> real symmetric matrix ``A``. !> !> \details !> This function computes all the eigenvalues of ``A``, all the eigenvalues in the half-open !> interval \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is ``rocblas_evect_original``, !> the eigenvectors for these eigenvalues will be computed as well. The eigenvectors are !> computed using a !> divide-and-conquer approach. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrix A. !> @param[in] vl - type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A or the eigenvalues within a set of indices. !> @param[in] vu - type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise.. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A or the eigenvalues in a half-open interval. !> @param[out] nev - pointer to a rocblas_int on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev = !> n. !> If erange is rocblas_erange_index, nev = iu - il + 1. Otherwise, 0 <= nev <= n. !> @param[out] W - pointer to type. Array on the GPU of dimension n. !> The first nev elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[out] Z - pointer to type. Array on the GPU of dimension ldz*nev. !> On exit, if evect is not rocblas_evect_none and info = 0, the first nev columns !> contain !> the eigenvectors of A corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> - Note: If erange is rocblas_range_value, then the values of nev are not known !> in advance. !> The user should ensure that Z is large enough to hold n columns, because all n !> columns !> can be used as workspace for internal computations. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrix Z. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, the algorithm did not converge. i columns of Z did not !> converge. interface rocsolver_ssyevdx function rocsolver_ssyevdx_(handle,evect,erange,uplo,n,A,lda,vl,vu,il,iu,nev,W,Z,ldz,myInfo) & bind(c, name="rocsolver_ssyevdx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevdx_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: myInfo end function end interface interface rocsolver_dsyevdx function rocsolver_dsyevdx_(handle,evect,erange,uplo,n,A,lda,vl,vu,il,iu,nev,W,Z,ldz,myInfo) & bind(c, name="rocsolver_dsyevdx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevdx_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: myInfo end function end interface !> \brief The HEEVDX functions compute a set of the eigenvalues and optionally the !> corresponding eigenvectors of a !> Hermitian matrix ``A``. !> !> \details !> This function computes all the eigenvalues of ``A``, all the eigenvalues in the half-open !> interval \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is ``rocblas_evect_original``, !> the eigenvectors for these eigenvalues will be computed as well. The eigenvectors are !> computed using a !> divide-and-conquer approach. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrix A is stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrix A. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrix A. !> @param[in] vl - real type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A or the eigenvalues within a set of indices. !> @param[in] vu - real type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A or the eigenvalues in a half-open interval. !> @param[out] nev - pointer to a rocblas_int on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev = !> n. !> If erange is rocblas_erange_index, nev = iu - il + 1. Otherwise, 0 <= nev <= n. !> @param[out] W - pointer to real type. Array on the GPU of dimension n. !> The first nev elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[out] Z - pointer to type. Array on the GPU of dimension ldz*nev. !> On exit, if evect is not rocblas_evect_none and info = 0, the first nev columns !> contain !> the eigenvectors of A corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> - Note: If erange is rocblas_range_value, then the values of nev are not known !> in advance. !> The user should ensure that Z is large enough to hold n columns, because all n !> columns !> can be used as workspace for internal computations. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrix Z. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i > 0, the algorithm did not converge. i columns of Z did not !> converge. interface rocsolver_cheevdx function rocsolver_cheevdx_(handle,evect,erange,uplo,n,A,lda,vl,vu,il,iu,nev,W,Z,ldz,myInfo) & bind(c, name="rocsolver_cheevdx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevdx_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: myInfo end function end interface interface rocsolver_zheevdx function rocsolver_zheevdx_(handle,evect,erange,uplo,n,A,lda,vl,vu,il,iu,nev,W,Z,ldz,myInfo) & bind(c, name="rocsolver_zheevdx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevdx_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: myInfo end function end interface !> \brief The SYEVDX_BATCHED functions compute a set of the eigenvalues and optionally the !> corresponding eigenvectors !> of a batch of real symmetric matrices A_l. !> !> \details !> This function computes all the eigenvalues of A_l, all the eigenvalues in the half-open !> interval \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is ``rocblas_evect_original``, !> the eigenvectors for these eigenvalues will be computed as well. The eigenvectors are !> computed using a !> divide-and-conquer approach. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] vl - type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] vu - type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[out] nev - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev[l] !> = n. !> If erange is rocblas_erange_index, nev[l] = iu - il + 1. Otherwise, 0 <= nev[l] !> <= n. !> @param[out] W - pointer to type. Array on the GPU (the size depends on the value of !> strideW). !> The first nev[l] elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] Z - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldz*nev[l]. !> On exit, if evect is not rocblas_evect_none and info[l] = 0, the first nev[l] !> columns contain !> the eigenvectors of A_l corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> - Note: If erange is rocblas_range_value, then the values of nev[l] are not !> known in advance. !> The user should ensure that Z_l is large enough to hold n columns, because all !> n columns !> can be used as workspace for internal computations. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrices Z_l. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. !> If info[l] = i > 0, the algorithm did not converge. i columns of Z_l did not !> converge. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssyevdx_batched function rocsolver_ssyevdx_batched_(handle,evect,erange,uplo,n,A,lda,vl,vu,il,iu,nev,W, & strideW,Z,ldz,myInfo,batch_count) & bind(c, name="rocsolver_ssyevdx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevdx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dsyevdx_batched function rocsolver_dsyevdx_batched_(handle,evect,erange,uplo,n,A,lda,vl,vu,il,iu,nev,W, & strideW,Z,ldz,myInfo,batch_count) & bind(c, name="rocsolver_dsyevdx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevdx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The HEEVDX_BATCHED functions compute a set of the eigenvalues and optionally the !> corresponding eigenvectors !> of a batch of Hermitian matrices A_l. !> !> \details !> This function computes all the eigenvalues of A_l, all the eigenvalues in the half-open !> interval \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is ``rocblas_evect_original``, !> the eigenvectors for these eigenvalues will be computed as well. The eigenvectors are !> computed using a !> divide-and-conquer approach. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] vl - real type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] vu - real type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[out] nev - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev[l] !> = n. !> If erange is rocblas_erange_index, nev[l] = iu - il + 1. Otherwise, 0 <= nev[l] !> <= n. !> @param[out] W - pointer to real type. Array on the GPU (the size depends on the value of !> strideW). !> The first nev[l] elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] Z - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldz*nev[l]. !> On exit, if evect is not rocblas_evect_none and info[l] = 0, the first nev[l] !> columns contain !> the eigenvectors of A_l corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> - Note: If erange is rocblas_range_value, then the values of nev[l] are not !> known in advance. !> The user should ensure that Z_l is large enough to hold n columns, because all !> n columns !> can be used as workspace for internal computations. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrices Z_l. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. !> If info[l] = i > 0, the algorithm did not converge. i columns of Z_l did not !> converge. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_cheevdx_batched function rocsolver_cheevdx_batched_(handle,evect,erange,uplo,n,A,lda,vl,vu,il,iu,nev,W, & strideW,Z,ldz,myInfo,batch_count) & bind(c, name="rocsolver_cheevdx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevdx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zheevdx_batched function rocsolver_zheevdx_batched_(handle,evect,erange,uplo,n,A,lda,vl,vu,il,iu,nev,W, & strideW,Z,ldz,myInfo,batch_count) & bind(c, name="rocsolver_zheevdx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevdx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The SYEVDX_STRIDED_BATCHED functions compute a set of the eigenvalues and optionally !> the corresponding eigenvectors !> of a batch of real symmetric matrices A_l. !> !> \details !> This function computes all the eigenvalues of A_l, all the eigenvalues in the half-open !> interval \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is ``rocblas_evect_original``, !> the eigenvectors for these eigenvalues will be computed as well. The eigenvectors are !> computed using a !> divide-and-conquer approach. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[in] vl - type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] vu - type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[out] nev - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev[l] !> = n. !> If erange is rocblas_erange_index, nev[l] = iu - il + 1. Otherwise, 0 <= nev[l] !> <= n. !> @param[out] W - pointer to type. Array on the GPU (the size depends on the value of !> strideW). !> The first nev[l] elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] Z - pointer to type. Array on the GPU (the size depends on the value of !> strideZ). !> On exit, if evect is not rocblas_evect_none and info[l] = 0, the first nev[l] !> columns contain !> the eigenvectors of A_l corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrices Z_l. !> @param[in] strideZ - rocblas_stride. !> Stride from the start of one matrix Z_l to the next one Z_(l+1). !> There is no restriction for the value of strideZ. The normal use case is !> strideZ >= ldz*nev[l]. !> - Note: If erange is rocblas_range_value, then the values of nev[l] are not !> known in advance. !> The user should ensure that Z_l is large enough to hold n columns, because all !> n columns !> can be used as workspace for internal computations. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. !> If info[l] = i > 0, the algorithm did not converge. i columns of Z_l did not !> converge. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssyevdx_strided_batched function rocsolver_ssyevdx_strided_batched_(handle,evect,erange,uplo,n,A,lda,strideA,vl,vu,il, & iu,nev,W,strideW,Z,ldz,strideZ,myInfo,batch_count) & bind(c, name="rocsolver_ssyevdx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevdx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz integer(c_int64_t),value :: strideZ type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dsyevdx_strided_batched function rocsolver_dsyevdx_strided_batched_(handle,evect,erange,uplo,n,A,lda,strideA,vl,vu,il, & iu,nev,W,strideW,Z,ldz,strideZ,myInfo,batch_count) & bind(c, name="rocsolver_dsyevdx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevdx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz integer(c_int64_t),value :: strideZ type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The HEEVDX_STRIDED_BATCHED functions compute a set of the eigenvalues and optionally !> the corresponding eigenvectors !> of a batch of Hermitian matrices A_l. !> !> \details !> This function computes all the eigenvalues of A_l, all the eigenvalues in the half-open !> interval \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is ``rocblas_evect_original``, !> the eigenvectors for these eigenvalues will be computed as well. The eigenvectors are !> computed using a !> divide-and-conquer approach. !> !> @param[in] handle - rocblas_handle. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower part of the symmetric matrices A_l is !> stored. !> If uplo indicates lower (or upper), then the upper (or lower) part of A_l !> is not used. !> @param[in] n - rocblas_int. n >= 0. !> Number of rows and columns of matrices A_l. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[in] vl - real type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] vu - real type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[out] nev - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev[l] !> = n. !> If erange is rocblas_erange_index, nev[l] = iu - il + 1. Otherwise, 0 <= nev[l] !> <= n. !> @param[out] W - pointer to real type. Array on the GPU (the size depends on the value of !> strideW). !> The first nev[l] elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] Z - pointer to type. Array on the GPU (the size depends on the value of !> strideZ). !> On exit, if evect is not rocblas_evect_none and info[l] = 0, the first nev[l] !> columns contain !> the eigenvectors of A_l corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrices Z_l. !> @param[in] strideZ - rocblas_stride. !> Stride from the start of one matrix Z_l to the next one Z_(l+1). !> There is no restriction for the value of strideZ. The normal use case is !> strideZ >= ldz*nev[l]. !> - Note: If erange is rocblas_range_value, then the values of nev[l] are not !> known in advance. !> The user should ensure that Z_l is large enough to hold n columns, because all !> n columns !> can be used as workspace for internal computations. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit for matrix A_l. !> If info[l] = i > 0, the algorithm did not converge. i columns of Z_l did not !> converge. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_cheevdx_strided_batched function rocsolver_cheevdx_strided_batched_(handle,evect,erange,uplo,n,A,lda,strideA,vl,vu,il, & iu,nev,W,strideW,Z,ldz,strideZ,myInfo,batch_count) & bind(c, name="rocsolver_cheevdx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevdx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz integer(c_int64_t),value :: strideZ type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zheevdx_strided_batched function rocsolver_zheevdx_strided_batched_(handle,evect,erange,uplo,n,A,lda,strideA,vl,vu,il, & iu,nev,W,strideW,Z,ldz,strideZ,myInfo,batch_count) & bind(c, name="rocsolver_zheevdx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevdx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int64_t),value :: strideA real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz integer(c_int64_t),value :: strideZ type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The SYGVDX functions compute a set of the eigenvalues and optionally the !> corresponding eigenvectors of !> a real generalized symmetric-definite eigenproblem. !> !> \details !> The problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A X = \lambda B X & \: \text{1st form,}\\% !> A B X = \lambda X & \: \text{2nd form, or}\\% !> B A X = \lambda X & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed depending on the !> value of ``evect``. !> !> When computed, the matrix Z of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z^T B Z=I & \: \text{if 1st or 2nd form, or}\\% !> Z^T B^{-1} Z=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> This function computes all the eigenvalues, all the eigenvalues in the half-open interval !> \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is ``rocblas_evect_original``, !> the eigenvectors for these eigenvalues will be computed as well. The eigenvectors are !> computed using a !> divide-and-conquer approach. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblem. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A and B are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A and B are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrix A. !> @param[out] B - pointer to type. Array on the GPU of dimension ldb*n. !> On entry, the symmetric positive definite matrix B. On exit, the !> triangular factor of B as returned by \ref rocsolver_spotrf "POTRF". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B. !> @param[in] vl - type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A or the eigenvalues within a set of indices. !> @param[in] vu - type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A or the eigenvalues in a half-open interval. !> @param[out] nev - pointer to a rocblas_int on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev = !> n. !> If erange is rocblas_erange_index, nev = iu - il + 1. Otherwise, 0 <= nev <= n. !> @param[out] W - pointer to type. Array on the GPU of dimension n. !> The first nev elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[out] Z - pointer to type. Array on the GPU of dimension ldz*nev. !> On exit, if evect is not rocblas_evect_none and info = 0, the first nev columns !> contain !> the eigenvectors of A corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> - Note: If erange is rocblas_range_value, then the values of nev are not known !> in advance. !> The user should ensure that Z is large enough to hold n columns, because all n !> columns !> can be used as workspace for internal computations. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrix Z. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i <= n, i columns of Z did not converge. !> If info = n + i, the leading minor of order i of B is not !> positive definite. interface rocsolver_ssygvdx function rocsolver_ssygvdx_(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu,nev,W,Z, & ldz,myInfo) & bind(c, name="rocsolver_ssygvdx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvdx_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: myInfo end function end interface interface rocsolver_dsygvdx function rocsolver_dsygvdx_(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu,nev,W,Z, & ldz,myInfo) & bind(c, name="rocsolver_dsygvdx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvdx_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: myInfo end function end interface !> \brief The HEGVDX functions compute a set of the eigenvalues and optionally the !> corresponding eigenvectors of !> a complex generalized Hermitian-definite eigenproblem. !> !> \details !> The problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A X = \lambda B X & \: \text{1st form,}\\% !> A B X = \lambda X & \: \text{2nd form, or}\\% !> B A X = \lambda X & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed depending on the !> value of ``evect``. !> !> When computed, the matrix Z of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z^H B Z=I & \: \text{if 1st or 2nd form, or}\\% !> Z^H B^{-1} Z=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> This function computes all the eigenvalues, all the eigenvalues in the half-open interval !> \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is ``rocblas_evect_original``, !> the eigenvectors for these eigenvalues will be computed as well. The eigenvectors are !> computed using a !> divide-and-conquer approach. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblem. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A and B are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A and B are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU of dimension lda*n. !> On entry, the matrix A. On exit, the contents of A are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrix A. !> @param[out] B - pointer to type. Array on the GPU of dimension ldb*n. !> On entry, the Hermitian positive definite matrix B. On exit, the !> triangular factor of B as returned by \ref rocsolver_spotrf "POTRF". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B. !> @param[in] vl - real type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A or the eigenvalues within a set of indices. !> @param[in] vu - real type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A or the eigenvalues in a half-open interval. !> @param[out] nev - pointer to a rocblas_int on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev = !> n. !> If erange is rocblas_erange_index, nev = iu - il + 1. Otherwise, 0 <= nev <= n. !> @param[out] W - pointer to real type. Array on the GPU of dimension n. !> The first nev elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[out] Z - pointer to type. Array on the GPU of dimension ldz*nev. !> On exit, if evect is not rocblas_evect_none and info = 0, the first nev columns !> contain !> the eigenvectors of A corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> - Note: If erange is rocblas_range_value, then the values of nev are not known !> in advance. !> The user should ensure that Z is large enough to hold n columns, because all n !> columns !> can be used as workspace for internal computations. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrix Z. !> @param[out] myInfo - pointer to a rocblas_int on the GPU. !> If info = 0, successful exit. !> If info = i <= n, i columns of Z did not converge. !> If info = n + i, the leading minor of order i of B is not !> positive definite. interface rocsolver_chegvdx function rocsolver_chegvdx_(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu,nev,W,Z, & ldz,myInfo) & bind(c, name="rocsolver_chegvdx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvdx_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu integer(c_int) :: nev type(c_ptr),value :: W type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_chegvdx_assumed_rank #else module procedure & rocsolver_chegvdx_rank_0,& rocsolver_chegvdx_rank_1,& rocsolver_chegvdx_full_rank #endif #endif end interface interface rocsolver_zhegvdx function rocsolver_zhegvdx_(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu,nev,W,Z, & ldz,myInfo) & bind(c, name="rocsolver_zhegvdx") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvdx_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu integer(c_int) :: nev type(c_ptr),value :: W type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsolver_zhegvdx_assumed_rank #else module procedure & rocsolver_zhegvdx_rank_0,& rocsolver_zhegvdx_rank_1,& rocsolver_zhegvdx_full_rank #endif #endif end interface !> \brief The SYGVDX_BATCHED functions compute a set of the eigenvalues and optionally !> the corresponding eigenvectors of a batch of real generalized symmetric-definite !> eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed depending on the !> value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^T B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^T B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> This function computes all the eigenvalues, all the eigenvalues in the half-open interval !> \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is ``rocblas_evect_original``, !> the eigenvectors for these eigenvalues will be computed as well. The eigenvectors are !> computed using a !> divide-and-conquer approach. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[out] B - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*n. !> On entry, the symmetric positive definite matrices B_l. On exit, the !> triangular factor of B_l as returned by \ref rocsolver_spotrf_batched !> "POTRF_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] vl - type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] vu - type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[out] nev - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev[l] !> = n. !> If erange is rocblas_erange_index, nev[l] = iu - il + 1. Otherwise, 0 <= nev[l] !> <= n. !> @param[out] W - pointer to type. Array on the GPU (the size depends on the value of !> strideW). !> The first nev[l] elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] Z - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldz*nev[l]. !> On exit, if evect is not rocblas_evect_none and info[l] = 0, the first nev[l] !> columns contain !> the eigenvectors of A_l corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> - Note: If erange is rocblas_range_value, then the values of nev[l] are not !> known in advance. !> The user should ensure that Z_l is large enough to hold n columns, because all !> n columns !> can be used as workspace for internal computations. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrices Z_l. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit of batch instance l. !> If info[l] = i <= n, i columns of Z_l did not converge. !> If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssygvdx_batched function rocsolver_ssygvdx_batched_(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu, & nev,W,strideW,Z,ldz,myInfo,batch_count) & bind(c, name="rocsolver_ssygvdx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvdx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dsygvdx_batched function rocsolver_dsygvdx_batched_(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu, & nev,W,strideW,Z,ldz,myInfo,batch_count) & bind(c, name="rocsolver_dsygvdx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvdx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The HEGVDX_BATCHED functions compute a set of the eigenvalues and optionally !> the corresponding eigenvectors of a batch of complex generalized Hermitian-definite !> eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed depending on the !> value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^H B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^H B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> This function computes all the eigenvalues, all the eigenvalues in the half-open interval !> \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is ``rocblas_evect_original``, !> the eigenvectors for these eigenvalues will be computed as well. The eigenvectors are !> computed using a !> divide-and-conquer approach. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension lda*n. !> On entry, the matrices A_l. On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[out] B - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldb*n. !> On entry, the Hermitian positive definite matrices B_l. On exit, the !> triangular factor of B_l as returned by \ref rocsolver_spotrf_batched !> "POTRF_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] vl - real type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] vu - real type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[out] nev - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev[l] !> = n. !> If erange is rocblas_erange_index, nev[l] = iu - il + 1. Otherwise, 0 <= nev[l] !> <= n. !> @param[out] W - pointer to real type. Array on the GPU (the size depends on the value of !> strideW). !> The first nev[l] elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] Z - Array of pointers to type. Each pointer points to an array on the GPU of !> dimension ldz*nev[l]. !> On exit, if evect is not rocblas_evect_none and info[l] = 0, the first nev[l] !> columns contain !> the eigenvectors of A_l corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> - Note: If erange is rocblas_range_value, then the values of nev[l] are not !> known in advance. !> The user should ensure that Z_l is large enough to hold n columns, because all !> n columns !> can be used as workspace for internal computations. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrices Z_l. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit of batch instance l. !> If info[l] = i <= n, i columns of Z_l did not converge. !> If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_chegvdx_batched function rocsolver_chegvdx_batched_(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu, & nev,W,strideW,Z,ldz,myInfo,batch_count) & bind(c, name="rocsolver_chegvdx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvdx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zhegvdx_batched function rocsolver_zhegvdx_batched_(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu, & nev,W,strideW,Z,ldz,myInfo,batch_count) & bind(c, name="rocsolver_zhegvdx_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvdx_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The SYGVDX_STRIDED_BATCHED functions compute a set of the eigenvalues and optionally !> the corresponding eigenvectors of a batch of real generalized symmetric-definite !> eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed depending on the !> value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^T B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^T B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> This function computes all the eigenvalues, all the eigenvalues in the half-open interval !> \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is ``rocblas_evect_original``, !> the eigenvectors for these eigenvalues will be computed as well. The eigenvectors are !> computed using a !> divide-and-conquer approach. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> On entry, the symmetric positive definite matrices B_l. On exit, the !> triangular factor of B_l, as returned by \ref rocsolver_spotrf_strided_batched !> "POTRF_STRIDED_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. The normal use is strideB >= !> ldb*n. !> @param[in] vl - type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] vu - type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[out] nev - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev[l] !> = n. !> If erange is rocblas_erange_index, nev[l] = iu - il + 1. Otherwise, 0 <= nev[l] !> <= n. !> @param[out] W - pointer to type. Array on the GPU (the size depends on the value of !> strideW). !> The first nev[l] elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] Z - pointer to type. Array on the GPU (the size depends on the value of !> strideZ). !> On exit, if evect is not rocblas_evect_none and info[l] = 0, the first nev[l] !> columns contain !> the eigenvectors of A_l corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrices Z_l. !> @param[in] strideZ - rocblas_stride. !> Stride from the start of one matrix Z_l to the next one Z_(l+1). !> There is no restriction for the value of strideZ. The normal use case is !> strideZ >= ldz*nev[l]. !> - Note: If erange is rocblas_range_value, then the values of nev[l] are not !> known in advance. !> The user should ensure that Z_l is large enough to hold n columns, because all !> n columns !> can be used as workspace for internal computations. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit of batch l. !> If info[l] = i <= n, i columns of Z_l did not converge. !> If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_ssygvdx_strided_batched function rocsolver_ssygvdx_strided_batched_(handle,itype,evect,erange,uplo,n,A,lda,strideA,B, & ldb,strideB,vl,vu,il,iu,nev,W,strideW,Z,ldz,strideZ,myInfo,batch_count) & bind(c, name="rocsolver_ssygvdx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvdx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz integer(c_int64_t),value :: strideZ type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_dsygvdx_strided_batched function rocsolver_dsygvdx_strided_batched_(handle,itype,evect,erange,uplo,n,A,lda,strideA,B, & ldb,strideB,vl,vu,il,iu,nev,W,strideW,Z,ldz,strideZ,myInfo,batch_count) & bind(c, name="rocsolver_dsygvdx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvdx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz integer(c_int64_t),value :: strideZ type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface !> \brief The HEGVDX_STRIDED_BATCHED functions compute a set of the eigenvalues and optionally !> the corresponding eigenvectors of a batch of complex generalized Hermitian-definite !> eigenproblems. !> !> \details !> For each instance in the batch, the problem solved by this function is either of the form !> !> \f[ !> \begin{array}{cl} !> A_l X_l = \lambda B_l X_l & \: \text{1st form,}\\% !> A_l B_l X_l = \lambda X_l & \: \text{2nd form, or}\\% !> B_l A_l X_l = \lambda X_l & \: \text{3rd form,} !> \end{array} !> \f] !> !> depending on the value of ``itype``. The eigenvectors are computed depending on the !> value of ``evect``. !> !> When computed, the matrix \f$Z_l\f$ of eigenvectors is normalized as follows: !> !> \f[ !> \begin{array}{cl} !> Z_l^H B_l^{} Z_l^{}=I & \: \text{if 1st or 2nd form, or}\\% !> Z_l^H B_l^{-1} Z_l^{}=I & \: \text{if 3rd form.} !> \end{array} !> \f] !> !> This function computes all the eigenvalues, all the eigenvalues in the half-open interval !> \f$(vl, vu]\f$, !> or the ``il`` -th through ``iu`` -th eigenvalues, depending on the value of ``erange``. If !> ``evect`` is ``rocblas_evect_original``, !> the eigenvectors for these eigenvalues will be computed as well. The eigenvectors are !> computed using a !> divide-and-conquer approach. !> !> @param[in] handle - rocblas_handle. !> @param[in] itype - `rocblas_eform`. !> Specifies the form of the generalized eigenproblems. !> @param[in] evect - `rocblas_evect`. !> Specifies whether the eigenvectors are to be computed. !> If evect is rocblas_evect_original, then the eigenvectors are computed. !> rocblas_evect_tridiagonal is not supported. !> @param[in] erange - `rocblas_erange`. !> Specifies the type of range or interval of the eigenvalues to be computed. !> @param[in] uplo - rocblas_fill. !> Specifies whether the upper or lower parts of the matrices !> A_l and B_l are stored. If uplo indicates lower (or upper), !> then the upper (or lower) parts of A_l and B_l are not used. !> @param[in] n - rocblas_int. n >= 0. !> The matrix dimensions. !> @param[inout] A - pointer to type. Array on the GPU (the size depends on the value of !> strideA). !> On entry, the matrices A_l. On exit, the contents of A_l are destroyed. !> @param[in] lda - rocblas_int. lda >= n. !> Specifies the leading dimension of matrices A_l. !> @param[in] strideA - rocblas_stride. !> Stride from the start of one matrix A_l to the next one A_(l+1). !> There is no restriction for the value of strideA. The normal use case is !> strideA >= lda*n. !> @param[out] B - pointer to type. Array on the GPU (the size depends on the value of !> strideB). !> On entry, the Hermitian positive definite matrices B_l. On exit, the !> triangular factor of B_l as returned by \ref rocsolver_spotrf_strided_batched !> "POTRF_STRIDED_BATCHED". !> @param[in] ldb - rocblas_int. ldb >= n. !> Specifies the leading dimension of B_l. !> @param[in] strideB - rocblas_stride. !> Stride from the start of one matrix B_l to the next one B_(l+1). !> There is no restriction for the value of strideB. The normal use is strideB >= !> ldb*n. !> @param[in] vl - real type. vl < vu. !> The lower bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] vu - real type. vl < vu. !> The upper bound of the search interval (vl, vu]. Ignored if range indicates to !> look !> for all the eigenvalues of A_l or the eigenvalues within a set of indices. !> @param[in] il - rocblas_int. il = 1 if n = 0, and 1 <= il <= iu otherwise. !> The index of the smallest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[in] iu - rocblas_int. iu = 0 if n = 0, and 1 <= il <= iu otherwise. !> The index of the largest eigenvalue to be computed. Ignored if range indicates !> to look !> for all the eigenvalues of A_l or the eigenvalues in a half-open interval. !> @param[out] nev - pointer to rocblas_int. Array of batch_count integers on the GPU. !> The total number of eigenvalues found. If erange is rocblas_erange_all, nev[l] !> = n. !> If erange is rocblas_erange_index, nev[l] = iu - il + 1. Otherwise, 0 <= nev[l] !> <= n. !> @param[out] W - pointer to real type. Array on the GPU (the size depends on the value of !> strideW). !> The first nev[l] elements contain the computed eigenvalues. (The remaining !> elements !> can be used as workspace for internal computations.) !> @param[in] strideW - rocblas_stride. !> Stride from the start of one vector W_l to the next one W_(l+1). !> There is no restriction for the value of strideW. The normal use case is !> strideW >= n. !> @param[out] Z - pointer to type. Array on the GPU (the size depends on the value of !> strideZ). !> On exit, if evect is not rocblas_evect_none and info[l] = 0, the first nev[l] !> columns contain !> the eigenvectors of A_l corresponding to the output eigenvalues. Not referenced !> if !> evect is rocblas_evect_none. !> @param[in] ldz - rocblas_int. ldz >= n. !> Specifies the leading dimension of matrices Z_l. !> @param[in] strideZ - rocblas_stride. !> Stride from the start of one matrix Z_l to the next one Z_(l+1). !> There is no restriction for the value of strideZ. The normal use case is !> strideZ >= ldz*nev[l]. !> - Note: If erange is rocblas_range_value, then the values of nev[l] are not !> known in advance. !> The user should ensure that Z_l is large enough to hold n columns, because all !> n columns !> can be used as workspace for internal computations. !> @param[out] myInfo - pointer to rocblas_int. Array of batch_count integers on the GPU. !> If info[l] = 0, successful exit of batch l. !> If info[l] = i <= n, i columns of Z_l did not converge. !> If info[l] = n + i, the leading minor of order i of B_l is not !> positive definite. !> @param[in] batch_count - rocblas_int. batch_count >= 0. !> Number of matrices in the batch. interface rocsolver_chegvdx_strided_batched function rocsolver_chegvdx_strided_batched_(handle,itype,evect,erange,uplo,n,A,lda,strideA,B, & ldb,strideB,vl,vu,il,iu,nev,W,strideW,Z,ldz,strideZ,myInfo,batch_count) & bind(c, name="rocsolver_chegvdx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvdx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 real(c_float),value :: vl real(c_float),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz integer(c_int64_t),value :: strideZ type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface interface rocsolver_zhegvdx_strided_batched function rocsolver_zhegvdx_strided_batched_(handle,itype,evect,erange,uplo,n,A,lda,strideA,B, & ldb,strideB,vl,vu,il,iu,nev,W,strideW,Z,ldz,strideZ,myInfo,batch_count) & bind(c, name="rocsolver_zhegvdx_strided_batched") use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvdx_strided_batched_ type(c_ptr),value :: handle integer(kind(rocblas_eform_ax)),value :: itype integer(kind(rocblas_evect_original)),value :: evect integer(kind(rocblas_erange_all)),value :: erange integer(kind(rocblas_fill_upper)),value :: uplo integer(c_int),value :: n 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 real(c_double),value :: vl real(c_double),value :: vu integer(c_int),value :: il integer(c_int),value :: iu type(c_ptr),value :: nev type(c_ptr),value :: W integer(c_int64_t),value :: strideW type(c_ptr),value :: Z integer(c_int),value :: ldz integer(c_int64_t),value :: strideZ type(c_ptr),value :: myInfo integer(c_int),value :: batch_count end function end interface #ifdef USE_FPOINTER_INTERFACES contains #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_clacgv_assumed_rank(handle,n,x,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clacgv_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocsolver_clacgv_assumed_rank = rocsolver_clacgv_(handle,n,c_loc(x),incx) end function #else function rocsolver_clacgv_rank_0(handle,n,x,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clacgv_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx ! rocsolver_clacgv_rank_0 = rocsolver_clacgv_(handle,n,c_loc(x),incx) end function function rocsolver_clacgv_rank_1(handle,n,x,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clacgv_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocsolver_clacgv_rank_1 = rocsolver_clacgv_(handle,n,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zlacgv_assumed_rank(handle,n,x,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlacgv_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx ! rocsolver_zlacgv_assumed_rank = rocsolver_zlacgv_(handle,n,c_loc(x),incx) end function #else function rocsolver_zlacgv_rank_0(handle,n,x,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlacgv_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx ! rocsolver_zlacgv_rank_0 = rocsolver_zlacgv_(handle,n,c_loc(x),incx) end function function rocsolver_zlacgv_rank_1(handle,n,x,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlacgv_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx ! rocsolver_zlacgv_rank_1 = rocsolver_zlacgv_(handle,n,c_loc(x),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_slaswp_assumed_rank(handle,n,A,lda,k1,k2,ipiv,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slaswp_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: k1 integer(c_int) :: k2 integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int) :: incx ! rocsolver_slaswp_assumed_rank = rocsolver_slaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv), & incx) end function #else function rocsolver_slaswp_rank_0(handle,n,A,lda,k1,k2,ipiv,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slaswp_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int) :: k1 integer(c_int) :: k2 integer(c_int),target :: ipiv integer(c_int) :: incx ! rocsolver_slaswp_rank_0 = rocsolver_slaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx) end function function rocsolver_slaswp_rank_1(handle,n,A,lda,k1,k2,ipiv,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slaswp_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: k1 integer(c_int) :: k2 integer(c_int),target,dimension(:) :: ipiv integer(c_int) :: incx ! rocsolver_slaswp_rank_1 = rocsolver_slaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx) end function function rocsolver_slaswp_full_rank(handle,n,A,lda,k1,k2,ipiv,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slaswp_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: k1 integer(c_int) :: k2 integer(c_int),target,dimension(:) :: ipiv integer(c_int) :: incx ! rocsolver_slaswp_full_rank = rocsolver_slaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dlaswp_assumed_rank(handle,n,A,lda,k1,k2,ipiv,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlaswp_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: k1 integer(c_int) :: k2 integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int) :: incx ! rocsolver_dlaswp_assumed_rank = rocsolver_dlaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv), & incx) end function #else function rocsolver_dlaswp_rank_0(handle,n,A,lda,k1,k2,ipiv,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlaswp_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int) :: k1 integer(c_int) :: k2 integer(c_int),target :: ipiv integer(c_int) :: incx ! rocsolver_dlaswp_rank_0 = rocsolver_dlaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx) end function function rocsolver_dlaswp_rank_1(handle,n,A,lda,k1,k2,ipiv,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlaswp_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: k1 integer(c_int) :: k2 integer(c_int),target,dimension(:) :: ipiv integer(c_int) :: incx ! rocsolver_dlaswp_rank_1 = rocsolver_dlaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx) end function function rocsolver_dlaswp_full_rank(handle,n,A,lda,k1,k2,ipiv,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlaswp_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: k1 integer(c_int) :: k2 integer(c_int),target,dimension(:) :: ipiv integer(c_int) :: incx ! rocsolver_dlaswp_full_rank = rocsolver_dlaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_claswp_assumed_rank(handle,n,A,lda,k1,k2,ipiv,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_claswp_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: k1 integer(c_int) :: k2 integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int) :: incx ! rocsolver_claswp_assumed_rank = rocsolver_claswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv), & incx) end function #else function rocsolver_claswp_rank_0(handle,n,A,lda,k1,k2,ipiv,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_claswp_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int) :: k1 integer(c_int) :: k2 integer(c_int),target :: ipiv integer(c_int) :: incx ! rocsolver_claswp_rank_0 = rocsolver_claswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx) end function function rocsolver_claswp_rank_1(handle,n,A,lda,k1,k2,ipiv,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_claswp_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: k1 integer(c_int) :: k2 integer(c_int),target,dimension(:) :: ipiv integer(c_int) :: incx ! rocsolver_claswp_rank_1 = rocsolver_claswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx) end function function rocsolver_claswp_full_rank(handle,n,A,lda,k1,k2,ipiv,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_claswp_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: k1 integer(c_int) :: k2 integer(c_int),target,dimension(:) :: ipiv integer(c_int) :: incx ! rocsolver_claswp_full_rank = rocsolver_claswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zlaswp_assumed_rank(handle,n,A,lda,k1,k2,ipiv,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlaswp_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: k1 integer(c_int) :: k2 integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int) :: incx ! rocsolver_zlaswp_assumed_rank = rocsolver_zlaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv), & incx) end function #else function rocsolver_zlaswp_rank_0(handle,n,A,lda,k1,k2,ipiv,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlaswp_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int) :: k1 integer(c_int) :: k2 integer(c_int),target :: ipiv integer(c_int) :: incx ! rocsolver_zlaswp_rank_0 = rocsolver_zlaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx) end function function rocsolver_zlaswp_rank_1(handle,n,A,lda,k1,k2,ipiv,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlaswp_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: k1 integer(c_int) :: k2 integer(c_int),target,dimension(:) :: ipiv integer(c_int) :: incx ! rocsolver_zlaswp_rank_1 = rocsolver_zlaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx) end function function rocsolver_zlaswp_full_rank(handle,n,A,lda,k1,k2,ipiv,incx) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlaswp_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: k1 integer(c_int) :: k2 integer(c_int),target,dimension(:) :: ipiv integer(c_int) :: incx ! rocsolver_zlaswp_full_rank = rocsolver_zlaswp_(handle,n,c_loc(A),lda,k1,k2,c_loc(ipiv),incx) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_slarfg_assumed_rank(handle,n,alpha,x,incx,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarfg_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float) :: tau ! rocsolver_slarfg_assumed_rank = rocsolver_slarfg_(handle,n,alpha,c_loc(x),incx,tau) end function #else function rocsolver_slarfg_rank_0(handle,n,alpha,x,incx,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarfg_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: x integer(c_int) :: incx real(c_float) :: tau ! rocsolver_slarfg_rank_0 = rocsolver_slarfg_(handle,n,alpha,c_loc(x),incx,tau) end function function rocsolver_slarfg_rank_1(handle,n,alpha,x,incx,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarfg_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: tau ! rocsolver_slarfg_rank_1 = rocsolver_slarfg_(handle,n,alpha,c_loc(x),incx,tau) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dlarfg_assumed_rank(handle,n,alpha,x,incx,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarfg_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double) :: tau ! rocsolver_dlarfg_assumed_rank = rocsolver_dlarfg_(handle,n,alpha,c_loc(x),incx,tau) end function #else function rocsolver_dlarfg_rank_0(handle,n,alpha,x,incx,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarfg_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: x integer(c_int) :: incx real(c_double) :: tau ! rocsolver_dlarfg_rank_0 = rocsolver_dlarfg_(handle,n,alpha,c_loc(x),incx,tau) end function function rocsolver_dlarfg_rank_1(handle,n,alpha,x,incx,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarfg_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: tau ! rocsolver_dlarfg_rank_1 = rocsolver_dlarfg_(handle,n,alpha,c_loc(x),incx,tau) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_clarfg_assumed_rank(handle,n,alpha,x,incx,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarfg_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex) :: tau ! rocsolver_clarfg_assumed_rank = rocsolver_clarfg_(handle,n,alpha,c_loc(x),incx,tau) end function #else function rocsolver_clarfg_rank_0(handle,n,alpha,x,incx,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarfg_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex) :: tau ! rocsolver_clarfg_rank_0 = rocsolver_clarfg_(handle,n,alpha,c_loc(x),incx,tau) end function function rocsolver_clarfg_rank_1(handle,n,alpha,x,incx,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarfg_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: tau ! rocsolver_clarfg_rank_1 = rocsolver_clarfg_(handle,n,alpha,c_loc(x),incx,tau) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zlarfg_assumed_rank(handle,n,alpha,x,incx,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarfg_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex) :: tau ! rocsolver_zlarfg_assumed_rank = rocsolver_zlarfg_(handle,n,alpha,c_loc(x),incx,tau) end function #else function rocsolver_zlarfg_rank_0(handle,n,alpha,x,incx,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarfg_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex) :: tau ! rocsolver_zlarfg_rank_0 = rocsolver_zlarfg_(handle,n,alpha,c_loc(x),incx,tau) end function function rocsolver_zlarfg_rank_1(handle,n,alpha,x,incx,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarfg_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: tau ! rocsolver_zlarfg_rank_1 = rocsolver_zlarfg_(handle,n,alpha,c_loc(x),incx,tau) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_slarft_assumed_rank(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarft_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: V integer(c_int) :: ldv real(c_float),target,contiguous,dimension(..) :: tau real(c_float),target,contiguous,dimension(..) :: T integer(c_int) :: ldt ! rocsolver_slarft_assumed_rank = rocsolver_slarft_(handle,myDirect,storev,n,k,c_loc(V),ldv, & c_loc(tau),c_loc(T),ldt) end function #else function rocsolver_slarft_rank_0(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarft_rank_0 type(c_ptr) :: handle integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: n integer(c_int) :: k real(c_float),target :: V integer(c_int) :: ldv real(c_float),target :: tau real(c_float),target :: T integer(c_int) :: ldt ! rocsolver_slarft_rank_0 = rocsolver_slarft_(handle,myDirect,storev,n,k,c_loc(V),ldv, & c_loc(tau),c_loc(T),ldt) end function function rocsolver_slarft_rank_1(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarft_rank_1 type(c_ptr) :: handle integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: V integer(c_int) :: ldv real(c_float),target,dimension(:) :: tau real(c_float),target,dimension(:) :: T integer(c_int) :: ldt ! rocsolver_slarft_rank_1 = rocsolver_slarft_(handle,myDirect,storev,n,k,c_loc(V),ldv, & c_loc(tau),c_loc(T),ldt) end function function rocsolver_slarft_full_rank(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarft_full_rank type(c_ptr) :: handle integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: V integer(c_int) :: ldv real(c_float),target,dimension(:) :: tau real(c_float),target,dimension(:,:) :: T integer(c_int) :: ldt ! rocsolver_slarft_full_rank = rocsolver_slarft_(handle,myDirect,storev,n,k,c_loc(V),ldv, & c_loc(tau),c_loc(T),ldt) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dlarft_assumed_rank(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarft_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: V integer(c_int) :: ldv real(c_double),target,contiguous,dimension(..) :: tau real(c_double),target,contiguous,dimension(..) :: T integer(c_int) :: ldt ! rocsolver_dlarft_assumed_rank = rocsolver_dlarft_(handle,myDirect,storev,n,k,c_loc(V),ldv, & c_loc(tau),c_loc(T),ldt) end function #else function rocsolver_dlarft_rank_0(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarft_rank_0 type(c_ptr) :: handle integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: n integer(c_int) :: k real(c_double),target :: V integer(c_int) :: ldv real(c_double),target :: tau real(c_double),target :: T integer(c_int) :: ldt ! rocsolver_dlarft_rank_0 = rocsolver_dlarft_(handle,myDirect,storev,n,k,c_loc(V),ldv, & c_loc(tau),c_loc(T),ldt) end function function rocsolver_dlarft_rank_1(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarft_rank_1 type(c_ptr) :: handle integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: V integer(c_int) :: ldv real(c_double),target,dimension(:) :: tau real(c_double),target,dimension(:) :: T integer(c_int) :: ldt ! rocsolver_dlarft_rank_1 = rocsolver_dlarft_(handle,myDirect,storev,n,k,c_loc(V),ldv, & c_loc(tau),c_loc(T),ldt) end function function rocsolver_dlarft_full_rank(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarft_full_rank type(c_ptr) :: handle integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: V integer(c_int) :: ldv real(c_double),target,dimension(:) :: tau real(c_double),target,dimension(:,:) :: T integer(c_int) :: ldt ! rocsolver_dlarft_full_rank = rocsolver_dlarft_(handle,myDirect,storev,n,k,c_loc(V),ldv, & c_loc(tau),c_loc(T),ldt) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_clarft_assumed_rank(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarft_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: V integer(c_int) :: ldv complex(c_float_complex),target,contiguous,dimension(..) :: tau complex(c_float_complex),target,contiguous,dimension(..) :: T integer(c_int) :: ldt ! rocsolver_clarft_assumed_rank = rocsolver_clarft_(handle,myDirect,storev,n,k,c_loc(V),ldv, & c_loc(tau),c_loc(T),ldt) end function #else function rocsolver_clarft_rank_0(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarft_rank_0 type(c_ptr) :: handle integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: V integer(c_int) :: ldv complex(c_float_complex),target :: tau complex(c_float_complex),target :: T integer(c_int) :: ldt ! rocsolver_clarft_rank_0 = rocsolver_clarft_(handle,myDirect,storev,n,k,c_loc(V),ldv, & c_loc(tau),c_loc(T),ldt) end function function rocsolver_clarft_rank_1(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarft_rank_1 type(c_ptr) :: handle integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: V integer(c_int) :: ldv complex(c_float_complex),target,dimension(:) :: tau complex(c_float_complex),target,dimension(:) :: T integer(c_int) :: ldt ! rocsolver_clarft_rank_1 = rocsolver_clarft_(handle,myDirect,storev,n,k,c_loc(V),ldv, & c_loc(tau),c_loc(T),ldt) end function function rocsolver_clarft_full_rank(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarft_full_rank type(c_ptr) :: handle integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: V integer(c_int) :: ldv complex(c_float_complex),target,dimension(:) :: tau complex(c_float_complex),target,dimension(:,:) :: T integer(c_int) :: ldt ! rocsolver_clarft_full_rank = rocsolver_clarft_(handle,myDirect,storev,n,k,c_loc(V),ldv, & c_loc(tau),c_loc(T),ldt) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zlarft_assumed_rank(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarft_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: V integer(c_int) :: ldv complex(c_double_complex),target,contiguous,dimension(..) :: tau complex(c_double_complex),target,contiguous,dimension(..) :: T integer(c_int) :: ldt ! rocsolver_zlarft_assumed_rank = rocsolver_zlarft_(handle,myDirect,storev,n,k,c_loc(V),ldv, & c_loc(tau),c_loc(T),ldt) end function #else function rocsolver_zlarft_rank_0(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarft_rank_0 type(c_ptr) :: handle integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: V integer(c_int) :: ldv complex(c_double_complex),target :: tau complex(c_double_complex),target :: T integer(c_int) :: ldt ! rocsolver_zlarft_rank_0 = rocsolver_zlarft_(handle,myDirect,storev,n,k,c_loc(V),ldv, & c_loc(tau),c_loc(T),ldt) end function function rocsolver_zlarft_rank_1(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarft_rank_1 type(c_ptr) :: handle integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: V integer(c_int) :: ldv complex(c_double_complex),target,dimension(:) :: tau complex(c_double_complex),target,dimension(:) :: T integer(c_int) :: ldt ! rocsolver_zlarft_rank_1 = rocsolver_zlarft_(handle,myDirect,storev,n,k,c_loc(V),ldv, & c_loc(tau),c_loc(T),ldt) end function function rocsolver_zlarft_full_rank(handle,myDirect,storev,n,k,V,ldv,tau,T,ldt) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarft_full_rank type(c_ptr) :: handle integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: V integer(c_int) :: ldv complex(c_double_complex),target,dimension(:) :: tau complex(c_double_complex),target,dimension(:,:) :: T integer(c_int) :: ldt ! rocsolver_zlarft_full_rank = rocsolver_zlarft_(handle,myDirect,storev,n,k,c_loc(V),ldv, & c_loc(tau),c_loc(T),ldt) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_slarf_assumed_rank(handle,side,m,n,x,incx,alpha,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarf_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocsolver_slarf_assumed_rank = rocsolver_slarf_(handle,side,m,n,c_loc(x),incx,alpha, & c_loc(A),lda) end function #else function rocsolver_slarf_rank_0(handle,side,m,n,x,incx,alpha,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarf_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target :: x integer(c_int) :: incx real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda ! rocsolver_slarf_rank_0 = rocsolver_slarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda) end function function rocsolver_slarf_rank_1(handle,side,m,n,x,incx,alpha,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarf_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda ! rocsolver_slarf_rank_1 = rocsolver_slarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda) end function function rocsolver_slarf_full_rank(handle,side,m,n,x,incx,alpha,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarf_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: x integer(c_int) :: incx real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda ! rocsolver_slarf_full_rank = rocsolver_slarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dlarf_assumed_rank(handle,side,m,n,x,incx,alpha,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarf_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: incx real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocsolver_dlarf_assumed_rank = rocsolver_dlarf_(handle,side,m,n,c_loc(x),incx,alpha, & c_loc(A),lda) end function #else function rocsolver_dlarf_rank_0(handle,side,m,n,x,incx,alpha,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarf_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target :: x integer(c_int) :: incx real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda ! rocsolver_dlarf_rank_0 = rocsolver_dlarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda) end function function rocsolver_dlarf_rank_1(handle,side,m,n,x,incx,alpha,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarf_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda ! rocsolver_dlarf_rank_1 = rocsolver_dlarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda) end function function rocsolver_dlarf_full_rank(handle,side,m,n,x,incx,alpha,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarf_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: x integer(c_int) :: incx real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda ! rocsolver_dlarf_full_rank = rocsolver_dlarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_clarf_assumed_rank(handle,side,m,n,x,incx,alpha,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarf_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocsolver_clarf_assumed_rank = rocsolver_clarf_(handle,side,m,n,c_loc(x),incx,alpha, & c_loc(A),lda) end function #else function rocsolver_clarf_rank_0(handle,side,m,n,x,incx,alpha,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarf_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: x integer(c_int) :: incx complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda ! rocsolver_clarf_rank_0 = rocsolver_clarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda) end function function rocsolver_clarf_rank_1(handle,side,m,n,x,incx,alpha,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarf_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda ! rocsolver_clarf_rank_1 = rocsolver_clarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda) end function function rocsolver_clarf_full_rank(handle,side,m,n,x,incx,alpha,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarf_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda ! rocsolver_clarf_full_rank = rocsolver_clarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zlarf_assumed_rank(handle,side,m,n,x,incx,alpha,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarf_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: incx complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocsolver_zlarf_assumed_rank = rocsolver_zlarf_(handle,side,m,n,c_loc(x),incx,alpha, & c_loc(A),lda) end function #else function rocsolver_zlarf_rank_0(handle,side,m,n,x,incx,alpha,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarf_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: x integer(c_int) :: incx complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda ! rocsolver_zlarf_rank_0 = rocsolver_zlarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda) end function function rocsolver_zlarf_rank_1(handle,side,m,n,x,incx,alpha,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarf_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda ! rocsolver_zlarf_rank_1 = rocsolver_zlarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda) end function function rocsolver_zlarf_full_rank(handle,side,m,n,x,incx,alpha,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarf_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: incx complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda ! rocsolver_zlarf_full_rank = rocsolver_zlarf_(handle,side,m,n,c_loc(x),incx,alpha,c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_slarfb_assumed_rank(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A, & lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarfb_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: V integer(c_int) :: ldv real(c_float),target,contiguous,dimension(..) :: T integer(c_int) :: ldt real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocsolver_slarfb_assumed_rank = rocsolver_slarfb_(handle,side,trans,myDirect,storev,m,n,k, & c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda) end function #else function rocsolver_slarfb_rank_0(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarfb_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: V integer(c_int) :: ldv real(c_float),target :: T integer(c_int) :: ldt real(c_float),target :: A integer(c_int) :: lda ! rocsolver_slarfb_rank_0 = rocsolver_slarfb_(handle,side,trans,myDirect,storev,m,n,k, & c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda) end function function rocsolver_slarfb_rank_1(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarfb_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: V integer(c_int) :: ldv real(c_float),target,dimension(:) :: T integer(c_int) :: ldt real(c_float),target,dimension(:) :: A integer(c_int) :: lda ! rocsolver_slarfb_rank_1 = rocsolver_slarfb_(handle,side,trans,myDirect,storev,m,n,k, & c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda) end function function rocsolver_slarfb_full_rank(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slarfb_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: V integer(c_int) :: ldv real(c_float),target,dimension(:,:) :: T integer(c_int) :: ldt real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda ! rocsolver_slarfb_full_rank = rocsolver_slarfb_(handle,side,trans,myDirect,storev,m,n,k, & c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dlarfb_assumed_rank(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A, & lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarfb_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: V integer(c_int) :: ldv real(c_double),target,contiguous,dimension(..) :: T integer(c_int) :: ldt real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocsolver_dlarfb_assumed_rank = rocsolver_dlarfb_(handle,side,trans,myDirect,storev,m,n,k, & c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda) end function #else function rocsolver_dlarfb_rank_0(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarfb_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: V integer(c_int) :: ldv real(c_double),target :: T integer(c_int) :: ldt real(c_double),target :: A integer(c_int) :: lda ! rocsolver_dlarfb_rank_0 = rocsolver_dlarfb_(handle,side,trans,myDirect,storev,m,n,k, & c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda) end function function rocsolver_dlarfb_rank_1(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarfb_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: V integer(c_int) :: ldv real(c_double),target,dimension(:) :: T integer(c_int) :: ldt real(c_double),target,dimension(:) :: A integer(c_int) :: lda ! rocsolver_dlarfb_rank_1 = rocsolver_dlarfb_(handle,side,trans,myDirect,storev,m,n,k, & c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda) end function function rocsolver_dlarfb_full_rank(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlarfb_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: V integer(c_int) :: ldv real(c_double),target,dimension(:,:) :: T integer(c_int) :: ldt real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda ! rocsolver_dlarfb_full_rank = rocsolver_dlarfb_(handle,side,trans,myDirect,storev,m,n,k, & c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_clarfb_assumed_rank(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A, & lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarfb_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: V integer(c_int) :: ldv complex(c_float_complex),target,contiguous,dimension(..) :: T integer(c_int) :: ldt complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocsolver_clarfb_assumed_rank = rocsolver_clarfb_(handle,side,trans,myDirect,storev,m,n,k, & c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda) end function #else function rocsolver_clarfb_rank_0(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarfb_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: V integer(c_int) :: ldv complex(c_float_complex),target :: T integer(c_int) :: ldt complex(c_float_complex),target :: A integer(c_int) :: lda ! rocsolver_clarfb_rank_0 = rocsolver_clarfb_(handle,side,trans,myDirect,storev,m,n,k, & c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda) end function function rocsolver_clarfb_rank_1(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarfb_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: V integer(c_int) :: ldv complex(c_float_complex),target,dimension(:) :: T integer(c_int) :: ldt complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda ! rocsolver_clarfb_rank_1 = rocsolver_clarfb_(handle,side,trans,myDirect,storev,m,n,k, & c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda) end function function rocsolver_clarfb_full_rank(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clarfb_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: V integer(c_int) :: ldv complex(c_float_complex),target,dimension(:,:) :: T integer(c_int) :: ldt complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda ! rocsolver_clarfb_full_rank = rocsolver_clarfb_(handle,side,trans,myDirect,storev,m,n,k, & c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zlarfb_assumed_rank(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A, & lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarfb_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: V integer(c_int) :: ldv complex(c_double_complex),target,contiguous,dimension(..) :: T integer(c_int) :: ldt complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda ! rocsolver_zlarfb_assumed_rank = rocsolver_zlarfb_(handle,side,trans,myDirect,storev,m,n,k, & c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda) end function #else function rocsolver_zlarfb_rank_0(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarfb_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: V integer(c_int) :: ldv complex(c_double_complex),target :: T integer(c_int) :: ldt complex(c_double_complex),target :: A integer(c_int) :: lda ! rocsolver_zlarfb_rank_0 = rocsolver_zlarfb_(handle,side,trans,myDirect,storev,m,n,k, & c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda) end function function rocsolver_zlarfb_rank_1(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarfb_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: V integer(c_int) :: ldv complex(c_double_complex),target,dimension(:) :: T integer(c_int) :: ldt complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda ! rocsolver_zlarfb_rank_1 = rocsolver_zlarfb_(handle,side,trans,myDirect,storev,m,n,k, & c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda) end function function rocsolver_zlarfb_full_rank(handle,side,trans,myDirect,storev,m,n,k,V,ldv,T,ldt,A,lda) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlarfb_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(kind(rocblas_forward_direction)) :: myDirect integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: V integer(c_int) :: ldv complex(c_double_complex),target,dimension(:,:) :: T integer(c_int) :: ldt complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda ! rocsolver_zlarfb_full_rank = rocsolver_zlarfb_(handle,side,trans,myDirect,storev,m,n,k, & c_loc(V),ldv,c_loc(T),ldt,c_loc(A),lda) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_slabrd_assumed_rank(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slabrd_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E real(c_float),target,contiguous,dimension(..) :: tauq real(c_float),target,contiguous,dimension(..) :: taup real(c_float),target,contiguous,dimension(..) :: X integer(c_int) :: ldx real(c_float),target,contiguous,dimension(..) :: Y integer(c_int) :: ldy ! rocsolver_slabrd_assumed_rank = rocsolver_slabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D), & c_loc(E),c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy) end function #else function rocsolver_slabrd_rank_0(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slabrd_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E real(c_float),target :: tauq real(c_float),target :: taup real(c_float),target :: X integer(c_int) :: ldx real(c_float),target :: Y integer(c_int) :: ldy ! rocsolver_slabrd_rank_0 = rocsolver_slabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy) end function function rocsolver_slabrd_rank_1(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slabrd_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:) :: tauq real(c_float),target,dimension(:) :: taup real(c_float),target,dimension(:) :: X integer(c_int) :: ldx real(c_float),target,dimension(:) :: Y integer(c_int) :: ldy ! rocsolver_slabrd_rank_1 = rocsolver_slabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy) end function function rocsolver_slabrd_full_rank(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slabrd_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:) :: tauq real(c_float),target,dimension(:) :: taup real(c_float),target,dimension(:,:) :: X integer(c_int) :: ldx real(c_float),target,dimension(:,:) :: Y integer(c_int) :: ldy ! rocsolver_slabrd_full_rank = rocsolver_slabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dlabrd_assumed_rank(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlabrd_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E real(c_double),target,contiguous,dimension(..) :: tauq real(c_double),target,contiguous,dimension(..) :: taup real(c_double),target,contiguous,dimension(..) :: X integer(c_int) :: ldx real(c_double),target,contiguous,dimension(..) :: Y integer(c_int) :: ldy ! rocsolver_dlabrd_assumed_rank = rocsolver_dlabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D), & c_loc(E),c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy) end function #else function rocsolver_dlabrd_rank_0(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlabrd_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E real(c_double),target :: tauq real(c_double),target :: taup real(c_double),target :: X integer(c_int) :: ldx real(c_double),target :: Y integer(c_int) :: ldy ! rocsolver_dlabrd_rank_0 = rocsolver_dlabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy) end function function rocsolver_dlabrd_rank_1(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlabrd_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:) :: tauq real(c_double),target,dimension(:) :: taup real(c_double),target,dimension(:) :: X integer(c_int) :: ldx real(c_double),target,dimension(:) :: Y integer(c_int) :: ldy ! rocsolver_dlabrd_rank_1 = rocsolver_dlabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy) end function function rocsolver_dlabrd_full_rank(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlabrd_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:) :: tauq real(c_double),target,dimension(:) :: taup real(c_double),target,dimension(:,:) :: X integer(c_int) :: ldx real(c_double),target,dimension(:,:) :: Y integer(c_int) :: ldy ! rocsolver_dlabrd_full_rank = rocsolver_dlabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_clabrd_assumed_rank(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clabrd_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E complex(c_float_complex),target,contiguous,dimension(..) :: tauq complex(c_float_complex),target,contiguous,dimension(..) :: taup complex(c_float_complex),target,contiguous,dimension(..) :: X integer(c_int) :: ldx complex(c_float_complex),target,contiguous,dimension(..) :: Y integer(c_int) :: ldy ! rocsolver_clabrd_assumed_rank = rocsolver_clabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D), & c_loc(E),c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy) end function #else function rocsolver_clabrd_rank_0(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clabrd_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E complex(c_float_complex),target :: tauq complex(c_float_complex),target :: taup complex(c_float_complex),target :: X integer(c_int) :: ldx complex(c_float_complex),target :: Y integer(c_int) :: ldy ! rocsolver_clabrd_rank_0 = rocsolver_clabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy) end function function rocsolver_clabrd_rank_1(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clabrd_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:) :: tauq complex(c_float_complex),target,dimension(:) :: taup complex(c_float_complex),target,dimension(:) :: X integer(c_int) :: ldx complex(c_float_complex),target,dimension(:) :: Y integer(c_int) :: ldy ! rocsolver_clabrd_rank_1 = rocsolver_clabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy) end function function rocsolver_clabrd_full_rank(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clabrd_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:) :: tauq complex(c_float_complex),target,dimension(:) :: taup complex(c_float_complex),target,dimension(:,:) :: X integer(c_int) :: ldx complex(c_float_complex),target,dimension(:,:) :: Y integer(c_int) :: ldy ! rocsolver_clabrd_full_rank = rocsolver_clabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zlabrd_assumed_rank(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlabrd_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E complex(c_double_complex),target,contiguous,dimension(..) :: tauq complex(c_double_complex),target,contiguous,dimension(..) :: taup complex(c_double_complex),target,contiguous,dimension(..) :: X integer(c_int) :: ldx complex(c_double_complex),target,contiguous,dimension(..) :: Y integer(c_int) :: ldy ! rocsolver_zlabrd_assumed_rank = rocsolver_zlabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D), & c_loc(E),c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy) end function #else function rocsolver_zlabrd_rank_0(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlabrd_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E complex(c_double_complex),target :: tauq complex(c_double_complex),target :: taup complex(c_double_complex),target :: X integer(c_int) :: ldx complex(c_double_complex),target :: Y integer(c_int) :: ldy ! rocsolver_zlabrd_rank_0 = rocsolver_zlabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy) end function function rocsolver_zlabrd_rank_1(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlabrd_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:) :: tauq complex(c_double_complex),target,dimension(:) :: taup complex(c_double_complex),target,dimension(:) :: X integer(c_int) :: ldx complex(c_double_complex),target,dimension(:) :: Y integer(c_int) :: ldy ! rocsolver_zlabrd_rank_1 = rocsolver_zlabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy) end function function rocsolver_zlabrd_full_rank(handle,m,n,k,A,lda,D,E,tauq,taup,X,ldx,Y,ldy) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlabrd_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:) :: tauq complex(c_double_complex),target,dimension(:) :: taup complex(c_double_complex),target,dimension(:,:) :: X integer(c_int) :: ldx complex(c_double_complex),target,dimension(:,:) :: Y integer(c_int) :: ldy ! rocsolver_zlabrd_full_rank = rocsolver_zlabrd_(handle,m,n,k,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup),c_loc(X),ldx,c_loc(Y),ldy) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_slatrd_assumed_rank(handle,uplo,n,k,A,lda,E,tau,W,ldw) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slatrd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: E real(c_float),target,contiguous,dimension(..) :: tau real(c_float),target,contiguous,dimension(..) :: W integer(c_int) :: ldw ! rocsolver_slatrd_assumed_rank = rocsolver_slatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E), & c_loc(tau),c_loc(W),ldw) end function #else function rocsolver_slatrd_rank_0(handle,uplo,n,k,A,lda,E,tau,W,ldw) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slatrd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: E real(c_float),target :: tau real(c_float),target :: W integer(c_int) :: ldw ! rocsolver_slatrd_rank_0 = rocsolver_slatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E), & c_loc(tau),c_loc(W),ldw) end function function rocsolver_slatrd_rank_1(handle,uplo,n,k,A,lda,E,tau,W,ldw) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slatrd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:) :: tau real(c_float),target,dimension(:) :: W integer(c_int) :: ldw ! rocsolver_slatrd_rank_1 = rocsolver_slatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E), & c_loc(tau),c_loc(W),ldw) end function function rocsolver_slatrd_full_rank(handle,uplo,n,k,A,lda,E,tau,W,ldw) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slatrd_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:) :: tau real(c_float),target,dimension(:,:) :: W integer(c_int) :: ldw ! rocsolver_slatrd_full_rank = rocsolver_slatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E), & c_loc(tau),c_loc(W),ldw) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dlatrd_assumed_rank(handle,uplo,n,k,A,lda,E,tau,W,ldw) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlatrd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: E real(c_double),target,contiguous,dimension(..) :: tau real(c_double),target,contiguous,dimension(..) :: W integer(c_int) :: ldw ! rocsolver_dlatrd_assumed_rank = rocsolver_dlatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E), & c_loc(tau),c_loc(W),ldw) end function #else function rocsolver_dlatrd_rank_0(handle,uplo,n,k,A,lda,E,tau,W,ldw) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlatrd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: E real(c_double),target :: tau real(c_double),target :: W integer(c_int) :: ldw ! rocsolver_dlatrd_rank_0 = rocsolver_dlatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E), & c_loc(tau),c_loc(W),ldw) end function function rocsolver_dlatrd_rank_1(handle,uplo,n,k,A,lda,E,tau,W,ldw) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlatrd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:) :: tau real(c_double),target,dimension(:) :: W integer(c_int) :: ldw ! rocsolver_dlatrd_rank_1 = rocsolver_dlatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E), & c_loc(tau),c_loc(W),ldw) end function function rocsolver_dlatrd_full_rank(handle,uplo,n,k,A,lda,E,tau,W,ldw) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlatrd_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:) :: tau real(c_double),target,dimension(:,:) :: W integer(c_int) :: ldw ! rocsolver_dlatrd_full_rank = rocsolver_dlatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E), & c_loc(tau),c_loc(W),ldw) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_clatrd_assumed_rank(handle,uplo,n,k,A,lda,E,tau,W,ldw) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clatrd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: E complex(c_float_complex),target,contiguous,dimension(..) :: tau complex(c_float_complex),target,contiguous,dimension(..) :: W integer(c_int) :: ldw ! rocsolver_clatrd_assumed_rank = rocsolver_clatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E), & c_loc(tau),c_loc(W),ldw) end function #else function rocsolver_clatrd_rank_0(handle,uplo,n,k,A,lda,E,tau,W,ldw) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clatrd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda real(c_float),target :: E complex(c_float_complex),target :: tau complex(c_float_complex),target :: W integer(c_int) :: ldw ! rocsolver_clatrd_rank_0 = rocsolver_clatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E), & c_loc(tau),c_loc(W),ldw) end function function rocsolver_clatrd_rank_1(handle,uplo,n,k,A,lda,E,tau,W,ldw) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clatrd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:) :: tau complex(c_float_complex),target,dimension(:) :: W integer(c_int) :: ldw ! rocsolver_clatrd_rank_1 = rocsolver_clatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E), & c_loc(tau),c_loc(W),ldw) end function function rocsolver_clatrd_full_rank(handle,uplo,n,k,A,lda,E,tau,W,ldw) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clatrd_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:) :: tau complex(c_float_complex),target,dimension(:,:) :: W integer(c_int) :: ldw ! rocsolver_clatrd_full_rank = rocsolver_clatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E), & c_loc(tau),c_loc(W),ldw) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zlatrd_assumed_rank(handle,uplo,n,k,A,lda,E,tau,W,ldw) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlatrd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: E complex(c_double_complex),target,contiguous,dimension(..) :: tau complex(c_double_complex),target,contiguous,dimension(..) :: W integer(c_int) :: ldw ! rocsolver_zlatrd_assumed_rank = rocsolver_zlatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E), & c_loc(tau),c_loc(W),ldw) end function #else function rocsolver_zlatrd_rank_0(handle,uplo,n,k,A,lda,E,tau,W,ldw) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlatrd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda real(c_double),target :: E complex(c_double_complex),target :: tau complex(c_double_complex),target :: W integer(c_int) :: ldw ! rocsolver_zlatrd_rank_0 = rocsolver_zlatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E), & c_loc(tau),c_loc(W),ldw) end function function rocsolver_zlatrd_rank_1(handle,uplo,n,k,A,lda,E,tau,W,ldw) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlatrd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:) :: tau complex(c_double_complex),target,dimension(:) :: W integer(c_int) :: ldw ! rocsolver_zlatrd_rank_1 = rocsolver_zlatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E), & c_loc(tau),c_loc(W),ldw) end function function rocsolver_zlatrd_full_rank(handle,uplo,n,k,A,lda,E,tau,W,ldw) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlatrd_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:) :: tau complex(c_double_complex),target,dimension(:,:) :: W integer(c_int) :: ldw ! rocsolver_zlatrd_full_rank = rocsolver_zlatrd_(handle,uplo,n,k,c_loc(A),lda,c_loc(E), & c_loc(tau),c_loc(W),ldw) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_slasyf_assumed_rank(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slasyf_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nb type(c_ptr) :: kb real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_slasyf_assumed_rank = rocsolver_slasyf_(handle,uplo,n,nb,kb,c_loc(A),lda, & c_loc(ipiv),myInfo) end function #else function rocsolver_slasyf_rank_0(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slasyf_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nb type(c_ptr) :: kb real(c_float),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_slasyf_rank_0 = rocsolver_slasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv), & myInfo) end function function rocsolver_slasyf_rank_1(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slasyf_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nb type(c_ptr) :: kb real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_slasyf_rank_1 = rocsolver_slasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv), & myInfo) end function function rocsolver_slasyf_full_rank(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_slasyf_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nb type(c_ptr) :: kb real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_slasyf_full_rank = rocsolver_slasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv), & myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dlasyf_assumed_rank(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlasyf_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nb type(c_ptr) :: kb real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_dlasyf_assumed_rank = rocsolver_dlasyf_(handle,uplo,n,nb,kb,c_loc(A),lda, & c_loc(ipiv),myInfo) end function #else function rocsolver_dlasyf_rank_0(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlasyf_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nb type(c_ptr) :: kb real(c_double),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_dlasyf_rank_0 = rocsolver_dlasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv), & myInfo) end function function rocsolver_dlasyf_rank_1(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlasyf_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nb type(c_ptr) :: kb real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_dlasyf_rank_1 = rocsolver_dlasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv), & myInfo) end function function rocsolver_dlasyf_full_rank(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dlasyf_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nb type(c_ptr) :: kb real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_dlasyf_full_rank = rocsolver_dlasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv), & myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_clasyf_assumed_rank(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clasyf_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nb type(c_ptr) :: kb complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_clasyf_assumed_rank = rocsolver_clasyf_(handle,uplo,n,nb,kb,c_loc(A),lda, & c_loc(ipiv),myInfo) end function #else function rocsolver_clasyf_rank_0(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clasyf_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nb type(c_ptr) :: kb complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_clasyf_rank_0 = rocsolver_clasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv), & myInfo) end function function rocsolver_clasyf_rank_1(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clasyf_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nb type(c_ptr) :: kb complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_clasyf_rank_1 = rocsolver_clasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv), & myInfo) end function function rocsolver_clasyf_full_rank(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_clasyf_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nb type(c_ptr) :: kb complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_clasyf_full_rank = rocsolver_clasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv), & myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zlasyf_assumed_rank(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlasyf_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nb type(c_ptr) :: kb complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_zlasyf_assumed_rank = rocsolver_zlasyf_(handle,uplo,n,nb,kb,c_loc(A),lda, & c_loc(ipiv),myInfo) end function #else function rocsolver_zlasyf_rank_0(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlasyf_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nb type(c_ptr) :: kb complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_zlasyf_rank_0 = rocsolver_zlasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv), & myInfo) end function function rocsolver_zlasyf_rank_1(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlasyf_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nb type(c_ptr) :: kb complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_zlasyf_rank_1 = rocsolver_zlasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv), & myInfo) end function function rocsolver_zlasyf_full_rank(handle,uplo,n,nb,kb,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zlasyf_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nb type(c_ptr) :: kb complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_zlasyf_full_rank = rocsolver_zlasyf_(handle,uplo,n,nb,kb,c_loc(A),lda,c_loc(ipiv), & myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sorg2r_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorg2r_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv ! rocsolver_sorg2r_assumed_rank = rocsolver_sorg2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_sorg2r_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorg2r_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv ! rocsolver_sorg2r_rank_0 = rocsolver_sorg2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sorg2r_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorg2r_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sorg2r_rank_1 = rocsolver_sorg2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sorg2r_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorg2r_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sorg2r_full_rank = rocsolver_sorg2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dorg2r_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorg2r_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv ! rocsolver_dorg2r_assumed_rank = rocsolver_dorg2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_dorg2r_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorg2r_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv ! rocsolver_dorg2r_rank_0 = rocsolver_dorg2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dorg2r_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorg2r_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dorg2r_rank_1 = rocsolver_dorg2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dorg2r_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorg2r_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dorg2r_full_rank = rocsolver_dorg2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cung2r_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cung2r_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_cung2r_assumed_rank = rocsolver_cung2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_cung2r_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cung2r_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv ! rocsolver_cung2r_rank_0 = rocsolver_cung2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cung2r_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cung2r_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cung2r_rank_1 = rocsolver_cung2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cung2r_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cung2r_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cung2r_full_rank = rocsolver_cung2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zung2r_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zung2r_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_zung2r_assumed_rank = rocsolver_zung2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_zung2r_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zung2r_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv ! rocsolver_zung2r_rank_0 = rocsolver_zung2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zung2r_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zung2r_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zung2r_rank_1 = rocsolver_zung2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zung2r_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zung2r_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zung2r_full_rank = rocsolver_zung2r_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sorgqr_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgqr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv ! rocsolver_sorgqr_assumed_rank = rocsolver_sorgqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_sorgqr_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgqr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv ! rocsolver_sorgqr_rank_0 = rocsolver_sorgqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sorgqr_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgqr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sorgqr_rank_1 = rocsolver_sorgqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sorgqr_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgqr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sorgqr_full_rank = rocsolver_sorgqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dorgqr_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgqr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv ! rocsolver_dorgqr_assumed_rank = rocsolver_dorgqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_dorgqr_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgqr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv ! rocsolver_dorgqr_rank_0 = rocsolver_dorgqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dorgqr_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgqr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dorgqr_rank_1 = rocsolver_dorgqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dorgqr_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgqr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dorgqr_full_rank = rocsolver_dorgqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cungqr_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungqr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_cungqr_assumed_rank = rocsolver_cungqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_cungqr_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungqr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv ! rocsolver_cungqr_rank_0 = rocsolver_cungqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cungqr_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungqr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cungqr_rank_1 = rocsolver_cungqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cungqr_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungqr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cungqr_full_rank = rocsolver_cungqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zungqr_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungqr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_zungqr_assumed_rank = rocsolver_zungqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_zungqr_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungqr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv ! rocsolver_zungqr_rank_0 = rocsolver_zungqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zungqr_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungqr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zungqr_rank_1 = rocsolver_zungqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zungqr_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungqr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zungqr_full_rank = rocsolver_zungqr_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sorgl2_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgl2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv ! rocsolver_sorgl2_assumed_rank = rocsolver_sorgl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_sorgl2_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgl2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv ! rocsolver_sorgl2_rank_0 = rocsolver_sorgl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sorgl2_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgl2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sorgl2_rank_1 = rocsolver_sorgl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sorgl2_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgl2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sorgl2_full_rank = rocsolver_sorgl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dorgl2_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgl2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv ! rocsolver_dorgl2_assumed_rank = rocsolver_dorgl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_dorgl2_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgl2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv ! rocsolver_dorgl2_rank_0 = rocsolver_dorgl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dorgl2_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgl2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dorgl2_rank_1 = rocsolver_dorgl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dorgl2_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgl2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dorgl2_full_rank = rocsolver_dorgl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cungl2_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungl2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_cungl2_assumed_rank = rocsolver_cungl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_cungl2_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungl2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv ! rocsolver_cungl2_rank_0 = rocsolver_cungl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cungl2_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungl2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cungl2_rank_1 = rocsolver_cungl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cungl2_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungl2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cungl2_full_rank = rocsolver_cungl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zungl2_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungl2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_zungl2_assumed_rank = rocsolver_zungl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_zungl2_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungl2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv ! rocsolver_zungl2_rank_0 = rocsolver_zungl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zungl2_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungl2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zungl2_rank_1 = rocsolver_zungl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zungl2_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungl2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zungl2_full_rank = rocsolver_zungl2_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sorglq_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorglq_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv ! rocsolver_sorglq_assumed_rank = rocsolver_sorglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_sorglq_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorglq_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv ! rocsolver_sorglq_rank_0 = rocsolver_sorglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sorglq_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorglq_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sorglq_rank_1 = rocsolver_sorglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sorglq_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorglq_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sorglq_full_rank = rocsolver_sorglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dorglq_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorglq_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv ! rocsolver_dorglq_assumed_rank = rocsolver_dorglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_dorglq_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorglq_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv ! rocsolver_dorglq_rank_0 = rocsolver_dorglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dorglq_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorglq_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dorglq_rank_1 = rocsolver_dorglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dorglq_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorglq_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dorglq_full_rank = rocsolver_dorglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cunglq_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunglq_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_cunglq_assumed_rank = rocsolver_cunglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_cunglq_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunglq_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv ! rocsolver_cunglq_rank_0 = rocsolver_cunglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cunglq_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunglq_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cunglq_rank_1 = rocsolver_cunglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cunglq_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunglq_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cunglq_full_rank = rocsolver_cunglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zunglq_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunglq_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_zunglq_assumed_rank = rocsolver_zunglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_zunglq_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunglq_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv ! rocsolver_zunglq_rank_0 = rocsolver_zunglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zunglq_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunglq_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zunglq_rank_1 = rocsolver_zunglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zunglq_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunglq_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zunglq_full_rank = rocsolver_zunglq_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sorg2l_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorg2l_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv ! rocsolver_sorg2l_assumed_rank = rocsolver_sorg2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_sorg2l_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorg2l_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv ! rocsolver_sorg2l_rank_0 = rocsolver_sorg2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sorg2l_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorg2l_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sorg2l_rank_1 = rocsolver_sorg2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sorg2l_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorg2l_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sorg2l_full_rank = rocsolver_sorg2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dorg2l_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorg2l_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv ! rocsolver_dorg2l_assumed_rank = rocsolver_dorg2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_dorg2l_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorg2l_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv ! rocsolver_dorg2l_rank_0 = rocsolver_dorg2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dorg2l_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorg2l_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dorg2l_rank_1 = rocsolver_dorg2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dorg2l_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorg2l_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dorg2l_full_rank = rocsolver_dorg2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cung2l_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cung2l_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_cung2l_assumed_rank = rocsolver_cung2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_cung2l_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cung2l_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv ! rocsolver_cung2l_rank_0 = rocsolver_cung2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cung2l_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cung2l_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cung2l_rank_1 = rocsolver_cung2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cung2l_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cung2l_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cung2l_full_rank = rocsolver_cung2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zung2l_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zung2l_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_zung2l_assumed_rank = rocsolver_zung2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_zung2l_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zung2l_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv ! rocsolver_zung2l_rank_0 = rocsolver_zung2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zung2l_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zung2l_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zung2l_rank_1 = rocsolver_zung2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zung2l_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zung2l_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zung2l_full_rank = rocsolver_zung2l_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sorgql_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgql_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv ! rocsolver_sorgql_assumed_rank = rocsolver_sorgql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_sorgql_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgql_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv ! rocsolver_sorgql_rank_0 = rocsolver_sorgql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sorgql_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgql_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sorgql_rank_1 = rocsolver_sorgql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sorgql_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgql_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sorgql_full_rank = rocsolver_sorgql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dorgql_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgql_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv ! rocsolver_dorgql_assumed_rank = rocsolver_dorgql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_dorgql_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgql_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv ! rocsolver_dorgql_rank_0 = rocsolver_dorgql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dorgql_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgql_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dorgql_rank_1 = rocsolver_dorgql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dorgql_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgql_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dorgql_full_rank = rocsolver_dorgql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cungql_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungql_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_cungql_assumed_rank = rocsolver_cungql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_cungql_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungql_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv ! rocsolver_cungql_rank_0 = rocsolver_cungql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cungql_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungql_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cungql_rank_1 = rocsolver_cungql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cungql_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungql_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cungql_full_rank = rocsolver_cungql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zungql_assumed_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungql_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_zungql_assumed_rank = rocsolver_zungql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_zungql_rank_0(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungql_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv ! rocsolver_zungql_rank_0 = rocsolver_zungql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zungql_rank_1(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungql_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zungql_rank_1 = rocsolver_zungql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zungql_full_rank(handle,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungql_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zungql_full_rank = rocsolver_zungql_(handle,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sorgbr_assumed_rank(handle,storev,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgbr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv ! rocsolver_sorgbr_assumed_rank = rocsolver_sorgbr_(handle,storev,m,n,k,c_loc(A),lda, & c_loc(ipiv)) end function #else function rocsolver_sorgbr_rank_0(handle,storev,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgbr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv ! rocsolver_sorgbr_rank_0 = rocsolver_sorgbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sorgbr_rank_1(handle,storev,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgbr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sorgbr_rank_1 = rocsolver_sorgbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sorgbr_full_rank(handle,storev,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgbr_full_rank type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sorgbr_full_rank = rocsolver_sorgbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dorgbr_assumed_rank(handle,storev,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgbr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv ! rocsolver_dorgbr_assumed_rank = rocsolver_dorgbr_(handle,storev,m,n,k,c_loc(A),lda, & c_loc(ipiv)) end function #else function rocsolver_dorgbr_rank_0(handle,storev,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgbr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv ! rocsolver_dorgbr_rank_0 = rocsolver_dorgbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dorgbr_rank_1(handle,storev,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgbr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dorgbr_rank_1 = rocsolver_dorgbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dorgbr_full_rank(handle,storev,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgbr_full_rank type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dorgbr_full_rank = rocsolver_dorgbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cungbr_assumed_rank(handle,storev,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungbr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_cungbr_assumed_rank = rocsolver_cungbr_(handle,storev,m,n,k,c_loc(A),lda, & c_loc(ipiv)) end function #else function rocsolver_cungbr_rank_0(handle,storev,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungbr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv ! rocsolver_cungbr_rank_0 = rocsolver_cungbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cungbr_rank_1(handle,storev,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungbr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cungbr_rank_1 = rocsolver_cungbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cungbr_full_rank(handle,storev,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungbr_full_rank type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cungbr_full_rank = rocsolver_cungbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zungbr_assumed_rank(handle,storev,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungbr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_zungbr_assumed_rank = rocsolver_zungbr_(handle,storev,m,n,k,c_loc(A),lda, & c_loc(ipiv)) end function #else function rocsolver_zungbr_rank_0(handle,storev,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungbr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv ! rocsolver_zungbr_rank_0 = rocsolver_zungbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zungbr_rank_1(handle,storev,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungbr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zungbr_rank_1 = rocsolver_zungbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zungbr_full_rank(handle,storev,m,n,k,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungbr_full_rank type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zungbr_full_rank = rocsolver_zungbr_(handle,storev,m,n,k,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sorgtr_assumed_rank(handle,uplo,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgtr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv ! rocsolver_sorgtr_assumed_rank = rocsolver_sorgtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_sorgtr_rank_0(handle,uplo,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgtr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv ! rocsolver_sorgtr_rank_0 = rocsolver_sorgtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sorgtr_rank_1(handle,uplo,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgtr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sorgtr_rank_1 = rocsolver_sorgtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sorgtr_full_rank(handle,uplo,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorgtr_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sorgtr_full_rank = rocsolver_sorgtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dorgtr_assumed_rank(handle,uplo,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgtr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv ! rocsolver_dorgtr_assumed_rank = rocsolver_dorgtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_dorgtr_rank_0(handle,uplo,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgtr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv ! rocsolver_dorgtr_rank_0 = rocsolver_dorgtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dorgtr_rank_1(handle,uplo,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgtr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dorgtr_rank_1 = rocsolver_dorgtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dorgtr_full_rank(handle,uplo,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorgtr_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dorgtr_full_rank = rocsolver_dorgtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cungtr_assumed_rank(handle,uplo,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungtr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_cungtr_assumed_rank = rocsolver_cungtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_cungtr_rank_0(handle,uplo,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungtr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv ! rocsolver_cungtr_rank_0 = rocsolver_cungtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cungtr_rank_1(handle,uplo,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungtr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cungtr_rank_1 = rocsolver_cungtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cungtr_full_rank(handle,uplo,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cungtr_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cungtr_full_rank = rocsolver_cungtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zungtr_assumed_rank(handle,uplo,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungtr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_zungtr_assumed_rank = rocsolver_zungtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_zungtr_rank_0(handle,uplo,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungtr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv ! rocsolver_zungtr_rank_0 = rocsolver_zungtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zungtr_rank_1(handle,uplo,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungtr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zungtr_rank_1 = rocsolver_zungtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zungtr_full_rank(handle,uplo,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zungtr_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zungtr_full_rank = rocsolver_zungtr_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sorm2r_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorm2r_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_sorm2r_assumed_rank = rocsolver_sorm2r_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_sorm2r_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorm2r_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv real(c_float),target :: C integer(c_int) :: ldc ! rocsolver_sorm2r_rank_0 = rocsolver_sorm2r_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_sorm2r_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorm2r_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_sorm2r_rank_1 = rocsolver_sorm2r_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_sorm2r_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorm2r_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_sorm2r_full_rank = rocsolver_sorm2r_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dorm2r_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorm2r_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_dorm2r_assumed_rank = rocsolver_dorm2r_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_dorm2r_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorm2r_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv real(c_double),target :: C integer(c_int) :: ldc ! rocsolver_dorm2r_rank_0 = rocsolver_dorm2r_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_dorm2r_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorm2r_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_dorm2r_rank_1 = rocsolver_dorm2r_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_dorm2r_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorm2r_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_dorm2r_full_rank = rocsolver_dorm2r_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cunm2r_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunm2r_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_cunm2r_assumed_rank = rocsolver_cunm2r_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_cunm2r_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunm2r_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocsolver_cunm2r_rank_0 = rocsolver_cunm2r_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_cunm2r_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunm2r_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_cunm2r_rank_1 = rocsolver_cunm2r_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_cunm2r_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunm2r_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_cunm2r_full_rank = rocsolver_cunm2r_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zunm2r_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunm2r_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_zunm2r_assumed_rank = rocsolver_zunm2r_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_zunm2r_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunm2r_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocsolver_zunm2r_rank_0 = rocsolver_zunm2r_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_zunm2r_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunm2r_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_zunm2r_rank_1 = rocsolver_zunm2r_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_zunm2r_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunm2r_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_zunm2r_full_rank = rocsolver_zunm2r_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sormqr_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormqr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_sormqr_assumed_rank = rocsolver_sormqr_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_sormqr_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormqr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv real(c_float),target :: C integer(c_int) :: ldc ! rocsolver_sormqr_rank_0 = rocsolver_sormqr_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_sormqr_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormqr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_sormqr_rank_1 = rocsolver_sormqr_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_sormqr_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormqr_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_sormqr_full_rank = rocsolver_sormqr_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dormqr_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormqr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_dormqr_assumed_rank = rocsolver_dormqr_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_dormqr_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormqr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv real(c_double),target :: C integer(c_int) :: ldc ! rocsolver_dormqr_rank_0 = rocsolver_dormqr_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_dormqr_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormqr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_dormqr_rank_1 = rocsolver_dormqr_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_dormqr_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormqr_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_dormqr_full_rank = rocsolver_dormqr_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cunmqr_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmqr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_cunmqr_assumed_rank = rocsolver_cunmqr_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_cunmqr_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmqr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocsolver_cunmqr_rank_0 = rocsolver_cunmqr_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_cunmqr_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmqr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_cunmqr_rank_1 = rocsolver_cunmqr_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_cunmqr_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmqr_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_cunmqr_full_rank = rocsolver_cunmqr_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zunmqr_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmqr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_zunmqr_assumed_rank = rocsolver_zunmqr_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_zunmqr_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmqr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocsolver_zunmqr_rank_0 = rocsolver_zunmqr_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_zunmqr_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmqr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_zunmqr_rank_1 = rocsolver_zunmqr_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_zunmqr_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmqr_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_zunmqr_full_rank = rocsolver_zunmqr_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sorml2_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorml2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_sorml2_assumed_rank = rocsolver_sorml2_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_sorml2_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorml2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv real(c_float),target :: C integer(c_int) :: ldc ! rocsolver_sorml2_rank_0 = rocsolver_sorml2_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_sorml2_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorml2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_sorml2_rank_1 = rocsolver_sorml2_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_sorml2_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorml2_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_sorml2_full_rank = rocsolver_sorml2_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dorml2_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorml2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_dorml2_assumed_rank = rocsolver_dorml2_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_dorml2_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorml2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv real(c_double),target :: C integer(c_int) :: ldc ! rocsolver_dorml2_rank_0 = rocsolver_dorml2_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_dorml2_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorml2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_dorml2_rank_1 = rocsolver_dorml2_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_dorml2_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorml2_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_dorml2_full_rank = rocsolver_dorml2_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cunml2_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunml2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_cunml2_assumed_rank = rocsolver_cunml2_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_cunml2_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunml2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocsolver_cunml2_rank_0 = rocsolver_cunml2_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_cunml2_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunml2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_cunml2_rank_1 = rocsolver_cunml2_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_cunml2_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunml2_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_cunml2_full_rank = rocsolver_cunml2_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zunml2_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunml2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_zunml2_assumed_rank = rocsolver_zunml2_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_zunml2_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunml2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocsolver_zunml2_rank_0 = rocsolver_zunml2_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_zunml2_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunml2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_zunml2_rank_1 = rocsolver_zunml2_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_zunml2_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunml2_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_zunml2_full_rank = rocsolver_zunml2_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sormlq_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormlq_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_sormlq_assumed_rank = rocsolver_sormlq_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_sormlq_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormlq_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv real(c_float),target :: C integer(c_int) :: ldc ! rocsolver_sormlq_rank_0 = rocsolver_sormlq_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_sormlq_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormlq_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_sormlq_rank_1 = rocsolver_sormlq_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_sormlq_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormlq_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_sormlq_full_rank = rocsolver_sormlq_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dormlq_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormlq_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_dormlq_assumed_rank = rocsolver_dormlq_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_dormlq_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormlq_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv real(c_double),target :: C integer(c_int) :: ldc ! rocsolver_dormlq_rank_0 = rocsolver_dormlq_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_dormlq_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormlq_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_dormlq_rank_1 = rocsolver_dormlq_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_dormlq_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormlq_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_dormlq_full_rank = rocsolver_dormlq_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cunmlq_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmlq_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_cunmlq_assumed_rank = rocsolver_cunmlq_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_cunmlq_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmlq_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocsolver_cunmlq_rank_0 = rocsolver_cunmlq_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_cunmlq_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmlq_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_cunmlq_rank_1 = rocsolver_cunmlq_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_cunmlq_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmlq_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_cunmlq_full_rank = rocsolver_cunmlq_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zunmlq_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmlq_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_zunmlq_assumed_rank = rocsolver_zunmlq_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_zunmlq_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmlq_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocsolver_zunmlq_rank_0 = rocsolver_zunmlq_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_zunmlq_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmlq_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_zunmlq_rank_1 = rocsolver_zunmlq_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_zunmlq_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmlq_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_zunmlq_full_rank = rocsolver_zunmlq_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sorm2l_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorm2l_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_sorm2l_assumed_rank = rocsolver_sorm2l_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_sorm2l_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorm2l_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv real(c_float),target :: C integer(c_int) :: ldc ! rocsolver_sorm2l_rank_0 = rocsolver_sorm2l_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_sorm2l_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorm2l_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_sorm2l_rank_1 = rocsolver_sorm2l_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_sorm2l_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sorm2l_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_sorm2l_full_rank = rocsolver_sorm2l_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dorm2l_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorm2l_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_dorm2l_assumed_rank = rocsolver_dorm2l_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_dorm2l_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorm2l_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv real(c_double),target :: C integer(c_int) :: ldc ! rocsolver_dorm2l_rank_0 = rocsolver_dorm2l_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_dorm2l_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorm2l_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_dorm2l_rank_1 = rocsolver_dorm2l_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_dorm2l_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dorm2l_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_dorm2l_full_rank = rocsolver_dorm2l_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cunm2l_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunm2l_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_cunm2l_assumed_rank = rocsolver_cunm2l_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_cunm2l_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunm2l_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocsolver_cunm2l_rank_0 = rocsolver_cunm2l_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_cunm2l_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunm2l_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_cunm2l_rank_1 = rocsolver_cunm2l_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_cunm2l_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunm2l_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_cunm2l_full_rank = rocsolver_cunm2l_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zunm2l_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunm2l_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_zunm2l_assumed_rank = rocsolver_zunm2l_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_zunm2l_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunm2l_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocsolver_zunm2l_rank_0 = rocsolver_zunm2l_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_zunm2l_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunm2l_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_zunm2l_rank_1 = rocsolver_zunm2l_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_zunm2l_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunm2l_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_zunm2l_full_rank = rocsolver_zunm2l_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sormql_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormql_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_sormql_assumed_rank = rocsolver_sormql_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_sormql_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormql_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv real(c_float),target :: C integer(c_int) :: ldc ! rocsolver_sormql_rank_0 = rocsolver_sormql_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_sormql_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormql_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_sormql_rank_1 = rocsolver_sormql_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_sormql_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormql_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_sormql_full_rank = rocsolver_sormql_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dormql_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormql_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_dormql_assumed_rank = rocsolver_dormql_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_dormql_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormql_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv real(c_double),target :: C integer(c_int) :: ldc ! rocsolver_dormql_rank_0 = rocsolver_dormql_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_dormql_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormql_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_dormql_rank_1 = rocsolver_dormql_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_dormql_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormql_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_dormql_full_rank = rocsolver_dormql_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cunmql_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmql_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_cunmql_assumed_rank = rocsolver_cunmql_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_cunmql_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmql_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocsolver_cunmql_rank_0 = rocsolver_cunmql_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_cunmql_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmql_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_cunmql_rank_1 = rocsolver_cunmql_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_cunmql_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmql_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_cunmql_full_rank = rocsolver_cunmql_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zunmql_assumed_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmql_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_zunmql_assumed_rank = rocsolver_zunmql_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_zunmql_rank_0(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmql_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocsolver_zunmql_rank_0 = rocsolver_zunmql_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_zunmql_rank_1(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmql_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_zunmql_rank_1 = rocsolver_zunmql_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_zunmql_full_rank(handle,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmql_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_zunmql_full_rank = rocsolver_zunmql_(handle,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sormbr_assumed_rank(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormbr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_sormbr_assumed_rank = rocsolver_sormbr_(handle,storev,side,trans,m,n,k,c_loc(A), & lda,c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_sormbr_rank_0(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormbr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv real(c_float),target :: C integer(c_int) :: ldc ! rocsolver_sormbr_rank_0 = rocsolver_sormbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_sormbr_rank_1(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormbr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_sormbr_rank_1 = rocsolver_sormbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_sormbr_full_rank(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormbr_full_rank type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_sormbr_full_rank = rocsolver_sormbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dormbr_assumed_rank(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormbr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_dormbr_assumed_rank = rocsolver_dormbr_(handle,storev,side,trans,m,n,k,c_loc(A), & lda,c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_dormbr_rank_0(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormbr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv real(c_double),target :: C integer(c_int) :: ldc ! rocsolver_dormbr_rank_0 = rocsolver_dormbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_dormbr_rank_1(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormbr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_dormbr_rank_1 = rocsolver_dormbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_dormbr_full_rank(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormbr_full_rank type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_dormbr_full_rank = rocsolver_dormbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cunmbr_assumed_rank(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmbr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_cunmbr_assumed_rank = rocsolver_cunmbr_(handle,storev,side,trans,m,n,k,c_loc(A), & lda,c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_cunmbr_rank_0(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmbr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocsolver_cunmbr_rank_0 = rocsolver_cunmbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_cunmbr_rank_1(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmbr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_cunmbr_rank_1 = rocsolver_cunmbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_cunmbr_full_rank(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmbr_full_rank type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_cunmbr_full_rank = rocsolver_cunmbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zunmbr_assumed_rank(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmbr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_zunmbr_assumed_rank = rocsolver_zunmbr_(handle,storev,side,trans,m,n,k,c_loc(A), & lda,c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_zunmbr_rank_0(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmbr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocsolver_zunmbr_rank_0 = rocsolver_zunmbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_zunmbr_rank_1(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmbr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_zunmbr_rank_1 = rocsolver_zunmbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_zunmbr_full_rank(handle,storev,side,trans,m,n,k,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmbr_full_rank type(c_ptr) :: handle integer(kind(rocblas_column_wise)) :: storev integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_zunmbr_full_rank = rocsolver_zunmbr_(handle,storev,side,trans,m,n,k,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sormtr_assumed_rank(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormtr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_sormtr_assumed_rank = rocsolver_sormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_sormtr_rank_0(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormtr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv real(c_float),target :: C integer(c_int) :: ldc ! rocsolver_sormtr_rank_0 = rocsolver_sormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_sormtr_rank_1(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormtr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_sormtr_rank_1 = rocsolver_sormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_sormtr_full_rank(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sormtr_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_sormtr_full_rank = rocsolver_sormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dormtr_assumed_rank(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormtr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_dormtr_assumed_rank = rocsolver_dormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_dormtr_rank_0(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormtr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv real(c_double),target :: C integer(c_int) :: ldc ! rocsolver_dormtr_rank_0 = rocsolver_dormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_dormtr_rank_1(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormtr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_dormtr_rank_1 = rocsolver_dormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_dormtr_full_rank(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dormtr_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_dormtr_full_rank = rocsolver_dormtr_(handle,side,uplo,trans,m,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cunmtr_assumed_rank(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmtr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_cunmtr_assumed_rank = rocsolver_cunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_cunmtr_rank_0(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmtr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocsolver_cunmtr_rank_0 = rocsolver_cunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_cunmtr_rank_1(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmtr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_cunmtr_rank_1 = rocsolver_cunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_cunmtr_full_rank(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cunmtr_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_cunmtr_full_rank = rocsolver_cunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zunmtr_assumed_rank(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmtr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsolver_zunmtr_assumed_rank = rocsolver_zunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #else function rocsolver_zunmtr_rank_0(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmtr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocsolver_zunmtr_rank_0 = rocsolver_zunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_zunmtr_rank_1(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmtr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsolver_zunmtr_rank_1 = rocsolver_zunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function function rocsolver_zunmtr_full_rank(handle,side,uplo,trans,m,n,A,lda,ipiv,C,ldc) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zunmtr_full_rank type(c_ptr) :: handle integer(kind(rocblas_side_left)) :: side integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsolver_zunmtr_full_rank = rocsolver_zunmtr_(handle,side,uplo,trans,m,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sbdsqr_assumed_rank(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sbdsqr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nv integer(c_int) :: nu integer(c_int) :: nc real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E real(c_float),target,contiguous,dimension(..) :: V integer(c_int) :: ldv real(c_float),target,contiguous,dimension(..) :: U integer(c_int) :: ldu real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_sbdsqr_assumed_rank = rocsolver_sbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E), & c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo) end function #else function rocsolver_sbdsqr_rank_0(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sbdsqr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nv integer(c_int) :: nu integer(c_int) :: nc real(c_float),target :: D real(c_float),target :: E real(c_float),target :: V integer(c_int) :: ldv real(c_float),target :: U integer(c_int) :: ldu real(c_float),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_sbdsqr_rank_0 = rocsolver_sbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E), & c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo) end function function rocsolver_sbdsqr_rank_1(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sbdsqr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nv integer(c_int) :: nu integer(c_int) :: nc real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:) :: V integer(c_int) :: ldv real(c_float),target,dimension(:) :: U integer(c_int) :: ldu real(c_float),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_sbdsqr_rank_1 = rocsolver_sbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E), & c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo) end function function rocsolver_sbdsqr_full_rank(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sbdsqr_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nv integer(c_int) :: nu integer(c_int) :: nc real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:,:) :: V integer(c_int) :: ldv real(c_float),target,dimension(:,:) :: U integer(c_int) :: ldu real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_sbdsqr_full_rank = rocsolver_sbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E), & c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dbdsqr_assumed_rank(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dbdsqr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nv integer(c_int) :: nu integer(c_int) :: nc real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E real(c_double),target,contiguous,dimension(..) :: V integer(c_int) :: ldv real(c_double),target,contiguous,dimension(..) :: U integer(c_int) :: ldu real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dbdsqr_assumed_rank = rocsolver_dbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E), & c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo) end function #else function rocsolver_dbdsqr_rank_0(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dbdsqr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nv integer(c_int) :: nu integer(c_int) :: nc real(c_double),target :: D real(c_double),target :: E real(c_double),target :: V integer(c_int) :: ldv real(c_double),target :: U integer(c_int) :: ldu real(c_double),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dbdsqr_rank_0 = rocsolver_dbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E), & c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo) end function function rocsolver_dbdsqr_rank_1(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dbdsqr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nv integer(c_int) :: nu integer(c_int) :: nc real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:) :: V integer(c_int) :: ldv real(c_double),target,dimension(:) :: U integer(c_int) :: ldu real(c_double),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dbdsqr_rank_1 = rocsolver_dbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E), & c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo) end function function rocsolver_dbdsqr_full_rank(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dbdsqr_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nv integer(c_int) :: nu integer(c_int) :: nc real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:,:) :: V integer(c_int) :: ldv real(c_double),target,dimension(:,:) :: U integer(c_int) :: ldu real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dbdsqr_full_rank = rocsolver_dbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E), & c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cbdsqr_assumed_rank(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cbdsqr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nv integer(c_int) :: nu integer(c_int) :: nc real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E complex(c_float_complex),target,contiguous,dimension(..) :: V integer(c_int) :: ldv complex(c_float_complex),target,contiguous,dimension(..) :: U integer(c_int) :: ldu complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_cbdsqr_assumed_rank = rocsolver_cbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E), & c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo) end function #else function rocsolver_cbdsqr_rank_0(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cbdsqr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nv integer(c_int) :: nu integer(c_int) :: nc real(c_float),target :: D real(c_float),target :: E complex(c_float_complex),target :: V integer(c_int) :: ldv complex(c_float_complex),target :: U integer(c_int) :: ldu complex(c_float_complex),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_cbdsqr_rank_0 = rocsolver_cbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E), & c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo) end function function rocsolver_cbdsqr_rank_1(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cbdsqr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nv integer(c_int) :: nu integer(c_int) :: nc real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:) :: V integer(c_int) :: ldv complex(c_float_complex),target,dimension(:) :: U integer(c_int) :: ldu complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_cbdsqr_rank_1 = rocsolver_cbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E), & c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo) end function function rocsolver_cbdsqr_full_rank(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cbdsqr_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nv integer(c_int) :: nu integer(c_int) :: nc real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:,:) :: V integer(c_int) :: ldv complex(c_float_complex),target,dimension(:,:) :: U integer(c_int) :: ldu complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_cbdsqr_full_rank = rocsolver_cbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E), & c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zbdsqr_assumed_rank(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zbdsqr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nv integer(c_int) :: nu integer(c_int) :: nc real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E complex(c_double_complex),target,contiguous,dimension(..) :: V integer(c_int) :: ldv complex(c_double_complex),target,contiguous,dimension(..) :: U integer(c_int) :: ldu complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zbdsqr_assumed_rank = rocsolver_zbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E), & c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo) end function #else function rocsolver_zbdsqr_rank_0(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zbdsqr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nv integer(c_int) :: nu integer(c_int) :: nc real(c_double),target :: D real(c_double),target :: E complex(c_double_complex),target :: V integer(c_int) :: ldv complex(c_double_complex),target :: U integer(c_int) :: ldu complex(c_double_complex),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zbdsqr_rank_0 = rocsolver_zbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E), & c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo) end function function rocsolver_zbdsqr_rank_1(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zbdsqr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nv integer(c_int) :: nu integer(c_int) :: nc real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:) :: V integer(c_int) :: ldv complex(c_double_complex),target,dimension(:) :: U integer(c_int) :: ldu complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zbdsqr_rank_1 = rocsolver_zbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E), & c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo) end function function rocsolver_zbdsqr_full_rank(handle,uplo,n,nv,nu,nc,D,E,V,ldv,U,ldu,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zbdsqr_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nv integer(c_int) :: nu integer(c_int) :: nc real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:,:) :: V integer(c_int) :: ldv complex(c_double_complex),target,dimension(:,:) :: U integer(c_int) :: ldu complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zbdsqr_full_rank = rocsolver_zbdsqr_(handle,uplo,n,nv,nu,nc,c_loc(D),c_loc(E), & c_loc(V),ldv,c_loc(U),ldu,c_loc(C),ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssterf_assumed_rank(handle,n,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssterf_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E type(c_ptr) :: myInfo ! rocsolver_ssterf_assumed_rank = rocsolver_ssterf_(handle,n,c_loc(D),c_loc(E),myInfo) end function #else function rocsolver_ssterf_rank_0(handle,n,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssterf_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: D real(c_float),target :: E type(c_ptr) :: myInfo ! rocsolver_ssterf_rank_0 = rocsolver_ssterf_(handle,n,c_loc(D),c_loc(E),myInfo) end function function rocsolver_ssterf_rank_1(handle,n,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssterf_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_ssterf_rank_1 = rocsolver_ssterf_(handle,n,c_loc(D),c_loc(E),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsterf_assumed_rank(handle,n,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsterf_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E type(c_ptr) :: myInfo ! rocsolver_dsterf_assumed_rank = rocsolver_dsterf_(handle,n,c_loc(D),c_loc(E),myInfo) end function #else function rocsolver_dsterf_rank_0(handle,n,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsterf_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: D real(c_double),target :: E type(c_ptr) :: myInfo ! rocsolver_dsterf_rank_0 = rocsolver_dsterf_(handle,n,c_loc(D),c_loc(E),myInfo) end function function rocsolver_dsterf_rank_1(handle,n,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsterf_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_dsterf_rank_1 = rocsolver_dsterf_(handle,n,c_loc(D),c_loc(E),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssteqr_assumed_rank(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssteqr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_ssteqr_assumed_rank = rocsolver_ssteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C), & ldc,myInfo) end function #else function rocsolver_ssteqr_rank_0(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssteqr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_float),target :: D real(c_float),target :: E real(c_float),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_ssteqr_rank_0 = rocsolver_ssteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc, & myInfo) end function function rocsolver_ssteqr_rank_1(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssteqr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_ssteqr_rank_1 = rocsolver_ssteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc, & myInfo) end function function rocsolver_ssteqr_full_rank(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssteqr_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_ssteqr_full_rank = rocsolver_ssteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C), & ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsteqr_assumed_rank(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsteqr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dsteqr_assumed_rank = rocsolver_dsteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C), & ldc,myInfo) end function #else function rocsolver_dsteqr_rank_0(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsteqr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_double),target :: D real(c_double),target :: E real(c_double),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dsteqr_rank_0 = rocsolver_dsteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc, & myInfo) end function function rocsolver_dsteqr_rank_1(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsteqr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dsteqr_rank_1 = rocsolver_dsteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc, & myInfo) end function function rocsolver_dsteqr_full_rank(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsteqr_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dsteqr_full_rank = rocsolver_dsteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C), & ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_csteqr_assumed_rank(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csteqr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_csteqr_assumed_rank = rocsolver_csteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C), & ldc,myInfo) end function #else function rocsolver_csteqr_rank_0(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csteqr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_float),target :: D real(c_float),target :: E complex(c_float_complex),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_csteqr_rank_0 = rocsolver_csteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc, & myInfo) end function function rocsolver_csteqr_rank_1(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csteqr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_csteqr_rank_1 = rocsolver_csteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc, & myInfo) end function function rocsolver_csteqr_full_rank(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csteqr_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_csteqr_full_rank = rocsolver_csteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C), & ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zsteqr_assumed_rank(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsteqr_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zsteqr_assumed_rank = rocsolver_zsteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C), & ldc,myInfo) end function #else function rocsolver_zsteqr_rank_0(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsteqr_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_double),target :: D real(c_double),target :: E complex(c_double_complex),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zsteqr_rank_0 = rocsolver_zsteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc, & myInfo) end function function rocsolver_zsteqr_rank_1(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsteqr_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zsteqr_rank_1 = rocsolver_zsteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc, & myInfo) end function function rocsolver_zsteqr_full_rank(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsteqr_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zsteqr_full_rank = rocsolver_zsteqr_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C), & ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sstedc_assumed_rank(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sstedc_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_sstedc_assumed_rank = rocsolver_sstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C), & ldc,myInfo) end function #else function rocsolver_sstedc_rank_0(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sstedc_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_float),target :: D real(c_float),target :: E real(c_float),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_sstedc_rank_0 = rocsolver_sstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc, & myInfo) end function function rocsolver_sstedc_rank_1(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sstedc_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_sstedc_rank_1 = rocsolver_sstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc, & myInfo) end function function rocsolver_sstedc_full_rank(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sstedc_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_sstedc_full_rank = rocsolver_sstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C), & ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dstedc_assumed_rank(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dstedc_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dstedc_assumed_rank = rocsolver_dstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C), & ldc,myInfo) end function #else function rocsolver_dstedc_rank_0(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dstedc_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_double),target :: D real(c_double),target :: E real(c_double),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dstedc_rank_0 = rocsolver_dstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc, & myInfo) end function function rocsolver_dstedc_rank_1(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dstedc_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dstedc_rank_1 = rocsolver_dstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc, & myInfo) end function function rocsolver_dstedc_full_rank(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dstedc_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dstedc_full_rank = rocsolver_dstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C), & ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cstedc_assumed_rank(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cstedc_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_cstedc_assumed_rank = rocsolver_cstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C), & ldc,myInfo) end function #else function rocsolver_cstedc_rank_0(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cstedc_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_float),target :: D real(c_float),target :: E complex(c_float_complex),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_cstedc_rank_0 = rocsolver_cstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc, & myInfo) end function function rocsolver_cstedc_rank_1(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cstedc_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_cstedc_rank_1 = rocsolver_cstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc, & myInfo) end function function rocsolver_cstedc_full_rank(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cstedc_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_cstedc_full_rank = rocsolver_cstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C), & ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zstedc_assumed_rank(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zstedc_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zstedc_assumed_rank = rocsolver_zstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C), & ldc,myInfo) end function #else function rocsolver_zstedc_rank_0(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zstedc_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_double),target :: D real(c_double),target :: E complex(c_double_complex),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zstedc_rank_0 = rocsolver_zstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc, & myInfo) end function function rocsolver_zstedc_rank_1(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zstedc_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zstedc_rank_1 = rocsolver_zstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C),ldc, & myInfo) end function function rocsolver_zstedc_full_rank(handle,evect,n,D,E,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zstedc_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(c_int) :: n real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zstedc_full_rank = rocsolver_zstedc_(handle,evect,n,c_loc(D),c_loc(E),c_loc(C), & ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetf2_npvt_assumed_rank(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_sgetf2_npvt_assumed_rank = rocsolver_sgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function #else function rocsolver_sgetf2_npvt_rank_0(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_sgetf2_npvt_rank_0 = rocsolver_sgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function function rocsolver_sgetf2_npvt_rank_1(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_sgetf2_npvt_rank_1 = rocsolver_sgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function function rocsolver_sgetf2_npvt_full_rank(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_sgetf2_npvt_full_rank = rocsolver_sgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetf2_npvt_assumed_rank(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dgetf2_npvt_assumed_rank = rocsolver_dgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function #else function rocsolver_dgetf2_npvt_rank_0(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dgetf2_npvt_rank_0 = rocsolver_dgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function function rocsolver_dgetf2_npvt_rank_1(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dgetf2_npvt_rank_1 = rocsolver_dgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function function rocsolver_dgetf2_npvt_full_rank(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dgetf2_npvt_full_rank = rocsolver_dgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetf2_npvt_assumed_rank(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cgetf2_npvt_assumed_rank = rocsolver_cgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function #else function rocsolver_cgetf2_npvt_rank_0(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cgetf2_npvt_rank_0 = rocsolver_cgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function function rocsolver_cgetf2_npvt_rank_1(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cgetf2_npvt_rank_1 = rocsolver_cgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function function rocsolver_cgetf2_npvt_full_rank(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cgetf2_npvt_full_rank = rocsolver_cgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetf2_npvt_assumed_rank(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zgetf2_npvt_assumed_rank = rocsolver_zgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function #else function rocsolver_zgetf2_npvt_rank_0(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zgetf2_npvt_rank_0 = rocsolver_zgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function function rocsolver_zgetf2_npvt_rank_1(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zgetf2_npvt_rank_1 = rocsolver_zgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function function rocsolver_zgetf2_npvt_full_rank(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zgetf2_npvt_full_rank = rocsolver_zgetf2_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetf2_npvt_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetf2_npvt_strided_batched_assumed_rank = rocsolver_sgetf2_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_sgetf2_npvt_strided_batched_rank_0(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetf2_npvt_strided_batched_rank_0 = rocsolver_sgetf2_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_sgetf2_npvt_strided_batched_rank_1(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetf2_npvt_strided_batched_rank_1 = rocsolver_sgetf2_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_sgetf2_npvt_strided_batched_full_rank(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_npvt_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetf2_npvt_strided_batched_full_rank = rocsolver_sgetf2_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetf2_npvt_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetf2_npvt_strided_batched_assumed_rank = rocsolver_dgetf2_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_dgetf2_npvt_strided_batched_rank_0(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetf2_npvt_strided_batched_rank_0 = rocsolver_dgetf2_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_dgetf2_npvt_strided_batched_rank_1(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetf2_npvt_strided_batched_rank_1 = rocsolver_dgetf2_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_dgetf2_npvt_strided_batched_full_rank(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_npvt_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetf2_npvt_strided_batched_full_rank = rocsolver_dgetf2_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetf2_npvt_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetf2_npvt_strided_batched_assumed_rank = rocsolver_cgetf2_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_cgetf2_npvt_strided_batched_rank_0(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetf2_npvt_strided_batched_rank_0 = rocsolver_cgetf2_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_cgetf2_npvt_strided_batched_rank_1(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetf2_npvt_strided_batched_rank_1 = rocsolver_cgetf2_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_cgetf2_npvt_strided_batched_full_rank(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_npvt_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetf2_npvt_strided_batched_full_rank = rocsolver_cgetf2_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetf2_npvt_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetf2_npvt_strided_batched_assumed_rank = rocsolver_zgetf2_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_zgetf2_npvt_strided_batched_rank_0(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetf2_npvt_strided_batched_rank_0 = rocsolver_zgetf2_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_zgetf2_npvt_strided_batched_rank_1(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetf2_npvt_strided_batched_rank_1 = rocsolver_zgetf2_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_zgetf2_npvt_strided_batched_full_rank(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_npvt_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetf2_npvt_strided_batched_full_rank = rocsolver_zgetf2_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetrf_npvt_assumed_rank(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_sgetrf_npvt_assumed_rank = rocsolver_sgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function #else function rocsolver_sgetrf_npvt_rank_0(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_sgetrf_npvt_rank_0 = rocsolver_sgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function function rocsolver_sgetrf_npvt_rank_1(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_sgetrf_npvt_rank_1 = rocsolver_sgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function function rocsolver_sgetrf_npvt_full_rank(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_sgetrf_npvt_full_rank = rocsolver_sgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetrf_npvt_assumed_rank(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dgetrf_npvt_assumed_rank = rocsolver_dgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function #else function rocsolver_dgetrf_npvt_rank_0(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dgetrf_npvt_rank_0 = rocsolver_dgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function function rocsolver_dgetrf_npvt_rank_1(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dgetrf_npvt_rank_1 = rocsolver_dgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function function rocsolver_dgetrf_npvt_full_rank(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dgetrf_npvt_full_rank = rocsolver_dgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetrf_npvt_assumed_rank(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cgetrf_npvt_assumed_rank = rocsolver_cgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function #else function rocsolver_cgetrf_npvt_rank_0(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cgetrf_npvt_rank_0 = rocsolver_cgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function function rocsolver_cgetrf_npvt_rank_1(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cgetrf_npvt_rank_1 = rocsolver_cgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function function rocsolver_cgetrf_npvt_full_rank(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cgetrf_npvt_full_rank = rocsolver_cgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetrf_npvt_assumed_rank(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zgetrf_npvt_assumed_rank = rocsolver_zgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function #else function rocsolver_zgetrf_npvt_rank_0(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zgetrf_npvt_rank_0 = rocsolver_zgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function function rocsolver_zgetrf_npvt_rank_1(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zgetrf_npvt_rank_1 = rocsolver_zgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function function rocsolver_zgetrf_npvt_full_rank(handle,m,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zgetrf_npvt_full_rank = rocsolver_zgetrf_npvt_(handle,m,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetrf_npvt_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetrf_npvt_strided_batched_assumed_rank = rocsolver_sgetrf_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_sgetrf_npvt_strided_batched_rank_0(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetrf_npvt_strided_batched_rank_0 = rocsolver_sgetrf_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_sgetrf_npvt_strided_batched_rank_1(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetrf_npvt_strided_batched_rank_1 = rocsolver_sgetrf_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_sgetrf_npvt_strided_batched_full_rank(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_npvt_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetrf_npvt_strided_batched_full_rank = rocsolver_sgetrf_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetrf_npvt_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetrf_npvt_strided_batched_assumed_rank = rocsolver_dgetrf_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_dgetrf_npvt_strided_batched_rank_0(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetrf_npvt_strided_batched_rank_0 = rocsolver_dgetrf_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_dgetrf_npvt_strided_batched_rank_1(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetrf_npvt_strided_batched_rank_1 = rocsolver_dgetrf_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_dgetrf_npvt_strided_batched_full_rank(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_npvt_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetrf_npvt_strided_batched_full_rank = rocsolver_dgetrf_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetrf_npvt_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetrf_npvt_strided_batched_assumed_rank = rocsolver_cgetrf_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_cgetrf_npvt_strided_batched_rank_0(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetrf_npvt_strided_batched_rank_0 = rocsolver_cgetrf_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_cgetrf_npvt_strided_batched_rank_1(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetrf_npvt_strided_batched_rank_1 = rocsolver_cgetrf_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_cgetrf_npvt_strided_batched_full_rank(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_npvt_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetrf_npvt_strided_batched_full_rank = rocsolver_cgetrf_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetrf_npvt_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetrf_npvt_strided_batched_assumed_rank = rocsolver_zgetrf_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_zgetrf_npvt_strided_batched_rank_0(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetrf_npvt_strided_batched_rank_0 = rocsolver_zgetrf_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_zgetrf_npvt_strided_batched_rank_1(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetrf_npvt_strided_batched_rank_1 = rocsolver_zgetrf_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_zgetrf_npvt_strided_batched_full_rank(handle,m,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_npvt_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetrf_npvt_strided_batched_full_rank = rocsolver_zgetrf_npvt_strided_batched_( & handle,m,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetf2_assumed_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_sgetf2_assumed_rank = rocsolver_sgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function rocsolver_sgetf2_rank_0(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_sgetf2_rank_0 = rocsolver_sgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_sgetf2_rank_1(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_sgetf2_rank_1 = rocsolver_sgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_sgetf2_full_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_sgetf2_full_rank = rocsolver_sgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetf2_assumed_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_dgetf2_assumed_rank = rocsolver_dgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function rocsolver_dgetf2_rank_0(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_dgetf2_rank_0 = rocsolver_dgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_dgetf2_rank_1(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_dgetf2_rank_1 = rocsolver_dgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_dgetf2_full_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_dgetf2_full_rank = rocsolver_dgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetf2_assumed_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_cgetf2_assumed_rank = rocsolver_cgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function rocsolver_cgetf2_rank_0(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_cgetf2_rank_0 = rocsolver_cgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_cgetf2_rank_1(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_cgetf2_rank_1 = rocsolver_cgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_cgetf2_full_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_cgetf2_full_rank = rocsolver_cgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetf2_assumed_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_zgetf2_assumed_rank = rocsolver_zgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function rocsolver_zgetf2_rank_0(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_zgetf2_rank_0 = rocsolver_zgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_zgetf2_rank_1(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_zgetf2_rank_1 = rocsolver_zgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_zgetf2_full_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_zgetf2_full_rank = rocsolver_zgetf2_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetf2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetf2_batched_assumed_rank = rocsolver_sgetf2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_sgetf2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetf2_batched_rank_0 = rocsolver_sgetf2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_sgetf2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetf2_batched_rank_1 = rocsolver_sgetf2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetf2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetf2_batched_assumed_rank = rocsolver_dgetf2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_dgetf2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetf2_batched_rank_0 = rocsolver_dgetf2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_dgetf2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetf2_batched_rank_1 = rocsolver_dgetf2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetf2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetf2_batched_assumed_rank = rocsolver_cgetf2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_cgetf2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetf2_batched_rank_0 = rocsolver_cgetf2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_cgetf2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetf2_batched_rank_1 = rocsolver_cgetf2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetf2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetf2_batched_assumed_rank = rocsolver_zgetf2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_zgetf2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetf2_batched_rank_0 = rocsolver_zgetf2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_zgetf2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetf2_batched_rank_1 = rocsolver_zgetf2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetf2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetf2_strided_batched_assumed_rank = rocsolver_sgetf2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_sgetf2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetf2_strided_batched_rank_0 = rocsolver_sgetf2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_sgetf2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetf2_strided_batched_rank_1 = rocsolver_sgetf2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_sgetf2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetf2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetf2_strided_batched_full_rank = rocsolver_sgetf2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetf2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetf2_strided_batched_assumed_rank = rocsolver_dgetf2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_dgetf2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetf2_strided_batched_rank_0 = rocsolver_dgetf2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_dgetf2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetf2_strided_batched_rank_1 = rocsolver_dgetf2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_dgetf2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetf2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetf2_strided_batched_full_rank = rocsolver_dgetf2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetf2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetf2_strided_batched_assumed_rank = rocsolver_cgetf2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_cgetf2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetf2_strided_batched_rank_0 = rocsolver_cgetf2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_cgetf2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetf2_strided_batched_rank_1 = rocsolver_cgetf2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_cgetf2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetf2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetf2_strided_batched_full_rank = rocsolver_cgetf2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetf2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetf2_strided_batched_assumed_rank = rocsolver_zgetf2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_zgetf2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetf2_strided_batched_rank_0 = rocsolver_zgetf2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_zgetf2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetf2_strided_batched_rank_1 = rocsolver_zgetf2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_zgetf2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetf2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetf2_strided_batched_full_rank = rocsolver_zgetf2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetrf_assumed_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_sgetrf_assumed_rank = rocsolver_sgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function rocsolver_sgetrf_rank_0(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_sgetrf_rank_0 = rocsolver_sgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_sgetrf_rank_1(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_sgetrf_rank_1 = rocsolver_sgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_sgetrf_full_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_sgetrf_full_rank = rocsolver_sgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetrf_assumed_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_dgetrf_assumed_rank = rocsolver_dgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function rocsolver_dgetrf_rank_0(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_dgetrf_rank_0 = rocsolver_dgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_dgetrf_rank_1(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_dgetrf_rank_1 = rocsolver_dgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_dgetrf_full_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_dgetrf_full_rank = rocsolver_dgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetrf_assumed_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_cgetrf_assumed_rank = rocsolver_cgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function rocsolver_cgetrf_rank_0(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_cgetrf_rank_0 = rocsolver_cgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_cgetrf_rank_1(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_cgetrf_rank_1 = rocsolver_cgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_cgetrf_full_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_cgetrf_full_rank = rocsolver_cgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetrf_assumed_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_zgetrf_assumed_rank = rocsolver_zgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function rocsolver_zgetrf_rank_0(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_zgetrf_rank_0 = rocsolver_zgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_zgetrf_rank_1(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_zgetrf_rank_1 = rocsolver_zgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_zgetrf_full_rank(handle,m,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_zgetrf_full_rank = rocsolver_zgetrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetrf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetrf_batched_assumed_rank = rocsolver_sgetrf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_sgetrf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetrf_batched_rank_0 = rocsolver_sgetrf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_sgetrf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetrf_batched_rank_1 = rocsolver_sgetrf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetrf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetrf_batched_assumed_rank = rocsolver_dgetrf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_dgetrf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetrf_batched_rank_0 = rocsolver_dgetrf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_dgetrf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetrf_batched_rank_1 = rocsolver_dgetrf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetrf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetrf_batched_assumed_rank = rocsolver_cgetrf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_cgetrf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetrf_batched_rank_0 = rocsolver_cgetrf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_cgetrf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetrf_batched_rank_1 = rocsolver_cgetrf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetrf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetrf_batched_assumed_rank = rocsolver_zgetrf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_zgetrf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetrf_batched_rank_0 = rocsolver_zgetrf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_zgetrf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetrf_batched_rank_1 = rocsolver_zgetrf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetrf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetrf_strided_batched_assumed_rank = rocsolver_sgetrf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_sgetrf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetrf_strided_batched_rank_0 = rocsolver_sgetrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_sgetrf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetrf_strided_batched_rank_1 = rocsolver_sgetrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_sgetrf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetrf_strided_batched_full_rank = rocsolver_sgetrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetrf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetrf_strided_batched_assumed_rank = rocsolver_dgetrf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_dgetrf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetrf_strided_batched_rank_0 = rocsolver_dgetrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_dgetrf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetrf_strided_batched_rank_1 = rocsolver_dgetrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_dgetrf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetrf_strided_batched_full_rank = rocsolver_dgetrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetrf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetrf_strided_batched_assumed_rank = rocsolver_cgetrf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_cgetrf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetrf_strided_batched_rank_0 = rocsolver_cgetrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_cgetrf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetrf_strided_batched_rank_1 = rocsolver_cgetrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_cgetrf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetrf_strided_batched_full_rank = rocsolver_cgetrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetrf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetrf_strided_batched_assumed_rank = rocsolver_zgetrf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_zgetrf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetrf_strided_batched_rank_0 = rocsolver_zgetrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_zgetrf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetrf_strided_batched_rank_1 = rocsolver_zgetrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_zgetrf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetrf_strided_batched_full_rank = rocsolver_zgetrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgeqr2_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv ! rocsolver_sgeqr2_assumed_rank = rocsolver_sgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_sgeqr2_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv ! rocsolver_sgeqr2_rank_0 = rocsolver_sgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sgeqr2_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sgeqr2_rank_1 = rocsolver_sgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sgeqr2_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sgeqr2_full_rank = rocsolver_sgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgeqr2_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv ! rocsolver_dgeqr2_assumed_rank = rocsolver_dgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_dgeqr2_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv ! rocsolver_dgeqr2_rank_0 = rocsolver_dgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dgeqr2_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dgeqr2_rank_1 = rocsolver_dgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dgeqr2_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dgeqr2_full_rank = rocsolver_dgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgeqr2_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_cgeqr2_assumed_rank = rocsolver_cgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_cgeqr2_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv ! rocsolver_cgeqr2_rank_0 = rocsolver_cgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cgeqr2_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cgeqr2_rank_1 = rocsolver_cgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cgeqr2_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cgeqr2_full_rank = rocsolver_cgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgeqr2_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_zgeqr2_assumed_rank = rocsolver_zgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_zgeqr2_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv ! rocsolver_zgeqr2_rank_0 = rocsolver_zgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zgeqr2_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zgeqr2_rank_1 = rocsolver_zgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zgeqr2_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zgeqr2_full_rank = rocsolver_zgeqr2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgeqr2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqr2_batched_assumed_rank = rocsolver_sgeqr2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_sgeqr2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqr2_batched_rank_0 = rocsolver_sgeqr2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_sgeqr2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqr2_batched_rank_1 = rocsolver_sgeqr2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgeqr2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqr2_batched_assumed_rank = rocsolver_dgeqr2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_dgeqr2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqr2_batched_rank_0 = rocsolver_dgeqr2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_dgeqr2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqr2_batched_rank_1 = rocsolver_dgeqr2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgeqr2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqr2_batched_assumed_rank = rocsolver_cgeqr2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_cgeqr2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqr2_batched_rank_0 = rocsolver_cgeqr2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_cgeqr2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqr2_batched_rank_1 = rocsolver_cgeqr2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgeqr2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqr2_batched_assumed_rank = rocsolver_zgeqr2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_zgeqr2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqr2_batched_rank_0 = rocsolver_zgeqr2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_zgeqr2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqr2_batched_rank_1 = rocsolver_zgeqr2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgeqr2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqr2_strided_batched_assumed_rank = rocsolver_sgeqr2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_sgeqr2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqr2_strided_batched_rank_0 = rocsolver_sgeqr2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_sgeqr2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqr2_strided_batched_rank_1 = rocsolver_sgeqr2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_sgeqr2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqr2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqr2_strided_batched_full_rank = rocsolver_sgeqr2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgeqr2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqr2_strided_batched_assumed_rank = rocsolver_dgeqr2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_dgeqr2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqr2_strided_batched_rank_0 = rocsolver_dgeqr2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_dgeqr2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqr2_strided_batched_rank_1 = rocsolver_dgeqr2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_dgeqr2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqr2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqr2_strided_batched_full_rank = rocsolver_dgeqr2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgeqr2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqr2_strided_batched_assumed_rank = rocsolver_cgeqr2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_cgeqr2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqr2_strided_batched_rank_0 = rocsolver_cgeqr2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_cgeqr2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqr2_strided_batched_rank_1 = rocsolver_cgeqr2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_cgeqr2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqr2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqr2_strided_batched_full_rank = rocsolver_cgeqr2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgeqr2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqr2_strided_batched_assumed_rank = rocsolver_zgeqr2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_zgeqr2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqr2_strided_batched_rank_0 = rocsolver_zgeqr2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_zgeqr2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqr2_strided_batched_rank_1 = rocsolver_zgeqr2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_zgeqr2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqr2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqr2_strided_batched_full_rank = rocsolver_zgeqr2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgerq2_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv ! rocsolver_sgerq2_assumed_rank = rocsolver_sgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_sgerq2_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv ! rocsolver_sgerq2_rank_0 = rocsolver_sgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sgerq2_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sgerq2_rank_1 = rocsolver_sgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sgerq2_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sgerq2_full_rank = rocsolver_sgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgerq2_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv ! rocsolver_dgerq2_assumed_rank = rocsolver_dgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_dgerq2_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv ! rocsolver_dgerq2_rank_0 = rocsolver_dgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dgerq2_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dgerq2_rank_1 = rocsolver_dgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dgerq2_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dgerq2_full_rank = rocsolver_dgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgerq2_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_cgerq2_assumed_rank = rocsolver_cgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_cgerq2_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv ! rocsolver_cgerq2_rank_0 = rocsolver_cgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cgerq2_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cgerq2_rank_1 = rocsolver_cgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cgerq2_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cgerq2_full_rank = rocsolver_cgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgerq2_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_zgerq2_assumed_rank = rocsolver_zgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_zgerq2_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv ! rocsolver_zgerq2_rank_0 = rocsolver_zgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zgerq2_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zgerq2_rank_1 = rocsolver_zgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zgerq2_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zgerq2_full_rank = rocsolver_zgerq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgerq2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgerq2_batched_assumed_rank = rocsolver_sgerq2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_sgerq2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgerq2_batched_rank_0 = rocsolver_sgerq2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_sgerq2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgerq2_batched_rank_1 = rocsolver_sgerq2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgerq2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgerq2_batched_assumed_rank = rocsolver_dgerq2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_dgerq2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgerq2_batched_rank_0 = rocsolver_dgerq2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_dgerq2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgerq2_batched_rank_1 = rocsolver_dgerq2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgerq2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgerq2_batched_assumed_rank = rocsolver_cgerq2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_cgerq2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgerq2_batched_rank_0 = rocsolver_cgerq2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_cgerq2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgerq2_batched_rank_1 = rocsolver_cgerq2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgerq2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgerq2_batched_assumed_rank = rocsolver_zgerq2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_zgerq2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgerq2_batched_rank_0 = rocsolver_zgerq2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_zgerq2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgerq2_batched_rank_1 = rocsolver_zgerq2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgerq2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgerq2_strided_batched_assumed_rank = rocsolver_sgerq2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_sgerq2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgerq2_strided_batched_rank_0 = rocsolver_sgerq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_sgerq2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgerq2_strided_batched_rank_1 = rocsolver_sgerq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_sgerq2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerq2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgerq2_strided_batched_full_rank = rocsolver_sgerq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgerq2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgerq2_strided_batched_assumed_rank = rocsolver_dgerq2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_dgerq2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgerq2_strided_batched_rank_0 = rocsolver_dgerq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_dgerq2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgerq2_strided_batched_rank_1 = rocsolver_dgerq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_dgerq2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerq2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgerq2_strided_batched_full_rank = rocsolver_dgerq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgerq2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgerq2_strided_batched_assumed_rank = rocsolver_cgerq2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_cgerq2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgerq2_strided_batched_rank_0 = rocsolver_cgerq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_cgerq2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgerq2_strided_batched_rank_1 = rocsolver_cgerq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_cgerq2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerq2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgerq2_strided_batched_full_rank = rocsolver_cgerq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgerq2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgerq2_strided_batched_assumed_rank = rocsolver_zgerq2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_zgerq2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgerq2_strided_batched_rank_0 = rocsolver_zgerq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_zgerq2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgerq2_strided_batched_rank_1 = rocsolver_zgerq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_zgerq2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerq2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgerq2_strided_batched_full_rank = rocsolver_zgerq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgeql2_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv ! rocsolver_sgeql2_assumed_rank = rocsolver_sgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_sgeql2_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv ! rocsolver_sgeql2_rank_0 = rocsolver_sgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sgeql2_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sgeql2_rank_1 = rocsolver_sgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sgeql2_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sgeql2_full_rank = rocsolver_sgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgeql2_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv ! rocsolver_dgeql2_assumed_rank = rocsolver_dgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_dgeql2_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv ! rocsolver_dgeql2_rank_0 = rocsolver_dgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dgeql2_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dgeql2_rank_1 = rocsolver_dgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dgeql2_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dgeql2_full_rank = rocsolver_dgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgeql2_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_cgeql2_assumed_rank = rocsolver_cgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_cgeql2_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv ! rocsolver_cgeql2_rank_0 = rocsolver_cgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cgeql2_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cgeql2_rank_1 = rocsolver_cgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cgeql2_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cgeql2_full_rank = rocsolver_cgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgeql2_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_zgeql2_assumed_rank = rocsolver_zgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_zgeql2_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv ! rocsolver_zgeql2_rank_0 = rocsolver_zgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zgeql2_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zgeql2_rank_1 = rocsolver_zgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zgeql2_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zgeql2_full_rank = rocsolver_zgeql2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgeql2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeql2_batched_assumed_rank = rocsolver_sgeql2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_sgeql2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeql2_batched_rank_0 = rocsolver_sgeql2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_sgeql2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeql2_batched_rank_1 = rocsolver_sgeql2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgeql2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeql2_batched_assumed_rank = rocsolver_dgeql2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_dgeql2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeql2_batched_rank_0 = rocsolver_dgeql2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_dgeql2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeql2_batched_rank_1 = rocsolver_dgeql2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgeql2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeql2_batched_assumed_rank = rocsolver_cgeql2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_cgeql2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeql2_batched_rank_0 = rocsolver_cgeql2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_cgeql2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeql2_batched_rank_1 = rocsolver_cgeql2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgeql2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeql2_batched_assumed_rank = rocsolver_zgeql2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_zgeql2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeql2_batched_rank_0 = rocsolver_zgeql2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_zgeql2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeql2_batched_rank_1 = rocsolver_zgeql2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgeql2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeql2_strided_batched_assumed_rank = rocsolver_sgeql2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_sgeql2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeql2_strided_batched_rank_0 = rocsolver_sgeql2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_sgeql2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeql2_strided_batched_rank_1 = rocsolver_sgeql2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_sgeql2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeql2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeql2_strided_batched_full_rank = rocsolver_sgeql2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgeql2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeql2_strided_batched_assumed_rank = rocsolver_dgeql2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_dgeql2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeql2_strided_batched_rank_0 = rocsolver_dgeql2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_dgeql2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeql2_strided_batched_rank_1 = rocsolver_dgeql2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_dgeql2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeql2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeql2_strided_batched_full_rank = rocsolver_dgeql2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgeql2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeql2_strided_batched_assumed_rank = rocsolver_cgeql2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_cgeql2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeql2_strided_batched_rank_0 = rocsolver_cgeql2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_cgeql2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeql2_strided_batched_rank_1 = rocsolver_cgeql2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_cgeql2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeql2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeql2_strided_batched_full_rank = rocsolver_cgeql2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgeql2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeql2_strided_batched_assumed_rank = rocsolver_zgeql2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_zgeql2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeql2_strided_batched_rank_0 = rocsolver_zgeql2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_zgeql2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeql2_strided_batched_rank_1 = rocsolver_zgeql2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_zgeql2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeql2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeql2_strided_batched_full_rank = rocsolver_zgeql2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgelq2_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv ! rocsolver_sgelq2_assumed_rank = rocsolver_sgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_sgelq2_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv ! rocsolver_sgelq2_rank_0 = rocsolver_sgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sgelq2_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sgelq2_rank_1 = rocsolver_sgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sgelq2_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sgelq2_full_rank = rocsolver_sgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgelq2_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv ! rocsolver_dgelq2_assumed_rank = rocsolver_dgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_dgelq2_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv ! rocsolver_dgelq2_rank_0 = rocsolver_dgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dgelq2_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dgelq2_rank_1 = rocsolver_dgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dgelq2_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dgelq2_full_rank = rocsolver_dgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgelq2_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_cgelq2_assumed_rank = rocsolver_cgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_cgelq2_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv ! rocsolver_cgelq2_rank_0 = rocsolver_cgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cgelq2_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cgelq2_rank_1 = rocsolver_cgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cgelq2_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cgelq2_full_rank = rocsolver_cgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgelq2_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_zgelq2_assumed_rank = rocsolver_zgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_zgelq2_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv ! rocsolver_zgelq2_rank_0 = rocsolver_zgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zgelq2_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zgelq2_rank_1 = rocsolver_zgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zgelq2_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zgelq2_full_rank = rocsolver_zgelq2_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgelq2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgelq2_batched_assumed_rank = rocsolver_sgelq2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_sgelq2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgelq2_batched_rank_0 = rocsolver_sgelq2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_sgelq2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgelq2_batched_rank_1 = rocsolver_sgelq2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgelq2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgelq2_batched_assumed_rank = rocsolver_dgelq2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_dgelq2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgelq2_batched_rank_0 = rocsolver_dgelq2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_dgelq2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgelq2_batched_rank_1 = rocsolver_dgelq2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgelq2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgelq2_batched_assumed_rank = rocsolver_cgelq2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_cgelq2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgelq2_batched_rank_0 = rocsolver_cgelq2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_cgelq2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgelq2_batched_rank_1 = rocsolver_cgelq2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgelq2_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgelq2_batched_assumed_rank = rocsolver_zgelq2_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_zgelq2_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgelq2_batched_rank_0 = rocsolver_zgelq2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_zgelq2_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgelq2_batched_rank_1 = rocsolver_zgelq2_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgelq2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgelq2_strided_batched_assumed_rank = rocsolver_sgelq2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_sgelq2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgelq2_strided_batched_rank_0 = rocsolver_sgelq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_sgelq2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgelq2_strided_batched_rank_1 = rocsolver_sgelq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_sgelq2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelq2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgelq2_strided_batched_full_rank = rocsolver_sgelq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgelq2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgelq2_strided_batched_assumed_rank = rocsolver_dgelq2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_dgelq2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgelq2_strided_batched_rank_0 = rocsolver_dgelq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_dgelq2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgelq2_strided_batched_rank_1 = rocsolver_dgelq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_dgelq2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelq2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgelq2_strided_batched_full_rank = rocsolver_dgelq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgelq2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgelq2_strided_batched_assumed_rank = rocsolver_cgelq2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_cgelq2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgelq2_strided_batched_rank_0 = rocsolver_cgelq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_cgelq2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgelq2_strided_batched_rank_1 = rocsolver_cgelq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_cgelq2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelq2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgelq2_strided_batched_full_rank = rocsolver_cgelq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgelq2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgelq2_strided_batched_assumed_rank = rocsolver_zgelq2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_zgelq2_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgelq2_strided_batched_rank_0 = rocsolver_zgelq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_zgelq2_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgelq2_strided_batched_rank_1 = rocsolver_zgelq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_zgelq2_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelq2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgelq2_strided_batched_full_rank = rocsolver_zgelq2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgeqrf_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv ! rocsolver_sgeqrf_assumed_rank = rocsolver_sgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_sgeqrf_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv ! rocsolver_sgeqrf_rank_0 = rocsolver_sgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sgeqrf_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sgeqrf_rank_1 = rocsolver_sgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sgeqrf_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sgeqrf_full_rank = rocsolver_sgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgeqrf_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv ! rocsolver_dgeqrf_assumed_rank = rocsolver_dgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_dgeqrf_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv ! rocsolver_dgeqrf_rank_0 = rocsolver_dgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dgeqrf_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dgeqrf_rank_1 = rocsolver_dgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dgeqrf_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dgeqrf_full_rank = rocsolver_dgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgeqrf_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_cgeqrf_assumed_rank = rocsolver_cgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_cgeqrf_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv ! rocsolver_cgeqrf_rank_0 = rocsolver_cgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cgeqrf_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cgeqrf_rank_1 = rocsolver_cgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cgeqrf_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cgeqrf_full_rank = rocsolver_cgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgeqrf_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_zgeqrf_assumed_rank = rocsolver_zgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_zgeqrf_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv ! rocsolver_zgeqrf_rank_0 = rocsolver_zgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zgeqrf_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zgeqrf_rank_1 = rocsolver_zgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zgeqrf_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zgeqrf_full_rank = rocsolver_zgeqrf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgeqrf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqrf_batched_assumed_rank = rocsolver_sgeqrf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_sgeqrf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqrf_batched_rank_0 = rocsolver_sgeqrf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_sgeqrf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqrf_batched_rank_1 = rocsolver_sgeqrf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgeqrf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqrf_batched_assumed_rank = rocsolver_dgeqrf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_dgeqrf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqrf_batched_rank_0 = rocsolver_dgeqrf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_dgeqrf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqrf_batched_rank_1 = rocsolver_dgeqrf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgeqrf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqrf_batched_assumed_rank = rocsolver_cgeqrf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_cgeqrf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqrf_batched_rank_0 = rocsolver_cgeqrf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_cgeqrf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqrf_batched_rank_1 = rocsolver_cgeqrf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgeqrf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqrf_batched_assumed_rank = rocsolver_zgeqrf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_zgeqrf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqrf_batched_rank_0 = rocsolver_zgeqrf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_zgeqrf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqrf_batched_rank_1 = rocsolver_zgeqrf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgeqrf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqrf_strided_batched_assumed_rank = rocsolver_sgeqrf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_sgeqrf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqrf_strided_batched_rank_0 = rocsolver_sgeqrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_sgeqrf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqrf_strided_batched_rank_1 = rocsolver_sgeqrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_sgeqrf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqrf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqrf_strided_batched_full_rank = rocsolver_sgeqrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgeqrf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqrf_strided_batched_assumed_rank = rocsolver_dgeqrf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_dgeqrf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqrf_strided_batched_rank_0 = rocsolver_dgeqrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_dgeqrf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqrf_strided_batched_rank_1 = rocsolver_dgeqrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_dgeqrf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqrf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqrf_strided_batched_full_rank = rocsolver_dgeqrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgeqrf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqrf_strided_batched_assumed_rank = rocsolver_cgeqrf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_cgeqrf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqrf_strided_batched_rank_0 = rocsolver_cgeqrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_cgeqrf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqrf_strided_batched_rank_1 = rocsolver_cgeqrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_cgeqrf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqrf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqrf_strided_batched_full_rank = rocsolver_cgeqrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgeqrf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqrf_strided_batched_assumed_rank = rocsolver_zgeqrf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_zgeqrf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqrf_strided_batched_rank_0 = rocsolver_zgeqrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_zgeqrf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqrf_strided_batched_rank_1 = rocsolver_zgeqrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_zgeqrf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqrf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqrf_strided_batched_full_rank = rocsolver_zgeqrf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgerqf_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv ! rocsolver_sgerqf_assumed_rank = rocsolver_sgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_sgerqf_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv ! rocsolver_sgerqf_rank_0 = rocsolver_sgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sgerqf_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sgerqf_rank_1 = rocsolver_sgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sgerqf_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sgerqf_full_rank = rocsolver_sgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgerqf_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv ! rocsolver_dgerqf_assumed_rank = rocsolver_dgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_dgerqf_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv ! rocsolver_dgerqf_rank_0 = rocsolver_dgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dgerqf_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dgerqf_rank_1 = rocsolver_dgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dgerqf_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dgerqf_full_rank = rocsolver_dgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgerqf_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_cgerqf_assumed_rank = rocsolver_cgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_cgerqf_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv ! rocsolver_cgerqf_rank_0 = rocsolver_cgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cgerqf_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cgerqf_rank_1 = rocsolver_cgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cgerqf_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cgerqf_full_rank = rocsolver_cgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgerqf_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_zgerqf_assumed_rank = rocsolver_zgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_zgerqf_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv ! rocsolver_zgerqf_rank_0 = rocsolver_zgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zgerqf_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zgerqf_rank_1 = rocsolver_zgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zgerqf_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zgerqf_full_rank = rocsolver_zgerqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgerqf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgerqf_batched_assumed_rank = rocsolver_sgerqf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_sgerqf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgerqf_batched_rank_0 = rocsolver_sgerqf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_sgerqf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgerqf_batched_rank_1 = rocsolver_sgerqf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgerqf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgerqf_batched_assumed_rank = rocsolver_dgerqf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_dgerqf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgerqf_batched_rank_0 = rocsolver_dgerqf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_dgerqf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgerqf_batched_rank_1 = rocsolver_dgerqf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgerqf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgerqf_batched_assumed_rank = rocsolver_cgerqf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_cgerqf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgerqf_batched_rank_0 = rocsolver_cgerqf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_cgerqf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgerqf_batched_rank_1 = rocsolver_cgerqf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgerqf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgerqf_batched_assumed_rank = rocsolver_zgerqf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_zgerqf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgerqf_batched_rank_0 = rocsolver_zgerqf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_zgerqf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgerqf_batched_rank_1 = rocsolver_zgerqf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgerqf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgerqf_strided_batched_assumed_rank = rocsolver_sgerqf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_sgerqf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgerqf_strided_batched_rank_0 = rocsolver_sgerqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_sgerqf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgerqf_strided_batched_rank_1 = rocsolver_sgerqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_sgerqf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgerqf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgerqf_strided_batched_full_rank = rocsolver_sgerqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgerqf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgerqf_strided_batched_assumed_rank = rocsolver_dgerqf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_dgerqf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgerqf_strided_batched_rank_0 = rocsolver_dgerqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_dgerqf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgerqf_strided_batched_rank_1 = rocsolver_dgerqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_dgerqf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgerqf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgerqf_strided_batched_full_rank = rocsolver_dgerqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgerqf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgerqf_strided_batched_assumed_rank = rocsolver_cgerqf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_cgerqf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgerqf_strided_batched_rank_0 = rocsolver_cgerqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_cgerqf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgerqf_strided_batched_rank_1 = rocsolver_cgerqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_cgerqf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgerqf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgerqf_strided_batched_full_rank = rocsolver_cgerqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgerqf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgerqf_strided_batched_assumed_rank = rocsolver_zgerqf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_zgerqf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgerqf_strided_batched_rank_0 = rocsolver_zgerqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_zgerqf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgerqf_strided_batched_rank_1 = rocsolver_zgerqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_zgerqf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgerqf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgerqf_strided_batched_full_rank = rocsolver_zgerqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgeqlf_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv ! rocsolver_sgeqlf_assumed_rank = rocsolver_sgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_sgeqlf_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv ! rocsolver_sgeqlf_rank_0 = rocsolver_sgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sgeqlf_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sgeqlf_rank_1 = rocsolver_sgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sgeqlf_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sgeqlf_full_rank = rocsolver_sgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgeqlf_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv ! rocsolver_dgeqlf_assumed_rank = rocsolver_dgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_dgeqlf_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv ! rocsolver_dgeqlf_rank_0 = rocsolver_dgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dgeqlf_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dgeqlf_rank_1 = rocsolver_dgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dgeqlf_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dgeqlf_full_rank = rocsolver_dgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgeqlf_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_cgeqlf_assumed_rank = rocsolver_cgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_cgeqlf_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv ! rocsolver_cgeqlf_rank_0 = rocsolver_cgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cgeqlf_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cgeqlf_rank_1 = rocsolver_cgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cgeqlf_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cgeqlf_full_rank = rocsolver_cgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgeqlf_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_zgeqlf_assumed_rank = rocsolver_zgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_zgeqlf_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv ! rocsolver_zgeqlf_rank_0 = rocsolver_zgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zgeqlf_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zgeqlf_rank_1 = rocsolver_zgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zgeqlf_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zgeqlf_full_rank = rocsolver_zgeqlf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgeqlf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqlf_batched_assumed_rank = rocsolver_sgeqlf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_sgeqlf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqlf_batched_rank_0 = rocsolver_sgeqlf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_sgeqlf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqlf_batched_rank_1 = rocsolver_sgeqlf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgeqlf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqlf_batched_assumed_rank = rocsolver_dgeqlf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_dgeqlf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqlf_batched_rank_0 = rocsolver_dgeqlf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_dgeqlf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqlf_batched_rank_1 = rocsolver_dgeqlf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgeqlf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqlf_batched_assumed_rank = rocsolver_cgeqlf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_cgeqlf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqlf_batched_rank_0 = rocsolver_cgeqlf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_cgeqlf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqlf_batched_rank_1 = rocsolver_cgeqlf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgeqlf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqlf_batched_assumed_rank = rocsolver_zgeqlf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_zgeqlf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqlf_batched_rank_0 = rocsolver_zgeqlf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_zgeqlf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqlf_batched_rank_1 = rocsolver_zgeqlf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgeqlf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqlf_strided_batched_assumed_rank = rocsolver_sgeqlf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_sgeqlf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqlf_strided_batched_rank_0 = rocsolver_sgeqlf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_sgeqlf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqlf_strided_batched_rank_1 = rocsolver_sgeqlf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_sgeqlf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgeqlf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgeqlf_strided_batched_full_rank = rocsolver_sgeqlf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgeqlf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqlf_strided_batched_assumed_rank = rocsolver_dgeqlf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_dgeqlf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqlf_strided_batched_rank_0 = rocsolver_dgeqlf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_dgeqlf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqlf_strided_batched_rank_1 = rocsolver_dgeqlf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_dgeqlf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgeqlf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgeqlf_strided_batched_full_rank = rocsolver_dgeqlf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgeqlf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqlf_strided_batched_assumed_rank = rocsolver_cgeqlf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_cgeqlf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqlf_strided_batched_rank_0 = rocsolver_cgeqlf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_cgeqlf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqlf_strided_batched_rank_1 = rocsolver_cgeqlf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_cgeqlf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgeqlf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgeqlf_strided_batched_full_rank = rocsolver_cgeqlf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgeqlf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqlf_strided_batched_assumed_rank = rocsolver_zgeqlf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_zgeqlf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqlf_strided_batched_rank_0 = rocsolver_zgeqlf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_zgeqlf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqlf_strided_batched_rank_1 = rocsolver_zgeqlf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_zgeqlf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgeqlf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgeqlf_strided_batched_full_rank = rocsolver_zgeqlf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgelqf_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv ! rocsolver_sgelqf_assumed_rank = rocsolver_sgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_sgelqf_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: ipiv ! rocsolver_sgelqf_rank_0 = rocsolver_sgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sgelqf_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sgelqf_rank_1 = rocsolver_sgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_sgelqf_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv ! rocsolver_sgelqf_full_rank = rocsolver_sgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgelqf_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv ! rocsolver_dgelqf_assumed_rank = rocsolver_dgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_dgelqf_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: ipiv ! rocsolver_dgelqf_rank_0 = rocsolver_dgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dgelqf_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dgelqf_rank_1 = rocsolver_dgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_dgelqf_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv ! rocsolver_dgelqf_full_rank = rocsolver_dgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgelqf_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_cgelqf_assumed_rank = rocsolver_cgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_cgelqf_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv ! rocsolver_cgelqf_rank_0 = rocsolver_cgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cgelqf_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cgelqf_rank_1 = rocsolver_cgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_cgelqf_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv ! rocsolver_cgelqf_full_rank = rocsolver_cgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgelqf_assumed_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv ! rocsolver_zgelqf_assumed_rank = rocsolver_zgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #else function rocsolver_zgelqf_rank_0(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv ! rocsolver_zgelqf_rank_0 = rocsolver_zgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zgelqf_rank_1(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zgelqf_rank_1 = rocsolver_zgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function function rocsolver_zgelqf_full_rank(handle,m,n,A,lda,ipiv) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv ! rocsolver_zgelqf_full_rank = rocsolver_zgelqf_(handle,m,n,c_loc(A),lda,c_loc(ipiv)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgelqf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgelqf_batched_assumed_rank = rocsolver_sgelqf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_sgelqf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgelqf_batched_rank_0 = rocsolver_sgelqf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_sgelqf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgelqf_batched_rank_1 = rocsolver_sgelqf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgelqf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgelqf_batched_assumed_rank = rocsolver_dgelqf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_dgelqf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgelqf_batched_rank_0 = rocsolver_dgelqf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_dgelqf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgelqf_batched_rank_1 = rocsolver_dgelqf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgelqf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgelqf_batched_assumed_rank = rocsolver_cgelqf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_cgelqf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgelqf_batched_rank_0 = rocsolver_cgelqf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_cgelqf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgelqf_batched_rank_1 = rocsolver_cgelqf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgelqf_batched_assumed_rank(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgelqf_batched_assumed_rank = rocsolver_zgelqf_batched_(handle,m,n,A,lda, & c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_zgelqf_batched_rank_0(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgelqf_batched_rank_0 = rocsolver_zgelqf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function function rocsolver_zgelqf_batched_rank_1(handle,m,n,A,lda,ipiv,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgelqf_batched_rank_1 = rocsolver_zgelqf_batched_(handle,m,n,A,lda,c_loc(ipiv), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgelqf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgelqf_strided_batched_assumed_rank = rocsolver_sgelqf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_sgelqf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgelqf_strided_batched_rank_0 = rocsolver_sgelqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_sgelqf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgelqf_strided_batched_rank_1 = rocsolver_sgelqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_sgelqf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgelqf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgelqf_strided_batched_full_rank = rocsolver_sgelqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgelqf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgelqf_strided_batched_assumed_rank = rocsolver_dgelqf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_dgelqf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgelqf_strided_batched_rank_0 = rocsolver_dgelqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_dgelqf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgelqf_strided_batched_rank_1 = rocsolver_dgelqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_dgelqf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgelqf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgelqf_strided_batched_full_rank = rocsolver_dgelqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgelqf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgelqf_strided_batched_assumed_rank = rocsolver_cgelqf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_cgelqf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgelqf_strided_batched_rank_0 = rocsolver_cgelqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_cgelqf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgelqf_strided_batched_rank_1 = rocsolver_cgelqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_cgelqf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgelqf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgelqf_strided_batched_full_rank = rocsolver_cgelqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgelqf_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgelqf_strided_batched_assumed_rank = rocsolver_zgelqf_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #else function rocsolver_zgelqf_strided_batched_rank_0(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgelqf_strided_batched_rank_0 = rocsolver_zgelqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_zgelqf_strided_batched_rank_1(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgelqf_strided_batched_rank_1 = rocsolver_zgelqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function function rocsolver_zgelqf_strided_batched_full_rank(handle,m,n,A,lda,strideA,ipiv,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgelqf_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgelqf_strided_batched_full_rank = rocsolver_zgelqf_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgebd2_assumed_rank(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E real(c_float),target,contiguous,dimension(..) :: tauq real(c_float),target,contiguous,dimension(..) :: taup ! rocsolver_sgebd2_assumed_rank = rocsolver_sgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function #else function rocsolver_sgebd2_rank_0(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E real(c_float),target :: tauq real(c_float),target :: taup ! rocsolver_sgebd2_rank_0 = rocsolver_sgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function function rocsolver_sgebd2_rank_1(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:) :: tauq real(c_float),target,dimension(:) :: taup ! rocsolver_sgebd2_rank_1 = rocsolver_sgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function function rocsolver_sgebd2_full_rank(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:) :: tauq real(c_float),target,dimension(:) :: taup ! rocsolver_sgebd2_full_rank = rocsolver_sgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgebd2_assumed_rank(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E real(c_double),target,contiguous,dimension(..) :: tauq real(c_double),target,contiguous,dimension(..) :: taup ! rocsolver_dgebd2_assumed_rank = rocsolver_dgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function #else function rocsolver_dgebd2_rank_0(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E real(c_double),target :: tauq real(c_double),target :: taup ! rocsolver_dgebd2_rank_0 = rocsolver_dgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function function rocsolver_dgebd2_rank_1(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:) :: tauq real(c_double),target,dimension(:) :: taup ! rocsolver_dgebd2_rank_1 = rocsolver_dgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function function rocsolver_dgebd2_full_rank(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:) :: tauq real(c_double),target,dimension(:) :: taup ! rocsolver_dgebd2_full_rank = rocsolver_dgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgebd2_assumed_rank(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E complex(c_float_complex),target,contiguous,dimension(..) :: tauq complex(c_float_complex),target,contiguous,dimension(..) :: taup ! rocsolver_cgebd2_assumed_rank = rocsolver_cgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function #else function rocsolver_cgebd2_rank_0(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E complex(c_float_complex),target :: tauq complex(c_float_complex),target :: taup ! rocsolver_cgebd2_rank_0 = rocsolver_cgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function function rocsolver_cgebd2_rank_1(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:) :: tauq complex(c_float_complex),target,dimension(:) :: taup ! rocsolver_cgebd2_rank_1 = rocsolver_cgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function function rocsolver_cgebd2_full_rank(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:) :: tauq complex(c_float_complex),target,dimension(:) :: taup ! rocsolver_cgebd2_full_rank = rocsolver_cgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgebd2_assumed_rank(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E complex(c_double_complex),target,contiguous,dimension(..) :: tauq complex(c_double_complex),target,contiguous,dimension(..) :: taup ! rocsolver_zgebd2_assumed_rank = rocsolver_zgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function #else function rocsolver_zgebd2_rank_0(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E complex(c_double_complex),target :: tauq complex(c_double_complex),target :: taup ! rocsolver_zgebd2_rank_0 = rocsolver_zgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function function rocsolver_zgebd2_rank_1(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:) :: tauq complex(c_double_complex),target,dimension(:) :: taup ! rocsolver_zgebd2_rank_1 = rocsolver_zgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function function rocsolver_zgebd2_full_rank(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:) :: tauq complex(c_double_complex),target,dimension(:) :: taup ! rocsolver_zgebd2_full_rank = rocsolver_zgebd2_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgebd2_batched_assumed_rank(handle,m,n,A,lda,D,strideD,E,strideE,tauq, & strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE real(c_float),target,contiguous,dimension(..) :: tauq integer(c_int64_t) :: strideQ real(c_float),target,contiguous,dimension(..) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgebd2_batched_assumed_rank = rocsolver_sgebd2_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function #else function rocsolver_sgebd2_batched_rank_0(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ, & taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE real(c_float),target :: tauq integer(c_int64_t) :: strideQ real(c_float),target :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgebd2_batched_rank_0 = rocsolver_sgebd2_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function function rocsolver_sgebd2_batched_rank_1(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ, & taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_float),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ real(c_float),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgebd2_batched_rank_1 = rocsolver_sgebd2_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgebd2_batched_assumed_rank(handle,m,n,A,lda,D,strideD,E,strideE,tauq, & strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE real(c_double),target,contiguous,dimension(..) :: tauq integer(c_int64_t) :: strideQ real(c_double),target,contiguous,dimension(..) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgebd2_batched_assumed_rank = rocsolver_dgebd2_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function #else function rocsolver_dgebd2_batched_rank_0(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ, & taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE real(c_double),target :: tauq integer(c_int64_t) :: strideQ real(c_double),target :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgebd2_batched_rank_0 = rocsolver_dgebd2_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function function rocsolver_dgebd2_batched_rank_1(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ, & taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_double),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ real(c_double),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgebd2_batched_rank_1 = rocsolver_dgebd2_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgebd2_batched_assumed_rank(handle,m,n,A,lda,D,strideD,E,strideE,tauq, & strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,contiguous,dimension(..) :: tauq integer(c_int64_t) :: strideQ complex(c_float_complex),target,contiguous,dimension(..) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgebd2_batched_assumed_rank = rocsolver_cgebd2_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function #else function rocsolver_cgebd2_batched_rank_0(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ, & taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE complex(c_float_complex),target :: tauq integer(c_int64_t) :: strideQ complex(c_float_complex),target :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgebd2_batched_rank_0 = rocsolver_cgebd2_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function function rocsolver_cgebd2_batched_rank_1(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ, & taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ complex(c_float_complex),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgebd2_batched_rank_1 = rocsolver_cgebd2_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgebd2_batched_assumed_rank(handle,m,n,A,lda,D,strideD,E,strideE,tauq, & strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,contiguous,dimension(..) :: tauq integer(c_int64_t) :: strideQ complex(c_double_complex),target,contiguous,dimension(..) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgebd2_batched_assumed_rank = rocsolver_zgebd2_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function #else function rocsolver_zgebd2_batched_rank_0(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ, & taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE complex(c_double_complex),target :: tauq integer(c_int64_t) :: strideQ complex(c_double_complex),target :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgebd2_batched_rank_0 = rocsolver_zgebd2_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function function rocsolver_zgebd2_batched_rank_1(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ, & taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ complex(c_double_complex),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgebd2_batched_rank_1 = rocsolver_zgebd2_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgebd2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,D,strideD,E, & strideE,tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE real(c_float),target,contiguous,dimension(..) :: tauq integer(c_int64_t) :: strideQ real(c_float),target,contiguous,dimension(..) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgebd2_strided_batched_assumed_rank = rocsolver_sgebd2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function #else function rocsolver_sgebd2_strided_batched_rank_0(handle,m,n,A,lda,strideA,D,strideD,E,strideE, & tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE real(c_float),target :: tauq integer(c_int64_t) :: strideQ real(c_float),target :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgebd2_strided_batched_rank_0 = rocsolver_sgebd2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function function rocsolver_sgebd2_strided_batched_rank_1(handle,m,n,A,lda,strideA,D,strideD,E,strideE, & tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_float),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ real(c_float),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgebd2_strided_batched_rank_1 = rocsolver_sgebd2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function function rocsolver_sgebd2_strided_batched_full_rank(handle,m,n,A,lda,strideA,D,strideD,E, & strideE,tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebd2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_float),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ real(c_float),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgebd2_strided_batched_full_rank = rocsolver_sgebd2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgebd2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,D,strideD,E, & strideE,tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE real(c_double),target,contiguous,dimension(..) :: tauq integer(c_int64_t) :: strideQ real(c_double),target,contiguous,dimension(..) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgebd2_strided_batched_assumed_rank = rocsolver_dgebd2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function #else function rocsolver_dgebd2_strided_batched_rank_0(handle,m,n,A,lda,strideA,D,strideD,E,strideE, & tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE real(c_double),target :: tauq integer(c_int64_t) :: strideQ real(c_double),target :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgebd2_strided_batched_rank_0 = rocsolver_dgebd2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function function rocsolver_dgebd2_strided_batched_rank_1(handle,m,n,A,lda,strideA,D,strideD,E,strideE, & tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_double),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ real(c_double),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgebd2_strided_batched_rank_1 = rocsolver_dgebd2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function function rocsolver_dgebd2_strided_batched_full_rank(handle,m,n,A,lda,strideA,D,strideD,E, & strideE,tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebd2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_double),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ real(c_double),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgebd2_strided_batched_full_rank = rocsolver_dgebd2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgebd2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,D,strideD,E, & strideE,tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,contiguous,dimension(..) :: tauq integer(c_int64_t) :: strideQ complex(c_float_complex),target,contiguous,dimension(..) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgebd2_strided_batched_assumed_rank = rocsolver_cgebd2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function #else function rocsolver_cgebd2_strided_batched_rank_0(handle,m,n,A,lda,strideA,D,strideD,E,strideE, & tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE complex(c_float_complex),target :: tauq integer(c_int64_t) :: strideQ complex(c_float_complex),target :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgebd2_strided_batched_rank_0 = rocsolver_cgebd2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function function rocsolver_cgebd2_strided_batched_rank_1(handle,m,n,A,lda,strideA,D,strideD,E,strideE, & tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ complex(c_float_complex),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgebd2_strided_batched_rank_1 = rocsolver_cgebd2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function function rocsolver_cgebd2_strided_batched_full_rank(handle,m,n,A,lda,strideA,D,strideD,E, & strideE,tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebd2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ complex(c_float_complex),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgebd2_strided_batched_full_rank = rocsolver_cgebd2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgebd2_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,D,strideD,E, & strideE,tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,contiguous,dimension(..) :: tauq integer(c_int64_t) :: strideQ complex(c_double_complex),target,contiguous,dimension(..) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgebd2_strided_batched_assumed_rank = rocsolver_zgebd2_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function #else function rocsolver_zgebd2_strided_batched_rank_0(handle,m,n,A,lda,strideA,D,strideD,E,strideE, & tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE complex(c_double_complex),target :: tauq integer(c_int64_t) :: strideQ complex(c_double_complex),target :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgebd2_strided_batched_rank_0 = rocsolver_zgebd2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function function rocsolver_zgebd2_strided_batched_rank_1(handle,m,n,A,lda,strideA,D,strideD,E,strideE, & tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ complex(c_double_complex),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgebd2_strided_batched_rank_1 = rocsolver_zgebd2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function function rocsolver_zgebd2_strided_batched_full_rank(handle,m,n,A,lda,strideA,D,strideD,E, & strideE,tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebd2_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ complex(c_double_complex),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgebd2_strided_batched_full_rank = rocsolver_zgebd2_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgebrd_assumed_rank(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E real(c_float),target,contiguous,dimension(..) :: tauq real(c_float),target,contiguous,dimension(..) :: taup ! rocsolver_sgebrd_assumed_rank = rocsolver_sgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function #else function rocsolver_sgebrd_rank_0(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E real(c_float),target :: tauq real(c_float),target :: taup ! rocsolver_sgebrd_rank_0 = rocsolver_sgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function function rocsolver_sgebrd_rank_1(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:) :: tauq real(c_float),target,dimension(:) :: taup ! rocsolver_sgebrd_rank_1 = rocsolver_sgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function function rocsolver_sgebrd_full_rank(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:) :: tauq real(c_float),target,dimension(:) :: taup ! rocsolver_sgebrd_full_rank = rocsolver_sgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgebrd_assumed_rank(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E real(c_double),target,contiguous,dimension(..) :: tauq real(c_double),target,contiguous,dimension(..) :: taup ! rocsolver_dgebrd_assumed_rank = rocsolver_dgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function #else function rocsolver_dgebrd_rank_0(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E real(c_double),target :: tauq real(c_double),target :: taup ! rocsolver_dgebrd_rank_0 = rocsolver_dgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function function rocsolver_dgebrd_rank_1(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:) :: tauq real(c_double),target,dimension(:) :: taup ! rocsolver_dgebrd_rank_1 = rocsolver_dgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function function rocsolver_dgebrd_full_rank(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:) :: tauq real(c_double),target,dimension(:) :: taup ! rocsolver_dgebrd_full_rank = rocsolver_dgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgebrd_assumed_rank(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E complex(c_float_complex),target,contiguous,dimension(..) :: tauq complex(c_float_complex),target,contiguous,dimension(..) :: taup ! rocsolver_cgebrd_assumed_rank = rocsolver_cgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function #else function rocsolver_cgebrd_rank_0(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E complex(c_float_complex),target :: tauq complex(c_float_complex),target :: taup ! rocsolver_cgebrd_rank_0 = rocsolver_cgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function function rocsolver_cgebrd_rank_1(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:) :: tauq complex(c_float_complex),target,dimension(:) :: taup ! rocsolver_cgebrd_rank_1 = rocsolver_cgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function function rocsolver_cgebrd_full_rank(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:) :: tauq complex(c_float_complex),target,dimension(:) :: taup ! rocsolver_cgebrd_full_rank = rocsolver_cgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgebrd_assumed_rank(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E complex(c_double_complex),target,contiguous,dimension(..) :: tauq complex(c_double_complex),target,contiguous,dimension(..) :: taup ! rocsolver_zgebrd_assumed_rank = rocsolver_zgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function #else function rocsolver_zgebrd_rank_0(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E complex(c_double_complex),target :: tauq complex(c_double_complex),target :: taup ! rocsolver_zgebrd_rank_0 = rocsolver_zgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function function rocsolver_zgebrd_rank_1(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:) :: tauq complex(c_double_complex),target,dimension(:) :: taup ! rocsolver_zgebrd_rank_1 = rocsolver_zgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function function rocsolver_zgebrd_full_rank(handle,m,n,A,lda,D,E,tauq,taup) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:) :: tauq complex(c_double_complex),target,dimension(:) :: taup ! rocsolver_zgebrd_full_rank = rocsolver_zgebrd_(handle,m,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tauq),c_loc(taup)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgebrd_batched_assumed_rank(handle,m,n,A,lda,D,strideD,E,strideE,tauq, & strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE real(c_float),target,contiguous,dimension(..) :: tauq integer(c_int64_t) :: strideQ real(c_float),target,contiguous,dimension(..) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgebrd_batched_assumed_rank = rocsolver_sgebrd_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function #else function rocsolver_sgebrd_batched_rank_0(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ, & taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE real(c_float),target :: tauq integer(c_int64_t) :: strideQ real(c_float),target :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgebrd_batched_rank_0 = rocsolver_sgebrd_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function function rocsolver_sgebrd_batched_rank_1(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ, & taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_float),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ real(c_float),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgebrd_batched_rank_1 = rocsolver_sgebrd_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgebrd_batched_assumed_rank(handle,m,n,A,lda,D,strideD,E,strideE,tauq, & strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE real(c_double),target,contiguous,dimension(..) :: tauq integer(c_int64_t) :: strideQ real(c_double),target,contiguous,dimension(..) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgebrd_batched_assumed_rank = rocsolver_dgebrd_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function #else function rocsolver_dgebrd_batched_rank_0(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ, & taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE real(c_double),target :: tauq integer(c_int64_t) :: strideQ real(c_double),target :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgebrd_batched_rank_0 = rocsolver_dgebrd_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function function rocsolver_dgebrd_batched_rank_1(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ, & taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_double),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ real(c_double),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgebrd_batched_rank_1 = rocsolver_dgebrd_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgebrd_batched_assumed_rank(handle,m,n,A,lda,D,strideD,E,strideE,tauq, & strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,contiguous,dimension(..) :: tauq integer(c_int64_t) :: strideQ complex(c_float_complex),target,contiguous,dimension(..) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgebrd_batched_assumed_rank = rocsolver_cgebrd_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function #else function rocsolver_cgebrd_batched_rank_0(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ, & taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE complex(c_float_complex),target :: tauq integer(c_int64_t) :: strideQ complex(c_float_complex),target :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgebrd_batched_rank_0 = rocsolver_cgebrd_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function function rocsolver_cgebrd_batched_rank_1(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ, & taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ complex(c_float_complex),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgebrd_batched_rank_1 = rocsolver_cgebrd_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgebrd_batched_assumed_rank(handle,m,n,A,lda,D,strideD,E,strideE,tauq, & strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,contiguous,dimension(..) :: tauq integer(c_int64_t) :: strideQ complex(c_double_complex),target,contiguous,dimension(..) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgebrd_batched_assumed_rank = rocsolver_zgebrd_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function #else function rocsolver_zgebrd_batched_rank_0(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ, & taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE complex(c_double_complex),target :: tauq integer(c_int64_t) :: strideQ complex(c_double_complex),target :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgebrd_batched_rank_0 = rocsolver_zgebrd_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function function rocsolver_zgebrd_batched_rank_1(handle,m,n,A,lda,D,strideD,E,strideE,tauq,strideQ, & taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ complex(c_double_complex),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgebrd_batched_rank_1 = rocsolver_zgebrd_batched_(handle,m,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgebrd_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,D,strideD,E, & strideE,tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE real(c_float),target,contiguous,dimension(..) :: tauq integer(c_int64_t) :: strideQ real(c_float),target,contiguous,dimension(..) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgebrd_strided_batched_assumed_rank = rocsolver_sgebrd_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function #else function rocsolver_sgebrd_strided_batched_rank_0(handle,m,n,A,lda,strideA,D,strideD,E,strideE, & tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE real(c_float),target :: tauq integer(c_int64_t) :: strideQ real(c_float),target :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgebrd_strided_batched_rank_0 = rocsolver_sgebrd_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function function rocsolver_sgebrd_strided_batched_rank_1(handle,m,n,A,lda,strideA,D,strideD,E,strideE, & tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_float),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ real(c_float),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgebrd_strided_batched_rank_1 = rocsolver_sgebrd_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function function rocsolver_sgebrd_strided_batched_full_rank(handle,m,n,A,lda,strideA,D,strideD,E, & strideE,tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgebrd_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_float),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ real(c_float),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_sgebrd_strided_batched_full_rank = rocsolver_sgebrd_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgebrd_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,D,strideD,E, & strideE,tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE real(c_double),target,contiguous,dimension(..) :: tauq integer(c_int64_t) :: strideQ real(c_double),target,contiguous,dimension(..) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgebrd_strided_batched_assumed_rank = rocsolver_dgebrd_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function #else function rocsolver_dgebrd_strided_batched_rank_0(handle,m,n,A,lda,strideA,D,strideD,E,strideE, & tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE real(c_double),target :: tauq integer(c_int64_t) :: strideQ real(c_double),target :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgebrd_strided_batched_rank_0 = rocsolver_dgebrd_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function function rocsolver_dgebrd_strided_batched_rank_1(handle,m,n,A,lda,strideA,D,strideD,E,strideE, & tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_double),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ real(c_double),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgebrd_strided_batched_rank_1 = rocsolver_dgebrd_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function function rocsolver_dgebrd_strided_batched_full_rank(handle,m,n,A,lda,strideA,D,strideD,E, & strideE,tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgebrd_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_double),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ real(c_double),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dgebrd_strided_batched_full_rank = rocsolver_dgebrd_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgebrd_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,D,strideD,E, & strideE,tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,contiguous,dimension(..) :: tauq integer(c_int64_t) :: strideQ complex(c_float_complex),target,contiguous,dimension(..) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgebrd_strided_batched_assumed_rank = rocsolver_cgebrd_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function #else function rocsolver_cgebrd_strided_batched_rank_0(handle,m,n,A,lda,strideA,D,strideD,E,strideE, & tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE complex(c_float_complex),target :: tauq integer(c_int64_t) :: strideQ complex(c_float_complex),target :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgebrd_strided_batched_rank_0 = rocsolver_cgebrd_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function function rocsolver_cgebrd_strided_batched_rank_1(handle,m,n,A,lda,strideA,D,strideD,E,strideE, & tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ complex(c_float_complex),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgebrd_strided_batched_rank_1 = rocsolver_cgebrd_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function function rocsolver_cgebrd_strided_batched_full_rank(handle,m,n,A,lda,strideA,D,strideD,E, & strideE,tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgebrd_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ complex(c_float_complex),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_cgebrd_strided_batched_full_rank = rocsolver_cgebrd_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgebrd_strided_batched_assumed_rank(handle,m,n,A,lda,strideA,D,strideD,E, & strideE,tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,contiguous,dimension(..) :: tauq integer(c_int64_t) :: strideQ complex(c_double_complex),target,contiguous,dimension(..) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgebrd_strided_batched_assumed_rank = rocsolver_zgebrd_strided_batched_(handle,m, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function #else function rocsolver_zgebrd_strided_batched_rank_0(handle,m,n,A,lda,strideA,D,strideD,E,strideE, & tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE complex(c_double_complex),target :: tauq integer(c_int64_t) :: strideQ complex(c_double_complex),target :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgebrd_strided_batched_rank_0 = rocsolver_zgebrd_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function function rocsolver_zgebrd_strided_batched_rank_1(handle,m,n,A,lda,strideA,D,strideD,E,strideE, & tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ complex(c_double_complex),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgebrd_strided_batched_rank_1 = rocsolver_zgebrd_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function function rocsolver_zgebrd_strided_batched_full_rank(handle,m,n,A,lda,strideA,D,strideD,E, & strideE,tauq,strideQ,taup,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgebrd_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,dimension(:) :: tauq integer(c_int64_t) :: strideQ complex(c_double_complex),target,dimension(:) :: taup integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zgebrd_strided_batched_full_rank = rocsolver_zgebrd_strided_batched_(handle,m,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tauq),strideQ,c_loc(taup), & strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetrs_assumed_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocsolver_sgetrs_assumed_rank = rocsolver_sgetrs_(handle,trans,n,nrhs,c_loc(A),lda, & c_loc(ipiv),c_loc(B),ldb) end function #else function rocsolver_sgetrs_rank_0(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv real(c_float),target :: B integer(c_int) :: ldb ! rocsolver_sgetrs_rank_0 = rocsolver_sgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb) end function function rocsolver_sgetrs_rank_1(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv real(c_float),target,dimension(:) :: B integer(c_int) :: ldb ! rocsolver_sgetrs_rank_1 = rocsolver_sgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb) end function function rocsolver_sgetrs_full_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocsolver_sgetrs_full_rank = rocsolver_sgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetrs_assumed_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocsolver_dgetrs_assumed_rank = rocsolver_dgetrs_(handle,trans,n,nrhs,c_loc(A),lda, & c_loc(ipiv),c_loc(B),ldb) end function #else function rocsolver_dgetrs_rank_0(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv real(c_double),target :: B integer(c_int) :: ldb ! rocsolver_dgetrs_rank_0 = rocsolver_dgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb) end function function rocsolver_dgetrs_rank_1(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv real(c_double),target,dimension(:) :: B integer(c_int) :: ldb ! rocsolver_dgetrs_rank_1 = rocsolver_dgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb) end function function rocsolver_dgetrs_full_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocsolver_dgetrs_full_rank = rocsolver_dgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetrs_assumed_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocsolver_cgetrs_assumed_rank = rocsolver_cgetrs_(handle,trans,n,nrhs,c_loc(A),lda, & c_loc(ipiv),c_loc(B),ldb) end function #else function rocsolver_cgetrs_rank_0(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv complex(c_float_complex),target :: B integer(c_int) :: ldb ! rocsolver_cgetrs_rank_0 = rocsolver_cgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb) end function function rocsolver_cgetrs_rank_1(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb ! rocsolver_cgetrs_rank_1 = rocsolver_cgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb) end function function rocsolver_cgetrs_full_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocsolver_cgetrs_full_rank = rocsolver_cgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetrs_assumed_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocsolver_zgetrs_assumed_rank = rocsolver_zgetrs_(handle,trans,n,nrhs,c_loc(A),lda, & c_loc(ipiv),c_loc(B),ldb) end function #else function rocsolver_zgetrs_rank_0(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv complex(c_double_complex),target :: B integer(c_int) :: ldb ! rocsolver_zgetrs_rank_0 = rocsolver_zgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb) end function function rocsolver_zgetrs_rank_1(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb ! rocsolver_zgetrs_rank_1 = rocsolver_zgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb) end function function rocsolver_zgetrs_full_rank(handle,trans,n,nrhs,A,lda,ipiv,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocsolver_zgetrs_full_rank = rocsolver_zgetrs_(handle,trans,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetrs_batched_assumed_rank(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb integer(c_int) :: batch_count ! rocsolver_sgetrs_batched_assumed_rank = rocsolver_sgetrs_batched_(handle,trans,n,nrhs,A,lda, & c_loc(ipiv),strideP,B,ldb,batch_count) end function #else function rocsolver_sgetrs_batched_rank_0(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb integer(c_int) :: batch_count ! rocsolver_sgetrs_batched_rank_0 = rocsolver_sgetrs_batched_(handle,trans,n,nrhs,A,lda, & c_loc(ipiv),strideP,B,ldb,batch_count) end function function rocsolver_sgetrs_batched_rank_1(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb integer(c_int) :: batch_count ! rocsolver_sgetrs_batched_rank_1 = rocsolver_sgetrs_batched_(handle,trans,n,nrhs,A,lda, & c_loc(ipiv),strideP,B,ldb,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetrs_batched_assumed_rank(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb integer(c_int) :: batch_count ! rocsolver_dgetrs_batched_assumed_rank = rocsolver_dgetrs_batched_(handle,trans,n,nrhs,A,lda, & c_loc(ipiv),strideP,B,ldb,batch_count) end function #else function rocsolver_dgetrs_batched_rank_0(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb integer(c_int) :: batch_count ! rocsolver_dgetrs_batched_rank_0 = rocsolver_dgetrs_batched_(handle,trans,n,nrhs,A,lda, & c_loc(ipiv),strideP,B,ldb,batch_count) end function function rocsolver_dgetrs_batched_rank_1(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb integer(c_int) :: batch_count ! rocsolver_dgetrs_batched_rank_1 = rocsolver_dgetrs_batched_(handle,trans,n,nrhs,A,lda, & c_loc(ipiv),strideP,B,ldb,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetrs_batched_assumed_rank(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb integer(c_int) :: batch_count ! rocsolver_cgetrs_batched_assumed_rank = rocsolver_cgetrs_batched_(handle,trans,n,nrhs,A,lda, & c_loc(ipiv),strideP,B,ldb,batch_count) end function #else function rocsolver_cgetrs_batched_rank_0(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb integer(c_int) :: batch_count ! rocsolver_cgetrs_batched_rank_0 = rocsolver_cgetrs_batched_(handle,trans,n,nrhs,A,lda, & c_loc(ipiv),strideP,B,ldb,batch_count) end function function rocsolver_cgetrs_batched_rank_1(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb integer(c_int) :: batch_count ! rocsolver_cgetrs_batched_rank_1 = rocsolver_cgetrs_batched_(handle,trans,n,nrhs,A,lda, & c_loc(ipiv),strideP,B,ldb,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetrs_batched_assumed_rank(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb integer(c_int) :: batch_count ! rocsolver_zgetrs_batched_assumed_rank = rocsolver_zgetrs_batched_(handle,trans,n,nrhs,A,lda, & c_loc(ipiv),strideP,B,ldb,batch_count) end function #else function rocsolver_zgetrs_batched_rank_0(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb integer(c_int) :: batch_count ! rocsolver_zgetrs_batched_rank_0 = rocsolver_zgetrs_batched_(handle,trans,n,nrhs,A,lda, & c_loc(ipiv),strideP,B,ldb,batch_count) end function function rocsolver_zgetrs_batched_rank_1(handle,trans,n,nrhs,A,lda,ipiv,strideP,B,ldb, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb integer(c_int) :: batch_count ! rocsolver_zgetrs_batched_rank_1 = rocsolver_zgetrs_batched_(handle,trans,n,nrhs,A,lda, & c_loc(ipiv),strideP,B,ldb,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetrs_strided_batched_assumed_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_sgetrs_strided_batched_assumed_rank = rocsolver_sgetrs_strided_batched_(handle, & trans,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count) end function #else function rocsolver_sgetrs_strided_batched_rank_0(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP real(c_float),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_sgetrs_strided_batched_rank_0 = rocsolver_sgetrs_strided_batched_(handle,trans,n, & nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_sgetrs_strided_batched_rank_1(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_sgetrs_strided_batched_rank_1 = rocsolver_sgetrs_strided_batched_(handle,trans,n, & nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_sgetrs_strided_batched_full_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetrs_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_sgetrs_strided_batched_full_rank = rocsolver_sgetrs_strided_batched_(handle,trans, & n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetrs_strided_batched_assumed_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_dgetrs_strided_batched_assumed_rank = rocsolver_dgetrs_strided_batched_(handle, & trans,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count) end function #else function rocsolver_dgetrs_strided_batched_rank_0(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP real(c_double),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_dgetrs_strided_batched_rank_0 = rocsolver_dgetrs_strided_batched_(handle,trans,n, & nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_dgetrs_strided_batched_rank_1(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_dgetrs_strided_batched_rank_1 = rocsolver_dgetrs_strided_batched_(handle,trans,n, & nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_dgetrs_strided_batched_full_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetrs_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_dgetrs_strided_batched_full_rank = rocsolver_dgetrs_strided_batched_(handle,trans, & n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetrs_strided_batched_assumed_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_cgetrs_strided_batched_assumed_rank = rocsolver_cgetrs_strided_batched_(handle, & trans,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count) end function #else function rocsolver_cgetrs_strided_batched_rank_0(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_cgetrs_strided_batched_rank_0 = rocsolver_cgetrs_strided_batched_(handle,trans,n, & nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_cgetrs_strided_batched_rank_1(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_cgetrs_strided_batched_rank_1 = rocsolver_cgetrs_strided_batched_(handle,trans,n, & nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_cgetrs_strided_batched_full_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetrs_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_cgetrs_strided_batched_full_rank = rocsolver_cgetrs_strided_batched_(handle,trans, & n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetrs_strided_batched_assumed_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_zgetrs_strided_batched_assumed_rank = rocsolver_zgetrs_strided_batched_(handle, & trans,n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count) end function #else function rocsolver_zgetrs_strided_batched_rank_0(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_zgetrs_strided_batched_rank_0 = rocsolver_zgetrs_strided_batched_(handle,trans,n, & nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_zgetrs_strided_batched_rank_1(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_zgetrs_strided_batched_rank_1 = rocsolver_zgetrs_strided_batched_(handle,trans,n, & nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_zgetrs_strided_batched_full_rank(handle,trans,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetrs_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_zgetrs_strided_batched_full_rank = rocsolver_zgetrs_strided_batched_(handle,trans, & n,nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgesv_assumed_rank(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesv_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_sgesv_assumed_rank = rocsolver_sgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb,myInfo) end function #else function rocsolver_sgesv_rank_0(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesv_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv real(c_float),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_sgesv_rank_0 = rocsolver_sgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B), & ldb,myInfo) end function function rocsolver_sgesv_rank_1(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesv_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv real(c_float),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_sgesv_rank_1 = rocsolver_sgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B), & ldb,myInfo) end function function rocsolver_sgesv_full_rank(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesv_full_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_sgesv_full_rank = rocsolver_sgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgesv_assumed_rank(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesv_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_dgesv_assumed_rank = rocsolver_dgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb,myInfo) end function #else function rocsolver_dgesv_rank_0(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesv_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv real(c_double),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_dgesv_rank_0 = rocsolver_dgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B), & ldb,myInfo) end function function rocsolver_dgesv_rank_1(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesv_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv real(c_double),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_dgesv_rank_1 = rocsolver_dgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B), & ldb,myInfo) end function function rocsolver_dgesv_full_rank(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesv_full_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_dgesv_full_rank = rocsolver_dgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgesv_assumed_rank(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesv_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_cgesv_assumed_rank = rocsolver_cgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb,myInfo) end function #else function rocsolver_cgesv_rank_0(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesv_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv complex(c_float_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_cgesv_rank_0 = rocsolver_cgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B), & ldb,myInfo) end function function rocsolver_cgesv_rank_1(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesv_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_cgesv_rank_1 = rocsolver_cgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B), & ldb,myInfo) end function function rocsolver_cgesv_full_rank(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesv_full_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_cgesv_full_rank = rocsolver_cgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgesv_assumed_rank(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesv_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_zgesv_assumed_rank = rocsolver_zgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb,myInfo) end function #else function rocsolver_zgesv_rank_0(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesv_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv complex(c_double_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_zgesv_rank_0 = rocsolver_zgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B), & ldb,myInfo) end function function rocsolver_zgesv_rank_1(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesv_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_zgesv_rank_1 = rocsolver_zgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv),c_loc(B), & ldb,myInfo) end function function rocsolver_zgesv_full_rank(handle,n,nrhs,A,lda,ipiv,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesv_full_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_zgesv_full_rank = rocsolver_zgesv_(handle,n,nrhs,c_loc(A),lda,c_loc(ipiv), & c_loc(B),ldb,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgesv_batched_assumed_rank(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesv_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgesv_batched_assumed_rank = rocsolver_sgesv_batched_(handle,n,nrhs,A,lda, & c_loc(ipiv),strideP,B,ldb,myInfo,batch_count) end function #else function rocsolver_sgesv_batched_rank_0(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesv_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgesv_batched_rank_0 = rocsolver_sgesv_batched_(handle,n,nrhs,A,lda,c_loc(ipiv), & strideP,B,ldb,myInfo,batch_count) end function function rocsolver_sgesv_batched_rank_1(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesv_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgesv_batched_rank_1 = rocsolver_sgesv_batched_(handle,n,nrhs,A,lda,c_loc(ipiv), & strideP,B,ldb,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgesv_batched_assumed_rank(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesv_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgesv_batched_assumed_rank = rocsolver_dgesv_batched_(handle,n,nrhs,A,lda, & c_loc(ipiv),strideP,B,ldb,myInfo,batch_count) end function #else function rocsolver_dgesv_batched_rank_0(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesv_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgesv_batched_rank_0 = rocsolver_dgesv_batched_(handle,n,nrhs,A,lda,c_loc(ipiv), & strideP,B,ldb,myInfo,batch_count) end function function rocsolver_dgesv_batched_rank_1(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesv_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgesv_batched_rank_1 = rocsolver_dgesv_batched_(handle,n,nrhs,A,lda,c_loc(ipiv), & strideP,B,ldb,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgesv_batched_assumed_rank(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesv_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgesv_batched_assumed_rank = rocsolver_cgesv_batched_(handle,n,nrhs,A,lda, & c_loc(ipiv),strideP,B,ldb,myInfo,batch_count) end function #else function rocsolver_cgesv_batched_rank_0(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesv_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgesv_batched_rank_0 = rocsolver_cgesv_batched_(handle,n,nrhs,A,lda,c_loc(ipiv), & strideP,B,ldb,myInfo,batch_count) end function function rocsolver_cgesv_batched_rank_1(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesv_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgesv_batched_rank_1 = rocsolver_cgesv_batched_(handle,n,nrhs,A,lda,c_loc(ipiv), & strideP,B,ldb,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgesv_batched_assumed_rank(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesv_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgesv_batched_assumed_rank = rocsolver_zgesv_batched_(handle,n,nrhs,A,lda, & c_loc(ipiv),strideP,B,ldb,myInfo,batch_count) end function #else function rocsolver_zgesv_batched_rank_0(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesv_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgesv_batched_rank_0 = rocsolver_zgesv_batched_(handle,n,nrhs,A,lda,c_loc(ipiv), & strideP,B,ldb,myInfo,batch_count) end function function rocsolver_zgesv_batched_rank_1(handle,n,nrhs,A,lda,ipiv,strideP,B,ldb,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesv_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgesv_batched_rank_1 = rocsolver_zgesv_batched_(handle,n,nrhs,A,lda,c_loc(ipiv), & strideP,B,ldb,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgesv_strided_batched_assumed_rank(handle,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesv_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgesv_strided_batched_assumed_rank = rocsolver_sgesv_strided_batched_(handle,n, & nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count) end function #else function rocsolver_sgesv_strided_batched_rank_0(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesv_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP real(c_float),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgesv_strided_batched_rank_0 = rocsolver_sgesv_strided_batched_(handle,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_sgesv_strided_batched_rank_1(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesv_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgesv_strided_batched_rank_1 = rocsolver_sgesv_strided_batched_(handle,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_sgesv_strided_batched_full_rank(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesv_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgesv_strided_batched_full_rank = rocsolver_sgesv_strided_batched_(handle,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgesv_strided_batched_assumed_rank(handle,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesv_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgesv_strided_batched_assumed_rank = rocsolver_dgesv_strided_batched_(handle,n, & nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count) end function #else function rocsolver_dgesv_strided_batched_rank_0(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesv_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP real(c_double),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgesv_strided_batched_rank_0 = rocsolver_dgesv_strided_batched_(handle,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_dgesv_strided_batched_rank_1(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesv_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgesv_strided_batched_rank_1 = rocsolver_dgesv_strided_batched_(handle,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_dgesv_strided_batched_full_rank(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesv_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgesv_strided_batched_full_rank = rocsolver_dgesv_strided_batched_(handle,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgesv_strided_batched_assumed_rank(handle,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesv_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgesv_strided_batched_assumed_rank = rocsolver_cgesv_strided_batched_(handle,n, & nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count) end function #else function rocsolver_cgesv_strided_batched_rank_0(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesv_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgesv_strided_batched_rank_0 = rocsolver_cgesv_strided_batched_(handle,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_cgesv_strided_batched_rank_1(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesv_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgesv_strided_batched_rank_1 = rocsolver_cgesv_strided_batched_(handle,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_cgesv_strided_batched_full_rank(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesv_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgesv_strided_batched_full_rank = rocsolver_cgesv_strided_batched_(handle,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgesv_strided_batched_assumed_rank(handle,n,nrhs,A,lda,strideA,ipiv, & strideP,B,ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesv_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgesv_strided_batched_assumed_rank = rocsolver_zgesv_strided_batched_(handle,n, & nrhs,c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count) end function #else function rocsolver_zgesv_strided_batched_rank_0(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesv_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgesv_strided_batched_rank_0 = rocsolver_zgesv_strided_batched_(handle,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_zgesv_strided_batched_rank_1(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesv_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgesv_strided_batched_rank_1 = rocsolver_zgesv_strided_batched_(handle,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_zgesv_strided_batched_full_rank(handle,n,nrhs,A,lda,strideA,ipiv,strideP,B, & ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesv_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgesv_strided_batched_full_rank = rocsolver_zgesv_strided_batched_(handle,n,nrhs, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,c_loc(B),ldb,strideB,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetri_assumed_rank(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_sgetri_assumed_rank = rocsolver_sgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function rocsolver_sgetri_rank_0(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_sgetri_rank_0 = rocsolver_sgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_sgetri_rank_1(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_sgetri_rank_1 = rocsolver_sgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_sgetri_full_rank(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_sgetri_full_rank = rocsolver_sgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetri_assumed_rank(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_dgetri_assumed_rank = rocsolver_dgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function rocsolver_dgetri_rank_0(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_dgetri_rank_0 = rocsolver_dgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_dgetri_rank_1(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_dgetri_rank_1 = rocsolver_dgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_dgetri_full_rank(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_dgetri_full_rank = rocsolver_dgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetri_assumed_rank(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_cgetri_assumed_rank = rocsolver_cgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function rocsolver_cgetri_rank_0(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_cgetri_rank_0 = rocsolver_cgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_cgetri_rank_1(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_cgetri_rank_1 = rocsolver_cgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_cgetri_full_rank(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_cgetri_full_rank = rocsolver_cgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetri_assumed_rank(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_zgetri_assumed_rank = rocsolver_zgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #else function rocsolver_zgetri_rank_0(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_zgetri_rank_0 = rocsolver_zgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_zgetri_rank_1(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_zgetri_rank_1 = rocsolver_zgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_zgetri_full_rank(handle,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_zgetri_full_rank = rocsolver_zgetri_(handle,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetri_batched_assumed_rank(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_batched_assumed_rank = rocsolver_sgetri_batched_(handle,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_sgetri_batched_rank_0(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_batched_rank_0 = rocsolver_sgetri_batched_(handle,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_sgetri_batched_rank_1(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_batched_rank_1 = rocsolver_sgetri_batched_(handle,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetri_batched_assumed_rank(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_batched_assumed_rank = rocsolver_dgetri_batched_(handle,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_dgetri_batched_rank_0(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_batched_rank_0 = rocsolver_dgetri_batched_(handle,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_dgetri_batched_rank_1(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_batched_rank_1 = rocsolver_dgetri_batched_(handle,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetri_batched_assumed_rank(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_batched_assumed_rank = rocsolver_cgetri_batched_(handle,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_cgetri_batched_rank_0(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_batched_rank_0 = rocsolver_cgetri_batched_(handle,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_cgetri_batched_rank_1(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_batched_rank_1 = rocsolver_cgetri_batched_(handle,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetri_batched_assumed_rank(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_batched_assumed_rank = rocsolver_zgetri_batched_(handle,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_zgetri_batched_rank_0(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_batched_rank_0 = rocsolver_zgetri_batched_(handle,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_zgetri_batched_rank_1(handle,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_batched_rank_1 = rocsolver_zgetri_batched_(handle,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetri_strided_batched_assumed_rank(handle,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_strided_batched_assumed_rank = rocsolver_sgetri_strided_batched_(handle,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_sgetri_strided_batched_rank_0(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_strided_batched_rank_0 = rocsolver_sgetri_strided_batched_(handle,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_sgetri_strided_batched_rank_1(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_strided_batched_rank_1 = rocsolver_sgetri_strided_batched_(handle,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_sgetri_strided_batched_full_rank(handle,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_strided_batched_full_rank = rocsolver_sgetri_strided_batched_(handle,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetri_strided_batched_assumed_rank(handle,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_strided_batched_assumed_rank = rocsolver_dgetri_strided_batched_(handle,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_dgetri_strided_batched_rank_0(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_strided_batched_rank_0 = rocsolver_dgetri_strided_batched_(handle,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_dgetri_strided_batched_rank_1(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_strided_batched_rank_1 = rocsolver_dgetri_strided_batched_(handle,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_dgetri_strided_batched_full_rank(handle,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_strided_batched_full_rank = rocsolver_dgetri_strided_batched_(handle,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetri_strided_batched_assumed_rank(handle,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_strided_batched_assumed_rank = rocsolver_cgetri_strided_batched_(handle,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_cgetri_strided_batched_rank_0(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_strided_batched_rank_0 = rocsolver_cgetri_strided_batched_(handle,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_cgetri_strided_batched_rank_1(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_strided_batched_rank_1 = rocsolver_cgetri_strided_batched_(handle,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_cgetri_strided_batched_full_rank(handle,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_strided_batched_full_rank = rocsolver_cgetri_strided_batched_(handle,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetri_strided_batched_assumed_rank(handle,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_strided_batched_assumed_rank = rocsolver_zgetri_strided_batched_(handle,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_zgetri_strided_batched_rank_0(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_strided_batched_rank_0 = rocsolver_zgetri_strided_batched_(handle,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_zgetri_strided_batched_rank_1(handle,n,A,lda,strideA,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_strided_batched_rank_1 = rocsolver_zgetri_strided_batched_(handle,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_zgetri_strided_batched_full_rank(handle,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_strided_batched_full_rank = rocsolver_zgetri_strided_batched_(handle,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetri_npvt_assumed_rank(handle,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_sgetri_npvt_assumed_rank = rocsolver_sgetri_npvt_(handle,n,c_loc(A),lda,myInfo) end function #else function rocsolver_sgetri_npvt_rank_0(handle,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_sgetri_npvt_rank_0 = rocsolver_sgetri_npvt_(handle,n,c_loc(A),lda,myInfo) end function function rocsolver_sgetri_npvt_rank_1(handle,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_sgetri_npvt_rank_1 = rocsolver_sgetri_npvt_(handle,n,c_loc(A),lda,myInfo) end function function rocsolver_sgetri_npvt_full_rank(handle,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_sgetri_npvt_full_rank = rocsolver_sgetri_npvt_(handle,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetri_npvt_assumed_rank(handle,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dgetri_npvt_assumed_rank = rocsolver_dgetri_npvt_(handle,n,c_loc(A),lda,myInfo) end function #else function rocsolver_dgetri_npvt_rank_0(handle,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dgetri_npvt_rank_0 = rocsolver_dgetri_npvt_(handle,n,c_loc(A),lda,myInfo) end function function rocsolver_dgetri_npvt_rank_1(handle,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dgetri_npvt_rank_1 = rocsolver_dgetri_npvt_(handle,n,c_loc(A),lda,myInfo) end function function rocsolver_dgetri_npvt_full_rank(handle,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dgetri_npvt_full_rank = rocsolver_dgetri_npvt_(handle,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetri_npvt_assumed_rank(handle,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cgetri_npvt_assumed_rank = rocsolver_cgetri_npvt_(handle,n,c_loc(A),lda,myInfo) end function #else function rocsolver_cgetri_npvt_rank_0(handle,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cgetri_npvt_rank_0 = rocsolver_cgetri_npvt_(handle,n,c_loc(A),lda,myInfo) end function function rocsolver_cgetri_npvt_rank_1(handle,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cgetri_npvt_rank_1 = rocsolver_cgetri_npvt_(handle,n,c_loc(A),lda,myInfo) end function function rocsolver_cgetri_npvt_full_rank(handle,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cgetri_npvt_full_rank = rocsolver_cgetri_npvt_(handle,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetri_npvt_assumed_rank(handle,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zgetri_npvt_assumed_rank = rocsolver_zgetri_npvt_(handle,n,c_loc(A),lda,myInfo) end function #else function rocsolver_zgetri_npvt_rank_0(handle,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zgetri_npvt_rank_0 = rocsolver_zgetri_npvt_(handle,n,c_loc(A),lda,myInfo) end function function rocsolver_zgetri_npvt_rank_1(handle,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zgetri_npvt_rank_1 = rocsolver_zgetri_npvt_(handle,n,c_loc(A),lda,myInfo) end function function rocsolver_zgetri_npvt_full_rank(handle,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zgetri_npvt_full_rank = rocsolver_zgetri_npvt_(handle,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetri_npvt_strided_batched_assumed_rank(handle,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_npvt_strided_batched_assumed_rank = rocsolver_sgetri_npvt_strided_batched_( & handle,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_sgetri_npvt_strided_batched_rank_0(handle,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_npvt_strided_batched_rank_0 = rocsolver_sgetri_npvt_strided_batched_( & handle,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_sgetri_npvt_strided_batched_rank_1(handle,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_npvt_strided_batched_rank_1 = rocsolver_sgetri_npvt_strided_batched_( & handle,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_sgetri_npvt_strided_batched_full_rank(handle,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_npvt_strided_batched_full_rank = rocsolver_sgetri_npvt_strided_batched_( & handle,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetri_npvt_strided_batched_assumed_rank(handle,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_npvt_strided_batched_assumed_rank = rocsolver_dgetri_npvt_strided_batched_( & handle,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_dgetri_npvt_strided_batched_rank_0(handle,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_npvt_strided_batched_rank_0 = rocsolver_dgetri_npvt_strided_batched_( & handle,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_dgetri_npvt_strided_batched_rank_1(handle,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_npvt_strided_batched_rank_1 = rocsolver_dgetri_npvt_strided_batched_( & handle,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_dgetri_npvt_strided_batched_full_rank(handle,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_npvt_strided_batched_full_rank = rocsolver_dgetri_npvt_strided_batched_( & handle,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetri_npvt_strided_batched_assumed_rank(handle,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_npvt_strided_batched_assumed_rank = rocsolver_cgetri_npvt_strided_batched_( & handle,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_cgetri_npvt_strided_batched_rank_0(handle,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_npvt_strided_batched_rank_0 = rocsolver_cgetri_npvt_strided_batched_( & handle,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_cgetri_npvt_strided_batched_rank_1(handle,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_npvt_strided_batched_rank_1 = rocsolver_cgetri_npvt_strided_batched_( & handle,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_cgetri_npvt_strided_batched_full_rank(handle,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_npvt_strided_batched_full_rank = rocsolver_cgetri_npvt_strided_batched_( & handle,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetri_npvt_strided_batched_assumed_rank(handle,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_npvt_strided_batched_assumed_rank = rocsolver_zgetri_npvt_strided_batched_( & handle,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_zgetri_npvt_strided_batched_rank_0(handle,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_npvt_strided_batched_rank_0 = rocsolver_zgetri_npvt_strided_batched_( & handle,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_zgetri_npvt_strided_batched_rank_1(handle,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_npvt_strided_batched_rank_1 = rocsolver_zgetri_npvt_strided_batched_( & handle,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_zgetri_npvt_strided_batched_full_rank(handle,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_npvt_strided_batched_full_rank = rocsolver_zgetri_npvt_strided_batched_( & handle,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgels_assumed_rank(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgels_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_sgels_assumed_rank = rocsolver_sgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B), & ldb,myInfo) end function #else function rocsolver_sgels_rank_0(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgels_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_sgels_rank_0 = rocsolver_sgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb, & myInfo) end function function rocsolver_sgels_rank_1(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgels_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_sgels_rank_1 = rocsolver_sgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb, & myInfo) end function function rocsolver_sgels_full_rank(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgels_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_sgels_full_rank = rocsolver_sgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B), & ldb,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgels_assumed_rank(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgels_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_dgels_assumed_rank = rocsolver_dgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B), & ldb,myInfo) end function #else function rocsolver_dgels_rank_0(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgels_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_dgels_rank_0 = rocsolver_dgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb, & myInfo) end function function rocsolver_dgels_rank_1(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgels_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_dgels_rank_1 = rocsolver_dgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb, & myInfo) end function function rocsolver_dgels_full_rank(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgels_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_dgels_full_rank = rocsolver_dgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B), & ldb,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgels_assumed_rank(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgels_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_cgels_assumed_rank = rocsolver_cgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B), & ldb,myInfo) end function #else function rocsolver_cgels_rank_0(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgels_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_cgels_rank_0 = rocsolver_cgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb, & myInfo) end function function rocsolver_cgels_rank_1(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgels_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_cgels_rank_1 = rocsolver_cgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb, & myInfo) end function function rocsolver_cgels_full_rank(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgels_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_cgels_full_rank = rocsolver_cgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B), & ldb,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgels_assumed_rank(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgels_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_zgels_assumed_rank = rocsolver_zgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B), & ldb,myInfo) end function #else function rocsolver_zgels_rank_0(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgels_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_zgels_rank_0 = rocsolver_zgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb, & myInfo) end function function rocsolver_zgels_rank_1(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgels_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_zgels_rank_1 = rocsolver_zgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B),ldb, & myInfo) end function function rocsolver_zgels_full_rank(handle,trans,m,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgels_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_zgels_full_rank = rocsolver_zgels_(handle,trans,m,n,nrhs,c_loc(A),lda,c_loc(B), & ldb,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgels_strided_batched_assumed_rank(handle,trans,m,n,nrhs,A,lda,strideA,B, & ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgels_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgels_strided_batched_assumed_rank = rocsolver_sgels_strided_batched_(handle, & trans,m,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function #else function rocsolver_sgels_strided_batched_rank_0(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgels_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgels_strided_batched_rank_0 = rocsolver_sgels_strided_batched_(handle,trans,m,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_sgels_strided_batched_rank_1(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgels_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgels_strided_batched_rank_1 = rocsolver_sgels_strided_batched_(handle,trans,m,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_sgels_strided_batched_full_rank(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgels_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgels_strided_batched_full_rank = rocsolver_sgels_strided_batched_(handle,trans,m, & n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgels_strided_batched_assumed_rank(handle,trans,m,n,nrhs,A,lda,strideA,B, & ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgels_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgels_strided_batched_assumed_rank = rocsolver_dgels_strided_batched_(handle, & trans,m,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function #else function rocsolver_dgels_strided_batched_rank_0(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgels_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgels_strided_batched_rank_0 = rocsolver_dgels_strided_batched_(handle,trans,m,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_dgels_strided_batched_rank_1(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgels_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgels_strided_batched_rank_1 = rocsolver_dgels_strided_batched_(handle,trans,m,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_dgels_strided_batched_full_rank(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgels_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgels_strided_batched_full_rank = rocsolver_dgels_strided_batched_(handle,trans,m, & n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgels_strided_batched_assumed_rank(handle,trans,m,n,nrhs,A,lda,strideA,B, & ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgels_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgels_strided_batched_assumed_rank = rocsolver_cgels_strided_batched_(handle, & trans,m,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function #else function rocsolver_cgels_strided_batched_rank_0(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgels_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgels_strided_batched_rank_0 = rocsolver_cgels_strided_batched_(handle,trans,m,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_cgels_strided_batched_rank_1(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgels_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgels_strided_batched_rank_1 = rocsolver_cgels_strided_batched_(handle,trans,m,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_cgels_strided_batched_full_rank(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgels_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgels_strided_batched_full_rank = rocsolver_cgels_strided_batched_(handle,trans,m, & n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgels_strided_batched_assumed_rank(handle,trans,m,n,nrhs,A,lda,strideA,B, & ldb,strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgels_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgels_strided_batched_assumed_rank = rocsolver_zgels_strided_batched_(handle, & trans,m,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function #else function rocsolver_zgels_strided_batched_rank_0(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgels_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgels_strided_batched_rank_0 = rocsolver_zgels_strided_batched_(handle,trans,m,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_zgels_strided_batched_rank_1(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgels_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgels_strided_batched_rank_1 = rocsolver_zgels_strided_batched_(handle,trans,m,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_zgels_strided_batched_full_rank(handle,trans,m,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgels_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgels_strided_batched_full_rank = rocsolver_zgels_strided_batched_(handle,trans,m, & n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_spotf2_assumed_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotf2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_spotf2_assumed_rank = rocsolver_spotf2_(handle,uplo,n,c_loc(A),lda,myInfo) end function #else function rocsolver_spotf2_rank_0(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotf2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_spotf2_rank_0 = rocsolver_spotf2_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_spotf2_rank_1(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotf2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_spotf2_rank_1 = rocsolver_spotf2_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_spotf2_full_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotf2_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_spotf2_full_rank = rocsolver_spotf2_(handle,uplo,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dpotf2_assumed_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dpotf2_assumed_rank = rocsolver_dpotf2_(handle,uplo,n,c_loc(A),lda,myInfo) end function #else function rocsolver_dpotf2_rank_0(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dpotf2_rank_0 = rocsolver_dpotf2_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_dpotf2_rank_1(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dpotf2_rank_1 = rocsolver_dpotf2_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_dpotf2_full_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dpotf2_full_rank = rocsolver_dpotf2_(handle,uplo,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cpotf2_assumed_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cpotf2_assumed_rank = rocsolver_cpotf2_(handle,uplo,n,c_loc(A),lda,myInfo) end function #else function rocsolver_cpotf2_rank_0(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cpotf2_rank_0 = rocsolver_cpotf2_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_cpotf2_rank_1(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cpotf2_rank_1 = rocsolver_cpotf2_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_cpotf2_full_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cpotf2_full_rank = rocsolver_cpotf2_(handle,uplo,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zpotf2_assumed_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zpotf2_assumed_rank = rocsolver_zpotf2_(handle,uplo,n,c_loc(A),lda,myInfo) end function #else function rocsolver_zpotf2_rank_0(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zpotf2_rank_0 = rocsolver_zpotf2_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_zpotf2_rank_1(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zpotf2_rank_1 = rocsolver_zpotf2_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_zpotf2_full_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zpotf2_full_rank = rocsolver_zpotf2_(handle,uplo,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_spotf2_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotf2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_spotf2_strided_batched_assumed_rank = rocsolver_spotf2_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_spotf2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotf2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_spotf2_strided_batched_rank_0 = rocsolver_spotf2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_spotf2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotf2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_spotf2_strided_batched_rank_1 = rocsolver_spotf2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_spotf2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotf2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_spotf2_strided_batched_full_rank = rocsolver_spotf2_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dpotf2_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dpotf2_strided_batched_assumed_rank = rocsolver_dpotf2_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_dpotf2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dpotf2_strided_batched_rank_0 = rocsolver_dpotf2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_dpotf2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dpotf2_strided_batched_rank_1 = rocsolver_dpotf2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_dpotf2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotf2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dpotf2_strided_batched_full_rank = rocsolver_dpotf2_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cpotf2_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cpotf2_strided_batched_assumed_rank = rocsolver_cpotf2_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_cpotf2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cpotf2_strided_batched_rank_0 = rocsolver_cpotf2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_cpotf2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cpotf2_strided_batched_rank_1 = rocsolver_cpotf2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_cpotf2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotf2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cpotf2_strided_batched_full_rank = rocsolver_cpotf2_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zpotf2_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zpotf2_strided_batched_assumed_rank = rocsolver_zpotf2_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_zpotf2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zpotf2_strided_batched_rank_0 = rocsolver_zpotf2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_zpotf2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zpotf2_strided_batched_rank_1 = rocsolver_zpotf2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_zpotf2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotf2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zpotf2_strided_batched_full_rank = rocsolver_zpotf2_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_spotrf_assumed_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrf_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_spotrf_assumed_rank = rocsolver_spotrf_(handle,uplo,n,c_loc(A),lda,myInfo) end function #else function rocsolver_spotrf_rank_0(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrf_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_spotrf_rank_0 = rocsolver_spotrf_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_spotrf_rank_1(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrf_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_spotrf_rank_1 = rocsolver_spotrf_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_spotrf_full_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrf_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_spotrf_full_rank = rocsolver_spotrf_(handle,uplo,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dpotrf_assumed_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dpotrf_assumed_rank = rocsolver_dpotrf_(handle,uplo,n,c_loc(A),lda,myInfo) end function #else function rocsolver_dpotrf_rank_0(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dpotrf_rank_0 = rocsolver_dpotrf_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_dpotrf_rank_1(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dpotrf_rank_1 = rocsolver_dpotrf_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_dpotrf_full_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dpotrf_full_rank = rocsolver_dpotrf_(handle,uplo,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cpotrf_assumed_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cpotrf_assumed_rank = rocsolver_cpotrf_(handle,uplo,n,c_loc(A),lda,myInfo) end function #else function rocsolver_cpotrf_rank_0(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cpotrf_rank_0 = rocsolver_cpotrf_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_cpotrf_rank_1(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cpotrf_rank_1 = rocsolver_cpotrf_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_cpotrf_full_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cpotrf_full_rank = rocsolver_cpotrf_(handle,uplo,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zpotrf_assumed_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zpotrf_assumed_rank = rocsolver_zpotrf_(handle,uplo,n,c_loc(A),lda,myInfo) end function #else function rocsolver_zpotrf_rank_0(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zpotrf_rank_0 = rocsolver_zpotrf_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_zpotrf_rank_1(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zpotrf_rank_1 = rocsolver_zpotrf_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_zpotrf_full_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zpotrf_full_rank = rocsolver_zpotrf_(handle,uplo,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_spotrf_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrf_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_spotrf_strided_batched_assumed_rank = rocsolver_spotrf_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_spotrf_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrf_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_spotrf_strided_batched_rank_0 = rocsolver_spotrf_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_spotrf_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrf_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_spotrf_strided_batched_rank_1 = rocsolver_spotrf_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_spotrf_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrf_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_spotrf_strided_batched_full_rank = rocsolver_spotrf_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dpotrf_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dpotrf_strided_batched_assumed_rank = rocsolver_dpotrf_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_dpotrf_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dpotrf_strided_batched_rank_0 = rocsolver_dpotrf_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_dpotrf_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dpotrf_strided_batched_rank_1 = rocsolver_dpotrf_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_dpotrf_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrf_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dpotrf_strided_batched_full_rank = rocsolver_dpotrf_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cpotrf_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cpotrf_strided_batched_assumed_rank = rocsolver_cpotrf_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_cpotrf_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cpotrf_strided_batched_rank_0 = rocsolver_cpotrf_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_cpotrf_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cpotrf_strided_batched_rank_1 = rocsolver_cpotrf_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_cpotrf_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrf_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cpotrf_strided_batched_full_rank = rocsolver_cpotrf_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zpotrf_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zpotrf_strided_batched_assumed_rank = rocsolver_zpotrf_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_zpotrf_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zpotrf_strided_batched_rank_0 = rocsolver_zpotrf_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_zpotrf_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zpotrf_strided_batched_rank_1 = rocsolver_zpotrf_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_zpotrf_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrf_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zpotrf_strided_batched_full_rank = rocsolver_zpotrf_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_spotrs_assumed_rank(handle,uplo,n,nrhs,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrs_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocsolver_spotrs_assumed_rank = rocsolver_spotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B), & ldb) end function #else function rocsolver_spotrs_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrs_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: B integer(c_int) :: ldb ! rocsolver_spotrs_rank_0 = rocsolver_spotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_spotrs_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrs_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: B integer(c_int) :: ldb ! rocsolver_spotrs_rank_1 = rocsolver_spotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_spotrs_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrs_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocsolver_spotrs_full_rank = rocsolver_spotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dpotrs_assumed_rank(handle,uplo,n,nrhs,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocsolver_dpotrs_assumed_rank = rocsolver_dpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B), & ldb) end function #else function rocsolver_dpotrs_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: B integer(c_int) :: ldb ! rocsolver_dpotrs_rank_0 = rocsolver_dpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_dpotrs_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: B integer(c_int) :: ldb ! rocsolver_dpotrs_rank_1 = rocsolver_dpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_dpotrs_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocsolver_dpotrs_full_rank = rocsolver_dpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cpotrs_assumed_rank(handle,uplo,n,nrhs,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocsolver_cpotrs_assumed_rank = rocsolver_cpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B), & ldb) end function #else function rocsolver_cpotrs_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb ! rocsolver_cpotrs_rank_0 = rocsolver_cpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_cpotrs_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb ! rocsolver_cpotrs_rank_1 = rocsolver_cpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_cpotrs_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocsolver_cpotrs_full_rank = rocsolver_cpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zpotrs_assumed_rank(handle,uplo,n,nrhs,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocsolver_zpotrs_assumed_rank = rocsolver_zpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B), & ldb) end function #else function rocsolver_zpotrs_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb ! rocsolver_zpotrs_rank_0 = rocsolver_zpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_zpotrs_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb ! rocsolver_zpotrs_rank_1 = rocsolver_zpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_zpotrs_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocsolver_zpotrs_full_rank = rocsolver_zpotrs_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_spotrs_strided_batched_assumed_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrs_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_spotrs_strided_batched_assumed_rank = rocsolver_spotrs_strided_batched_(handle, & uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #else function rocsolver_spotrs_strided_batched_rank_0(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrs_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_spotrs_strided_batched_rank_0 = rocsolver_spotrs_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_spotrs_strided_batched_rank_1(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrs_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_spotrs_strided_batched_rank_1 = rocsolver_spotrs_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_spotrs_strided_batched_full_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotrs_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_spotrs_strided_batched_full_rank = rocsolver_spotrs_strided_batched_(handle,uplo, & n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dpotrs_strided_batched_assumed_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_dpotrs_strided_batched_assumed_rank = rocsolver_dpotrs_strided_batched_(handle, & uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #else function rocsolver_dpotrs_strided_batched_rank_0(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_dpotrs_strided_batched_rank_0 = rocsolver_dpotrs_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_dpotrs_strided_batched_rank_1(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_dpotrs_strided_batched_rank_1 = rocsolver_dpotrs_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_dpotrs_strided_batched_full_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotrs_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_dpotrs_strided_batched_full_rank = rocsolver_dpotrs_strided_batched_(handle,uplo, & n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cpotrs_strided_batched_assumed_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_cpotrs_strided_batched_assumed_rank = rocsolver_cpotrs_strided_batched_(handle, & uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #else function rocsolver_cpotrs_strided_batched_rank_0(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_cpotrs_strided_batched_rank_0 = rocsolver_cpotrs_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_cpotrs_strided_batched_rank_1(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_cpotrs_strided_batched_rank_1 = rocsolver_cpotrs_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_cpotrs_strided_batched_full_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotrs_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_cpotrs_strided_batched_full_rank = rocsolver_cpotrs_strided_batched_(handle,uplo, & n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zpotrs_strided_batched_assumed_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_zpotrs_strided_batched_assumed_rank = rocsolver_zpotrs_strided_batched_(handle, & uplo,n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #else function rocsolver_zpotrs_strided_batched_rank_0(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_zpotrs_strided_batched_rank_0 = rocsolver_zpotrs_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_zpotrs_strided_batched_rank_1(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_zpotrs_strided_batched_rank_1 = rocsolver_zpotrs_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_zpotrs_strided_batched_full_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotrs_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_zpotrs_strided_batched_full_rank = rocsolver_zpotrs_strided_batched_(handle,uplo, & n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sposv_assumed_rank(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sposv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_sposv_assumed_rank = rocsolver_sposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B), & ldb,myInfo) end function #else function rocsolver_sposv_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sposv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_sposv_rank_0 = rocsolver_sposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo) end function function rocsolver_sposv_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sposv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_sposv_rank_1 = rocsolver_sposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo) end function function rocsolver_sposv_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sposv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_sposv_full_rank = rocsolver_sposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb, & myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dposv_assumed_rank(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dposv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_dposv_assumed_rank = rocsolver_dposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B), & ldb,myInfo) end function #else function rocsolver_dposv_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dposv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_dposv_rank_0 = rocsolver_dposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo) end function function rocsolver_dposv_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dposv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_dposv_rank_1 = rocsolver_dposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo) end function function rocsolver_dposv_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dposv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_dposv_full_rank = rocsolver_dposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb, & myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cposv_assumed_rank(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cposv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_cposv_assumed_rank = rocsolver_cposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B), & ldb,myInfo) end function #else function rocsolver_cposv_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cposv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_cposv_rank_0 = rocsolver_cposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo) end function function rocsolver_cposv_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cposv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_cposv_rank_1 = rocsolver_cposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo) end function function rocsolver_cposv_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cposv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_cposv_full_rank = rocsolver_cposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb, & myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zposv_assumed_rank(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zposv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_zposv_assumed_rank = rocsolver_zposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B), & ldb,myInfo) end function #else function rocsolver_zposv_rank_0(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zposv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_zposv_rank_0 = rocsolver_zposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo) end function function rocsolver_zposv_rank_1(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zposv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_zposv_rank_1 = rocsolver_zposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb,myInfo) end function function rocsolver_zposv_full_rank(handle,uplo,n,nrhs,A,lda,B,ldb,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zposv_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo ! rocsolver_zposv_full_rank = rocsolver_zposv_(handle,uplo,n,nrhs,c_loc(A),lda,c_loc(B),ldb, & myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sposv_strided_batched_assumed_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sposv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sposv_strided_batched_assumed_rank = rocsolver_sposv_strided_batched_(handle,uplo, & n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function #else function rocsolver_sposv_strided_batched_rank_0(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sposv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sposv_strided_batched_rank_0 = rocsolver_sposv_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_sposv_strided_batched_rank_1(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sposv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sposv_strided_batched_rank_1 = rocsolver_sposv_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_sposv_strided_batched_full_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sposv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sposv_strided_batched_full_rank = rocsolver_sposv_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dposv_strided_batched_assumed_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dposv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dposv_strided_batched_assumed_rank = rocsolver_dposv_strided_batched_(handle,uplo, & n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function #else function rocsolver_dposv_strided_batched_rank_0(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dposv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dposv_strided_batched_rank_0 = rocsolver_dposv_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_dposv_strided_batched_rank_1(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dposv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dposv_strided_batched_rank_1 = rocsolver_dposv_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_dposv_strided_batched_full_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dposv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dposv_strided_batched_full_rank = rocsolver_dposv_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cposv_strided_batched_assumed_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cposv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cposv_strided_batched_assumed_rank = rocsolver_cposv_strided_batched_(handle,uplo, & n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function #else function rocsolver_cposv_strided_batched_rank_0(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cposv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cposv_strided_batched_rank_0 = rocsolver_cposv_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_cposv_strided_batched_rank_1(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cposv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cposv_strided_batched_rank_1 = rocsolver_cposv_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_cposv_strided_batched_full_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cposv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cposv_strided_batched_full_rank = rocsolver_cposv_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zposv_strided_batched_assumed_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zposv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zposv_strided_batched_assumed_rank = rocsolver_zposv_strided_batched_(handle,uplo, & n,nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function #else function rocsolver_zposv_strided_batched_rank_0(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zposv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zposv_strided_batched_rank_0 = rocsolver_zposv_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_zposv_strided_batched_rank_1(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zposv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zposv_strided_batched_rank_1 = rocsolver_zposv_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function function rocsolver_zposv_strided_batched_full_rank(handle,uplo,n,nrhs,A,lda,strideA,B,ldb, & strideB,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zposv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n integer(c_int) :: nrhs complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zposv_strided_batched_full_rank = rocsolver_zposv_strided_batched_(handle,uplo,n, & nrhs,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_spotri_assumed_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotri_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_spotri_assumed_rank = rocsolver_spotri_(handle,uplo,n,c_loc(A),lda,myInfo) end function #else function rocsolver_spotri_rank_0(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotri_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_spotri_rank_0 = rocsolver_spotri_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_spotri_rank_1(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotri_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_spotri_rank_1 = rocsolver_spotri_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_spotri_full_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotri_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_spotri_full_rank = rocsolver_spotri_(handle,uplo,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dpotri_assumed_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotri_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dpotri_assumed_rank = rocsolver_dpotri_(handle,uplo,n,c_loc(A),lda,myInfo) end function #else function rocsolver_dpotri_rank_0(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotri_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dpotri_rank_0 = rocsolver_dpotri_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_dpotri_rank_1(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotri_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dpotri_rank_1 = rocsolver_dpotri_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_dpotri_full_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotri_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dpotri_full_rank = rocsolver_dpotri_(handle,uplo,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cpotri_assumed_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotri_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cpotri_assumed_rank = rocsolver_cpotri_(handle,uplo,n,c_loc(A),lda,myInfo) end function #else function rocsolver_cpotri_rank_0(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotri_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cpotri_rank_0 = rocsolver_cpotri_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_cpotri_rank_1(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotri_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cpotri_rank_1 = rocsolver_cpotri_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_cpotri_full_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotri_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_cpotri_full_rank = rocsolver_cpotri_(handle,uplo,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zpotri_assumed_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotri_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zpotri_assumed_rank = rocsolver_zpotri_(handle,uplo,n,c_loc(A),lda,myInfo) end function #else function rocsolver_zpotri_rank_0(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotri_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zpotri_rank_0 = rocsolver_zpotri_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_zpotri_rank_1(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotri_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zpotri_rank_1 = rocsolver_zpotri_(handle,uplo,n,c_loc(A),lda,myInfo) end function function rocsolver_zpotri_full_rank(handle,uplo,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotri_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_zpotri_full_rank = rocsolver_zpotri_(handle,uplo,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_spotri_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotri_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_spotri_strided_batched_assumed_rank = rocsolver_spotri_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_spotri_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotri_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_spotri_strided_batched_rank_0 = rocsolver_spotri_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_spotri_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotri_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_spotri_strided_batched_rank_1 = rocsolver_spotri_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_spotri_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_spotri_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_spotri_strided_batched_full_rank = rocsolver_spotri_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dpotri_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotri_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dpotri_strided_batched_assumed_rank = rocsolver_dpotri_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_dpotri_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotri_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dpotri_strided_batched_rank_0 = rocsolver_dpotri_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_dpotri_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotri_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dpotri_strided_batched_rank_1 = rocsolver_dpotri_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_dpotri_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dpotri_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dpotri_strided_batched_full_rank = rocsolver_dpotri_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cpotri_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotri_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cpotri_strided_batched_assumed_rank = rocsolver_cpotri_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_cpotri_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotri_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cpotri_strided_batched_rank_0 = rocsolver_cpotri_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_cpotri_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotri_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cpotri_strided_batched_rank_1 = rocsolver_cpotri_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_cpotri_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cpotri_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cpotri_strided_batched_full_rank = rocsolver_cpotri_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zpotri_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotri_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zpotri_strided_batched_assumed_rank = rocsolver_zpotri_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_zpotri_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotri_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zpotri_strided_batched_rank_0 = rocsolver_zpotri_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_zpotri_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotri_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zpotri_strided_batched_rank_1 = rocsolver_zpotri_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_zpotri_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zpotri_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zpotri_strided_batched_full_rank = rocsolver_zpotri_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgesvd_assumed_rank(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv, & E,fast_alg,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: S real(c_float),target,contiguous,dimension(..) :: U integer(c_int) :: ldu real(c_float),target,contiguous,dimension(..) :: V integer(c_int) :: ldv real(c_float),target,contiguous,dimension(..) :: E integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo ! rocsolver_sgesvd_assumed_rank = rocsolver_sgesvd_(handle,left_svect,right_svect,m,n, & c_loc(A),lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo) end function #else function rocsolver_sgesvd_rank_0(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E, & fast_alg,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: S real(c_float),target :: U integer(c_int) :: ldu real(c_float),target :: V integer(c_int) :: ldv real(c_float),target :: E integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo ! rocsolver_sgesvd_rank_0 = rocsolver_sgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda, & c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo) end function function rocsolver_sgesvd_rank_1(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E, & fast_alg,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: S real(c_float),target,dimension(:) :: U integer(c_int) :: ldu real(c_float),target,dimension(:) :: V integer(c_int) :: ldv real(c_float),target,dimension(:) :: E integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo ! rocsolver_sgesvd_rank_1 = rocsolver_sgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda, & c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo) end function function rocsolver_sgesvd_full_rank(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E, & fast_alg,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_full_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: S real(c_float),target,dimension(:,:) :: U integer(c_int) :: ldu real(c_float),target,dimension(:,:) :: V integer(c_int) :: ldv real(c_float),target,dimension(:) :: E integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo ! rocsolver_sgesvd_full_rank = rocsolver_sgesvd_(handle,left_svect,right_svect,m,n,c_loc(A), & lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgesvd_assumed_rank(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv, & E,fast_alg,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: S real(c_double),target,contiguous,dimension(..) :: U integer(c_int) :: ldu real(c_double),target,contiguous,dimension(..) :: V integer(c_int) :: ldv real(c_double),target,contiguous,dimension(..) :: E integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo ! rocsolver_dgesvd_assumed_rank = rocsolver_dgesvd_(handle,left_svect,right_svect,m,n, & c_loc(A),lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo) end function #else function rocsolver_dgesvd_rank_0(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E, & fast_alg,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: S real(c_double),target :: U integer(c_int) :: ldu real(c_double),target :: V integer(c_int) :: ldv real(c_double),target :: E integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo ! rocsolver_dgesvd_rank_0 = rocsolver_dgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda, & c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo) end function function rocsolver_dgesvd_rank_1(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E, & fast_alg,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: S real(c_double),target,dimension(:) :: U integer(c_int) :: ldu real(c_double),target,dimension(:) :: V integer(c_int) :: ldv real(c_double),target,dimension(:) :: E integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo ! rocsolver_dgesvd_rank_1 = rocsolver_dgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda, & c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo) end function function rocsolver_dgesvd_full_rank(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E, & fast_alg,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_full_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: S real(c_double),target,dimension(:,:) :: U integer(c_int) :: ldu real(c_double),target,dimension(:,:) :: V integer(c_int) :: ldv real(c_double),target,dimension(:) :: E integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo ! rocsolver_dgesvd_full_rank = rocsolver_dgesvd_(handle,left_svect,right_svect,m,n,c_loc(A), & lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgesvd_assumed_rank(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv, & E,fast_alg,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: S complex(c_float_complex),target,contiguous,dimension(..) :: U integer(c_int) :: ldu complex(c_float_complex),target,contiguous,dimension(..) :: V integer(c_int) :: ldv real(c_float),target,contiguous,dimension(..) :: E integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo ! rocsolver_cgesvd_assumed_rank = rocsolver_cgesvd_(handle,left_svect,right_svect,m,n, & c_loc(A),lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo) end function #else function rocsolver_cgesvd_rank_0(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E, & fast_alg,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda real(c_float),target :: S complex(c_float_complex),target :: U integer(c_int) :: ldu complex(c_float_complex),target :: V integer(c_int) :: ldv real(c_float),target :: E integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo ! rocsolver_cgesvd_rank_0 = rocsolver_cgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda, & c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo) end function function rocsolver_cgesvd_rank_1(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E, & fast_alg,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: S complex(c_float_complex),target,dimension(:) :: U integer(c_int) :: ldu complex(c_float_complex),target,dimension(:) :: V integer(c_int) :: ldv real(c_float),target,dimension(:) :: E integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo ! rocsolver_cgesvd_rank_1 = rocsolver_cgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda, & c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo) end function function rocsolver_cgesvd_full_rank(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E, & fast_alg,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_full_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: S complex(c_float_complex),target,dimension(:,:) :: U integer(c_int) :: ldu complex(c_float_complex),target,dimension(:,:) :: V integer(c_int) :: ldv real(c_float),target,dimension(:) :: E integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo ! rocsolver_cgesvd_full_rank = rocsolver_cgesvd_(handle,left_svect,right_svect,m,n,c_loc(A), & lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgesvd_assumed_rank(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv, & E,fast_alg,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: S complex(c_double_complex),target,contiguous,dimension(..) :: U integer(c_int) :: ldu complex(c_double_complex),target,contiguous,dimension(..) :: V integer(c_int) :: ldv real(c_double),target,contiguous,dimension(..) :: E integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo ! rocsolver_zgesvd_assumed_rank = rocsolver_zgesvd_(handle,left_svect,right_svect,m,n, & c_loc(A),lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo) end function #else function rocsolver_zgesvd_rank_0(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E, & fast_alg,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda real(c_double),target :: S complex(c_double_complex),target :: U integer(c_int) :: ldu complex(c_double_complex),target :: V integer(c_int) :: ldv real(c_double),target :: E integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo ! rocsolver_zgesvd_rank_0 = rocsolver_zgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda, & c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo) end function function rocsolver_zgesvd_rank_1(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E, & fast_alg,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: S complex(c_double_complex),target,dimension(:) :: U integer(c_int) :: ldu complex(c_double_complex),target,dimension(:) :: V integer(c_int) :: ldv real(c_double),target,dimension(:) :: E integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo ! rocsolver_zgesvd_rank_1 = rocsolver_zgesvd_(handle,left_svect,right_svect,m,n,c_loc(A),lda, & c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo) end function function rocsolver_zgesvd_full_rank(handle,left_svect,right_svect,m,n,A,lda,S,U,ldu,V,ldv,E, & fast_alg,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_full_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: S complex(c_double_complex),target,dimension(:,:) :: U integer(c_int) :: ldu complex(c_double_complex),target,dimension(:,:) :: V integer(c_int) :: ldv real(c_double),target,dimension(:) :: E integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo ! rocsolver_zgesvd_full_rank = rocsolver_zgesvd_(handle,left_svect,right_svect,m,n,c_loc(A), & lda,c_loc(S),c_loc(U),ldu,c_loc(V),ldv,c_loc(E),fast_alg,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgesvd_batched_assumed_rank(handle,left_svect,right_svect,m,n,A,lda,S, & strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: S integer(c_int64_t) :: strideS real(c_float),target,contiguous,dimension(..) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU real(c_float),target,contiguous,dimension(..) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgesvd_batched_assumed_rank = rocsolver_sgesvd_batched_(handle,left_svect, & right_svect,m,n,A,lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E), & strideE,fast_alg,myInfo,batch_count) end function #else function rocsolver_sgesvd_batched_rank_0(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U, & ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: S integer(c_int64_t) :: strideS real(c_float),target :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU real(c_float),target :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_float),target :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgesvd_batched_rank_0 = rocsolver_sgesvd_batched_(handle,left_svect,right_svect,m, & n,A,lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE, & fast_alg,myInfo,batch_count) end function function rocsolver_sgesvd_batched_rank_1(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U, & ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: S integer(c_int64_t) :: strideS real(c_float),target,dimension(:) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU real(c_float),target,dimension(:) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgesvd_batched_rank_1 = rocsolver_sgesvd_batched_(handle,left_svect,right_svect,m, & n,A,lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE, & fast_alg,myInfo,batch_count) end function function rocsolver_sgesvd_batched_full_rank(handle,left_svect,right_svect,m,n,A,lda,S,strideS, & U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: S integer(c_int64_t) :: strideS real(c_float),target,dimension(:,:) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU real(c_float),target,dimension(:,:) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgesvd_batched_full_rank = rocsolver_sgesvd_batched_(handle,left_svect, & right_svect,m,n,A,lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E), & strideE,fast_alg,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgesvd_batched_assumed_rank(handle,left_svect,right_svect,m,n,A,lda,S, & strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: S integer(c_int64_t) :: strideS real(c_double),target,contiguous,dimension(..) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU real(c_double),target,contiguous,dimension(..) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgesvd_batched_assumed_rank = rocsolver_dgesvd_batched_(handle,left_svect, & right_svect,m,n,A,lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E), & strideE,fast_alg,myInfo,batch_count) end function #else function rocsolver_dgesvd_batched_rank_0(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U, & ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: S integer(c_int64_t) :: strideS real(c_double),target :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU real(c_double),target :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_double),target :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgesvd_batched_rank_0 = rocsolver_dgesvd_batched_(handle,left_svect,right_svect,m, & n,A,lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE, & fast_alg,myInfo,batch_count) end function function rocsolver_dgesvd_batched_rank_1(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U, & ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: S integer(c_int64_t) :: strideS real(c_double),target,dimension(:) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU real(c_double),target,dimension(:) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgesvd_batched_rank_1 = rocsolver_dgesvd_batched_(handle,left_svect,right_svect,m, & n,A,lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE, & fast_alg,myInfo,batch_count) end function function rocsolver_dgesvd_batched_full_rank(handle,left_svect,right_svect,m,n,A,lda,S,strideS, & U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: S integer(c_int64_t) :: strideS real(c_double),target,dimension(:,:) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU real(c_double),target,dimension(:,:) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgesvd_batched_full_rank = rocsolver_dgesvd_batched_(handle,left_svect, & right_svect,m,n,A,lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E), & strideE,fast_alg,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgesvd_batched_assumed_rank(handle,left_svect,right_svect,m,n,A,lda,S, & strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: S integer(c_int64_t) :: strideS complex(c_float_complex),target,contiguous,dimension(..) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU complex(c_float_complex),target,contiguous,dimension(..) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgesvd_batched_assumed_rank = rocsolver_cgesvd_batched_(handle,left_svect, & right_svect,m,n,A,lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E), & strideE,fast_alg,myInfo,batch_count) end function #else function rocsolver_cgesvd_batched_rank_0(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U, & ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: S integer(c_int64_t) :: strideS complex(c_float_complex),target :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU complex(c_float_complex),target :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_float),target :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgesvd_batched_rank_0 = rocsolver_cgesvd_batched_(handle,left_svect,right_svect,m, & n,A,lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE, & fast_alg,myInfo,batch_count) end function function rocsolver_cgesvd_batched_rank_1(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U, & ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: S integer(c_int64_t) :: strideS complex(c_float_complex),target,dimension(:) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU complex(c_float_complex),target,dimension(:) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgesvd_batched_rank_1 = rocsolver_cgesvd_batched_(handle,left_svect,right_svect,m, & n,A,lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE, & fast_alg,myInfo,batch_count) end function function rocsolver_cgesvd_batched_full_rank(handle,left_svect,right_svect,m,n,A,lda,S,strideS, & U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: S integer(c_int64_t) :: strideS complex(c_float_complex),target,dimension(:,:) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU complex(c_float_complex),target,dimension(:,:) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgesvd_batched_full_rank = rocsolver_cgesvd_batched_(handle,left_svect, & right_svect,m,n,A,lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E), & strideE,fast_alg,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgesvd_batched_assumed_rank(handle,left_svect,right_svect,m,n,A,lda,S, & strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: S integer(c_int64_t) :: strideS complex(c_double_complex),target,contiguous,dimension(..) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU complex(c_double_complex),target,contiguous,dimension(..) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgesvd_batched_assumed_rank = rocsolver_zgesvd_batched_(handle,left_svect, & right_svect,m,n,A,lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E), & strideE,fast_alg,myInfo,batch_count) end function #else function rocsolver_zgesvd_batched_rank_0(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U, & ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: S integer(c_int64_t) :: strideS complex(c_double_complex),target :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU complex(c_double_complex),target :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_double),target :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgesvd_batched_rank_0 = rocsolver_zgesvd_batched_(handle,left_svect,right_svect,m, & n,A,lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE, & fast_alg,myInfo,batch_count) end function function rocsolver_zgesvd_batched_rank_1(handle,left_svect,right_svect,m,n,A,lda,S,strideS,U, & ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: S integer(c_int64_t) :: strideS complex(c_double_complex),target,dimension(:) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU complex(c_double_complex),target,dimension(:) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgesvd_batched_rank_1 = rocsolver_zgesvd_batched_(handle,left_svect,right_svect,m, & n,A,lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E),strideE, & fast_alg,myInfo,batch_count) end function function rocsolver_zgesvd_batched_full_rank(handle,left_svect,right_svect,m,n,A,lda,S,strideS, & U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: S integer(c_int64_t) :: strideS complex(c_double_complex),target,dimension(:,:) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU complex(c_double_complex),target,dimension(:,:) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgesvd_batched_full_rank = rocsolver_zgesvd_batched_(handle,left_svect, & right_svect,m,n,A,lda,c_loc(S),strideS,c_loc(U),ldu,strideU,c_loc(V),ldv,strideV,c_loc(E), & strideE,fast_alg,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgesvd_strided_batched_assumed_rank(handle,left_svect,right_svect,m,n,A, & lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: S integer(c_int64_t) :: strideS real(c_float),target,contiguous,dimension(..) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU real(c_float),target,contiguous,dimension(..) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgesvd_strided_batched_assumed_rank = rocsolver_sgesvd_strided_batched_(handle, & left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU, & c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count) end function #else function rocsolver_sgesvd_strided_batched_rank_0(handle,left_svect,right_svect,m,n,A,lda, & strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: S integer(c_int64_t) :: strideS real(c_float),target :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU real(c_float),target :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_float),target :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgesvd_strided_batched_rank_0 = rocsolver_sgesvd_strided_batched_(handle, & left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU, & c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count) end function function rocsolver_sgesvd_strided_batched_rank_1(handle,left_svect,right_svect,m,n,A,lda, & strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: S integer(c_int64_t) :: strideS real(c_float),target,dimension(:) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU real(c_float),target,dimension(:) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgesvd_strided_batched_rank_1 = rocsolver_sgesvd_strided_batched_(handle, & left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU, & c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count) end function function rocsolver_sgesvd_strided_batched_full_rank(handle,left_svect,right_svect,m,n,A,lda, & strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgesvd_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: S integer(c_int64_t) :: strideS real(c_float),target,dimension(:,:) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU real(c_float),target,dimension(:,:) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgesvd_strided_batched_full_rank = rocsolver_sgesvd_strided_batched_(handle, & left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU, & c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgesvd_strided_batched_assumed_rank(handle,left_svect,right_svect,m,n,A, & lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: S integer(c_int64_t) :: strideS real(c_double),target,contiguous,dimension(..) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU real(c_double),target,contiguous,dimension(..) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgesvd_strided_batched_assumed_rank = rocsolver_dgesvd_strided_batched_(handle, & left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU, & c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count) end function #else function rocsolver_dgesvd_strided_batched_rank_0(handle,left_svect,right_svect,m,n,A,lda, & strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: S integer(c_int64_t) :: strideS real(c_double),target :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU real(c_double),target :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_double),target :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgesvd_strided_batched_rank_0 = rocsolver_dgesvd_strided_batched_(handle, & left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU, & c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count) end function function rocsolver_dgesvd_strided_batched_rank_1(handle,left_svect,right_svect,m,n,A,lda, & strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: S integer(c_int64_t) :: strideS real(c_double),target,dimension(:) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU real(c_double),target,dimension(:) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgesvd_strided_batched_rank_1 = rocsolver_dgesvd_strided_batched_(handle, & left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU, & c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count) end function function rocsolver_dgesvd_strided_batched_full_rank(handle,left_svect,right_svect,m,n,A,lda, & strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgesvd_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: S integer(c_int64_t) :: strideS real(c_double),target,dimension(:,:) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU real(c_double),target,dimension(:,:) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgesvd_strided_batched_full_rank = rocsolver_dgesvd_strided_batched_(handle, & left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU, & c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgesvd_strided_batched_assumed_rank(handle,left_svect,right_svect,m,n,A, & lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: S integer(c_int64_t) :: strideS complex(c_float_complex),target,contiguous,dimension(..) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU complex(c_float_complex),target,contiguous,dimension(..) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgesvd_strided_batched_assumed_rank = rocsolver_cgesvd_strided_batched_(handle, & left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU, & c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count) end function #else function rocsolver_cgesvd_strided_batched_rank_0(handle,left_svect,right_svect,m,n,A,lda, & strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: S integer(c_int64_t) :: strideS complex(c_float_complex),target :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU complex(c_float_complex),target :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_float),target :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgesvd_strided_batched_rank_0 = rocsolver_cgesvd_strided_batched_(handle, & left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU, & c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count) end function function rocsolver_cgesvd_strided_batched_rank_1(handle,left_svect,right_svect,m,n,A,lda, & strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: S integer(c_int64_t) :: strideS complex(c_float_complex),target,dimension(:) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU complex(c_float_complex),target,dimension(:) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgesvd_strided_batched_rank_1 = rocsolver_cgesvd_strided_batched_(handle, & left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU, & c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count) end function function rocsolver_cgesvd_strided_batched_full_rank(handle,left_svect,right_svect,m,n,A,lda, & strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgesvd_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: S integer(c_int64_t) :: strideS complex(c_float_complex),target,dimension(:,:) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU complex(c_float_complex),target,dimension(:,:) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgesvd_strided_batched_full_rank = rocsolver_cgesvd_strided_batched_(handle, & left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU, & c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgesvd_strided_batched_assumed_rank(handle,left_svect,right_svect,m,n,A, & lda,strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: S integer(c_int64_t) :: strideS complex(c_double_complex),target,contiguous,dimension(..) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU complex(c_double_complex),target,contiguous,dimension(..) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgesvd_strided_batched_assumed_rank = rocsolver_zgesvd_strided_batched_(handle, & left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU, & c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count) end function #else function rocsolver_zgesvd_strided_batched_rank_0(handle,left_svect,right_svect,m,n,A,lda, & strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: S integer(c_int64_t) :: strideS complex(c_double_complex),target :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU complex(c_double_complex),target :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_double),target :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgesvd_strided_batched_rank_0 = rocsolver_zgesvd_strided_batched_(handle, & left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU, & c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count) end function function rocsolver_zgesvd_strided_batched_rank_1(handle,left_svect,right_svect,m,n,A,lda, & strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: S integer(c_int64_t) :: strideS complex(c_double_complex),target,dimension(:) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU complex(c_double_complex),target,dimension(:) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgesvd_strided_batched_rank_1 = rocsolver_zgesvd_strided_batched_(handle, & left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU, & c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count) end function function rocsolver_zgesvd_strided_batched_full_rank(handle,left_svect,right_svect,m,n,A,lda, & strideA,S,strideS,U,ldu,strideU,V,ldv,strideV,E,strideE,fast_alg,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgesvd_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_svect_all)) :: left_svect integer(kind(rocblas_svect_all)) :: right_svect integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: S integer(c_int64_t) :: strideS complex(c_double_complex),target,dimension(:,:) :: U integer(c_int) :: ldu integer(c_int64_t) :: strideU complex(c_double_complex),target,dimension(:,:) :: V integer(c_int) :: ldv integer(c_int64_t) :: strideV real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE integer(kind(rocblas_outofplace)) :: fast_alg type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgesvd_strided_batched_full_rank = rocsolver_zgesvd_strided_batched_(handle, & left_svect,right_svect,m,n,c_loc(A),lda,strideA,c_loc(S),strideS,c_loc(U),ldu,strideU, & c_loc(V),ldv,strideV,c_loc(E),strideE,fast_alg,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssytd2_assumed_rank(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E real(c_float),target,contiguous,dimension(..) :: tau ! rocsolver_ssytd2_assumed_rank = rocsolver_ssytd2_(handle,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),c_loc(tau)) end function #else function rocsolver_ssytd2_rank_0(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E real(c_float),target :: tau ! rocsolver_ssytd2_rank_0 = rocsolver_ssytd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function function rocsolver_ssytd2_rank_1(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:) :: tau ! rocsolver_ssytd2_rank_1 = rocsolver_ssytd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function function rocsolver_ssytd2_full_rank(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:) :: tau ! rocsolver_ssytd2_full_rank = rocsolver_ssytd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsytd2_assumed_rank(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E real(c_double),target,contiguous,dimension(..) :: tau ! rocsolver_dsytd2_assumed_rank = rocsolver_dsytd2_(handle,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),c_loc(tau)) end function #else function rocsolver_dsytd2_rank_0(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E real(c_double),target :: tau ! rocsolver_dsytd2_rank_0 = rocsolver_dsytd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function function rocsolver_dsytd2_rank_1(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:) :: tau ! rocsolver_dsytd2_rank_1 = rocsolver_dsytd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function function rocsolver_dsytd2_full_rank(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:) :: tau ! rocsolver_dsytd2_full_rank = rocsolver_dsytd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_chetd2_assumed_rank(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetd2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E complex(c_float_complex),target,contiguous,dimension(..) :: tau ! rocsolver_chetd2_assumed_rank = rocsolver_chetd2_(handle,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),c_loc(tau)) end function #else function rocsolver_chetd2_rank_0(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetd2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E complex(c_float_complex),target :: tau ! rocsolver_chetd2_rank_0 = rocsolver_chetd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function function rocsolver_chetd2_rank_1(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetd2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:) :: tau ! rocsolver_chetd2_rank_1 = rocsolver_chetd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function function rocsolver_chetd2_full_rank(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetd2_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:) :: tau ! rocsolver_chetd2_full_rank = rocsolver_chetd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zhetd2_assumed_rank(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E complex(c_double_complex),target,contiguous,dimension(..) :: tau ! rocsolver_zhetd2_assumed_rank = rocsolver_zhetd2_(handle,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),c_loc(tau)) end function #else function rocsolver_zhetd2_rank_0(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E complex(c_double_complex),target :: tau ! rocsolver_zhetd2_rank_0 = rocsolver_zhetd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function function rocsolver_zhetd2_rank_1(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:) :: tau ! rocsolver_zhetd2_rank_1 = rocsolver_zhetd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function function rocsolver_zhetd2_full_rank(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:) :: tau ! rocsolver_zhetd2_full_rank = rocsolver_zhetd2_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssytd2_batched_assumed_rank(handle,uplo,n,A,lda,D,strideD,E,strideE,tau, & strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE real(c_float),target,contiguous,dimension(..) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_ssytd2_batched_assumed_rank = rocsolver_ssytd2_batched_(handle,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #else function rocsolver_ssytd2_batched_rank_0(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE real(c_float),target :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_ssytd2_batched_rank_0 = rocsolver_ssytd2_batched_(handle,uplo,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_ssytd2_batched_rank_1(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_float),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_ssytd2_batched_rank_1 = rocsolver_ssytd2_batched_(handle,uplo,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsytd2_batched_assumed_rank(handle,uplo,n,A,lda,D,strideD,E,strideE,tau, & strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE real(c_double),target,contiguous,dimension(..) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dsytd2_batched_assumed_rank = rocsolver_dsytd2_batched_(handle,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #else function rocsolver_dsytd2_batched_rank_0(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE real(c_double),target :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dsytd2_batched_rank_0 = rocsolver_dsytd2_batched_(handle,uplo,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_dsytd2_batched_rank_1(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_double),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dsytd2_batched_rank_1 = rocsolver_dsytd2_batched_(handle,uplo,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_chetd2_batched_assumed_rank(handle,uplo,n,A,lda,D,strideD,E,strideE,tau, & strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetd2_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,contiguous,dimension(..) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_chetd2_batched_assumed_rank = rocsolver_chetd2_batched_(handle,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #else function rocsolver_chetd2_batched_rank_0(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetd2_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE complex(c_float_complex),target :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_chetd2_batched_rank_0 = rocsolver_chetd2_batched_(handle,uplo,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_chetd2_batched_rank_1(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetd2_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_chetd2_batched_rank_1 = rocsolver_chetd2_batched_(handle,uplo,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zhetd2_batched_assumed_rank(handle,uplo,n,A,lda,D,strideD,E,strideE,tau, & strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,contiguous,dimension(..) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zhetd2_batched_assumed_rank = rocsolver_zhetd2_batched_(handle,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #else function rocsolver_zhetd2_batched_rank_0(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE complex(c_double_complex),target :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zhetd2_batched_rank_0 = rocsolver_zhetd2_batched_(handle,uplo,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_zhetd2_batched_rank_1(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zhetd2_batched_rank_1 = rocsolver_zhetd2_batched_(handle,uplo,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssytd2_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,D,strideD, & E,strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE real(c_float),target,contiguous,dimension(..) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_ssytd2_strided_batched_assumed_rank = rocsolver_ssytd2_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP, & batch_count) end function #else function rocsolver_ssytd2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE real(c_float),target :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_ssytd2_strided_batched_rank_0 = rocsolver_ssytd2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_ssytd2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_float),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_ssytd2_strided_batched_rank_1 = rocsolver_ssytd2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_ssytd2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytd2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_float),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_ssytd2_strided_batched_full_rank = rocsolver_ssytd2_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsytd2_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,D,strideD, & E,strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE real(c_double),target,contiguous,dimension(..) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dsytd2_strided_batched_assumed_rank = rocsolver_dsytd2_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP, & batch_count) end function #else function rocsolver_dsytd2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE real(c_double),target :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dsytd2_strided_batched_rank_0 = rocsolver_dsytd2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_dsytd2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_double),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dsytd2_strided_batched_rank_1 = rocsolver_dsytd2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_dsytd2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytd2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_double),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dsytd2_strided_batched_full_rank = rocsolver_dsytd2_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_chetd2_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,D,strideD, & E,strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetd2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,contiguous,dimension(..) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_chetd2_strided_batched_assumed_rank = rocsolver_chetd2_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP, & batch_count) end function #else function rocsolver_chetd2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetd2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE complex(c_float_complex),target :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_chetd2_strided_batched_rank_0 = rocsolver_chetd2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_chetd2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetd2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_chetd2_strided_batched_rank_1 = rocsolver_chetd2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_chetd2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetd2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_chetd2_strided_batched_full_rank = rocsolver_chetd2_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zhetd2_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,D,strideD, & E,strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,contiguous,dimension(..) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zhetd2_strided_batched_assumed_rank = rocsolver_zhetd2_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP, & batch_count) end function #else function rocsolver_zhetd2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE complex(c_double_complex),target :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zhetd2_strided_batched_rank_0 = rocsolver_zhetd2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_zhetd2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zhetd2_strided_batched_rank_1 = rocsolver_zhetd2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_zhetd2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetd2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zhetd2_strided_batched_full_rank = rocsolver_zhetd2_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssytrd_assumed_rank(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E real(c_float),target,contiguous,dimension(..) :: tau ! rocsolver_ssytrd_assumed_rank = rocsolver_ssytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),c_loc(tau)) end function #else function rocsolver_ssytrd_rank_0(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E real(c_float),target :: tau ! rocsolver_ssytrd_rank_0 = rocsolver_ssytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function function rocsolver_ssytrd_rank_1(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:) :: tau ! rocsolver_ssytrd_rank_1 = rocsolver_ssytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function function rocsolver_ssytrd_full_rank(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E real(c_float),target,dimension(:) :: tau ! rocsolver_ssytrd_full_rank = rocsolver_ssytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsytrd_assumed_rank(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E real(c_double),target,contiguous,dimension(..) :: tau ! rocsolver_dsytrd_assumed_rank = rocsolver_dsytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),c_loc(tau)) end function #else function rocsolver_dsytrd_rank_0(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E real(c_double),target :: tau ! rocsolver_dsytrd_rank_0 = rocsolver_dsytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function function rocsolver_dsytrd_rank_1(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:) :: tau ! rocsolver_dsytrd_rank_1 = rocsolver_dsytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function function rocsolver_dsytrd_full_rank(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E real(c_double),target,dimension(:) :: tau ! rocsolver_dsytrd_full_rank = rocsolver_dsytrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_chetrd_assumed_rank(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetrd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E complex(c_float_complex),target,contiguous,dimension(..) :: tau ! rocsolver_chetrd_assumed_rank = rocsolver_chetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),c_loc(tau)) end function #else function rocsolver_chetrd_rank_0(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetrd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E complex(c_float_complex),target :: tau ! rocsolver_chetrd_rank_0 = rocsolver_chetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function function rocsolver_chetrd_rank_1(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetrd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:) :: tau ! rocsolver_chetrd_rank_1 = rocsolver_chetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function function rocsolver_chetrd_full_rank(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetrd_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E complex(c_float_complex),target,dimension(:) :: tau ! rocsolver_chetrd_full_rank = rocsolver_chetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zhetrd_assumed_rank(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E complex(c_double_complex),target,contiguous,dimension(..) :: tau ! rocsolver_zhetrd_assumed_rank = rocsolver_zhetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),c_loc(tau)) end function #else function rocsolver_zhetrd_rank_0(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E complex(c_double_complex),target :: tau ! rocsolver_zhetrd_rank_0 = rocsolver_zhetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function function rocsolver_zhetrd_rank_1(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:) :: tau ! rocsolver_zhetrd_rank_1 = rocsolver_zhetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function function rocsolver_zhetrd_full_rank(handle,uplo,n,A,lda,D,E,tau) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E complex(c_double_complex),target,dimension(:) :: tau ! rocsolver_zhetrd_full_rank = rocsolver_zhetrd_(handle,uplo,n,c_loc(A),lda,c_loc(D),c_loc(E), & c_loc(tau)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssytrd_batched_assumed_rank(handle,uplo,n,A,lda,D,strideD,E,strideE,tau, & strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE real(c_float),target,contiguous,dimension(..) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_ssytrd_batched_assumed_rank = rocsolver_ssytrd_batched_(handle,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #else function rocsolver_ssytrd_batched_rank_0(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE real(c_float),target :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_ssytrd_batched_rank_0 = rocsolver_ssytrd_batched_(handle,uplo,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_ssytrd_batched_rank_1(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_float),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_ssytrd_batched_rank_1 = rocsolver_ssytrd_batched_(handle,uplo,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsytrd_batched_assumed_rank(handle,uplo,n,A,lda,D,strideD,E,strideE,tau, & strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE real(c_double),target,contiguous,dimension(..) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dsytrd_batched_assumed_rank = rocsolver_dsytrd_batched_(handle,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #else function rocsolver_dsytrd_batched_rank_0(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE real(c_double),target :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dsytrd_batched_rank_0 = rocsolver_dsytrd_batched_(handle,uplo,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_dsytrd_batched_rank_1(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_double),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dsytrd_batched_rank_1 = rocsolver_dsytrd_batched_(handle,uplo,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_chetrd_batched_assumed_rank(handle,uplo,n,A,lda,D,strideD,E,strideE,tau, & strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetrd_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,contiguous,dimension(..) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_chetrd_batched_assumed_rank = rocsolver_chetrd_batched_(handle,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #else function rocsolver_chetrd_batched_rank_0(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetrd_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE complex(c_float_complex),target :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_chetrd_batched_rank_0 = rocsolver_chetrd_batched_(handle,uplo,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_chetrd_batched_rank_1(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetrd_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_chetrd_batched_rank_1 = rocsolver_chetrd_batched_(handle,uplo,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zhetrd_batched_assumed_rank(handle,uplo,n,A,lda,D,strideD,E,strideE,tau, & strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,contiguous,dimension(..) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zhetrd_batched_assumed_rank = rocsolver_zhetrd_batched_(handle,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #else function rocsolver_zhetrd_batched_rank_0(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE complex(c_double_complex),target :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zhetrd_batched_rank_0 = rocsolver_zhetrd_batched_(handle,uplo,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_zhetrd_batched_rank_1(handle,uplo,n,A,lda,D,strideD,E,strideE,tau,strideP, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zhetrd_batched_rank_1 = rocsolver_zhetrd_batched_(handle,uplo,n,A,lda,c_loc(D), & strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssytrd_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,D,strideD, & E,strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE real(c_float),target,contiguous,dimension(..) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_ssytrd_strided_batched_assumed_rank = rocsolver_ssytrd_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP, & batch_count) end function #else function rocsolver_ssytrd_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE real(c_float),target :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_ssytrd_strided_batched_rank_0 = rocsolver_ssytrd_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_ssytrd_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_float),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_ssytrd_strided_batched_rank_1 = rocsolver_ssytrd_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_ssytrd_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrd_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_float),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_ssytrd_strided_batched_full_rank = rocsolver_ssytrd_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsytrd_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,D,strideD, & E,strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE real(c_double),target,contiguous,dimension(..) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dsytrd_strided_batched_assumed_rank = rocsolver_dsytrd_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP, & batch_count) end function #else function rocsolver_dsytrd_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE real(c_double),target :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dsytrd_strided_batched_rank_0 = rocsolver_dsytrd_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_dsytrd_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_double),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dsytrd_strided_batched_rank_1 = rocsolver_dsytrd_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_dsytrd_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrd_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE real(c_double),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_dsytrd_strided_batched_full_rank = rocsolver_dsytrd_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_chetrd_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,D,strideD, & E,strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetrd_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,contiguous,dimension(..) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_chetrd_strided_batched_assumed_rank = rocsolver_chetrd_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP, & batch_count) end function #else function rocsolver_chetrd_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetrd_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE complex(c_float_complex),target :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_chetrd_strided_batched_rank_0 = rocsolver_chetrd_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_chetrd_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetrd_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_chetrd_strided_batched_rank_1 = rocsolver_chetrd_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_chetrd_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chetrd_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_float_complex),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_chetrd_strided_batched_full_rank = rocsolver_chetrd_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zhetrd_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,D,strideD, & E,strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,contiguous,dimension(..) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zhetrd_strided_batched_assumed_rank = rocsolver_zhetrd_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP, & batch_count) end function #else function rocsolver_zhetrd_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE complex(c_double_complex),target :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zhetrd_strided_batched_rank_0 = rocsolver_zhetrd_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_zhetrd_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zhetrd_strided_batched_rank_1 = rocsolver_zhetrd_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function function rocsolver_zhetrd_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,D,strideD,E, & strideE,tau,strideP,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhetrd_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE complex(c_double_complex),target,dimension(:) :: tau integer(c_int64_t) :: strideP integer(c_int) :: batch_count ! rocsolver_zhetrd_strided_batched_full_rank = rocsolver_zhetrd_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,c_loc(tau),strideP,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssygs2_assumed_rank(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocsolver_ssygs2_assumed_rank = rocsolver_ssygs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B), & ldb) end function #else function rocsolver_ssygs2_rank_0(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: B integer(c_int) :: ldb ! rocsolver_ssygs2_rank_0 = rocsolver_ssygs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_ssygs2_rank_1(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: B integer(c_int) :: ldb ! rocsolver_ssygs2_rank_1 = rocsolver_ssygs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_ssygs2_full_rank(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocsolver_ssygs2_full_rank = rocsolver_ssygs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsygs2_assumed_rank(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocsolver_dsygs2_assumed_rank = rocsolver_dsygs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B), & ldb) end function #else function rocsolver_dsygs2_rank_0(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: B integer(c_int) :: ldb ! rocsolver_dsygs2_rank_0 = rocsolver_dsygs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_dsygs2_rank_1(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: B integer(c_int) :: ldb ! rocsolver_dsygs2_rank_1 = rocsolver_dsygs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_dsygs2_full_rank(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocsolver_dsygs2_full_rank = rocsolver_dsygs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_chegs2_assumed_rank(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegs2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocsolver_chegs2_assumed_rank = rocsolver_chegs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B), & ldb) end function #else function rocsolver_chegs2_rank_0(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegs2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb ! rocsolver_chegs2_rank_0 = rocsolver_chegs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_chegs2_rank_1(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegs2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb ! rocsolver_chegs2_rank_1 = rocsolver_chegs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_chegs2_full_rank(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegs2_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocsolver_chegs2_full_rank = rocsolver_chegs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zhegs2_assumed_rank(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocsolver_zhegs2_assumed_rank = rocsolver_zhegs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B), & ldb) end function #else function rocsolver_zhegs2_rank_0(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb ! rocsolver_zhegs2_rank_0 = rocsolver_zhegs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_zhegs2_rank_1(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb ! rocsolver_zhegs2_rank_1 = rocsolver_zhegs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_zhegs2_full_rank(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocsolver_zhegs2_full_rank = rocsolver_zhegs2_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssygs2_strided_batched_assumed_rank(handle,itype,uplo,n,A,lda,strideA,B, & ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_ssygs2_strided_batched_assumed_rank = rocsolver_ssygs2_strided_batched_(handle, & itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #else function rocsolver_ssygs2_strided_batched_rank_0(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_ssygs2_strided_batched_rank_0 = rocsolver_ssygs2_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_ssygs2_strided_batched_rank_1(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_ssygs2_strided_batched_rank_1 = rocsolver_ssygs2_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_ssygs2_strided_batched_full_rank(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygs2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_ssygs2_strided_batched_full_rank = rocsolver_ssygs2_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsygs2_strided_batched_assumed_rank(handle,itype,uplo,n,A,lda,strideA,B, & ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_dsygs2_strided_batched_assumed_rank = rocsolver_dsygs2_strided_batched_(handle, & itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #else function rocsolver_dsygs2_strided_batched_rank_0(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_dsygs2_strided_batched_rank_0 = rocsolver_dsygs2_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_dsygs2_strided_batched_rank_1(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_dsygs2_strided_batched_rank_1 = rocsolver_dsygs2_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_dsygs2_strided_batched_full_rank(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygs2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_dsygs2_strided_batched_full_rank = rocsolver_dsygs2_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_chegs2_strided_batched_assumed_rank(handle,itype,uplo,n,A,lda,strideA,B, & ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegs2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_chegs2_strided_batched_assumed_rank = rocsolver_chegs2_strided_batched_(handle, & itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #else function rocsolver_chegs2_strided_batched_rank_0(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegs2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_chegs2_strided_batched_rank_0 = rocsolver_chegs2_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_chegs2_strided_batched_rank_1(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegs2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_chegs2_strided_batched_rank_1 = rocsolver_chegs2_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_chegs2_strided_batched_full_rank(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegs2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_chegs2_strided_batched_full_rank = rocsolver_chegs2_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zhegs2_strided_batched_assumed_rank(handle,itype,uplo,n,A,lda,strideA,B, & ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_zhegs2_strided_batched_assumed_rank = rocsolver_zhegs2_strided_batched_(handle, & itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #else function rocsolver_zhegs2_strided_batched_rank_0(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_zhegs2_strided_batched_rank_0 = rocsolver_zhegs2_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_zhegs2_strided_batched_rank_1(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_zhegs2_strided_batched_rank_1 = rocsolver_zhegs2_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_zhegs2_strided_batched_full_rank(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegs2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_zhegs2_strided_batched_full_rank = rocsolver_zhegs2_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssygst_assumed_rank(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygst_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocsolver_ssygst_assumed_rank = rocsolver_ssygst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B), & ldb) end function #else function rocsolver_ssygst_rank_0(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygst_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: B integer(c_int) :: ldb ! rocsolver_ssygst_rank_0 = rocsolver_ssygst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_ssygst_rank_1(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygst_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: B integer(c_int) :: ldb ! rocsolver_ssygst_rank_1 = rocsolver_ssygst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_ssygst_full_rank(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygst_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocsolver_ssygst_full_rank = rocsolver_ssygst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsygst_assumed_rank(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygst_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocsolver_dsygst_assumed_rank = rocsolver_dsygst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B), & ldb) end function #else function rocsolver_dsygst_rank_0(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygst_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: B integer(c_int) :: ldb ! rocsolver_dsygst_rank_0 = rocsolver_dsygst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_dsygst_rank_1(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygst_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: B integer(c_int) :: ldb ! rocsolver_dsygst_rank_1 = rocsolver_dsygst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_dsygst_full_rank(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygst_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocsolver_dsygst_full_rank = rocsolver_dsygst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_chegst_assumed_rank(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegst_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocsolver_chegst_assumed_rank = rocsolver_chegst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B), & ldb) end function #else function rocsolver_chegst_rank_0(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegst_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb ! rocsolver_chegst_rank_0 = rocsolver_chegst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_chegst_rank_1(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegst_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb ! rocsolver_chegst_rank_1 = rocsolver_chegst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_chegst_full_rank(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegst_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocsolver_chegst_full_rank = rocsolver_chegst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zhegst_assumed_rank(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegst_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb ! rocsolver_zhegst_assumed_rank = rocsolver_zhegst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B), & ldb) end function #else function rocsolver_zhegst_rank_0(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegst_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb ! rocsolver_zhegst_rank_0 = rocsolver_zhegst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_zhegst_rank_1(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegst_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb ! rocsolver_zhegst_rank_1 = rocsolver_zhegst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function function rocsolver_zhegst_full_rank(handle,itype,uplo,n,A,lda,B,ldb) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegst_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb ! rocsolver_zhegst_full_rank = rocsolver_zhegst_(handle,itype,uplo,n,c_loc(A),lda,c_loc(B),ldb) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssygst_strided_batched_assumed_rank(handle,itype,uplo,n,A,lda,strideA,B, & ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygst_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_ssygst_strided_batched_assumed_rank = rocsolver_ssygst_strided_batched_(handle, & itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #else function rocsolver_ssygst_strided_batched_rank_0(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygst_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_ssygst_strided_batched_rank_0 = rocsolver_ssygst_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_ssygst_strided_batched_rank_1(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygst_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_ssygst_strided_batched_rank_1 = rocsolver_ssygst_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_ssygst_strided_batched_full_rank(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygst_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_ssygst_strided_batched_full_rank = rocsolver_ssygst_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsygst_strided_batched_assumed_rank(handle,itype,uplo,n,A,lda,strideA,B, & ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygst_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_dsygst_strided_batched_assumed_rank = rocsolver_dsygst_strided_batched_(handle, & itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #else function rocsolver_dsygst_strided_batched_rank_0(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygst_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_dsygst_strided_batched_rank_0 = rocsolver_dsygst_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_dsygst_strided_batched_rank_1(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygst_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_dsygst_strided_batched_rank_1 = rocsolver_dsygst_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_dsygst_strided_batched_full_rank(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygst_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_dsygst_strided_batched_full_rank = rocsolver_dsygst_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_chegst_strided_batched_assumed_rank(handle,itype,uplo,n,A,lda,strideA,B, & ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegst_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_chegst_strided_batched_assumed_rank = rocsolver_chegst_strided_batched_(handle, & itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #else function rocsolver_chegst_strided_batched_rank_0(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegst_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_chegst_strided_batched_rank_0 = rocsolver_chegst_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_chegst_strided_batched_rank_1(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegst_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_chegst_strided_batched_rank_1 = rocsolver_chegst_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_chegst_strided_batched_full_rank(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegst_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_chegst_strided_batched_full_rank = rocsolver_chegst_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zhegst_strided_batched_assumed_rank(handle,itype,uplo,n,A,lda,strideA,B, & ldb,strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegst_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_zhegst_strided_batched_assumed_rank = rocsolver_zhegst_strided_batched_(handle, & itype,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #else function rocsolver_zhegst_strided_batched_rank_0(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegst_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_zhegst_strided_batched_rank_0 = rocsolver_zhegst_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_zhegst_strided_batched_rank_1(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegst_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_zhegst_strided_batched_rank_1 = rocsolver_zhegst_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function function rocsolver_zhegst_strided_batched_full_rank(handle,itype,uplo,n,A,lda,strideA,B,ldb, & strideB,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegst_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB integer(c_int) :: batch_count ! rocsolver_zhegst_strided_batched_full_rank = rocsolver_zhegst_strided_batched_(handle,itype, & uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssyev_assumed_rank(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyev_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E type(c_ptr) :: myInfo ! rocsolver_ssyev_assumed_rank = rocsolver_ssyev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function #else function rocsolver_ssyev_rank_0(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyev_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E type(c_ptr) :: myInfo ! rocsolver_ssyev_rank_0 = rocsolver_ssyev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function function rocsolver_ssyev_rank_1(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyev_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_ssyev_rank_1 = rocsolver_ssyev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function function rocsolver_ssyev_full_rank(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyev_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_ssyev_full_rank = rocsolver_ssyev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsyev_assumed_rank(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyev_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E type(c_ptr) :: myInfo ! rocsolver_dsyev_assumed_rank = rocsolver_dsyev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function #else function rocsolver_dsyev_rank_0(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyev_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E type(c_ptr) :: myInfo ! rocsolver_dsyev_rank_0 = rocsolver_dsyev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function function rocsolver_dsyev_rank_1(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyev_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_dsyev_rank_1 = rocsolver_dsyev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function function rocsolver_dsyev_full_rank(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyev_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_dsyev_full_rank = rocsolver_dsyev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cheev_assumed_rank(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheev_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E type(c_ptr) :: myInfo ! rocsolver_cheev_assumed_rank = rocsolver_cheev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function #else function rocsolver_cheev_rank_0(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheev_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E type(c_ptr) :: myInfo ! rocsolver_cheev_rank_0 = rocsolver_cheev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function function rocsolver_cheev_rank_1(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheev_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_cheev_rank_1 = rocsolver_cheev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function function rocsolver_cheev_full_rank(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheev_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_cheev_full_rank = rocsolver_cheev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zheev_assumed_rank(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheev_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E type(c_ptr) :: myInfo ! rocsolver_zheev_assumed_rank = rocsolver_zheev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function #else function rocsolver_zheev_rank_0(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheev_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E type(c_ptr) :: myInfo ! rocsolver_zheev_rank_0 = rocsolver_zheev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function function rocsolver_zheev_rank_1(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheev_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_zheev_rank_1 = rocsolver_zheev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function function rocsolver_zheev_full_rank(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheev_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_zheev_full_rank = rocsolver_zheev_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssyev_batched_assumed_rank(handle,evect,uplo,n,A,lda,D,strideD,E,strideE, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyev_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssyev_batched_assumed_rank = rocsolver_ssyev_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_ssyev_batched_rank_0(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyev_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssyev_batched_rank_0 = rocsolver_ssyev_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_ssyev_batched_rank_1(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyev_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssyev_batched_rank_1 = rocsolver_ssyev_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsyev_batched_assumed_rank(handle,evect,uplo,n,A,lda,D,strideD,E,strideE, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyev_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsyev_batched_assumed_rank = rocsolver_dsyev_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_dsyev_batched_rank_0(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyev_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsyev_batched_rank_0 = rocsolver_dsyev_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_dsyev_batched_rank_1(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyev_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsyev_batched_rank_1 = rocsolver_dsyev_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cheev_batched_assumed_rank(handle,evect,uplo,n,A,lda,D,strideD,E,strideE, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheev_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cheev_batched_assumed_rank = rocsolver_cheev_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_cheev_batched_rank_0(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheev_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cheev_batched_rank_0 = rocsolver_cheev_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_cheev_batched_rank_1(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheev_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cheev_batched_rank_1 = rocsolver_cheev_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zheev_batched_assumed_rank(handle,evect,uplo,n,A,lda,D,strideD,E,strideE, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheev_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zheev_batched_assumed_rank = rocsolver_zheev_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_zheev_batched_rank_0(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheev_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zheev_batched_rank_0 = rocsolver_zheev_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_zheev_batched_rank_1(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheev_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zheev_batched_rank_1 = rocsolver_zheev_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssyev_strided_batched_assumed_rank(handle,evect,uplo,n,A,lda,strideA,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyev_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssyev_strided_batched_assumed_rank = rocsolver_ssyev_strided_batched_(handle, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_ssyev_strided_batched_rank_0(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyev_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssyev_strided_batched_rank_0 = rocsolver_ssyev_strided_batched_(handle,evect,uplo, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_ssyev_strided_batched_rank_1(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyev_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssyev_strided_batched_rank_1 = rocsolver_ssyev_strided_batched_(handle,evect,uplo, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_ssyev_strided_batched_full_rank(handle,evect,uplo,n,A,lda,strideA,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyev_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssyev_strided_batched_full_rank = rocsolver_ssyev_strided_batched_(handle,evect, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsyev_strided_batched_assumed_rank(handle,evect,uplo,n,A,lda,strideA,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyev_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsyev_strided_batched_assumed_rank = rocsolver_dsyev_strided_batched_(handle, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_dsyev_strided_batched_rank_0(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyev_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsyev_strided_batched_rank_0 = rocsolver_dsyev_strided_batched_(handle,evect,uplo, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_dsyev_strided_batched_rank_1(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyev_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsyev_strided_batched_rank_1 = rocsolver_dsyev_strided_batched_(handle,evect,uplo, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_dsyev_strided_batched_full_rank(handle,evect,uplo,n,A,lda,strideA,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyev_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsyev_strided_batched_full_rank = rocsolver_dsyev_strided_batched_(handle,evect, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cheev_strided_batched_assumed_rank(handle,evect,uplo,n,A,lda,strideA,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheev_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cheev_strided_batched_assumed_rank = rocsolver_cheev_strided_batched_(handle, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_cheev_strided_batched_rank_0(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheev_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cheev_strided_batched_rank_0 = rocsolver_cheev_strided_batched_(handle,evect,uplo, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_cheev_strided_batched_rank_1(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheev_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cheev_strided_batched_rank_1 = rocsolver_cheev_strided_batched_(handle,evect,uplo, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_cheev_strided_batched_full_rank(handle,evect,uplo,n,A,lda,strideA,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheev_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cheev_strided_batched_full_rank = rocsolver_cheev_strided_batched_(handle,evect, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zheev_strided_batched_assumed_rank(handle,evect,uplo,n,A,lda,strideA,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheev_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zheev_strided_batched_assumed_rank = rocsolver_zheev_strided_batched_(handle, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_zheev_strided_batched_rank_0(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheev_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zheev_strided_batched_rank_0 = rocsolver_zheev_strided_batched_(handle,evect,uplo, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_zheev_strided_batched_rank_1(handle,evect,uplo,n,A,lda,strideA,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheev_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zheev_strided_batched_rank_1 = rocsolver_zheev_strided_batched_(handle,evect,uplo, & n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_zheev_strided_batched_full_rank(handle,evect,uplo,n,A,lda,strideA,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheev_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zheev_strided_batched_full_rank = rocsolver_zheev_strided_batched_(handle,evect, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssyevd_assumed_rank(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E type(c_ptr) :: myInfo ! rocsolver_ssyevd_assumed_rank = rocsolver_ssyevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function #else function rocsolver_ssyevd_rank_0(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E type(c_ptr) :: myInfo ! rocsolver_ssyevd_rank_0 = rocsolver_ssyevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function function rocsolver_ssyevd_rank_1(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_ssyevd_rank_1 = rocsolver_ssyevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function function rocsolver_ssyevd_full_rank(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_ssyevd_full_rank = rocsolver_ssyevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsyevd_assumed_rank(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E type(c_ptr) :: myInfo ! rocsolver_dsyevd_assumed_rank = rocsolver_dsyevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function #else function rocsolver_dsyevd_rank_0(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E type(c_ptr) :: myInfo ! rocsolver_dsyevd_rank_0 = rocsolver_dsyevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function function rocsolver_dsyevd_rank_1(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_dsyevd_rank_1 = rocsolver_dsyevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function function rocsolver_dsyevd_full_rank(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_dsyevd_full_rank = rocsolver_dsyevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cheevd_assumed_rank(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E type(c_ptr) :: myInfo ! rocsolver_cheevd_assumed_rank = rocsolver_cheevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function #else function rocsolver_cheevd_rank_0(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda real(c_float),target :: D real(c_float),target :: E type(c_ptr) :: myInfo ! rocsolver_cheevd_rank_0 = rocsolver_cheevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function function rocsolver_cheevd_rank_1(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_cheevd_rank_1 = rocsolver_cheevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function function rocsolver_cheevd_full_rank(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevd_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_cheevd_full_rank = rocsolver_cheevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zheevd_assumed_rank(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E type(c_ptr) :: myInfo ! rocsolver_zheevd_assumed_rank = rocsolver_zheevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function #else function rocsolver_zheevd_rank_0(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda real(c_double),target :: D real(c_double),target :: E type(c_ptr) :: myInfo ! rocsolver_zheevd_rank_0 = rocsolver_zheevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function function rocsolver_zheevd_rank_1(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_zheevd_rank_1 = rocsolver_zheevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function function rocsolver_zheevd_full_rank(handle,evect,uplo,n,A,lda,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevd_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_zheevd_full_rank = rocsolver_zheevd_(handle,evect,uplo,n,c_loc(A),lda,c_loc(D), & c_loc(E),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssyevd_batched_assumed_rank(handle,evect,uplo,n,A,lda,D,strideD,E,strideE, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssyevd_batched_assumed_rank = rocsolver_ssyevd_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_ssyevd_batched_rank_0(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssyevd_batched_rank_0 = rocsolver_ssyevd_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_ssyevd_batched_rank_1(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssyevd_batched_rank_1 = rocsolver_ssyevd_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsyevd_batched_assumed_rank(handle,evect,uplo,n,A,lda,D,strideD,E,strideE, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsyevd_batched_assumed_rank = rocsolver_dsyevd_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_dsyevd_batched_rank_0(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsyevd_batched_rank_0 = rocsolver_dsyevd_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_dsyevd_batched_rank_1(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsyevd_batched_rank_1 = rocsolver_dsyevd_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cheevd_batched_assumed_rank(handle,evect,uplo,n,A,lda,D,strideD,E,strideE, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevd_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cheevd_batched_assumed_rank = rocsolver_cheevd_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_cheevd_batched_rank_0(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevd_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cheevd_batched_rank_0 = rocsolver_cheevd_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_cheevd_batched_rank_1(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevd_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cheevd_batched_rank_1 = rocsolver_cheevd_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zheevd_batched_assumed_rank(handle,evect,uplo,n,A,lda,D,strideD,E,strideE, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevd_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zheevd_batched_assumed_rank = rocsolver_zheevd_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_zheevd_batched_rank_0(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevd_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zheevd_batched_rank_0 = rocsolver_zheevd_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_zheevd_batched_rank_1(handle,evect,uplo,n,A,lda,D,strideD,E,strideE,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevd_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zheevd_batched_rank_1 = rocsolver_zheevd_batched_(handle,evect,uplo,n,A,lda, & c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssyevd_strided_batched_assumed_rank(handle,evect,uplo,n,A,lda,strideA,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssyevd_strided_batched_assumed_rank = rocsolver_ssyevd_strided_batched_(handle, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_ssyevd_strided_batched_rank_0(handle,evect,uplo,n,A,lda,strideA,D,strideD, & E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssyevd_strided_batched_rank_0 = rocsolver_ssyevd_strided_batched_(handle,evect, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_ssyevd_strided_batched_rank_1(handle,evect,uplo,n,A,lda,strideA,D,strideD, & E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssyevd_strided_batched_rank_1 = rocsolver_ssyevd_strided_batched_(handle,evect, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_ssyevd_strided_batched_full_rank(handle,evect,uplo,n,A,lda,strideA,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssyevd_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssyevd_strided_batched_full_rank = rocsolver_ssyevd_strided_batched_(handle,evect, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsyevd_strided_batched_assumed_rank(handle,evect,uplo,n,A,lda,strideA,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsyevd_strided_batched_assumed_rank = rocsolver_dsyevd_strided_batched_(handle, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_dsyevd_strided_batched_rank_0(handle,evect,uplo,n,A,lda,strideA,D,strideD, & E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsyevd_strided_batched_rank_0 = rocsolver_dsyevd_strided_batched_(handle,evect, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_dsyevd_strided_batched_rank_1(handle,evect,uplo,n,A,lda,strideA,D,strideD, & E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsyevd_strided_batched_rank_1 = rocsolver_dsyevd_strided_batched_(handle,evect, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_dsyevd_strided_batched_full_rank(handle,evect,uplo,n,A,lda,strideA,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsyevd_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsyevd_strided_batched_full_rank = rocsolver_dsyevd_strided_batched_(handle,evect, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cheevd_strided_batched_assumed_rank(handle,evect,uplo,n,A,lda,strideA,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevd_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cheevd_strided_batched_assumed_rank = rocsolver_cheevd_strided_batched_(handle, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_cheevd_strided_batched_rank_0(handle,evect,uplo,n,A,lda,strideA,D,strideD, & E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevd_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cheevd_strided_batched_rank_0 = rocsolver_cheevd_strided_batched_(handle,evect, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_cheevd_strided_batched_rank_1(handle,evect,uplo,n,A,lda,strideA,D,strideD, & E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevd_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cheevd_strided_batched_rank_1 = rocsolver_cheevd_strided_batched_(handle,evect, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_cheevd_strided_batched_full_rank(handle,evect,uplo,n,A,lda,strideA,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cheevd_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cheevd_strided_batched_full_rank = rocsolver_cheevd_strided_batched_(handle,evect, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zheevd_strided_batched_assumed_rank(handle,evect,uplo,n,A,lda,strideA,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevd_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zheevd_strided_batched_assumed_rank = rocsolver_zheevd_strided_batched_(handle, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_zheevd_strided_batched_rank_0(handle,evect,uplo,n,A,lda,strideA,D,strideD, & E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevd_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zheevd_strided_batched_rank_0 = rocsolver_zheevd_strided_batched_(handle,evect, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_zheevd_strided_batched_rank_1(handle,evect,uplo,n,A,lda,strideA,D,strideD, & E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevd_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zheevd_strided_batched_rank_1 = rocsolver_zheevd_strided_batched_(handle,evect, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_zheevd_strided_batched_full_rank(handle,evect,uplo,n,A,lda,strideA,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zheevd_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zheevd_strided_batched_full_rank = rocsolver_zheevd_strided_batched_(handle,evect, & uplo,n,c_loc(A),lda,strideA,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssygv_assumed_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E type(c_ptr) :: myInfo ! rocsolver_ssygv_assumed_rank = rocsolver_ssygv_(handle,itype,evect,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(D),c_loc(E),myInfo) end function #else function rocsolver_ssygv_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: B integer(c_int) :: ldb real(c_float),target :: D real(c_float),target :: E type(c_ptr) :: myInfo ! rocsolver_ssygv_rank_0 = rocsolver_ssygv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(D),c_loc(E),myInfo) end function function rocsolver_ssygv_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_ssygv_rank_1 = rocsolver_ssygv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(D),c_loc(E),myInfo) end function function rocsolver_ssygv_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygv_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_ssygv_full_rank = rocsolver_ssygv_(handle,itype,evect,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(D),c_loc(E),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsygv_assumed_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E type(c_ptr) :: myInfo ! rocsolver_dsygv_assumed_rank = rocsolver_dsygv_(handle,itype,evect,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(D),c_loc(E),myInfo) end function #else function rocsolver_dsygv_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: B integer(c_int) :: ldb real(c_double),target :: D real(c_double),target :: E type(c_ptr) :: myInfo ! rocsolver_dsygv_rank_0 = rocsolver_dsygv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(D),c_loc(E),myInfo) end function function rocsolver_dsygv_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_dsygv_rank_1 = rocsolver_dsygv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(D),c_loc(E),myInfo) end function function rocsolver_dsygv_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygv_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_dsygv_full_rank = rocsolver_dsygv_(handle,itype,evect,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(D),c_loc(E),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_chegv_assumed_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E type(c_ptr) :: myInfo ! rocsolver_chegv_assumed_rank = rocsolver_chegv_(handle,itype,evect,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(D),c_loc(E),myInfo) end function #else function rocsolver_chegv_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb real(c_float),target :: D real(c_float),target :: E type(c_ptr) :: myInfo ! rocsolver_chegv_rank_0 = rocsolver_chegv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(D),c_loc(E),myInfo) end function function rocsolver_chegv_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_chegv_rank_1 = rocsolver_chegv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(D),c_loc(E),myInfo) end function function rocsolver_chegv_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegv_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_chegv_full_rank = rocsolver_chegv_(handle,itype,evect,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(D),c_loc(E),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zhegv_assumed_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegv_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E type(c_ptr) :: myInfo ! rocsolver_zhegv_assumed_rank = rocsolver_zhegv_(handle,itype,evect,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(D),c_loc(E),myInfo) end function #else function rocsolver_zhegv_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegv_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb real(c_double),target :: D real(c_double),target :: E type(c_ptr) :: myInfo ! rocsolver_zhegv_rank_0 = rocsolver_zhegv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(D),c_loc(E),myInfo) end function function rocsolver_zhegv_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegv_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_zhegv_rank_1 = rocsolver_zhegv_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(D),c_loc(E),myInfo) end function function rocsolver_zhegv_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegv_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_zhegv_full_rank = rocsolver_zhegv_(handle,itype,evect,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(D),c_loc(E),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssygv_batched_assumed_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD, & E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygv_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssygv_batched_assumed_rank = rocsolver_ssygv_batched_(handle,itype,evect,uplo,n,A, & lda,B,ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_ssygv_batched_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygv_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssygv_batched_rank_0 = rocsolver_ssygv_batched_(handle,itype,evect,uplo,n,A,lda,B, & ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_ssygv_batched_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygv_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssygv_batched_rank_1 = rocsolver_ssygv_batched_(handle,itype,evect,uplo,n,A,lda,B, & ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsygv_batched_assumed_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD, & E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygv_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsygv_batched_assumed_rank = rocsolver_dsygv_batched_(handle,itype,evect,uplo,n,A, & lda,B,ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_dsygv_batched_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygv_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsygv_batched_rank_0 = rocsolver_dsygv_batched_(handle,itype,evect,uplo,n,A,lda,B, & ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_dsygv_batched_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygv_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsygv_batched_rank_1 = rocsolver_dsygv_batched_(handle,itype,evect,uplo,n,A,lda,B, & ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_chegv_batched_assumed_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD, & E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegv_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_chegv_batched_assumed_rank = rocsolver_chegv_batched_(handle,itype,evect,uplo,n,A, & lda,B,ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_chegv_batched_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegv_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_chegv_batched_rank_0 = rocsolver_chegv_batched_(handle,itype,evect,uplo,n,A,lda,B, & ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_chegv_batched_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegv_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_chegv_batched_rank_1 = rocsolver_chegv_batched_(handle,itype,evect,uplo,n,A,lda,B, & ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zhegv_batched_assumed_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD, & E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegv_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zhegv_batched_assumed_rank = rocsolver_zhegv_batched_(handle,itype,evect,uplo,n,A, & lda,B,ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_zhegv_batched_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegv_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zhegv_batched_rank_0 = rocsolver_zhegv_batched_(handle,itype,evect,uplo,n,A,lda,B, & ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_zhegv_batched_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegv_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zhegv_batched_rank_1 = rocsolver_zhegv_batched_(handle,itype,evect,uplo,n,A,lda,B, & ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssygv_strided_batched_assumed_rank(handle,itype,evect,uplo,n,A,lda,strideA, & B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssygv_strided_batched_assumed_rank = rocsolver_ssygv_strided_batched_(handle, & itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E), & strideE,myInfo,batch_count) end function #else function rocsolver_ssygv_strided_batched_rank_0(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssygv_strided_batched_rank_0 = rocsolver_ssygv_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function function rocsolver_ssygv_strided_batched_rank_1(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssygv_strided_batched_rank_1 = rocsolver_ssygv_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function function rocsolver_ssygv_strided_batched_full_rank(handle,itype,evect,uplo,n,A,lda,strideA,B, & ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssygv_strided_batched_full_rank = rocsolver_ssygv_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsygv_strided_batched_assumed_rank(handle,itype,evect,uplo,n,A,lda,strideA, & B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsygv_strided_batched_assumed_rank = rocsolver_dsygv_strided_batched_(handle, & itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E), & strideE,myInfo,batch_count) end function #else function rocsolver_dsygv_strided_batched_rank_0(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsygv_strided_batched_rank_0 = rocsolver_dsygv_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function function rocsolver_dsygv_strided_batched_rank_1(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsygv_strided_batched_rank_1 = rocsolver_dsygv_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function function rocsolver_dsygv_strided_batched_full_rank(handle,itype,evect,uplo,n,A,lda,strideA,B, & ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsygv_strided_batched_full_rank = rocsolver_dsygv_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_chegv_strided_batched_assumed_rank(handle,itype,evect,uplo,n,A,lda,strideA, & B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_chegv_strided_batched_assumed_rank = rocsolver_chegv_strided_batched_(handle, & itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E), & strideE,myInfo,batch_count) end function #else function rocsolver_chegv_strided_batched_rank_0(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_chegv_strided_batched_rank_0 = rocsolver_chegv_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function function rocsolver_chegv_strided_batched_rank_1(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_chegv_strided_batched_rank_1 = rocsolver_chegv_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function function rocsolver_chegv_strided_batched_full_rank(handle,itype,evect,uplo,n,A,lda,strideA,B, & ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_chegv_strided_batched_full_rank = rocsolver_chegv_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zhegv_strided_batched_assumed_rank(handle,itype,evect,uplo,n,A,lda,strideA, & B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegv_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zhegv_strided_batched_assumed_rank = rocsolver_zhegv_strided_batched_(handle, & itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E), & strideE,myInfo,batch_count) end function #else function rocsolver_zhegv_strided_batched_rank_0(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegv_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zhegv_strided_batched_rank_0 = rocsolver_zhegv_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function function rocsolver_zhegv_strided_batched_rank_1(handle,itype,evect,uplo,n,A,lda,strideA,B,ldb, & strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegv_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zhegv_strided_batched_rank_1 = rocsolver_zhegv_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function function rocsolver_zhegv_strided_batched_full_rank(handle,itype,evect,uplo,n,A,lda,strideA,B, & ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegv_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zhegv_strided_batched_full_rank = rocsolver_zhegv_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssygvd_assumed_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E type(c_ptr) :: myInfo ! rocsolver_ssygvd_assumed_rank = rocsolver_ssygvd_(handle,itype,evect,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(D),c_loc(E),myInfo) end function #else function rocsolver_ssygvd_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: B integer(c_int) :: ldb real(c_float),target :: D real(c_float),target :: E type(c_ptr) :: myInfo ! rocsolver_ssygvd_rank_0 = rocsolver_ssygvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(D),c_loc(E),myInfo) end function function rocsolver_ssygvd_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_ssygvd_rank_1 = rocsolver_ssygvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(D),c_loc(E),myInfo) end function function rocsolver_ssygvd_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_ssygvd_full_rank = rocsolver_ssygvd_(handle,itype,evect,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(D),c_loc(E),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsygvd_assumed_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E type(c_ptr) :: myInfo ! rocsolver_dsygvd_assumed_rank = rocsolver_dsygvd_(handle,itype,evect,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(D),c_loc(E),myInfo) end function #else function rocsolver_dsygvd_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: B integer(c_int) :: ldb real(c_double),target :: D real(c_double),target :: E type(c_ptr) :: myInfo ! rocsolver_dsygvd_rank_0 = rocsolver_dsygvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(D),c_loc(E),myInfo) end function function rocsolver_dsygvd_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_dsygvd_rank_1 = rocsolver_dsygvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(D),c_loc(E),myInfo) end function function rocsolver_dsygvd_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_dsygvd_full_rank = rocsolver_dsygvd_(handle,itype,evect,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(D),c_loc(E),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_chegvd_assumed_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: D real(c_float),target,contiguous,dimension(..) :: E type(c_ptr) :: myInfo ! rocsolver_chegvd_assumed_rank = rocsolver_chegvd_(handle,itype,evect,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(D),c_loc(E),myInfo) end function #else function rocsolver_chegvd_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb real(c_float),target :: D real(c_float),target :: E type(c_ptr) :: myInfo ! rocsolver_chegvd_rank_0 = rocsolver_chegvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(D),c_loc(E),myInfo) end function function rocsolver_chegvd_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_chegvd_rank_1 = rocsolver_chegvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(D),c_loc(E),myInfo) end function function rocsolver_chegvd_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvd_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: D real(c_float),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_chegvd_full_rank = rocsolver_chegvd_(handle,itype,evect,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(D),c_loc(E),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zhegvd_assumed_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: D real(c_double),target,contiguous,dimension(..) :: E type(c_ptr) :: myInfo ! rocsolver_zhegvd_assumed_rank = rocsolver_zhegvd_(handle,itype,evect,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(D),c_loc(E),myInfo) end function #else function rocsolver_zhegvd_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb real(c_double),target :: D real(c_double),target :: E type(c_ptr) :: myInfo ! rocsolver_zhegvd_rank_0 = rocsolver_zhegvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(D),c_loc(E),myInfo) end function function rocsolver_zhegvd_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_zhegvd_rank_1 = rocsolver_zhegvd_(handle,itype,evect,uplo,n,c_loc(A),lda,c_loc(B), & ldb,c_loc(D),c_loc(E),myInfo) end function function rocsolver_zhegvd_full_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D,E,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: D real(c_double),target,dimension(:) :: E type(c_ptr) :: myInfo ! rocsolver_zhegvd_full_rank = rocsolver_zhegvd_(handle,itype,evect,uplo,n,c_loc(A),lda, & c_loc(B),ldb,c_loc(D),c_loc(E),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssygvd_batched_assumed_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssygvd_batched_assumed_rank = rocsolver_ssygvd_batched_(handle,itype,evect,uplo,n, & A,lda,B,ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_ssygvd_batched_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssygvd_batched_rank_0 = rocsolver_ssygvd_batched_(handle,itype,evect,uplo,n,A,lda, & B,ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_ssygvd_batched_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssygvd_batched_rank_1 = rocsolver_ssygvd_batched_(handle,itype,evect,uplo,n,A,lda, & B,ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsygvd_batched_assumed_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsygvd_batched_assumed_rank = rocsolver_dsygvd_batched_(handle,itype,evect,uplo,n, & A,lda,B,ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_dsygvd_batched_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsygvd_batched_rank_0 = rocsolver_dsygvd_batched_(handle,itype,evect,uplo,n,A,lda, & B,ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_dsygvd_batched_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsygvd_batched_rank_1 = rocsolver_dsygvd_batched_(handle,itype,evect,uplo,n,A,lda, & B,ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_chegvd_batched_assumed_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvd_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_chegvd_batched_assumed_rank = rocsolver_chegvd_batched_(handle,itype,evect,uplo,n, & A,lda,B,ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_chegvd_batched_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvd_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_chegvd_batched_rank_0 = rocsolver_chegvd_batched_(handle,itype,evect,uplo,n,A,lda, & B,ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_chegvd_batched_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvd_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_chegvd_batched_rank_1 = rocsolver_chegvd_batched_(handle,itype,evect,uplo,n,A,lda, & B,ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zhegvd_batched_assumed_rank(handle,itype,evect,uplo,n,A,lda,B,ldb,D, & strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zhegvd_batched_assumed_rank = rocsolver_zhegvd_batched_(handle,itype,evect,uplo,n, & A,lda,B,ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #else function rocsolver_zhegvd_batched_rank_0(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zhegvd_batched_rank_0 = rocsolver_zhegvd_batched_(handle,itype,evect,uplo,n,A,lda, & B,ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function function rocsolver_zhegvd_batched_rank_1(handle,itype,evect,uplo,n,A,lda,B,ldb,D,strideD,E, & strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda type(c_ptr) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zhegvd_batched_rank_1 = rocsolver_zhegvd_batched_(handle,itype,evect,uplo,n,A,lda, & B,ldb,c_loc(D),strideD,c_loc(E),strideE,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssygvd_strided_batched_assumed_rank(handle,itype,evect,uplo,n,A,lda, & strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssygvd_strided_batched_assumed_rank = rocsolver_ssygvd_strided_batched_(handle, & itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E), & strideE,myInfo,batch_count) end function #else function rocsolver_ssygvd_strided_batched_rank_0(handle,itype,evect,uplo,n,A,lda,strideA,B, & ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssygvd_strided_batched_rank_0 = rocsolver_ssygvd_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function function rocsolver_ssygvd_strided_batched_rank_1(handle,itype,evect,uplo,n,A,lda,strideA,B, & ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssygvd_strided_batched_rank_1 = rocsolver_ssygvd_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function function rocsolver_ssygvd_strided_batched_full_rank(handle,itype,evect,uplo,n,A,lda,strideA,B, & ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssygvd_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssygvd_strided_batched_full_rank = rocsolver_ssygvd_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsygvd_strided_batched_assumed_rank(handle,itype,evect,uplo,n,A,lda, & strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsygvd_strided_batched_assumed_rank = rocsolver_dsygvd_strided_batched_(handle, & itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E), & strideE,myInfo,batch_count) end function #else function rocsolver_dsygvd_strided_batched_rank_0(handle,itype,evect,uplo,n,A,lda,strideA,B, & ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsygvd_strided_batched_rank_0 = rocsolver_dsygvd_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function function rocsolver_dsygvd_strided_batched_rank_1(handle,itype,evect,uplo,n,A,lda,strideA,B, & ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsygvd_strided_batched_rank_1 = rocsolver_dsygvd_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function function rocsolver_dsygvd_strided_batched_full_rank(handle,itype,evect,uplo,n,A,lda,strideA,B, & ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsygvd_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsygvd_strided_batched_full_rank = rocsolver_dsygvd_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_chegvd_strided_batched_assumed_rank(handle,itype,evect,uplo,n,A,lda, & strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvd_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_float),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_chegvd_strided_batched_assumed_rank = rocsolver_chegvd_strided_batched_(handle, & itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E), & strideE,myInfo,batch_count) end function #else function rocsolver_chegvd_strided_batched_rank_0(handle,itype,evect,uplo,n,A,lda,strideA,B, & ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvd_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target :: D integer(c_int64_t) :: strideD real(c_float),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_chegvd_strided_batched_rank_0 = rocsolver_chegvd_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function function rocsolver_chegvd_strided_batched_rank_1(handle,itype,evect,uplo,n,A,lda,strideA,B, & ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvd_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_chegvd_strided_batched_rank_1 = rocsolver_chegvd_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function function rocsolver_chegvd_strided_batched_full_rank(handle,itype,evect,uplo,n,A,lda,strideA,B, & ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvd_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_float),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_float),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_chegvd_strided_batched_full_rank = rocsolver_chegvd_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zhegvd_strided_batched_assumed_rank(handle,itype,evect,uplo,n,A,lda, & strideA,B,ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target,contiguous,dimension(..) :: D integer(c_int64_t) :: strideD real(c_double),target,contiguous,dimension(..) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zhegvd_strided_batched_assumed_rank = rocsolver_zhegvd_strided_batched_(handle, & itype,evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E), & strideE,myInfo,batch_count) end function #else function rocsolver_zhegvd_strided_batched_rank_0(handle,itype,evect,uplo,n,A,lda,strideA,B, & ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target :: D integer(c_int64_t) :: strideD real(c_double),target :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zhegvd_strided_batched_rank_0 = rocsolver_zhegvd_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function function rocsolver_zhegvd_strided_batched_rank_1(handle,itype,evect,uplo,n,A,lda,strideA,B, & ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zhegvd_strided_batched_rank_1 = rocsolver_zhegvd_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function function rocsolver_zhegvd_strided_batched_full_rank(handle,itype,evect,uplo,n,A,lda,strideA,B, & ldb,strideB,D,strideD,E,strideE,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvd_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_int64_t) :: strideB real(c_double),target,dimension(:) :: D integer(c_int64_t) :: strideD real(c_double),target,dimension(:) :: E integer(c_int64_t) :: strideE type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zhegvd_strided_batched_full_rank = rocsolver_zhegvd_strided_batched_(handle,itype, & evect,uplo,n,c_loc(A),lda,strideA,c_loc(B),ldb,strideB,c_loc(D),strideD,c_loc(E),strideE, & myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetri_outofplace_assumed_rank(handle,n,A,lda,ipiv,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_sgetri_outofplace_assumed_rank = rocsolver_sgetri_outofplace_(handle,n,c_loc(A), & lda,c_loc(ipiv),c_loc(C),ldc,myInfo) end function #else function rocsolver_sgetri_outofplace_rank_0(handle,n,A,lda,ipiv,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv real(c_float),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_sgetri_outofplace_rank_0 = rocsolver_sgetri_outofplace_(handle,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc,myInfo) end function function rocsolver_sgetri_outofplace_rank_1(handle,n,A,lda,ipiv,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv real(c_float),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_sgetri_outofplace_rank_1 = rocsolver_sgetri_outofplace_(handle,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc,myInfo) end function function rocsolver_sgetri_outofplace_full_rank(handle,n,A,lda,ipiv,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_sgetri_outofplace_full_rank = rocsolver_sgetri_outofplace_(handle,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetri_outofplace_assumed_rank(handle,n,A,lda,ipiv,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dgetri_outofplace_assumed_rank = rocsolver_dgetri_outofplace_(handle,n,c_loc(A), & lda,c_loc(ipiv),c_loc(C),ldc,myInfo) end function #else function rocsolver_dgetri_outofplace_rank_0(handle,n,A,lda,ipiv,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv real(c_double),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dgetri_outofplace_rank_0 = rocsolver_dgetri_outofplace_(handle,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc,myInfo) end function function rocsolver_dgetri_outofplace_rank_1(handle,n,A,lda,ipiv,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv real(c_double),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dgetri_outofplace_rank_1 = rocsolver_dgetri_outofplace_(handle,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc,myInfo) end function function rocsolver_dgetri_outofplace_full_rank(handle,n,A,lda,ipiv,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dgetri_outofplace_full_rank = rocsolver_dgetri_outofplace_(handle,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetri_outofplace_assumed_rank(handle,n,A,lda,ipiv,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_cgetri_outofplace_assumed_rank = rocsolver_cgetri_outofplace_(handle,n,c_loc(A), & lda,c_loc(ipiv),c_loc(C),ldc,myInfo) end function #else function rocsolver_cgetri_outofplace_rank_0(handle,n,A,lda,ipiv,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv complex(c_float_complex),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_cgetri_outofplace_rank_0 = rocsolver_cgetri_outofplace_(handle,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc,myInfo) end function function rocsolver_cgetri_outofplace_rank_1(handle,n,A,lda,ipiv,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_cgetri_outofplace_rank_1 = rocsolver_cgetri_outofplace_(handle,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc,myInfo) end function function rocsolver_cgetri_outofplace_full_rank(handle,n,A,lda,ipiv,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_cgetri_outofplace_full_rank = rocsolver_cgetri_outofplace_(handle,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetri_outofplace_assumed_rank(handle,n,A,lda,ipiv,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zgetri_outofplace_assumed_rank = rocsolver_zgetri_outofplace_(handle,n,c_loc(A), & lda,c_loc(ipiv),c_loc(C),ldc,myInfo) end function #else function rocsolver_zgetri_outofplace_rank_0(handle,n,A,lda,ipiv,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv complex(c_double_complex),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zgetri_outofplace_rank_0 = rocsolver_zgetri_outofplace_(handle,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc,myInfo) end function function rocsolver_zgetri_outofplace_rank_1(handle,n,A,lda,ipiv,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zgetri_outofplace_rank_1 = rocsolver_zgetri_outofplace_(handle,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc,myInfo) end function function rocsolver_zgetri_outofplace_full_rank(handle,n,A,lda,ipiv,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zgetri_outofplace_full_rank = rocsolver_zgetri_outofplace_(handle,n,c_loc(A),lda, & c_loc(ipiv),c_loc(C),ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetri_outofplace_batched_assumed_rank(handle,n,A,lda,ipiv,strideP,C,ldc, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_outofplace_batched_assumed_rank = rocsolver_sgetri_outofplace_batched_( & handle,n,A,lda,c_loc(ipiv),strideP,C,ldc,myInfo,batch_count) end function #else function rocsolver_sgetri_outofplace_batched_rank_0(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_outofplace_batched_rank_0 = rocsolver_sgetri_outofplace_batched_(handle,n, & A,lda,c_loc(ipiv),strideP,C,ldc,myInfo,batch_count) end function function rocsolver_sgetri_outofplace_batched_rank_1(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_outofplace_batched_rank_1 = rocsolver_sgetri_outofplace_batched_(handle,n, & A,lda,c_loc(ipiv),strideP,C,ldc,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetri_outofplace_batched_assumed_rank(handle,n,A,lda,ipiv,strideP,C,ldc, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_outofplace_batched_assumed_rank = rocsolver_dgetri_outofplace_batched_( & handle,n,A,lda,c_loc(ipiv),strideP,C,ldc,myInfo,batch_count) end function #else function rocsolver_dgetri_outofplace_batched_rank_0(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_outofplace_batched_rank_0 = rocsolver_dgetri_outofplace_batched_(handle,n, & A,lda,c_loc(ipiv),strideP,C,ldc,myInfo,batch_count) end function function rocsolver_dgetri_outofplace_batched_rank_1(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_outofplace_batched_rank_1 = rocsolver_dgetri_outofplace_batched_(handle,n, & A,lda,c_loc(ipiv),strideP,C,ldc,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetri_outofplace_batched_assumed_rank(handle,n,A,lda,ipiv,strideP,C,ldc, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_outofplace_batched_assumed_rank = rocsolver_cgetri_outofplace_batched_( & handle,n,A,lda,c_loc(ipiv),strideP,C,ldc,myInfo,batch_count) end function #else function rocsolver_cgetri_outofplace_batched_rank_0(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_outofplace_batched_rank_0 = rocsolver_cgetri_outofplace_batched_(handle,n, & A,lda,c_loc(ipiv),strideP,C,ldc,myInfo,batch_count) end function function rocsolver_cgetri_outofplace_batched_rank_1(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_outofplace_batched_rank_1 = rocsolver_cgetri_outofplace_batched_(handle,n, & A,lda,c_loc(ipiv),strideP,C,ldc,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetri_outofplace_batched_assumed_rank(handle,n,A,lda,ipiv,strideP,C,ldc, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_outofplace_batched_assumed_rank = rocsolver_zgetri_outofplace_batched_( & handle,n,A,lda,c_loc(ipiv),strideP,C,ldc,myInfo,batch_count) end function #else function rocsolver_zgetri_outofplace_batched_rank_0(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_outofplace_batched_rank_0 = rocsolver_zgetri_outofplace_batched_(handle,n, & A,lda,c_loc(ipiv),strideP,C,ldc,myInfo,batch_count) end function function rocsolver_zgetri_outofplace_batched_rank_1(handle,n,A,lda,ipiv,strideP,C,ldc,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_outofplace_batched_rank_1 = rocsolver_zgetri_outofplace_batched_(handle,n, & A,lda,c_loc(ipiv),strideP,C,ldc,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetri_outofplace_strided_batched_assumed_rank(handle,n,A,lda,strideA,ipiv, & strideP,C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_outofplace_strided_batched_assumed_rank = & rocsolver_sgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv), & strideP,c_loc(C),ldc,strideC,myInfo,batch_count) end function #else function rocsolver_sgetri_outofplace_strided_batched_rank_0(handle,n,A,lda,strideA,ipiv, & strideP,C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP real(c_float),target :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_outofplace_strided_batched_rank_0 = & rocsolver_sgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv), & strideP,c_loc(C),ldc,strideC,myInfo,batch_count) end function function rocsolver_sgetri_outofplace_strided_batched_rank_1(handle,n,A,lda,strideA,ipiv, & strideP,C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP real(c_float),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_outofplace_strided_batched_rank_1 = & rocsolver_sgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv), & strideP,c_loc(C),ldc,strideC,myInfo,batch_count) end function function rocsolver_sgetri_outofplace_strided_batched_full_rank(handle,n,A,lda,strideA,ipiv, & strideP,C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_outofplace_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_outofplace_strided_batched_full_rank = & rocsolver_sgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv), & strideP,c_loc(C),ldc,strideC,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetri_outofplace_strided_batched_assumed_rank(handle,n,A,lda,strideA,ipiv, & strideP,C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_outofplace_strided_batched_assumed_rank = & rocsolver_dgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv), & strideP,c_loc(C),ldc,strideC,myInfo,batch_count) end function #else function rocsolver_dgetri_outofplace_strided_batched_rank_0(handle,n,A,lda,strideA,ipiv, & strideP,C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP real(c_double),target :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_outofplace_strided_batched_rank_0 = & rocsolver_dgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv), & strideP,c_loc(C),ldc,strideC,myInfo,batch_count) end function function rocsolver_dgetri_outofplace_strided_batched_rank_1(handle,n,A,lda,strideA,ipiv, & strideP,C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP real(c_double),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_outofplace_strided_batched_rank_1 = & rocsolver_dgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv), & strideP,c_loc(C),ldc,strideC,myInfo,batch_count) end function function rocsolver_dgetri_outofplace_strided_batched_full_rank(handle,n,A,lda,strideA,ipiv, & strideP,C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_outofplace_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_outofplace_strided_batched_full_rank = & rocsolver_dgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv), & strideP,c_loc(C),ldc,strideC,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetri_outofplace_strided_batched_assumed_rank(handle,n,A,lda,strideA,ipiv, & strideP,C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_outofplace_strided_batched_assumed_rank = & rocsolver_cgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv), & strideP,c_loc(C),ldc,strideC,myInfo,batch_count) end function #else function rocsolver_cgetri_outofplace_strided_batched_rank_0(handle,n,A,lda,strideA,ipiv, & strideP,C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP complex(c_float_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_outofplace_strided_batched_rank_0 = & rocsolver_cgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv), & strideP,c_loc(C),ldc,strideC,myInfo,batch_count) end function function rocsolver_cgetri_outofplace_strided_batched_rank_1(handle,n,A,lda,strideA,ipiv, & strideP,C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_outofplace_strided_batched_rank_1 = & rocsolver_cgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv), & strideP,c_loc(C),ldc,strideC,myInfo,batch_count) end function function rocsolver_cgetri_outofplace_strided_batched_full_rank(handle,n,A,lda,strideA,ipiv, & strideP,C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_outofplace_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_outofplace_strided_batched_full_rank = & rocsolver_cgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv), & strideP,c_loc(C),ldc,strideC,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetri_outofplace_strided_batched_assumed_rank(handle,n,A,lda,strideA,ipiv, & strideP,C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_outofplace_strided_batched_assumed_rank = & rocsolver_zgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv), & strideP,c_loc(C),ldc,strideC,myInfo,batch_count) end function #else function rocsolver_zgetri_outofplace_strided_batched_rank_0(handle,n,A,lda,strideA,ipiv, & strideP,C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP complex(c_double_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_outofplace_strided_batched_rank_0 = & rocsolver_zgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv), & strideP,c_loc(C),ldc,strideC,myInfo,batch_count) end function function rocsolver_zgetri_outofplace_strided_batched_rank_1(handle,n,A,lda,strideA,ipiv, & strideP,C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_outofplace_strided_batched_rank_1 = & rocsolver_zgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv), & strideP,c_loc(C),ldc,strideC,myInfo,batch_count) end function function rocsolver_zgetri_outofplace_strided_batched_full_rank(handle,n,A,lda,strideA,ipiv, & strideP,C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_outofplace_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_outofplace_strided_batched_full_rank = & rocsolver_zgetri_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(ipiv), & strideP,c_loc(C),ldc,strideC,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetri_npvt_outofplace_assumed_rank(handle,n,A,lda,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_sgetri_npvt_outofplace_assumed_rank = rocsolver_sgetri_npvt_outofplace_(handle,n, & c_loc(A),lda,c_loc(C),ldc,myInfo) end function #else function rocsolver_sgetri_npvt_outofplace_rank_0(handle,n,A,lda,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_sgetri_npvt_outofplace_rank_0 = rocsolver_sgetri_npvt_outofplace_(handle,n, & c_loc(A),lda,c_loc(C),ldc,myInfo) end function function rocsolver_sgetri_npvt_outofplace_rank_1(handle,n,A,lda,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_sgetri_npvt_outofplace_rank_1 = rocsolver_sgetri_npvt_outofplace_(handle,n, & c_loc(A),lda,c_loc(C),ldc,myInfo) end function function rocsolver_sgetri_npvt_outofplace_full_rank(handle,n,A,lda,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_sgetri_npvt_outofplace_full_rank = rocsolver_sgetri_npvt_outofplace_(handle,n, & c_loc(A),lda,c_loc(C),ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetri_npvt_outofplace_assumed_rank(handle,n,A,lda,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dgetri_npvt_outofplace_assumed_rank = rocsolver_dgetri_npvt_outofplace_(handle,n, & c_loc(A),lda,c_loc(C),ldc,myInfo) end function #else function rocsolver_dgetri_npvt_outofplace_rank_0(handle,n,A,lda,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dgetri_npvt_outofplace_rank_0 = rocsolver_dgetri_npvt_outofplace_(handle,n, & c_loc(A),lda,c_loc(C),ldc,myInfo) end function function rocsolver_dgetri_npvt_outofplace_rank_1(handle,n,A,lda,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dgetri_npvt_outofplace_rank_1 = rocsolver_dgetri_npvt_outofplace_(handle,n, & c_loc(A),lda,c_loc(C),ldc,myInfo) end function function rocsolver_dgetri_npvt_outofplace_full_rank(handle,n,A,lda,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_dgetri_npvt_outofplace_full_rank = rocsolver_dgetri_npvt_outofplace_(handle,n, & c_loc(A),lda,c_loc(C),ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetri_npvt_outofplace_assumed_rank(handle,n,A,lda,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_cgetri_npvt_outofplace_assumed_rank = rocsolver_cgetri_npvt_outofplace_(handle,n, & c_loc(A),lda,c_loc(C),ldc,myInfo) end function #else function rocsolver_cgetri_npvt_outofplace_rank_0(handle,n,A,lda,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_cgetri_npvt_outofplace_rank_0 = rocsolver_cgetri_npvt_outofplace_(handle,n, & c_loc(A),lda,c_loc(C),ldc,myInfo) end function function rocsolver_cgetri_npvt_outofplace_rank_1(handle,n,A,lda,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_cgetri_npvt_outofplace_rank_1 = rocsolver_cgetri_npvt_outofplace_(handle,n, & c_loc(A),lda,c_loc(C),ldc,myInfo) end function function rocsolver_cgetri_npvt_outofplace_full_rank(handle,n,A,lda,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_cgetri_npvt_outofplace_full_rank = rocsolver_cgetri_npvt_outofplace_(handle,n, & c_loc(A),lda,c_loc(C),ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetri_npvt_outofplace_assumed_rank(handle,n,A,lda,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zgetri_npvt_outofplace_assumed_rank = rocsolver_zgetri_npvt_outofplace_(handle,n, & c_loc(A),lda,c_loc(C),ldc,myInfo) end function #else function rocsolver_zgetri_npvt_outofplace_rank_0(handle,n,A,lda,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zgetri_npvt_outofplace_rank_0 = rocsolver_zgetri_npvt_outofplace_(handle,n, & c_loc(A),lda,c_loc(C),ldc,myInfo) end function function rocsolver_zgetri_npvt_outofplace_rank_1(handle,n,A,lda,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zgetri_npvt_outofplace_rank_1 = rocsolver_zgetri_npvt_outofplace_(handle,n, & c_loc(A),lda,c_loc(C),ldc,myInfo) end function function rocsolver_zgetri_npvt_outofplace_full_rank(handle,n,A,lda,C,ldc,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc type(c_ptr) :: myInfo ! rocsolver_zgetri_npvt_outofplace_full_rank = rocsolver_zgetri_npvt_outofplace_(handle,n, & c_loc(A),lda,c_loc(C),ldc,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_sgetri_npvt_outofplace_strided_batched_assumed_rank(handle,n,A,lda,strideA, & C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_npvt_outofplace_strided_batched_assumed_rank = & rocsolver_sgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C), & ldc,strideC,myInfo,batch_count) end function #else function rocsolver_sgetri_npvt_outofplace_strided_batched_rank_0(handle,n,A,lda,strideA,C,ldc, & strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_npvt_outofplace_strided_batched_rank_0 = & rocsolver_sgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C), & ldc,strideC,myInfo,batch_count) end function function rocsolver_sgetri_npvt_outofplace_strided_batched_rank_1(handle,n,A,lda,strideA,C,ldc, & strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_npvt_outofplace_strided_batched_rank_1 = & rocsolver_sgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C), & ldc,strideC,myInfo,batch_count) end function function rocsolver_sgetri_npvt_outofplace_strided_batched_full_rank(handle,n,A,lda,strideA,C, & ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_sgetri_npvt_outofplace_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_sgetri_npvt_outofplace_strided_batched_full_rank = & rocsolver_sgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C), & ldc,strideC,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dgetri_npvt_outofplace_strided_batched_assumed_rank(handle,n,A,lda,strideA, & C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_npvt_outofplace_strided_batched_assumed_rank = & rocsolver_dgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C), & ldc,strideC,myInfo,batch_count) end function #else function rocsolver_dgetri_npvt_outofplace_strided_batched_rank_0(handle,n,A,lda,strideA,C,ldc, & strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_npvt_outofplace_strided_batched_rank_0 = & rocsolver_dgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C), & ldc,strideC,myInfo,batch_count) end function function rocsolver_dgetri_npvt_outofplace_strided_batched_rank_1(handle,n,A,lda,strideA,C,ldc, & strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_npvt_outofplace_strided_batched_rank_1 = & rocsolver_dgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C), & ldc,strideC,myInfo,batch_count) end function function rocsolver_dgetri_npvt_outofplace_strided_batched_full_rank(handle,n,A,lda,strideA,C, & ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dgetri_npvt_outofplace_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dgetri_npvt_outofplace_strided_batched_full_rank = & rocsolver_dgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C), & ldc,strideC,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_cgetri_npvt_outofplace_strided_batched_assumed_rank(handle,n,A,lda,strideA, & C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_npvt_outofplace_strided_batched_assumed_rank = & rocsolver_cgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C), & ldc,strideC,myInfo,batch_count) end function #else function rocsolver_cgetri_npvt_outofplace_strided_batched_rank_0(handle,n,A,lda,strideA,C,ldc, & strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_npvt_outofplace_strided_batched_rank_0 = & rocsolver_cgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C), & ldc,strideC,myInfo,batch_count) end function function rocsolver_cgetri_npvt_outofplace_strided_batched_rank_1(handle,n,A,lda,strideA,C,ldc, & strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_npvt_outofplace_strided_batched_rank_1 = & rocsolver_cgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C), & ldc,strideC,myInfo,batch_count) end function function rocsolver_cgetri_npvt_outofplace_strided_batched_full_rank(handle,n,A,lda,strideA,C, & ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_cgetri_npvt_outofplace_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_cgetri_npvt_outofplace_strided_batched_full_rank = & rocsolver_cgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C), & ldc,strideC,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zgetri_npvt_outofplace_strided_batched_assumed_rank(handle,n,A,lda,strideA, & C,ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_strided_batched_assumed_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_npvt_outofplace_strided_batched_assumed_rank = & rocsolver_zgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C), & ldc,strideC,myInfo,batch_count) end function #else function rocsolver_zgetri_npvt_outofplace_strided_batched_rank_0(handle,n,A,lda,strideA,C,ldc, & strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_strided_batched_rank_0 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_npvt_outofplace_strided_batched_rank_0 = & rocsolver_zgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C), & ldc,strideC,myInfo,batch_count) end function function rocsolver_zgetri_npvt_outofplace_strided_batched_rank_1(handle,n,A,lda,strideA,C,ldc, & strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_strided_batched_rank_1 type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_npvt_outofplace_strided_batched_rank_1 = & rocsolver_zgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C), & ldc,strideC,myInfo,batch_count) end function function rocsolver_zgetri_npvt_outofplace_strided_batched_full_rank(handle,n,A,lda,strideA,C, & ldc,strideC,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zgetri_npvt_outofplace_strided_batched_full_rank type(c_ptr) :: handle integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc integer(c_int64_t) :: strideC type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zgetri_npvt_outofplace_strided_batched_full_rank = & rocsolver_zgetri_npvt_outofplace_strided_batched_(handle,n,c_loc(A),lda,strideA,c_loc(C), & ldc,strideC,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_strtri_assumed_rank(handle,uplo,diag,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_strtri_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_strtri_assumed_rank = rocsolver_strtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo) end function #else function rocsolver_strtri_rank_0(handle,uplo,diag,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_strtri_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_strtri_rank_0 = rocsolver_strtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo) end function function rocsolver_strtri_rank_1(handle,uplo,diag,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_strtri_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_strtri_rank_1 = rocsolver_strtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo) end function function rocsolver_strtri_full_rank(handle,uplo,diag,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_strtri_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_strtri_full_rank = rocsolver_strtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dtrtri_assumed_rank(handle,uplo,diag,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dtrtri_assumed_rank = rocsolver_dtrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo) end function #else function rocsolver_dtrtri_rank_0(handle,uplo,diag,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dtrtri_rank_0 = rocsolver_dtrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo) end function function rocsolver_dtrtri_rank_1(handle,uplo,diag,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dtrtri_rank_1 = rocsolver_dtrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo) end function function rocsolver_dtrtri_full_rank(handle,uplo,diag,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_dtrtri_full_rank = rocsolver_dtrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ctrtri_assumed_rank(handle,uplo,diag,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_ctrtri_assumed_rank = rocsolver_ctrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo) end function #else function rocsolver_ctrtri_rank_0(handle,uplo,diag,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_ctrtri_rank_0 = rocsolver_ctrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo) end function function rocsolver_ctrtri_rank_1(handle,uplo,diag,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_ctrtri_rank_1 = rocsolver_ctrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo) end function function rocsolver_ctrtri_full_rank(handle,uplo,diag,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_ctrtri_full_rank = rocsolver_ctrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ztrtri_assumed_rank(handle,uplo,diag,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_ztrtri_assumed_rank = rocsolver_ztrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo) end function #else function rocsolver_ztrtri_rank_0(handle,uplo,diag,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_ztrtri_rank_0 = rocsolver_ztrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo) end function function rocsolver_ztrtri_rank_1(handle,uplo,diag,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_ztrtri_rank_1 = rocsolver_ztrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo) end function function rocsolver_ztrtri_full_rank(handle,uplo,diag,n,A,lda,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: myInfo ! rocsolver_ztrtri_full_rank = rocsolver_ztrtri_(handle,uplo,diag,n,c_loc(A),lda,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_strtri_strided_batched_assumed_rank(handle,uplo,diag,n,A,lda,strideA, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_strtri_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_strtri_strided_batched_assumed_rank = rocsolver_strtri_strided_batched_(handle, & uplo,diag,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_strtri_strided_batched_rank_0(handle,uplo,diag,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_strtri_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_strtri_strided_batched_rank_0 = rocsolver_strtri_strided_batched_(handle,uplo, & diag,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_strtri_strided_batched_rank_1(handle,uplo,diag,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_strtri_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_strtri_strided_batched_rank_1 = rocsolver_strtri_strided_batched_(handle,uplo, & diag,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_strtri_strided_batched_full_rank(handle,uplo,diag,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_strtri_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_strtri_strided_batched_full_rank = rocsolver_strtri_strided_batched_(handle,uplo, & diag,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dtrtri_strided_batched_assumed_rank(handle,uplo,diag,n,A,lda,strideA, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dtrtri_strided_batched_assumed_rank = rocsolver_dtrtri_strided_batched_(handle, & uplo,diag,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_dtrtri_strided_batched_rank_0(handle,uplo,diag,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dtrtri_strided_batched_rank_0 = rocsolver_dtrtri_strided_batched_(handle,uplo, & diag,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_dtrtri_strided_batched_rank_1(handle,uplo,diag,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dtrtri_strided_batched_rank_1 = rocsolver_dtrtri_strided_batched_(handle,uplo, & diag,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_dtrtri_strided_batched_full_rank(handle,uplo,diag,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dtrtri_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dtrtri_strided_batched_full_rank = rocsolver_dtrtri_strided_batched_(handle,uplo, & diag,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ctrtri_strided_batched_assumed_rank(handle,uplo,diag,n,A,lda,strideA, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ctrtri_strided_batched_assumed_rank = rocsolver_ctrtri_strided_batched_(handle, & uplo,diag,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_ctrtri_strided_batched_rank_0(handle,uplo,diag,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ctrtri_strided_batched_rank_0 = rocsolver_ctrtri_strided_batched_(handle,uplo, & diag,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_ctrtri_strided_batched_rank_1(handle,uplo,diag,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ctrtri_strided_batched_rank_1 = rocsolver_ctrtri_strided_batched_(handle,uplo, & diag,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_ctrtri_strided_batched_full_rank(handle,uplo,diag,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ctrtri_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ctrtri_strided_batched_full_rank = rocsolver_ctrtri_strided_batched_(handle,uplo, & diag,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ztrtri_strided_batched_assumed_rank(handle,uplo,diag,n,A,lda,strideA, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ztrtri_strided_batched_assumed_rank = rocsolver_ztrtri_strided_batched_(handle, & uplo,diag,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #else function rocsolver_ztrtri_strided_batched_rank_0(handle,uplo,diag,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ztrtri_strided_batched_rank_0 = rocsolver_ztrtri_strided_batched_(handle,uplo, & diag,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_ztrtri_strided_batched_rank_1(handle,uplo,diag,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ztrtri_strided_batched_rank_1 = rocsolver_ztrtri_strided_batched_(handle,uplo, & diag,n,c_loc(A),lda,strideA,myInfo,batch_count) end function function rocsolver_ztrtri_strided_batched_full_rank(handle,uplo,diag,n,A,lda,strideA,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ztrtri_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(kind(rocblas_diagonal_non_unit)) :: diag integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ztrtri_strided_batched_full_rank = rocsolver_ztrtri_strided_batched_(handle,uplo, & diag,n,c_loc(A),lda,strideA,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssytf2_assumed_rank(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_ssytf2_assumed_rank = rocsolver_ssytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv), & myInfo) end function #else function rocsolver_ssytf2_rank_0(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_ssytf2_rank_0 = rocsolver_ssytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_ssytf2_rank_1(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_ssytf2_rank_1 = rocsolver_ssytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_ssytf2_full_rank(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_ssytf2_full_rank = rocsolver_ssytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsytf2_assumed_rank(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_dsytf2_assumed_rank = rocsolver_dsytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv), & myInfo) end function #else function rocsolver_dsytf2_rank_0(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_dsytf2_rank_0 = rocsolver_dsytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_dsytf2_rank_1(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_dsytf2_rank_1 = rocsolver_dsytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_dsytf2_full_rank(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_dsytf2_full_rank = rocsolver_dsytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_csytf2_assumed_rank(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytf2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_csytf2_assumed_rank = rocsolver_csytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv), & myInfo) end function #else function rocsolver_csytf2_rank_0(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytf2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_csytf2_rank_0 = rocsolver_csytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_csytf2_rank_1(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytf2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_csytf2_rank_1 = rocsolver_csytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_csytf2_full_rank(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytf2_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_csytf2_full_rank = rocsolver_csytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zsytf2_assumed_rank(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_zsytf2_assumed_rank = rocsolver_zsytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv), & myInfo) end function #else function rocsolver_zsytf2_rank_0(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_zsytf2_rank_0 = rocsolver_zsytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_zsytf2_rank_1(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_zsytf2_rank_1 = rocsolver_zsytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_zsytf2_full_rank(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_zsytf2_full_rank = rocsolver_zsytf2_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssytf2_batched_assumed_rank(handle,uplo,n,A,lda,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssytf2_batched_assumed_rank = rocsolver_ssytf2_batched_(handle,uplo,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_ssytf2_batched_rank_0(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssytf2_batched_rank_0 = rocsolver_ssytf2_batched_(handle,uplo,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_ssytf2_batched_rank_1(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssytf2_batched_rank_1 = rocsolver_ssytf2_batched_(handle,uplo,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsytf2_batched_assumed_rank(handle,uplo,n,A,lda,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsytf2_batched_assumed_rank = rocsolver_dsytf2_batched_(handle,uplo,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_dsytf2_batched_rank_0(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsytf2_batched_rank_0 = rocsolver_dsytf2_batched_(handle,uplo,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_dsytf2_batched_rank_1(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsytf2_batched_rank_1 = rocsolver_dsytf2_batched_(handle,uplo,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_csytf2_batched_assumed_rank(handle,uplo,n,A,lda,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytf2_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_csytf2_batched_assumed_rank = rocsolver_csytf2_batched_(handle,uplo,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_csytf2_batched_rank_0(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytf2_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_csytf2_batched_rank_0 = rocsolver_csytf2_batched_(handle,uplo,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_csytf2_batched_rank_1(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytf2_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_csytf2_batched_rank_1 = rocsolver_csytf2_batched_(handle,uplo,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zsytf2_batched_assumed_rank(handle,uplo,n,A,lda,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zsytf2_batched_assumed_rank = rocsolver_zsytf2_batched_(handle,uplo,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_zsytf2_batched_rank_0(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zsytf2_batched_rank_0 = rocsolver_zsytf2_batched_(handle,uplo,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_zsytf2_batched_rank_1(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zsytf2_batched_rank_1 = rocsolver_zsytf2_batched_(handle,uplo,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssytf2_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,ipiv, & strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssytf2_strided_batched_assumed_rank = rocsolver_ssytf2_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_ssytf2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssytf2_strided_batched_rank_0 = rocsolver_ssytf2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_ssytf2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssytf2_strided_batched_rank_1 = rocsolver_ssytf2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_ssytf2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytf2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssytf2_strided_batched_full_rank = rocsolver_ssytf2_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsytf2_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,ipiv, & strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsytf2_strided_batched_assumed_rank = rocsolver_dsytf2_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_dsytf2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsytf2_strided_batched_rank_0 = rocsolver_dsytf2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_dsytf2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsytf2_strided_batched_rank_1 = rocsolver_dsytf2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_dsytf2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytf2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsytf2_strided_batched_full_rank = rocsolver_dsytf2_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_csytf2_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,ipiv, & strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytf2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_csytf2_strided_batched_assumed_rank = rocsolver_csytf2_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_csytf2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytf2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_csytf2_strided_batched_rank_0 = rocsolver_csytf2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_csytf2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytf2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_csytf2_strided_batched_rank_1 = rocsolver_csytf2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_csytf2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytf2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_csytf2_strided_batched_full_rank = rocsolver_csytf2_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zsytf2_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,ipiv, & strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zsytf2_strided_batched_assumed_rank = rocsolver_zsytf2_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_zsytf2_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zsytf2_strided_batched_rank_0 = rocsolver_zsytf2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_zsytf2_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zsytf2_strided_batched_rank_1 = rocsolver_zsytf2_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_zsytf2_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytf2_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zsytf2_strided_batched_full_rank = rocsolver_zsytf2_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssytrf_assumed_rank(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_ssytrf_assumed_rank = rocsolver_ssytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv), & myInfo) end function #else function rocsolver_ssytrf_rank_0(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_ssytrf_rank_0 = rocsolver_ssytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_ssytrf_rank_1(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_ssytrf_rank_1 = rocsolver_ssytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_ssytrf_full_rank(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_ssytrf_full_rank = rocsolver_ssytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsytrf_assumed_rank(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_dsytrf_assumed_rank = rocsolver_dsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv), & myInfo) end function #else function rocsolver_dsytrf_rank_0(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_dsytrf_rank_0 = rocsolver_dsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_dsytrf_rank_1(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_dsytrf_rank_1 = rocsolver_dsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_dsytrf_full_rank(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_dsytrf_full_rank = rocsolver_dsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_csytrf_assumed_rank(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrf_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_csytrf_assumed_rank = rocsolver_csytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv), & myInfo) end function #else function rocsolver_csytrf_rank_0(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrf_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_csytrf_rank_0 = rocsolver_csytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_csytrf_rank_1(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrf_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_csytrf_rank_1 = rocsolver_csytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_csytrf_full_rank(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrf_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_csytrf_full_rank = rocsolver_csytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zsytrf_assumed_rank(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv type(c_ptr) :: myInfo ! rocsolver_zsytrf_assumed_rank = rocsolver_zsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv), & myInfo) end function #else function rocsolver_zsytrf_rank_0(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int),target :: ipiv type(c_ptr) :: myInfo ! rocsolver_zsytrf_rank_0 = rocsolver_zsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_zsytrf_rank_1(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_zsytrf_rank_1 = rocsolver_zsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function function rocsolver_zsytrf_full_rank(handle,uplo,n,A,lda,ipiv,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv type(c_ptr) :: myInfo ! rocsolver_zsytrf_full_rank = rocsolver_zsytrf_(handle,uplo,n,c_loc(A),lda,c_loc(ipiv),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssytrf_batched_assumed_rank(handle,uplo,n,A,lda,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssytrf_batched_assumed_rank = rocsolver_ssytrf_batched_(handle,uplo,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_ssytrf_batched_rank_0(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssytrf_batched_rank_0 = rocsolver_ssytrf_batched_(handle,uplo,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_ssytrf_batched_rank_1(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssytrf_batched_rank_1 = rocsolver_ssytrf_batched_(handle,uplo,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsytrf_batched_assumed_rank(handle,uplo,n,A,lda,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsytrf_batched_assumed_rank = rocsolver_dsytrf_batched_(handle,uplo,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_dsytrf_batched_rank_0(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsytrf_batched_rank_0 = rocsolver_dsytrf_batched_(handle,uplo,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_dsytrf_batched_rank_1(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsytrf_batched_rank_1 = rocsolver_dsytrf_batched_(handle,uplo,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_csytrf_batched_assumed_rank(handle,uplo,n,A,lda,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrf_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_csytrf_batched_assumed_rank = rocsolver_csytrf_batched_(handle,uplo,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_csytrf_batched_rank_0(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrf_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_csytrf_batched_rank_0 = rocsolver_csytrf_batched_(handle,uplo,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_csytrf_batched_rank_1(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrf_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_csytrf_batched_rank_1 = rocsolver_csytrf_batched_(handle,uplo,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zsytrf_batched_assumed_rank(handle,uplo,n,A,lda,ipiv,strideP,myInfo, & batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zsytrf_batched_assumed_rank = rocsolver_zsytrf_batched_(handle,uplo,n,A,lda, & c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_zsytrf_batched_rank_0(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zsytrf_batched_rank_0 = rocsolver_zsytrf_batched_(handle,uplo,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function function rocsolver_zsytrf_batched_rank_1(handle,uplo,n,A,lda,ipiv,strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n type(c_ptr) :: A integer(c_int) :: lda integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zsytrf_batched_rank_1 = rocsolver_zsytrf_batched_(handle,uplo,n,A,lda,c_loc(ipiv), & strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_ssytrf_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,ipiv, & strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssytrf_strided_batched_assumed_rank = rocsolver_ssytrf_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_ssytrf_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssytrf_strided_batched_rank_0 = rocsolver_ssytrf_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_ssytrf_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssytrf_strided_batched_rank_1 = rocsolver_ssytrf_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_ssytrf_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_ssytrf_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_ssytrf_strided_batched_full_rank = rocsolver_ssytrf_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_dsytrf_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,ipiv, & strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsytrf_strided_batched_assumed_rank = rocsolver_dsytrf_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_dsytrf_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsytrf_strided_batched_rank_0 = rocsolver_dsytrf_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_dsytrf_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsytrf_strided_batched_rank_1 = rocsolver_dsytrf_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_dsytrf_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_dsytrf_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_dsytrf_strided_batched_full_rank = rocsolver_dsytrf_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_csytrf_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,ipiv, & strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrf_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_csytrf_strided_batched_assumed_rank = rocsolver_csytrf_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_csytrf_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrf_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_csytrf_strided_batched_rank_0 = rocsolver_csytrf_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_csytrf_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrf_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_csytrf_strided_batched_rank_1 = rocsolver_csytrf_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_csytrf_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_csytrf_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_csytrf_strided_batched_full_rank = rocsolver_csytrf_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zsytrf_strided_batched_assumed_rank(handle,uplo,n,A,lda,strideA,ipiv, & strideP,myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_strided_batched_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,contiguous,dimension(..) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zsytrf_strided_batched_assumed_rank = rocsolver_zsytrf_strided_batched_(handle, & uplo,n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #else function rocsolver_zsytrf_strided_batched_rank_0(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_strided_batched_rank_0 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zsytrf_strided_batched_rank_0 = rocsolver_zsytrf_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_zsytrf_strided_batched_rank_1(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_strided_batched_rank_1 type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zsytrf_strided_batched_rank_1 = rocsolver_zsytrf_strided_batched_(handle,uplo,n, & c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function function rocsolver_zsytrf_strided_batched_full_rank(handle,uplo,n,A,lda,strideA,ipiv,strideP, & myInfo,batch_count) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zsytrf_strided_batched_full_rank type(c_ptr) :: handle integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int64_t) :: strideA integer(c_int),target,dimension(:) :: ipiv integer(c_int64_t) :: strideP type(c_ptr) :: myInfo integer(c_int) :: batch_count ! rocsolver_zsytrf_strided_batched_full_rank = rocsolver_zsytrf_strided_batched_(handle,uplo, & n,c_loc(A),lda,strideA,c_loc(ipiv),strideP,myInfo,batch_count) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_chegvdx_assumed_rank(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il, & iu,nev,W,Z,ldz,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvdx_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_erange_all)) :: erange integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float) :: vl real(c_float) :: vu integer(c_int) :: il integer(c_int) :: iu integer(c_int) :: nev real(c_float),target,contiguous,dimension(..) :: W complex(c_float_complex),target,contiguous,dimension(..) :: Z integer(c_int) :: ldz integer(c_int),target,contiguous,dimension(..) :: myInfo ! rocsolver_chegvdx_assumed_rank = rocsolver_chegvdx_(handle,itype,evect,erange,uplo,n, & c_loc(A),lda,c_loc(B),ldb,vl,vu,il,iu,nev,c_loc(W),c_loc(Z),ldz,c_loc(myInfo)) end function #else function rocsolver_chegvdx_rank_0(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu, & nev,W,Z,ldz,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvdx_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_erange_all)) :: erange integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target :: A integer(c_int) :: lda complex(c_float_complex),target :: B integer(c_int) :: ldb real(c_float) :: vl real(c_float) :: vu integer(c_int) :: il integer(c_int) :: iu integer(c_int) :: nev real(c_float),target :: W complex(c_float_complex),target :: Z integer(c_int) :: ldz integer(c_int),target :: myInfo ! rocsolver_chegvdx_rank_0 = rocsolver_chegvdx_(handle,itype,evect,erange,uplo,n,c_loc(A),lda, & c_loc(B),ldb,vl,vu,il,iu,nev,c_loc(W),c_loc(Z),ldz,c_loc(myInfo)) end function function rocsolver_chegvdx_rank_1(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu, & nev,W,Z,ldz,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvdx_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_erange_all)) :: erange integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb real(c_float) :: vl real(c_float) :: vu integer(c_int) :: il integer(c_int) :: iu integer(c_int) :: nev real(c_float),target,dimension(:) :: W complex(c_float_complex),target,dimension(:) :: Z integer(c_int) :: ldz integer(c_int),target,dimension(:) :: myInfo ! rocsolver_chegvdx_rank_1 = rocsolver_chegvdx_(handle,itype,evect,erange,uplo,n,c_loc(A),lda, & c_loc(B),ldb,vl,vu,il,iu,nev,c_loc(W),c_loc(Z),ldz,c_loc(myInfo)) end function function rocsolver_chegvdx_full_rank(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu, & nev,W,Z,ldz,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_chegvdx_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_erange_all)) :: erange integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float) :: vl real(c_float) :: vu integer(c_int) :: il integer(c_int) :: iu integer(c_int) :: nev real(c_float),target,dimension(:) :: W complex(c_float_complex),target,dimension(:,:) :: Z integer(c_int) :: ldz integer(c_int),target,dimension(:) :: myInfo ! rocsolver_chegvdx_full_rank = rocsolver_chegvdx_(handle,itype,evect,erange,uplo,n,c_loc(A), & lda,c_loc(B),ldb,vl,vu,il,iu,nev,c_loc(W),c_loc(Z),ldz,c_loc(myInfo)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsolver_zhegvdx_assumed_rank(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il, & iu,nev,W,Z,ldz,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvdx_assumed_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_erange_all)) :: erange integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double) :: vl real(c_double) :: vu integer(c_int) :: il integer(c_int) :: iu integer(c_int) :: nev real(c_double),target,contiguous,dimension(..) :: W complex(c_double_complex),target,contiguous,dimension(..) :: Z integer(c_int) :: ldz integer(c_int),target,contiguous,dimension(..) :: myInfo ! rocsolver_zhegvdx_assumed_rank = rocsolver_zhegvdx_(handle,itype,evect,erange,uplo,n, & c_loc(A),lda,c_loc(B),ldb,vl,vu,il,iu,nev,c_loc(W),c_loc(Z),ldz,c_loc(myInfo)) end function #else function rocsolver_zhegvdx_rank_0(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu, & nev,W,Z,ldz,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvdx_rank_0 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_erange_all)) :: erange integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target :: A integer(c_int) :: lda complex(c_double_complex),target :: B integer(c_int) :: ldb real(c_double) :: vl real(c_double) :: vu integer(c_int) :: il integer(c_int) :: iu integer(c_int) :: nev real(c_double),target :: W complex(c_double_complex),target :: Z integer(c_int) :: ldz integer(c_int),target :: myInfo ! rocsolver_zhegvdx_rank_0 = rocsolver_zhegvdx_(handle,itype,evect,erange,uplo,n,c_loc(A),lda, & c_loc(B),ldb,vl,vu,il,iu,nev,c_loc(W),c_loc(Z),ldz,c_loc(myInfo)) end function function rocsolver_zhegvdx_rank_1(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu, & nev,W,Z,ldz,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvdx_rank_1 type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_erange_all)) :: erange integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb real(c_double) :: vl real(c_double) :: vu integer(c_int) :: il integer(c_int) :: iu integer(c_int) :: nev real(c_double),target,dimension(:) :: W complex(c_double_complex),target,dimension(:) :: Z integer(c_int) :: ldz integer(c_int),target,dimension(:) :: myInfo ! rocsolver_zhegvdx_rank_1 = rocsolver_zhegvdx_(handle,itype,evect,erange,uplo,n,c_loc(A),lda, & c_loc(B),ldb,vl,vu,il,iu,nev,c_loc(W),c_loc(Z),ldz,c_loc(myInfo)) end function function rocsolver_zhegvdx_full_rank(handle,itype,evect,erange,uplo,n,A,lda,B,ldb,vl,vu,il,iu, & nev,W,Z,ldz,myInfo) use iso_c_binding use hipfort_rocsolver_enums use hipfort_rocblas_enums implicit none integer(kind(rocblas_status_success)) :: rocsolver_zhegvdx_full_rank type(c_ptr) :: handle integer(kind(rocblas_eform_ax)) :: itype integer(kind(rocblas_evect_original)) :: evect integer(kind(rocblas_erange_all)) :: erange integer(kind(rocblas_fill_upper)) :: uplo integer(c_int) :: n complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double) :: vl real(c_double) :: vu integer(c_int) :: il integer(c_int) :: iu integer(c_int) :: nev real(c_double),target,dimension(:) :: W complex(c_double_complex),target,dimension(:,:) :: Z integer(c_int) :: ldz integer(c_int),target,dimension(:) :: myInfo ! rocsolver_zhegvdx_full_rank = rocsolver_zhegvdx_(handle,itype,evect,erange,uplo,n,c_loc(A), & lda,c_loc(B),ldb,vl,vu,il,iu,nev,c_loc(W),c_loc(Z),ldz,c_loc(myInfo)) end function #endif #endif end module hipfort_rocsolver hipfort-rocm-10.0.0/lib/hipfort/hipfort_rocsolver_enums.F90000066400000000000000000000105441524740623400236750ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_rocsolver_enums implicit none ! rocblas_layer_mode_ex_ enum, bind(c) enumerator :: rocblas_layer_mode_ex_log_kernel = 16 end enum ! rocblas_direct_ enum, bind(c) enumerator :: rocblas_forward_direction = 171 enumerator :: rocblas_backward_direction = 172 end enum ! rocblas_storev_ enum, bind(c) enumerator :: rocblas_column_wise = 181 enumerator :: rocblas_row_wise = 182 end enum ! rocblas_svect_ enum, bind(c) enumerator :: rocblas_svect_all = 191 enumerator :: rocblas_svect_singular = 192 enumerator :: rocblas_svect_overwrite = 193 enumerator :: rocblas_svect_none = 194 end enum ! rocblas_workmode_ enum, bind(c) enumerator :: rocblas_outofplace = 201 enumerator :: rocblas_inplace = 202 end enum ! rocblas_evect_ enum, bind(c) enumerator :: rocblas_evect_original = 211 enumerator :: rocblas_evect_tridiagonal = 212 enumerator :: rocblas_evect_none = 213 end enum ! rocblas_eform_ enum, bind(c) enumerator :: rocblas_eform_ax = 221 enumerator :: rocblas_eform_abx = 222 enumerator :: rocblas_eform_bax = 223 end enum ! rocblas_erange_ enum, bind(c) enumerator :: rocblas_erange_all = 231 enumerator :: rocblas_erange_value = 232 enumerator :: rocblas_erange_index = 233 end enum ! rocblas_eorder_ enum, bind(c) enumerator :: rocblas_eorder_blocks = 241 enumerator :: rocblas_eorder_entire = 242 end enum ! rocblas_esort_ enum, bind(c) enumerator :: rocblas_esort_none = 251 enumerator :: rocblas_esort_ascending = 252 end enum ! rocblas_srange_ enum, bind(c) enumerator :: rocblas_srange_all = 261 enumerator :: rocblas_srange_value = 262 enumerator :: rocblas_srange_index = 263 end enum ! rocsolver_rfinfo_mode_ enum, bind(c) enumerator :: rocsolver_rfinfo_mode_lu = 271 enumerator :: rocsolver_rfinfo_mode_cholesky = 272 end enum ! rocblas_pivot_ enum, bind(c) enumerator :: rocblas_pivot_variable = 281 enumerator :: rocblas_pivot_top = 282 enumerator :: rocblas_pivot_bottom = 283 end enum ! rocsolver_alg_mode_ enum, bind(c) enumerator :: rocsolver_alg_mode_gpu = 291 enumerator :: rocsolver_alg_mode_hybrid = 292 enumerator :: rocsolver_alg_mode_mixed = 293 end enum ! rocsolver_norm_type_ enum, bind(c) enumerator :: rocsolver_norm_type_one = 301 enumerator :: rocsolver_norm_type_frobenius = 302 enumerator :: rocsolver_norm_type_infinity = 303 enumerator :: rocsolver_norm_type_max = 304 end enum ! rocsolver_function_ enum, bind(c) enumerator :: rocsolver_function_bdsqr = 401 enumerator :: rocsolver_function_gesvd = 402 enumerator :: rocsolver_function_sterf = 403 enumerator :: rocsolver_function_steqr = 404 enumerator :: rocsolver_function_syev_heev = 405 end enum end module hipfort_rocsolver_enums hipfort-rocm-10.0.0/lib/hipfort/hipfort_rocsparse.F90000066400000000000000000121443261524740623400224620ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_rocsparse use hipfort_rocsparse_enums implicit none !> \ingroup aux_module !> \brief Create a rocSPARSE handle. !> !> \details !> \p rocsparse_create_handle creates the rocSPARSE library context. It must be !> initialized before any other rocSPARSE API function is invoked and must be passed to !> all subsequent library function calls. The handle should be destroyed at the end !> using rocsparse_destroy_handle(). !> !> @param[out] handle - the pointer to the handle to the rocSPARSE library context. !> !> \retval rocsparse_status_success the initialization succeeded. !> \retval rocsparse_status_invalid_handle \p handle pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_create_handle function rocsparse_create_handle_(handle) bind(c, name="rocsparse_create_handle") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_handle_ type(c_ptr) :: handle end function end interface !> \ingroup aux_module !> \brief Create a rocSPARSE handle on a user-defined stream. !> !> \details !> \p rocsparse_handle_create associates the handle with the user-provided \p stream !> before performing any setup work. All device memory allocation and initialization are !> enqueued on \p stream using stream-ordered operations, so handle creation is !> asynchronous with respect to the host: it returns to the caller without blocking the !> calling CPU thread or any GPU stream. !> !> \note !> This routine is not compatible with HIP graph stream capture. It performs !> stream-ordered device allocations and a warm-up kernel launch, so it must not be !> called while \p stream (or any other stream) is being captured into a HIP graph. !> !> \note !> The handle is fully initialized for operations submitted on \p stream (stream !> ordering guarantees correctness). If the handle must be used on a different stream !> before \p stream has finished executing, the caller must first synchronize \p stream !> (e.g. via \p hipStreamSynchronize or a HIP event dependency). !> !> The handle should be destroyed at the end using \ref rocsparse_handle_destroy or !> \ref rocsparse_destroy_handle. !> !> @param[out] handle - the pointer to the handle to the rocSPARSE library context. !> @param[in] stream - the user-defined stream to associate with the handle and to use for !> all stream-ordered setup work during creation. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the initialization succeeded. !> \retval rocsparse_status_invalid_pointer \p handle pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_handle_create function rocsparse_handle_create_(handle,stream,p_error) bind(c, name="rocsparse_handle_create") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_handle_create_ type(c_ptr) :: handle type(c_ptr),value :: stream type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Destroy a rocSPARSE handle. !> !> \details !> \p rocsparse_destroy_handle destroys the rocSPARSE library context and releases all !> resources used by the rocSPARSE library. !> !> @param[in] handle - the handle to the rocSPARSE library context. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle \p handle is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_destroy_handle function rocsparse_destroy_handle_(handle) bind(c, name="rocsparse_destroy_handle") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_destroy_handle_ type(c_ptr),value :: handle end function end interface !> \ingroup aux_module !> \brief Destroy a rocSPARSE handle. !> !> \details !> \p rocsparse_handle_destroy destroys the rocSPARSE library context and releases !> all resources used by the rocSPARSE library. !> !> @param[in] handle - the handle to the rocSPARSE library context, which can be a null pointer. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_handle_destroy function rocsparse_handle_destroy_(handle,p_error) bind(c, name="rocsparse_handle_destroy") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_handle_destroy_ type(c_ptr),value :: handle type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Destroy a rocSPARSE error descriptor. !> !> \details !> \p rocsparse_destroy_error destroys the rocSPARSE error descriptor. !> !> @param[in] error - the pointer to the rocSPARSE error descriptor, which can be a null !> pointer. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_destroy_error function rocsparse_destroy_error_(error) bind(c, name="rocsparse_destroy_error") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_destroy_error_ type(c_ptr),value :: error end function end interface !> \ingroup aux_module !> \brief Error message from a rocSPARSE error descriptor. !> !> \details !> \p rocsparse_error_message returns a C-style string that provides details for the error. !> !> @param[in] error - the error to the rocSPARSE error descriptor. !> !> @return an error message from a rocSPARSE error descriptor. !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_error_get_message function rocsparse_error_get_message_(error) bind(c, name="rocsparse_error_get_message") use iso_c_binding use hipfort_rocsparse_enums implicit none type(c_ptr) :: rocsparse_error_get_message_ type(c_ptr),value :: error end function end interface !> \ingroup aux_module !> \brief Return the string representation of a rocSPARSE status code enum name. !> !> \details !> \p rocsparse_get_status_name takes a rocSPARSE status as input and returns the string !> representation of this status. !> If the status is not recognized, the function returns "Unrecognized status code". !> !> @param[in] status - a rocSPARSE status. !> !> \retval pointer to null-terminated string. interface rocsparse_get_status_name function rocsparse_get_status_name_(status) bind(c, name="rocsparse_get_status_name") use iso_c_binding use hipfort_rocsparse_enums implicit none type(c_ptr) :: rocsparse_get_status_name_ integer(kind(rocsparse_status_success)),value :: status end function end interface !> \ingroup aux_module !> \brief Return the rocSPARSE status code description as a string. !> !> \details !> \p rocsparse_get_status_description takes a rocSPARSE status as input and returns the status !> description as a string. !> If the status is not recognized, the function returns "Unrecognized status code" !> !> @param[in] status - a rocSPARSE status. !> !> \retval pointer to null-terminated string. interface rocsparse_get_status_description function rocsparse_get_status_description_(status) & bind(c, name="rocsparse_get_status_description") use iso_c_binding use hipfort_rocsparse_enums implicit none type(c_ptr) :: rocsparse_get_status_description_ integer(kind(rocsparse_status_success)),value :: status end function end interface !> \ingroup aux_module !> \brief Specify user-defined HIP stream. !> !> \details !> \p rocsparse_set_stream specifies the stream to be used by the rocSPARSE library !> context and all subsequent function calls. !> !> @param[inout] handle - the handle to the rocSPARSE library context. !> @param[in] stream - the stream to be used by the rocSPARSE library context. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle \p handle is invalid. !> !> \par Example !> This example illustrates how a user-defined stream can be used in rocSPARSE. !> \code{.c} !> // Create rocSPARSE handle !> rocsparse_handle handle; !> rocsparse_create_handle(&handle); !> !> // Create stream !> hipStream_t stream; !> hipStreamCreate(&stream); !> !> // Set stream to rocSPARSE handle !> rocsparse_set_stream(handle, stream); !> !> // Do some work !> // ... !> !> // Clean up !> rocsparse_destroy_handle(handle); !> hipStreamDestroy(stream); !> \endcode interface rocsparse_set_stream function rocsparse_set_stream_(handle,stream) bind(c, name="rocsparse_set_stream") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_set_stream_ type(c_ptr),value :: handle type(c_ptr),value :: stream end function end interface !> \ingroup aux_module !> \brief Get the current stream from the library context. !> !> \details !> \p rocsparse_get_stream gets the rocSPARSE library context stream which will !> be used for all subsequent function calls. !> !> @param[in] handle - the handle to the rocSPARSE library context. !> @param[out] stream - the stream currently used by the rocSPARSE library context. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle \p handle is invalid. interface rocsparse_get_stream function rocsparse_get_stream_(handle,stream) bind(c, name="rocsparse_get_stream") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_get_stream_ type(c_ptr),value :: handle type(c_ptr) :: stream end function end interface !> \ingroup aux_module !> \brief Specify the pointer mode. !> !> \details !> \p rocsparse_set_pointer_mode specifies the pointer mode to be used by the rocSPARSE !> library context and all subsequent function calls. For example, many rocSPARSE routines take !> \f$\alpha\f$ and \f$\beta\f$ pointers as parameters. These can be either host memory pointers !> or device memory pointers, depending on what the pointer mode is set to. By default, all !> values are passed !> using host pointer mode. Valid pointer modes are `rocsparse_pointer_mode_host` !> or `rocsparse_pointer_mode_device`. !> !> @param[in] handle - the handle to the rocSPARSE library context. !> @param[in] pointer_mode - the pointer mode to be used by the rocSPARSE library context. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle \p handle is invalid. interface rocsparse_set_pointer_mode function rocsparse_set_pointer_mode_(handle,pointer_mode) & bind(c, name="rocsparse_set_pointer_mode") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_set_pointer_mode_ type(c_ptr),value :: handle integer(kind(rocsparse_pointer_mode_host)),value :: pointer_mode end function end interface !> \ingroup aux_module !> \brief Get the current pointer mode from the library context. !> !> \details !> \p rocsparse_get_pointer_mode gets the rocSPARSE library context pointer mode which !> will be used for all subsequent function calls. !> !> @param[in] handle - the handle to the rocSPARSE library context. !> @param[out] pointer_mode - the pointer mode that is currently used by the rocSPARSE library !> context. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle \p handle is invalid. interface rocsparse_get_pointer_mode function rocsparse_get_pointer_mode_(handle,pointer_mode) & bind(c, name="rocsparse_get_pointer_mode") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_get_pointer_mode_ type(c_ptr),value :: handle type(c_ptr),value :: pointer_mode end function end interface !> \ingroup aux_module !> \brief Get rocSPARSE version !> !> \details !> \p rocsparse_get_version gets the rocSPARSE library version number. !> - patch = version % 100 !> - minor = version / 100 % 1000 !> - major = version / 100000 !> !> @param[in] handle - the handle to the rocSPARSE library context. !> @param[out] version - the version number of the rocSPARSE library. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle \p handle is invalid. !> \par Example !> \code{.c} !> rocsparse_handle handle; !> rocsparse_create_handle(&handle); !> rocsparse_get_version(handle, &rocsparse_ver); !> rocsparse_destroy_handle(handle); !> \endcode interface rocsparse_get_version function rocsparse_get_version_(handle,version) bind(c, name="rocsparse_get_version") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_get_version_ type(c_ptr),value :: handle integer(c_int) :: version end function end interface !> \ingroup aux_module !> \brief Get the rocSPARSE git revision. !> !> \details !> \p rocsparse_get_git_rev gets the rocSPARSE library git commit revision (SHA-1). !> !> @param[in] handle - the handle to the rocSPARSE library context. !> @param[out] rev - the git commit revision (SHA-1). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle \p handle is invalid. !> \par Example !> \code{.c} !> rocsparse_handle handle; !> rocsparse_create_handle(&handle); !> rocsparse_get_git_rev(handle, rocsparse_rev); !> rocsparse_destroy_handle(handle); !> \endcode interface rocsparse_get_git_rev function rocsparse_get_git_rev_(handle,rev) bind(c, name="rocsparse_get_git_rev") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_get_git_rev_ type(c_ptr),value :: handle type(c_ptr),value :: rev end function end interface !> \ingroup aux_module !> \brief Create a matrix descriptor. !> \details !> \p rocsparse_create_mat_descr creates a matrix descriptor. It initializes !> `rocsparse_matrix_type` to `rocsparse_matrix_type_general`, `rocsparse_fill_mode` !> to `rocsparse_fill_mode_lower`, `rocsparse_diag_type` to `rocsparse_diag_type_non_unit`, !> `rocsparse_index_base` to `rocsparse_index_base_zero`, and `rocsparse_storage_mode` !> to `rocsparse_storage_mode_sorted`. It should be destroyed at the end using !> `rocsparse_destroy_mat_descr`(). !> !> The matrix type, fill mode, diag type, index base, and storage mode can be set using the !> \ref rocsparse_set_mat_type, \ref rocsparse_set_mat_fill_mode, `rocsparse_set_mat_diag_type`, !> \ref rocsparse_set_mat_index_base, and \ref rocsparse_set_mat_storage_mode APIs respectively. !> !> @param[out] descr - the pointer to the matrix descriptor. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr pointer is invalid. interface rocsparse_create_mat_descr function rocsparse_create_mat_descr_(descr) bind(c, name="rocsparse_create_mat_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_mat_descr_ type(c_ptr) :: descr end function end interface !> \ingroup aux_module !> \brief Copy a matrix descriptor. !> \details !> \p rocsparse_copy_mat_descr copies a matrix descriptor. Both source and destination !> matrix descriptors must be initialized prior to calling \p rocsparse_copy_mat_descr. !> !> @param[out] dest - the pointer to the destination matrix descriptor. !> @param[in] src - the pointer to the source matrix descriptor. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p src or \p dest pointer is invalid. interface rocsparse_copy_mat_descr function rocsparse_copy_mat_descr_(dest,src) bind(c, name="rocsparse_copy_mat_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_copy_mat_descr_ type(c_ptr),value :: dest type(c_ptr),value :: src end function end interface !> \ingroup aux_module !> \brief Destroy a matrix descriptor. !> !> \details !> \p rocsparse_destroy_mat_descr destroys a matrix descriptor and releases all !> resources used by the descriptor. !> !> @param[in] descr - the matrix descriptor. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr is invalid. interface rocsparse_destroy_mat_descr function rocsparse_destroy_mat_descr_(descr) bind(c, name="rocsparse_destroy_mat_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_destroy_mat_descr_ type(c_ptr),value :: descr end function end interface !> \ingroup aux_module !> \brief Specify the index base of a matrix descriptor. !> !> \details !> \p rocsparse_set_mat_index_base sets the index base of a matrix descriptor. Valid !> options are `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> !> @param[inout] descr - the matrix descriptor. !> @param[in] base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr pointer is invalid. !> \retval rocsparse_status_invalid_value \p base is invalid. interface rocsparse_set_mat_index_base function rocsparse_set_mat_index_base_(descr,base) bind(c, name="rocsparse_set_mat_index_base") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_set_mat_index_base_ type(c_ptr),value :: descr integer(kind(rocsparse_index_base_zero)),value :: base end function end interface !> \ingroup aux_module !> \brief Get the index base of a matrix descriptor. !> !> \details !> \p rocsparse_get_mat_index_base returns the index base of a matrix descriptor. !> !> @param[in] descr - the matrix descriptor. !> !> \returns `rocsparse_index_base_zero` or `rocsparse_index_base_one`. interface rocsparse_get_mat_index_base function rocsparse_get_mat_index_base_(descr) bind(c, name="rocsparse_get_mat_index_base") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_index_base_zero)) :: rocsparse_get_mat_index_base_ type(c_ptr),value :: descr end function end interface !> \ingroup aux_module !> \brief Specify the matrix type of a matrix descriptor. !> !> \details !> \p rocsparse_set_mat_type sets the matrix type of a matrix descriptor. Valid !> matrix types are `rocsparse_matrix_type_general`, !> `rocsparse_matrix_type_symmetric`, `rocsparse_matrix_type_hermitian`, or !> `rocsparse_matrix_type_triangular`. !> !> @param[inout] descr - the matrix descriptor. !> @param[in] myType - `rocsparse_matrix_type_general`, `rocsparse_matrix_type_symmetric`, !> `rocsparse_matrix_type_hermitian`, or !> `rocsparse_matrix_type_triangular`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr pointer is invalid. !> \retval rocsparse_status_invalid_value \p type is invalid. interface rocsparse_set_mat_type function rocsparse_set_mat_type_(descr,myType) bind(c, name="rocsparse_set_mat_type") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_set_mat_type_ type(c_ptr),value :: descr integer(kind(rocsparse_matrix_type_general)),value :: myType end function end interface !> \ingroup aux_module !> \brief Get the matrix type of a matrix descriptor. !> !> \details !> \p rocsparse_get_mat_type returns the matrix type of a matrix descriptor. !> !> @param[in] descr - the matrix descriptor. !> !> \returns `rocsparse_matrix_type_general`, `rocsparse_matrix_type_symmetric`, !> `rocsparse_matrix_type_hermitian`, or !> `rocsparse_matrix_type_triangular`. interface rocsparse_get_mat_type function rocsparse_get_mat_type_(descr) bind(c, name="rocsparse_get_mat_type") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_matrix_type_general)) :: rocsparse_get_mat_type_ type(c_ptr),value :: descr end function end interface !> \ingroup aux_module !> \brief Specify the matrix fill mode of a matrix descriptor. !> !> \details !> \p rocsparse_set_mat_fill_mode sets the matrix fill mode of a matrix descriptor. !> Valid fill modes are `rocsparse_fill_mode_lower` or !> `rocsparse_fill_mode_upper`. !> !> @param[inout] descr - the matrix descriptor. !> @param[in] fill_mode - `rocsparse_fill_mode_lower` or `rocsparse_fill_mode_upper`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr pointer is invalid. !> \retval rocsparse_status_invalid_value \p fill_mode is invalid. interface rocsparse_set_mat_fill_mode function rocsparse_set_mat_fill_mode_(descr,fill_mode) & bind(c, name="rocsparse_set_mat_fill_mode") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_set_mat_fill_mode_ type(c_ptr),value :: descr integer(kind(rocsparse_fill_mode_lower)),value :: fill_mode end function end interface !> \ingroup aux_module !> \brief Get the matrix fill mode of a matrix descriptor. !> !> \details !> \p rocsparse_get_mat_fill_mode returns the matrix fill mode of a matrix descriptor. !> !> @param[in] descr - the matrix descriptor. !> !> \returns `rocsparse_fill_mode_lower` or `rocsparse_fill_mode_upper`. interface rocsparse_get_mat_fill_mode function rocsparse_get_mat_fill_mode_(descr) bind(c, name="rocsparse_get_mat_fill_mode") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_fill_mode_lower)) :: rocsparse_get_mat_fill_mode_ type(c_ptr),value :: descr end function end interface !> \ingroup aux_module !> \brief Specify the matrix diagonal type of a matrix descriptor. !> !> \details !> \p rocsparse_set_mat_diag_type sets the matrix diagonal type of a matrix !> descriptor. Valid diagonal types are `rocsparse_diag_type_unit` or !> `rocsparse_diag_type_non_unit`. !> !> @param[inout] descr - the matrix descriptor. !> @param[in] diag_type - `rocsparse_diag_type_unit` or `rocsparse_diag_type_non_unit`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr pointer is invalid. !> \retval rocsparse_status_invalid_value \p diag_type is invalid. interface rocsparse_set_mat_diag_type function rocsparse_set_mat_diag_type_(descr,diag_type) & bind(c, name="rocsparse_set_mat_diag_type") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_set_mat_diag_type_ type(c_ptr),value :: descr integer(kind(rocsparse_diag_type_non_unit)),value :: diag_type end function end interface !> \ingroup aux_module !> \brief Get the matrix diagonal type of a matrix descriptor. !> !> \details !> \p rocsparse_get_mat_diag_type returns the matrix diagonal type of a matrix !> descriptor. !> !> @param[in] descr - the matrix descriptor. !> !> \returns `rocsparse_diag_type_unit` or `rocsparse_diag_type_non_unit`. interface rocsparse_get_mat_diag_type function rocsparse_get_mat_diag_type_(descr) bind(c, name="rocsparse_get_mat_diag_type") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_diag_type_non_unit)) :: rocsparse_get_mat_diag_type_ type(c_ptr),value :: descr end function end interface !> \ingroup aux_module !> \brief Specify the matrix storage mode of a matrix descriptor. !> !> \details !> \p rocsparse_set_mat_storage_mode sets the matrix storage mode of a matrix descriptor. !> Valid fill modes are `rocsparse_storage_mode_sorted` or !> `rocsparse_storage_mode_unsorted`. !> !> @param[inout] descr - the matrix descriptor. !> @param[in] storage_mode - `rocsparse_storage_mode_sorted` or !> `rocsparse_storage_mode_unsorted`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr pointer is invalid. !> \retval rocsparse_status_invalid_value \p storage_mode is invalid. interface rocsparse_set_mat_storage_mode function rocsparse_set_mat_storage_mode_(descr,storage_mode) & bind(c, name="rocsparse_set_mat_storage_mode") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_set_mat_storage_mode_ type(c_ptr),value :: descr integer(kind(rocsparse_storage_mode_sorted)),value :: storage_mode end function end interface !> \ingroup aux_module !> \brief Get the matrix storage mode of a matrix descriptor. !> !> \details !> \p rocsparse_get_mat_storage_mode returns the matrix storage mode of a matrix descriptor. !> !> @param[in] descr - the matrix descriptor. !> !> \returns `rocsparse_storage_mode_sorted` or `rocsparse_storage_mode_unsorted`. interface rocsparse_get_mat_storage_mode function rocsparse_get_mat_storage_mode_(descr) bind(c, name="rocsparse_get_mat_storage_mode") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_storage_mode_sorted)) :: rocsparse_get_mat_storage_mode_ type(c_ptr),value :: descr end function end interface !> \ingroup aux_module !> \brief Create a \p HYB matrix structure !> !> \details !> \p rocsparse_create_hyb_mat creates a structure that holds the matrix in \p HYB !> storage format. It should be destroyed at the end using rocsparse_destroy_hyb_mat(). !> !> @param[inout] hyb - the pointer to the hybrid matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p hyb pointer is invalid. interface rocsparse_create_hyb_mat function rocsparse_create_hyb_mat_(hyb) bind(c, name="rocsparse_create_hyb_mat") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_hyb_mat_ type(c_ptr) :: hyb end function end interface !> \ingroup aux_module !> \brief Copy a \p HYB matrix structure. !> !> \details !> \p rocsparse_copy_hyb_mat copies a matrix info structure. Both source and destination !> matrix info structure must be initialized prior to calling \p rocsparse_copy_hyb_mat. !> !> @param[out] dest - the pointer to the destination matrix info structure. !> @param[in] src - the pointer to the source matrix info structure. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p hyb pointer is invalid. interface rocsparse_copy_hyb_mat function rocsparse_copy_hyb_mat_(dest,src) bind(c, name="rocsparse_copy_hyb_mat") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_copy_hyb_mat_ type(c_ptr),value :: dest type(c_ptr),value :: src end function end interface !> \ingroup aux_module !> \brief Destroy a \p HYB matrix structure. !> !> \details !> \p rocsparse_destroy_hyb_mat destroys a \p HYB structure. !> !> @param[in] hyb - the hybrid matrix structure. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p hyb pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_destroy_hyb_mat function rocsparse_destroy_hyb_mat_(hyb) bind(c, name="rocsparse_destroy_hyb_mat") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_destroy_hyb_mat_ type(c_ptr),value :: hyb end function end interface !> \ingroup aux_module !> \brief Create a matrix info structure. !> !> \details !> \p rocsparse_create_mat_info creates a structure that holds the matrix info data !> that is gathered during the analysis routines available. It should be destroyed !> at the end using `rocsparse_destroy_mat_info()`. !> !> @param[inout] myInfo - the pointer to the info structure. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p info pointer is invalid. interface rocsparse_create_mat_info function rocsparse_create_mat_info_(myInfo) bind(c, name="rocsparse_create_mat_info") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_mat_info_ type(c_ptr) :: myInfo end function end interface !> \ingroup aux_module !> \brief Copy a matrix info structure. !> \details !> \p rocsparse_copy_mat_info copies a matrix info structure. Both source and destination !> matrix info structure must be initialized prior to calling \p rocsparse_copy_mat_info. !> !> @param[out] dest - the pointer to the destination matrix info structure. !> @param[in] src - the pointer to the source matrix info structure. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p src or \p dest pointer is invalid. interface rocsparse_copy_mat_info function rocsparse_copy_mat_info_(dest,src) bind(c, name="rocsparse_copy_mat_info") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_copy_mat_info_ type(c_ptr),value :: dest type(c_ptr),value :: src end function end interface !> \ingroup aux_module !> \brief Destroy a matrix info structure !> !> \details !> \p rocsparse_destroy_mat_info destroys a matrix info structure. !> !> @param[in] myInfo - the info structure. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p info pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_destroy_mat_info function rocsparse_destroy_mat_info_(myInfo) bind(c, name="rocsparse_destroy_mat_info") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_destroy_mat_info_ type(c_ptr),value :: myInfo end function end interface !> \ingroup aux_module !> \brief Create a color info structure !> !> \details !> \p rocsparse_create_color_info creates a structure that holds the color info data !> that is gathered during the analysis routines. It should be destroyed !> at the end using rocsparse_destroy_color_info(). !> !> @param[inout] myInfo - the pointer to the info structure. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p info pointer is invalid. interface rocsparse_create_color_info function rocsparse_create_color_info_(myInfo) bind(c, name="rocsparse_create_color_info") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_color_info_ type(c_ptr) :: myInfo end function end interface !> \ingroup aux_module !> \brief Copy a color info structure. !> \details !> \p rocsparse_copy_color_info copies a color info structure. Both source and destination !> color info structure must be initialized prior to calling \p rocsparse_copy_color_info. !> !> @param[out] dest - the pointer to the destination color info structure. !> @param[in] src - the pointer to the source color info structure. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p src or \p dest pointer is invalid. interface rocsparse_copy_color_info function rocsparse_copy_color_info_(dest,src) bind(c, name="rocsparse_copy_color_info") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_copy_color_info_ type(c_ptr),value :: dest type(c_ptr),value :: src end function end interface !> \ingroup aux_module !> \brief Destroy a color info structure. !> !> \details !> \p rocsparse_destroy_color_info destroys a color info structure. !> !> @param[in] myInfo - the info structure. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p info pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_destroy_color_info function rocsparse_destroy_color_info_(myInfo) bind(c, name="rocsparse_destroy_color_info") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_destroy_color_info_ type(c_ptr),value :: myInfo end function end interface !> \ingroup aux_module !> \brief Create a sparse vector descriptor. !> \details !> \p rocsparse_create_spvec_descr creates a sparse vector descriptor. It should be !> destroyed at the end using `rocsparse_destroy_mat_descr()`. !> !> @param[out] descr - the pointer to the sparse vector descriptor. !> @param[in] mySize - size of the sparse vector. !> @param[in] nnz - number of non-zeros in sparse vector. !> @param[in] indices - indices of the sparse vector where non-zeros occur. Must be an array of !> length \p nnz. !> @param[in] values - non-zero values in the sparse vector. Must be an array of length \p nnz. !> @param[in] idx_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p indices, or \p values is invalid. !> \retval rocsparse_status_invalid_size if \p size or \p nnz is invalid. !> \retval rocsparse_status_invalid_value if \p idx_type, \p idx_base, or \p data_type is !> invalid. interface rocsparse_create_spvec_descr function rocsparse_create_spvec_descr_(descr,mySize,nnz,indices,values,idx_type,idx_base, & data_type) & bind(c, name="rocsparse_create_spvec_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_spvec_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: mySize integer(c_int64_t),value :: nnz type(c_ptr),value :: indices type(c_ptr),value :: values integer(kind(rocsparse_indextype_i32)),value :: idx_type integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_datatype_f16_r)),value :: data_type end function end interface interface rocsparse_create_const_spvec_descr function rocsparse_create_const_spvec_descr_(descr,mySize,nnz,indices,values,idx_type, & idx_base,data_type) & bind(c, name="rocsparse_create_const_spvec_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_const_spvec_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: mySize integer(c_int64_t),value :: nnz type(c_ptr),value :: indices type(c_ptr),value :: values integer(kind(rocsparse_indextype_i32)),value :: idx_type integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_datatype_f16_r)),value :: data_type end function end interface !> \ingroup aux_module !> \brief Destroy a sparse vector descriptor. !> !> \details !> \p rocsparse_destroy_spvec_descr destroys a sparse vector descriptor and releases all !> resources used by the descriptor. !> !> @param[in] descr - the matrix descriptor. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr is invalid. interface rocsparse_destroy_spvec_descr function rocsparse_destroy_spvec_descr_(descr) bind(c, name="rocsparse_destroy_spvec_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_destroy_spvec_descr_ type(c_ptr),value :: descr end function end interface !> \ingroup aux_module !> \brief Get the fields of the sparse vector descriptor. !> \details !> \p rocsparse_spvec_get gets the fields of the sparse vector descriptor. !> !> @param[in] descr - the pointer to the sparse vector descriptor. !> @param[out] mySize - size of the sparse vector. !> @param[out] nnz - number of non-zeros in sparse vector. !> @param[out] indices - indices of the sparse vector where non-zeros occur. Must be an array of !> length \p nnz. !> @param[out] values - non-zero values in the sparse vector. Must be an array of length \p nnz. !> @param[out] idx_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[out] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[out] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p indices, or \p values is invalid. !> \retval rocsparse_status_invalid_size if \p size or \p nnz is invalid. !> \retval rocsparse_status_invalid_value if \p idx_type, \p idx_base, or \p data_type is !> invalid. interface rocsparse_spvec_get function rocsparse_spvec_get_(descr,mySize,nnz,indices,values,idx_type,idx_base,data_type) & bind(c, name="rocsparse_spvec_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spvec_get_ type(c_ptr),value :: descr type(c_ptr),value :: mySize integer(c_int64_t) :: nnz type(c_ptr) :: indices type(c_ptr) :: values type(c_ptr),value :: idx_type type(c_ptr),value :: idx_base type(c_ptr),value :: data_type end function end interface interface rocsparse_const_spvec_get function rocsparse_const_spvec_get_(descr,mySize,nnz,indices,values,idx_type,idx_base, & data_type) & bind(c, name="rocsparse_const_spvec_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_const_spvec_get_ type(c_ptr),value :: descr type(c_ptr),value :: mySize integer(c_int64_t) :: nnz type(c_ptr) :: indices type(c_ptr) :: values type(c_ptr),value :: idx_type type(c_ptr),value :: idx_base type(c_ptr),value :: data_type end function end interface !> \ingroup aux_module !> \brief Get the index base stored in the sparse vector descriptor. !> !> @param[in] descr - the pointer to the sparse vector descriptor. !> @param[out] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr is invalid. !> \retval rocsparse_status_invalid_value if \p idx_base is invalid. interface rocsparse_spvec_get_index_base function rocsparse_spvec_get_index_base_(descr,idx_base) & bind(c, name="rocsparse_spvec_get_index_base") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spvec_get_index_base_ type(c_ptr),value :: descr type(c_ptr),value :: idx_base end function end interface !> \ingroup aux_module !> \brief Get the values array stored in the sparse vector descriptor !> !> @param[in] descr - the pointer to the sparse vector descriptor. !> @param[out] values - non-zero values in the sparse vector. Must be an array of length \p nnz. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p values is invalid. interface rocsparse_spvec_get_values function rocsparse_spvec_get_values_(descr,values) bind(c, name="rocsparse_spvec_get_values") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spvec_get_values_ type(c_ptr),value :: descr type(c_ptr) :: values end function end interface interface rocsparse_const_spvec_get_values function rocsparse_const_spvec_get_values_(descr,values) & bind(c, name="rocsparse_const_spvec_get_values") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_const_spvec_get_values_ type(c_ptr),value :: descr type(c_ptr) :: values end function end interface !> \ingroup aux_module !> \brief Set the values array in the sparse vector descriptor. !> !> @param[inout] descr - the pointer to the sparse vector descriptor. !> @param[in] values - non-zero values in the sparse vector. Must be an array of length \p nnz. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p values is invalid. interface rocsparse_spvec_set_values function rocsparse_spvec_set_values_(descr,values) bind(c, name="rocsparse_spvec_set_values") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spvec_set_values_ type(c_ptr),value :: descr type(c_ptr),value :: values end function end interface !> \ingroup aux_module !> \brief Create a sparse COO matrix descriptor. !> \details !> \p rocsparse_create_coo_descr creates a sparse COO matrix descriptor. It should be !> destroyed at the end using \p rocsparse_destroy_spmat_descr. !> !> @param[out] descr - the pointer to the sparse COO matrix descriptor. !> @param[in] rows - number of rows in the COO matrix. !> @param[in] cols - number of columns in the COO matrix !> @param[in] nnz - number of non-zeros in the COO matrix. !> @param[in] coo_row_ind - row indices of the COO matrix. Must be an array of length \p nnz. !> @param[in] coo_col_ind - column indices of the COO matrix. Must be an array of length \p nnz. !> @param[in] coo_val - values of the COO matrix. Must be an array of length \p nnz. !> @param[in] idx_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p coo_row_ind, \p coo_col_ind, or \p !> coo_val is invalid. !> \retval rocsparse_status_invalid_size if \p rows, \p cols, or \p nnz is invalid. !> \retval rocsparse_status_invalid_value if \p idx_type, \p idx_base, or \p data_type is !> invalid. interface rocsparse_create_coo_descr function rocsparse_create_coo_descr_(descr,rows,cols,nnz,coo_row_ind,coo_col_ind,coo_val, & idx_type,idx_base,data_type) & bind(c, name="rocsparse_create_coo_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_coo_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: nnz type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind type(c_ptr),value :: coo_val integer(kind(rocsparse_indextype_i32)),value :: idx_type integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_datatype_f16_r)),value :: data_type end function end interface interface rocsparse_create_const_coo_descr function rocsparse_create_const_coo_descr_(descr,rows,cols,nnz,coo_row_ind,coo_col_ind, & coo_val,idx_type,idx_base,data_type) & bind(c, name="rocsparse_create_const_coo_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_const_coo_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: nnz type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind type(c_ptr),value :: coo_val integer(kind(rocsparse_indextype_i32)),value :: idx_type integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_datatype_f16_r)),value :: data_type end function end interface !> \ingroup aux_module !> \brief Create a sparse COO AoS matrix descriptor. !> \details !> \p rocsparse_create_coo_aos_descr creates a sparse COO AoS matrix descriptor. It should be !> destroyed at the end using \p rocsparse_destroy_spmat_descr. !> !> @param[out] descr - the pointer to the sparse COO AoS matrix descriptor. !> @param[in] rows - number of rows in the COO AoS matrix. !> @param[in] cols - number of columns in the COO AoS matrix !> @param[in] nnz - number of non-zeros in the COO AoS matrix. !> @param[in] coo_ind - indices of the COO AoS matrix. Must be an array of length !> \p nnz. !> @param[in] coo_val - values of the COO AoS matrix. Must be an array of length \p nnz. !> @param[in] idx_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p coo_ind, or \p coo_val is invalid. !> \retval rocsparse_status_invalid_size if \p rows, \p cols, or \p nnz is invalid. !> \retval rocsparse_status_invalid_value if \p idx_type, \p idx_base, or \p data_type is !> invalid. interface rocsparse_create_coo_aos_descr function rocsparse_create_coo_aos_descr_(descr,rows,cols,nnz,coo_ind,coo_val,idx_type, & idx_base,data_type) & bind(c, name="rocsparse_create_coo_aos_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_coo_aos_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: nnz type(c_ptr),value :: coo_ind type(c_ptr),value :: coo_val integer(kind(rocsparse_indextype_i32)),value :: idx_type integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_datatype_f16_r)),value :: data_type end function end interface !> \ingroup aux_module !> \brief Create a sparse BSR matrix descriptor. !> \details !> \p rocsparse_create_bsr_descr creates a sparse BSR matrix descriptor. It should be !> destroyed at the end using \p rocsparse_destroy_spmat_descr. !> !> @param[out] descr - the pointer to the sparse BSR matrix descriptor. !> @param[in] brows - number of block rows in the BSR matrix. !> @param[in] bcols - number of block columns in the BSR matrix. !> @param[in] bnnz - number of non-zero blocks in the BSR matrix. !> @param[in] block_dir - direction of the internal block storage. !> @param[in] block_dim - dimension of the blocks. !> @param[in] bsr_row_ptr - row offsets of the BSR matrix (must be array of length \p brows+1 ). !> @param[in] bsr_col_ind - column indices of the BSR matrix (must be array of length \p bnnz ). !> @param[in] bsr_val - values of the BSR matrix (must be array of length \p bnnz * \p block_dim !> * \p block_dim ). !> @param[in] row_ptr_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[in] col_ind_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p bsr_row_ptr, \p bsr_col_ind, or \p !> bsr_val is invalid. !> \retval rocsparse_status_invalid_size if \p brows, \p bcols, \p bnnz, or \p block_dim is !> invalid. !> \retval rocsparse_status_invalid_value if \p row_ptr_type, \p col_ind_type, \p idx_base, \p !> data_type, or \p block_dir is invalid. interface rocsparse_create_bsr_descr function rocsparse_create_bsr_descr_(descr,brows,bcols,bnnz,block_dir,block_dim,bsr_row_ptr, & bsr_col_ind,bsr_val,row_ptr_type,col_ind_type,idx_base,data_type) & bind(c, name="rocsparse_create_bsr_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_bsr_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: brows integer(c_int64_t),value :: bcols integer(c_int64_t),value :: bnnz integer(kind(rocsparse_direction_row)),value :: block_dir integer(c_int64_t),value :: block_dim type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind type(c_ptr),value :: bsr_val integer(kind(rocsparse_indextype_i32)),value :: row_ptr_type integer(kind(rocsparse_indextype_i32)),value :: col_ind_type integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_datatype_f16_r)),value :: data_type end function end interface interface rocsparse_create_const_bsr_descr function rocsparse_create_const_bsr_descr_(descr,brows,bcols,bnnz,block_dir,block_dim, & bsr_row_ptr,bsr_col_ind,bsr_val,row_ptr_type,col_ind_type,idx_base,data_type) & bind(c, name="rocsparse_create_const_bsr_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_const_bsr_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: brows integer(c_int64_t),value :: bcols integer(c_int64_t),value :: bnnz integer(kind(rocsparse_direction_row)),value :: block_dir integer(c_int64_t),value :: block_dim type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind type(c_ptr),value :: bsr_val integer(kind(rocsparse_indextype_i32)),value :: row_ptr_type integer(kind(rocsparse_indextype_i32)),value :: col_ind_type integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_datatype_f16_r)),value :: data_type end function end interface !> \ingroup aux_module !> \brief Create a sparse CSR matrix descriptor. !> \details !> \p rocsparse_create_csr_descr creates a sparse CSR matrix descriptor. It should be !> destroyed at the end using \p rocsparse_destroy_spmat_descr. !> !> @param[out] descr - the pointer to the sparse CSR matrix descriptor. !> @param[in] rows - number of rows in the CSR matrix. !> @param[in] cols - number of columns in the CSR matrix !> @param[in] nnz - number of non-zeros in the CSR matrix. !> @param[in] csr_row_ptr - row offsets of the CSR matrix. Must be an array of length \p rows+1. !> @param[in] csr_col_ind - column indices of the CSR matrix. Must be an array of length \p nnz. !> @param[in] csr_val - values of the CSR matrix. Must be an array of length \p nnz. !> @param[in] row_ptr_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[in] col_ind_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p csr_row_ptr, \p csr_col_ind, or \p !> csr_val is invalid. !> \retval rocsparse_status_invalid_size if \p rows, \p cols, or \p nnz is invalid. !> \retval rocsparse_status_invalid_value if \p row_ptr_type, \p col_ind_type, \p idx_base, or !> \p data_type is invalid. interface rocsparse_create_csr_descr function rocsparse_create_csr_descr_(descr,rows,cols,nnz,csr_row_ptr,csr_col_ind,csr_val, & row_ptr_type,col_ind_type,idx_base,data_type) & bind(c, name="rocsparse_create_csr_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_csr_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: nnz type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: csr_val integer(kind(rocsparse_indextype_i32)),value :: row_ptr_type integer(kind(rocsparse_indextype_i32)),value :: col_ind_type integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_datatype_f16_r)),value :: data_type end function end interface interface rocsparse_create_const_csr_descr function rocsparse_create_const_csr_descr_(descr,rows,cols,nnz,csr_row_ptr,csr_col_ind, & csr_val,row_ptr_type,col_ind_type,idx_base,data_type) & bind(c, name="rocsparse_create_const_csr_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_const_csr_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: nnz type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: csr_val integer(kind(rocsparse_indextype_i32)),value :: row_ptr_type integer(kind(rocsparse_indextype_i32)),value :: col_ind_type integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_datatype_f16_r)),value :: data_type end function end interface !> \ingroup aux_module !> \brief Create a sparse CSC matrix descriptor. !> \details !> \p rocsparse_create_csc_descr creates a sparse CSC matrix descriptor. It should be !> destroyed at the end using \p rocsparse_destroy_spmat_descr. !> !> @param[out] descr - the pointer to the sparse CSC matrix descriptor. !> @param[in] rows - number of rows in the CSC matrix. !> @param[in] cols - number of columns in the CSC matrix. !> @param[in] nnz - number of non-zeros in the CSC matrix. !> @param[in] csc_col_ptr - column offsets of the CSC matrix. Must be an array of length \p !> cols+1. !> @param[in] csc_row_ind - row indices of the CSC matrix. Must be an array of length \p nnz. !> @param[in] csc_val - values of the CSC matrix. Must be an array of length \p nnz. !> @param[in] col_ptr_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[in] row_ind_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p csc_col_ptr, \p csc_row_ind, or \p !> csc_val is invalid. !> \retval rocsparse_status_invalid_size if \p rows, \p cols, or \p nnz is invalid. !> \retval rocsparse_status_invalid_value if \p col_ptr_type, \p row_ind_type, \p idx_base, or !> \p data_type is invalid. interface rocsparse_create_csc_descr function rocsparse_create_csc_descr_(descr,rows,cols,nnz,csc_col_ptr,csc_row_ind,csc_val, & col_ptr_type,row_ind_type,idx_base,data_type) & bind(c, name="rocsparse_create_csc_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_csc_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: nnz type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind type(c_ptr),value :: csc_val integer(kind(rocsparse_indextype_i32)),value :: col_ptr_type integer(kind(rocsparse_indextype_i32)),value :: row_ind_type integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_datatype_f16_r)),value :: data_type end function end interface interface rocsparse_create_const_csc_descr function rocsparse_create_const_csc_descr_(descr,rows,cols,nnz,csc_col_ptr,csc_row_ind, & csc_val,col_ptr_type,row_ind_type,idx_base,data_type) & bind(c, name="rocsparse_create_const_csc_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_const_csc_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: nnz type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind type(c_ptr),value :: csc_val integer(kind(rocsparse_indextype_i32)),value :: col_ptr_type integer(kind(rocsparse_indextype_i32)),value :: row_ind_type integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_datatype_f16_r)),value :: data_type end function end interface !> \ingroup aux_module !> \brief Create a sparse ELL matrix descriptor. !> \details !> \p rocsparse_create_ell_descr creates a sparse ELL matrix descriptor. It should be !> destroyed at the end using \p rocsparse_destroy_spmat_descr. !> !> @param[out] descr - the pointer to the sparse ELL matrix descriptor. !> @param[in] rows - number of rows in the ELL matrix. !> @param[in] cols - number of columns in the ELL matrix. !> @param[in] ell_col_ind - column indices of the ELL matrix. Must be an array of length \p !> rows*ell_width. !> @param[in] ell_val - values of the ELL matrix. Must be an array of length \p rows*ell_width. !> @param[in] ell_width - width of the ELL matrix. !> @param[in] idx_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p ell_col_ind, or \p ell_val is !> invalid. !> \retval rocsparse_status_invalid_size if \p rows, \p cols, \p ell_width is invalid. !> \retval rocsparse_status_invalid_value if \p idx_type, \p idx_base, or \p data_type is !> invalid. interface rocsparse_create_ell_descr function rocsparse_create_ell_descr_(descr,rows,cols,ell_col_ind,ell_val,ell_width,idx_type, & idx_base,data_type) & bind(c, name="rocsparse_create_ell_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_ell_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols type(c_ptr),value :: ell_col_ind type(c_ptr),value :: ell_val integer(c_int64_t),value :: ell_width integer(kind(rocsparse_indextype_i32)),value :: idx_type integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_datatype_f16_r)),value :: data_type end function end interface !> \ingroup aux_module !> \brief Create a sparse blocked ELL matrix descriptor. !> \details !> \p rocsparse_create_bell_descr creates a sparse blocked ELL matrix descriptor. It should be !> destroyed at the end using \p rocsparse_destroy_spmat_descr. !> !> Currently the only routine that supports the Blocked ELL format is \ref rocsparse_spmm. !> !> @param[out] descr - the pointer to the sparse blocked ELL matrix descriptor. !> @param[in] rows - number of rows in the blocked ELL matrix. !> @param[in] cols - number of columns in the blocked ELL matrix !> @param[in] ell_block_dir - `rocsparse_direction_row` or `rocsparse_direction_column`. !> @param[in] ell_block_dim - block dimension of the sparse blocked ELL matrix. !> @param[in] ell_cols - column indices of the blocked ELL matrix. Must be an array of length \p !> rows*ell_width. !> @param[in] ell_col_ind - column indices of the blocked ELL matrix. Must be an array of length !> \p rows*ell_width. !> @param[in] ell_val - values of the blocked ELL matrix. Must be an array of length \p !> rows*ell_width. !> @param[in] idx_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p ell_cols, \p ell_col_ind, or \p !> ell_val is invalid. !> \retval rocsparse_status_invalid_size if \p rows or \p cols is invalid. !> \retval rocsparse_status_invalid_value if \p idx_type, \p idx_base, or \p data_type is !> invalid. interface rocsparse_create_bell_descr function rocsparse_create_bell_descr_(descr,rows,cols,ell_block_dir,ell_block_dim,ell_cols, & ell_col_ind,ell_val,idx_type,idx_base,data_type) & bind(c, name="rocsparse_create_bell_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_bell_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(kind(rocsparse_direction_row)),value :: ell_block_dir integer(c_int64_t),value :: ell_block_dim integer(c_int64_t),value :: ell_cols type(c_ptr),value :: ell_col_ind type(c_ptr),value :: ell_val integer(kind(rocsparse_indextype_i32)),value :: idx_type integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_datatype_f16_r)),value :: data_type end function end interface interface rocsparse_create_const_bell_descr function rocsparse_create_const_bell_descr_(descr,rows,cols,ell_block_dir,ell_block_dim, & ell_cols,ell_col_ind,ell_val,idx_type,idx_base,data_type) & bind(c, name="rocsparse_create_const_bell_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_const_bell_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(kind(rocsparse_direction_row)),value :: ell_block_dir integer(c_int64_t),value :: ell_block_dim integer(c_int64_t),value :: ell_cols type(c_ptr),value :: ell_col_ind type(c_ptr),value :: ell_val integer(kind(rocsparse_indextype_i32)),value :: idx_type integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_datatype_f16_r)),value :: data_type end function end interface !> \ingroup aux_module !> \brief Create a sparse sliced ELL matrix descriptor. !> \details !> \p rocsparse_create_sell_descr creates a sparse sliced ELL matrix descriptor. It should be !> destroyed at the end using \p rocsparse_destroy_spmat_descr. !> !> Currently the only routine that supports the sliced ELL format is \ref rocsparse_spmv. !> !> @param[out] descr - the pointer to the sparse sliced ELL matrix descriptor. !> @param[in] rows - number of rows in the sliced ELL matrix. !> @param[in] cols - number of columns in the sliced ELL matrix. !> @param[in] nnz - number of non-zeros in the sliced ELL matrix. !> @param[in] sell_slice_size - slice size in the sliced ELL matrix. !> @param[in] sell_colval_size - size of the column and value arrays in the sliced ELL matrix. !> @param[in] sell_slice_offsets - slice offsets into column and value matrix. Must be an array !> of length \p nslices+1 where \p nslice=m/sell_slice_size. !> @param[in] sell_col_ind - column indices of the sliced ELL matrix. Must be an array of length !> \p sell_colval_size. !> @param[in] sell_val - values of the sliced ELL matrix. Must be an array of length \p !> sell_colval_size. !> @param[in] sell_slice_offsets_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[in] sell_col_ind_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p sell_slice_offsets, \p sell_col_ind, !> or \p sell_val is invalid. !> \retval rocsparse_status_invalid_size if \p rows, \p cols, \p nnz, \p sell_slice_size, or \p !> sell_colval_size is invalid. !> \retval rocsparse_status_invalid_value if \p idx_type, \p idx_base, or \p data_type is !> invalid. interface rocsparse_create_sell_descr function rocsparse_create_sell_descr_(descr,rows,cols,nnz,sell_slice_size,sell_colval_size, & sell_slice_offsets,sell_col_ind,sell_val,sell_slice_offsets_type,sell_col_ind_type, & idx_base,data_type) & bind(c, name="rocsparse_create_sell_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_sell_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: nnz integer(c_int64_t),value :: sell_slice_size integer(c_int64_t),value :: sell_colval_size type(c_ptr),value :: sell_slice_offsets type(c_ptr),value :: sell_col_ind type(c_ptr),value :: sell_val integer(kind(rocsparse_indextype_i32)),value :: sell_slice_offsets_type integer(kind(rocsparse_indextype_i32)),value :: sell_col_ind_type integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_datatype_f16_r)),value :: data_type end function end interface interface rocsparse_create_const_sell_descr function rocsparse_create_const_sell_descr_(descr,rows,cols,nnz,sell_slice_size, & sell_colval_size,sell_slice_offsets,sell_col_ind,sell_val,sell_slice_offsets_type, & sell_col_ind_type,idx_base,data_type) & bind(c, name="rocsparse_create_const_sell_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_const_sell_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: nnz integer(c_int64_t),value :: sell_slice_size integer(c_int64_t),value :: sell_colval_size type(c_ptr),value :: sell_slice_offsets type(c_ptr),value :: sell_col_ind type(c_ptr),value :: sell_val integer(kind(rocsparse_indextype_i32)),value :: sell_slice_offsets_type integer(kind(rocsparse_indextype_i32)),value :: sell_col_ind_type integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_datatype_f16_r)),value :: data_type end function end interface !> \ingroup aux_module !> \brief Destroy a sparse matrix descriptor. !> !> \details !> \p rocsparse_destroy_spmat_descr destroys a sparse matrix descriptor and releases all !> resources used by the descriptor. !> !> Currently the only routine that supports the Blocked ELL format is \ref rocsparse_spmm. !> !> @param[in] descr - the matrix descriptor. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr is invalid. interface rocsparse_destroy_spmat_descr function rocsparse_destroy_spmat_descr_(descr) bind(c, name="rocsparse_destroy_spmat_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_destroy_spmat_descr_ type(c_ptr),value :: descr end function end interface !> \ingroup aux_module !> \brief Sparse matrix to sparse matrix conversion. !> !> \details !> \p rocsparse_create_sparse_to_sparse_descr creates the descriptor of the sparse_to_sparse !> algorithm. !> !> @param[out] descr - pointer to the descriptor of the sparse_to_sparse algorithm. !> @param[in] source - source sparse matrix descriptor. !> @param[in] target - target sparse matrix descriptor. !> @param[in] alg - algorithm for the sparse_to_sparse computation. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_value if any required enumeration is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p source, or \p target !> pointer is invalid. interface rocsparse_create_sparse_to_sparse_descr function rocsparse_create_sparse_to_sparse_descr_(descr,source,target,alg) & bind(c, name="rocsparse_create_sparse_to_sparse_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_sparse_to_sparse_descr_ type(c_ptr) :: descr type(c_ptr),value :: source type(c_ptr),value :: target integer(kind(rocsparse_sparse_to_sparse_alg_default)),value :: alg end function end interface !> \ingroup aux_module !> \brief Sparse matrix to sparse matrix conversion. !> !> \details !> \p rocsparse_sparse_to_sparse_permissive allows the routine to allocate an intermediate !> sparse matrix !> to perform the conversion. By default, the routine is not permissive. !> @param[in] descr - descriptor of the sparse_to_sparse algorithm. !> \retval rocsparse_status_success the operation completed successfully. interface rocsparse_sparse_to_sparse_permissive function rocsparse_sparse_to_sparse_permissive_(descr) & bind(c, name="rocsparse_sparse_to_sparse_permissive") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sparse_to_sparse_permissive_ type(c_ptr),value :: descr end function end interface !> \ingroup aux_module !> \brief Sparse matrix to sparse matrix conversion. !> !> \details !> \p rocsparse_destroy_sparse_to_sparse_descr destroys the descriptor of the sparse_to_sparse !> algorithm. !> !> @param[in] descr - descriptor of the sparse_to_sparse algorithm. !> \retval rocsparse_status_success the operation completed successfully. interface rocsparse_destroy_sparse_to_sparse_descr function rocsparse_destroy_sparse_to_sparse_descr_(descr) & bind(c, name="rocsparse_destroy_sparse_to_sparse_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_destroy_sparse_to_sparse_descr_ type(c_ptr),value :: descr end function end interface !> \ingroup aux_module !> \brief Sparse matrix extraction. !> !> \details !> \p rocsparse_create_extract_descr creates the descriptor of the extract algorithm. !> !> @param[out] descr - pointer to the descriptor of the extract algorithm. !> @param[in] source - source sparse matrix descriptor. !> @param[in] target - target sparse matrix descriptor. !> @param[in] alg - algorithm for the extract computation. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_value if any required enumeration is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p source, or \p target !> pointer is invalid. interface rocsparse_create_extract_descr function rocsparse_create_extract_descr_(descr,source,target,alg) & bind(c, name="rocsparse_create_extract_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_extract_descr_ type(c_ptr) :: descr type(c_ptr),value :: source type(c_ptr),value :: target integer(kind(rocsparse_extract_alg_default)),value :: alg end function end interface !> \ingroup aux_module !> \brief Sparse matrix extraction. !> !> \details !> \p rocsparse_destroy_extract_descr destroys the descriptor of the \ref rocsparse_extract !> routine. !> !> @param[in] descr - descriptor of the extract routine. !> \retval rocsparse_status_success the operation completed successfully. interface rocsparse_destroy_extract_descr function rocsparse_destroy_extract_descr_(descr) bind(c, name="rocsparse_destroy_extract_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_destroy_extract_descr_ type(c_ptr),value :: descr end function end interface !> \ingroup aux_module !> \brief Sparse matrix SpGEAM routine descriptor creation. !> !> \details !> \p rocsparse_create_spgeam_descr creates the descriptor of the \ref !> rocsparse_spgeam_buffer_size and !> `rocsparse_spgeam` routines. !> !> @param[out] descr - pointer to the descriptor of the SpGEAM routine. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr pointer is invalid. interface rocsparse_create_spgeam_descr function rocsparse_create_spgeam_descr_(descr) bind(c, name="rocsparse_create_spgeam_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_spgeam_descr_ type(c_ptr) :: descr end function end interface !> \ingroup aux_module !> \brief Destroy a sparse matrix SpGEAM. !> !> \details !> \p rocsparse_destroy_spgeam_descr destroys the descriptor of the \ref !> rocsparse_spgeam_buffer_size and !> `rocsparse_spgeam` routines. !> !> @param[in] descr - descriptor of the SpGEAM routine. !> \retval rocsparse_status_success the operation completed successfully. interface rocsparse_destroy_spgeam_descr function rocsparse_destroy_spgeam_descr_(descr) bind(c, name="rocsparse_destroy_spgeam_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_destroy_spgeam_descr_ type(c_ptr),value :: descr end function end interface !> \ingroup aux_module !> \brief Set the requested `rocsparse_spgeam_input` data in the SpGEAM descriptor. !> !> @param[in] handle - the pointer to the handle to the rocSPARSE library context. !> @param[inout] descr - the pointer to the SpGEAM descriptor. !> @param[in] input - one of the values from `rocsparse_spgeam_input`. !> @param[in] myData - input data. !> @param[in] data_size_in_bytes - input data size. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p data is invalid. !> \retval rocsparse_status_invalid_value if \p input is invalid. !> \retval rocsparse_status_invalid_size if \p data_size_in_bytes is invalid. interface rocsparse_spgeam_set_input function rocsparse_spgeam_set_input_(handle,descr,input,myData,data_size_in_bytes,p_error) & bind(c, name="rocsparse_spgeam_set_input") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spgeam_set_input_ type(c_ptr),value :: handle type(c_ptr),value :: descr integer(kind(rocsparse_spgeam_input_alg)),value :: input type(c_ptr),value :: myData integer(c_size_t),value :: data_size_in_bytes type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Get the requested `rocsparse_spgeam_output` data from the SpGEAM descriptor. !> !> @param[in] handle - the pointer to the handle to the rocSPARSE library context. !> @param[inout] descr - the pointer to the SpGEAM descriptor. !> @param[in] output - `rocsparse_spgeam_output_nnz`. !> @param[in] myData - output data. !> @param[in] data_size_in_bytes - output data size. !> @param[out] error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p data is invalid. !> \retval rocsparse_status_invalid_value if \p output is invalid. !> \retval rocsparse_status_invalid_size if \p data_size_in_bytes is invalid. interface rocsparse_spgeam_get_output function rocsparse_spgeam_get_output_(handle,descr,output,myData,data_size_in_bytes,error) & bind(c, name="rocsparse_spgeam_get_output") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spgeam_get_output_ type(c_ptr),value :: handle type(c_ptr),value :: descr integer(kind(rocsparse_spgeam_output_nnz)),value :: output type(c_ptr),value :: myData integer(c_size_t),value :: data_size_in_bytes type(c_ptr) :: error end function end interface !> \ingroup aux_module !> \brief Sparse matrix SpMV routine descriptor creation. !> !> \details !> \p rocsparse_create_spmv_descr creates the descriptor of the \ref !> rocsparse_v2_spmv_buffer_size and !> `rocsparse_v2_spmv` routines. !> !> @param[out] descr - pointer to the descriptor of the SpMV routine. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr pointer is invalid. interface rocsparse_create_spmv_descr function rocsparse_create_spmv_descr_(descr) bind(c, name="rocsparse_create_spmv_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_spmv_descr_ type(c_ptr) :: descr end function end interface !> \ingroup aux_module !> \brief Destroy a sparse matrix SpMV routine descriptor. !> !> \details !> \p rocsparse_destroy_spmv_descr destroys the descriptor of the \ref !> rocsparse_v2_spmv_buffer_size and !> `rocsparse_v2_spmv` routines. !> !> @param[in] descr - descriptor of the v2_spmv routine. !> \retval rocsparse_status_success the operation completed successfully. interface rocsparse_destroy_spmv_descr function rocsparse_destroy_spmv_descr_(descr) bind(c, name="rocsparse_destroy_spmv_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_destroy_spmv_descr_ type(c_ptr),value :: descr end function end interface !> \ingroup aux_module !> \brief Set the requested `rocsparse_spmv_input` data in the SpMV descriptor. !> !> @param[in] handle - the pointer to the handle to the rocSPARSE library context. !> @param[inout] descr - the pointer to the SpMV descriptor. !> @param[in] input - one possible value of `rocsparse_spmv_input`. !> @param[in] in - input value. !> @param[in] size_in_bytes - input value size in bytes. !> @param[out] error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p in is invalid. !> \retval rocsparse_status_invalid_value if \p input is invalid. !> \retval rocsparse_status_invalid_size if \p size_in_bytes is zero. interface rocsparse_spmv_set_input function rocsparse_spmv_set_input_(handle,descr,input,in,size_in_bytes,error) & bind(c, name="rocsparse_spmv_set_input") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spmv_set_input_ type(c_ptr),value :: handle type(c_ptr),value :: descr integer(kind(rocsparse_spmv_input_alg)),value :: input type(c_ptr),value :: in integer(c_size_t),value :: size_in_bytes type(c_ptr) :: error end function end interface !> \ingroup aux_module !> \brief Sparse matrix sptrsv routine descriptor creation. !> !> \details !> \p rocsparse_create_sptrsv_descr creates the descriptor of the \ref !> rocsparse_sptrsv_buffer_size and !> `rocsparse_sptrsv` routines. !> !> @param[in] handle - the handle to the rocSPARSE library context. !> @param[out] p_sptrsv_descr - pointer to the descriptor of the sptrsv routine. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_invalid_handle \p handle pointer is invalid. !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr pointer is invalid. interface rocsparse_sptrsv_descr_create function rocsparse_sptrsv_descr_create_(handle,p_sptrsv_descr,p_error) & bind(c, name="rocsparse_sptrsv_descr_create") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sptrsv_descr_create_ type(c_ptr),value :: handle type(c_ptr) :: p_sptrsv_descr type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Destroy a sparse matrix sptrsv routine descriptor. !> !> \details !> \p rocsparse_destroy_sptrsv_descr destroys the descriptor of the \ref !> rocsparse_sptrsv_buffer_size and !> `rocsparse_sptrsv` routines. !> !> @param[in] handle - the handle to the rocSPARSE library context. !> @param[in] sptrsv_descr - descriptor of the sptrsv routine. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_invalid_handle \p handle pointer is invalid. !> \retval rocsparse_status_success the operation completed successfully. interface rocsparse_sptrsv_descr_destroy function rocsparse_sptrsv_descr_destroy_(handle,sptrsv_descr,p_error) & bind(c, name="rocsparse_sptrsv_descr_destroy") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sptrsv_descr_destroy_ type(c_ptr),value :: handle type(c_ptr),value :: sptrsv_descr type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Sparse matrix sptrsv routine descriptor creation. !> !> \details !> \p rocsparse_create_sptrsv_descr creates the descriptor of the \ref !> rocsparse_sptrsv_buffer_size and !> `rocsparse_sptrsv` routines. !> !> @param[out] descr - pointer to the descriptor of the sptrsv routine. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr pointer is invalid. interface rocsparse_create_sptrsv_descr function rocsparse_create_sptrsv_descr_(descr) bind(c, name="rocsparse_create_sptrsv_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_sptrsv_descr_ type(c_ptr) :: descr end function end interface !> \ingroup aux_module !> \brief Destroy a sparse matrix sptrsv routine descriptor. !> !> \details !> \p rocsparse_destroy_sptrsv_descr destroys the descriptor of the \ref !> rocsparse_sptrsv_buffer_size and !> `rocsparse_sptrsv` routines. !> !> @param[in] descr - descriptor of the sptrsv routine. !> \retval rocsparse_status_success the operation completed successfully. interface rocsparse_destroy_sptrsv_descr function rocsparse_destroy_sptrsv_descr_(descr) bind(c, name="rocsparse_destroy_sptrsv_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_destroy_sptrsv_descr_ type(c_ptr),value :: descr end function end interface !> \ingroup aux_module !> \brief Set the requested `rocsparse_sptrsv_input` data in the sptrsv descriptor. !> !> @param[in] handle - the pointer to the handle to the rocSPARSE library context. !> @param[inout] descr - the pointer to the sptrsv descriptor. !> @param[in] input - value of `rocsparse_sptrsv_input`. !> @param[in] myData - input data. !> @param[in] data_size_in_bytes - input data size in bytes. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p data is invalid. !> \retval rocsparse_status_invalid_value if \p input is invalid. !> \retval rocsparse_status_invalid_size if \p data_size_in_bytes is invalid. interface rocsparse_sptrsv_set_input function rocsparse_sptrsv_set_input_(handle,descr,input,myData,data_size_in_bytes,p_error) & bind(c, name="rocsparse_sptrsv_set_input") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sptrsv_set_input_ type(c_ptr),value :: handle type(c_ptr),value :: descr integer(kind(rocsparse_sptrsv_input_alg)),value :: input type(c_ptr),value :: myData integer(c_size_t),value :: data_size_in_bytes type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Get the requested `rocsparse_sptrsv_output` data from the sptrsv descriptor. !> !> @param[in] handle - the pointer to the handle to the rocSPARSE library context. !> @param[inout] descr - the pointer to the sptrsv descriptor. !> @param[in] output - value of `rocsparse_sptrsv_output`. !> @param[out] myData - output data. !> @param[in] data_size_in_bytes - output data size in bytes. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p data is invalid. !> \retval rocsparse_status_invalid_value if \p output is invalid. !> \retval rocsparse_status_invalid_size if \p data_size_in_bytes is invalid. interface rocsparse_sptrsv_get_output function rocsparse_sptrsv_get_output_(handle,descr,output,myData,data_size_in_bytes,p_error) & bind(c, name="rocsparse_sptrsv_get_output") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sptrsv_get_output_ type(c_ptr),value :: handle type(c_ptr),value :: descr integer(kind(rocsparse_sptrsv_output_zero_pivot_position)),value :: output type(c_ptr),value :: myData integer(c_size_t),value :: data_size_in_bytes type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Sparse matrix sptrsm routine descriptor creation. !> !> \details !> \p rocsparse_create_sptrsm_descr creates the descriptor of the \ref !> rocsparse_sptrsm_buffer_size and !> `rocsparse_sptrsm` routines. !> !> @param[out] descr - pointer to the descriptor of the sptrsm routine. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr pointer is invalid. interface rocsparse_create_sptrsm_descr function rocsparse_create_sptrsm_descr_(descr) bind(c, name="rocsparse_create_sptrsm_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_sptrsm_descr_ type(c_ptr) :: descr end function end interface !> \ingroup aux_module !> \brief Destroy sparse matrix sptrsm routine descriptor. !> !> \details !> \p rocsparse_destroy_sptrsm_descr destroys the descriptor of the \ref !> rocsparse_sptrsm_buffer_size and !> `rocsparse_sptrsm` routines. !> !> @param[in] descr - descriptor of the sptrsm routine. !> \retval rocsparse_status_success the operation completed successfully. interface rocsparse_destroy_sptrsm_descr function rocsparse_destroy_sptrsm_descr_(descr) bind(c, name="rocsparse_destroy_sptrsm_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_destroy_sptrsm_descr_ type(c_ptr),value :: descr end function end interface !> \ingroup aux_module !> \brief Set the requested `rocsparse_sptrsm_input` data in the sptrsm descriptor. !> !> @param[in] handle - the pointer to the handle to the rocSPARSE library context. !> @param[inout] descr - the pointer to the sptrsm descriptor. !> @param[in] input - value of `rocsparse_sptrsm_input`. !> @param[in] myData - input data. !> @param[in] data_size - input data size. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p data is invalid. !> \retval rocsparse_status_invalid_value if \p input is invalid. !> \retval rocsparse_status_invalid_size if \p data_size is invalid. interface rocsparse_sptrsm_set_input function rocsparse_sptrsm_set_input_(handle,descr,input,myData,data_size,p_error) & bind(c, name="rocsparse_sptrsm_set_input") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sptrsm_set_input_ type(c_ptr),value :: handle type(c_ptr),value :: descr integer(kind(rocsparse_sptrsm_input_alg)),value :: input type(c_ptr),value :: myData integer(c_size_t),value :: data_size type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Get the requested `rocsparse_sptrsm_output` data from the sptrsm descriptor. !> !> @param[in] handle - the pointer to the handle to the rocSPARSE library context. !> @param[inout] descr - the pointer to the sptrsm descriptor. !> @param[in] output - value of `rocsparse_sptrsm_output`. !> @param[out] myData - output data. !> @param[in] data_size_in_bytes - output data size in bytes. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p data is invalid. !> \retval rocsparse_status_invalid_value if \p output is invalid. !> \retval rocsparse_status_invalid_size if \p data_size_in_bytes is invalid. interface rocsparse_sptrsm_get_output function rocsparse_sptrsm_get_output_(handle,descr,output,myData,data_size_in_bytes,p_error) & bind(c, name="rocsparse_sptrsm_get_output") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sptrsm_get_output_ type(c_ptr),value :: handle type(c_ptr),value :: descr integer(kind(rocsparse_sptrsm_output_zero_pivot_position)),value :: output type(c_ptr),value :: myData integer(c_size_t),value :: data_size_in_bytes type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Create SpIC0 descriptor. !> !> \details !> \p rocsparse_spic0_descr_create creates the descriptor of the configuration of the sparse !> Incomplete Cholesky of level 0. !> @param[in] handle - the handle to the rocSPARSE library context. !> @param[out] p_spic0_descr - pointer to the descriptor of the Spic0 routine. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_invalid_handle \p handle pointer is invalid. !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr pointer is invalid. interface rocsparse_spic0_descr_create function rocsparse_spic0_descr_create_(handle,p_spic0_descr,p_error) & bind(c, name="rocsparse_spic0_descr_create") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spic0_descr_create_ type(c_ptr),value :: handle type(c_ptr) :: p_spic0_descr type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Destroy SpIC0 descriptor. !> !> \details !> \p rocsparse_spic0_descr_destroy destroys the descriptor of the configuration of the sparse !> Incomplete Cholesky of level 0. !> !> @param[in] handle - the handle to the rocSPARSE library context. !> @param[in] spic0_descr - descriptor of the spic0 routine. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> \retval rocsparse_status_invalid_handle \p handle pointer is invalid. !> \retval rocsparse_status_success the operation completed successfully. interface rocsparse_spic0_descr_destroy function rocsparse_spic0_descr_destroy_(handle,spic0_descr,p_error) & bind(c, name="rocsparse_spic0_descr_destroy") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spic0_descr_destroy_ type(c_ptr),value :: handle type(c_ptr),value :: spic0_descr type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Set the requested `rocsparse_spic0_input` data in the SpIC0 descriptor. !> !> \note !> - `rocsparse_spic0_input_alg` is `rocsparse_spic0_alg`. It can only be set before applying !> any phase. !> - `rocsparse_spic0_input_compute_datatype` is `rocsparse_datatype`. It can only be set before !> applying any phase. For now, it must be of value type of A. !> - `rocsparse_spic0_input_analysis_policy` is `rocsparse_analysis_policy`. It can only be set !> before applying any phase. !> - `rocsparse_spic0_input_singularity_tolerance` is a device/host double pointer. Its device !> mode is determined from the `rocsparse_handle`. !> - `rocsparse_spic0_input_boost_enable` is an \p int32_t. !> - `rocsparse_spic0_input_boost_value` is a pointer to a scalar of value type A. Its device !> mode is determined from the `rocsparse_handle`. !> - `rocsparse_spic0_input_boost_tolerance` is a double pointer. Its device mode is determined !> from the `rocsparse_handle`. !> !> @param[in] handle - the pointer to the handle to the rocSPARSE library context. !> @param[inout] spic0_descr - the pointer to the SpIC0 descriptor. !> @param[in] spic0_input - value of `rocsparse_spic0_input`. !> @param[in] input - input data. !> @param[in] input_size_in_bytes - input data size in bytes. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p data is invalid. !> \retval rocsparse_status_invalid_value if \p input is invalid. !> \retval rocsparse_status_invalid_size if \p data_size_in_bytes is invalid. interface rocsparse_spic0_set_input function rocsparse_spic0_set_input_(handle,spic0_descr,spic0_input,input,input_size_in_bytes, & p_error) & bind(c, name="rocsparse_spic0_set_input") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spic0_set_input_ type(c_ptr),value :: handle type(c_ptr),value :: spic0_descr integer(kind(rocsparse_spic0_input_alg)),value :: spic0_input type(c_ptr),value :: input integer(c_size_t),value :: input_size_in_bytes type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Get the requested `rocsparse_spic0_output` data from the SpIC0 descriptor. !> \note !> - `rocsparse_spic0_output_singularity` is `rocsparse_singularity`. It will be considered as !> an array of size \p batch_count. !> - `rocsparse_spic0_output_singularity_position` is \p int64_t. It will be considered as an !> array of size \p batch_count. !> @param[in] handle - the pointer to the handle to the rocSPARSE library context. !> @param[inout] spic0_descr - the pointer to the SpIC0 descriptor. !> @param[in] spic0_output - value of `rocsparse_spic0_output`. !> @param[out] output - output data !> @param[in] output_size_in_bytes - output data size in bytes. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p data is invalid. !> \retval rocsparse_status_invalid_value if \p output is invalid. !> \retval rocsparse_status_invalid_size if \p data_size_in_bytes is invalid. interface rocsparse_spic0_get_output function rocsparse_spic0_get_output_(handle,spic0_descr,spic0_output,output, & output_size_in_bytes,p_error) & bind(c, name="rocsparse_spic0_get_output") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spic0_get_output_ type(c_ptr),value :: handle type(c_ptr),value :: spic0_descr integer(kind(rocsparse_spic0_output_singularity)),value :: spic0_output type(c_ptr),value :: output integer(c_size_t),value :: output_size_in_bytes type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Create SpILU0 descriptor. !> !> \details !> \p rocsparse_spilu0_descr_create creates the descriptor of the configuration of the sparse !> Incomplete LU of level 0. !> !> @param[in] handle - the handle to the rocSPARSE library context. !> @param[out] p_spilu0_descr - pointer to the descriptor of the Spilu0 routine. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_invalid_handle \p handle pointer is invalid. !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr pointer is invalid. interface rocsparse_spilu0_descr_create function rocsparse_spilu0_descr_create_(handle,p_spilu0_descr,p_error) & bind(c, name="rocsparse_spilu0_descr_create") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spilu0_descr_create_ type(c_ptr),value :: handle type(c_ptr) :: p_spilu0_descr type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Destroy SpILU0 descriptor. !> !> \details !> \p rocsparse_spilu0_descr_destroy destroys the descriptor of the configuration of the sparse !> Incomplete LU of level 0. !> !> @param[in] handle - the handle to the rocSPARSE library context. !> @param[in] spilu0_descr - descriptor of the spilu0 routine. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> \retval rocsparse_status_invalid_handle \p handle pointer is invalid. !> \retval rocsparse_status_success the operation completed successfully. interface rocsparse_spilu0_descr_destroy function rocsparse_spilu0_descr_destroy_(handle,spilu0_descr,p_error) & bind(c, name="rocsparse_spilu0_descr_destroy") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spilu0_descr_destroy_ type(c_ptr),value :: handle type(c_ptr),value :: spilu0_descr type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Set the requested `rocsparse_spilu0_input` data in the SpILU0 descriptor. !> !> \note !> - `rocsparse_spilu0_input_alg` is `rocsparse_spilu0_alg`. It can only be set before applying !> any phase. !> - `rocsparse_spilu0_input_compute_datatype` is `rocsparse_datatype`. It can only be set !> before applying any phase. For now, it must be of value type of A. !> - `rocsparse_spilu0_input_analysis_policy` is `rocsparse_analysis_policy`. It can only be set !> before applying any phase. !> - `rocsparse_spilu0_input_singularity_tolerance` is a device/host double pointer. Its device !> mode is determined from the `rocsparse_handle`. No batched tolerances can be specified. !> - `rocsparse_spilu0_input_boost_enable` is a host \p int32_t. Set to 1 to enable and 0 to !> disable. !> - `rocsparse_spilu0_input_boost_value` is a pointer to a scalar of value type of A. Its !> device mode is determined from the `rocsparse_handle`. No batched boost values can be !> specified. !> - `rocsparse_spilu0_input_boost_tolerance` is a double pointer. Its device mode is determined !> from the `rocsparse_handle`. No batched boost tolerances can be specified. !> !> @param[in] handle - the pointer to the handle to the rocSPARSE library context. !> @param[inout] spilu0_descr - the pointer to the SpILU0 descriptor. !> @param[in] spilu0_input - value of `rocsparse_spilu0_input`. !> @param[in] input - input data. !> @param[in] input_size_in_bytes - input data size in bytes. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p data is invalid. !> \retval rocsparse_status_invalid_value if \p input is invalid. !> \retval rocsparse_status_invalid_size if \p data_size_in_bytes is invalid. interface rocsparse_spilu0_set_input function rocsparse_spilu0_set_input_(handle,spilu0_descr,spilu0_input,input, & input_size_in_bytes,p_error) & bind(c, name="rocsparse_spilu0_set_input") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spilu0_set_input_ type(c_ptr),value :: handle type(c_ptr),value :: spilu0_descr integer(kind(rocsparse_spilu0_input_alg)),value :: spilu0_input type(c_ptr),value :: input integer(c_size_t),value :: input_size_in_bytes type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Get the requested `rocsparse_spilu0_output` data from the SpILU0 descriptor. !> \note !> - `rocsparse_spilu0_output_singularity` is `rocsparse_singularity`. It will be considered as !> an array of size \p batch_count. !> - `rocsparse_spilu0_output_singularity_position` is int64_t. It will be considered as an !> array of size \p batch_count. !> @param[in] handle - the pointer to the handle to the rocSPARSE library context. !> @param[inout] spilu0_descr - the pointer to the SpILU0 descriptor. !> @param[in] spilu0_output - value of `rocsparse_spilu0_output`. !> @param[out] output - output data. !> @param[in] output_size_in_bytes - output data size in bytes. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p data is invalid. !> \retval rocsparse_status_invalid_value if \p output is invalid. !> \retval rocsparse_status_invalid_size if \p data_size_in_bytes is invalid. interface rocsparse_spilu0_get_output function rocsparse_spilu0_get_output_(handle,spilu0_descr,spilu0_output,output, & output_size_in_bytes,p_error) & bind(c, name="rocsparse_spilu0_get_output") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spilu0_get_output_ type(c_ptr),value :: handle type(c_ptr),value :: spilu0_descr integer(kind(rocsparse_spilu0_output_singularity)),value :: spilu0_output type(c_ptr),value :: output integer(c_size_t),value :: output_size_in_bytes type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Create SpILDLT0 descriptor. !> !> \details !> \p rocsparse_spildlt0_descr_create creates the descriptor of the configuration of the sparse !> Incomplete \f$LDL^H\f$ of level 0. !> @param[in] handle - the handle to the rocSPARSE library context. !> @param[out] p_spildlt0_descr - pointer to the descriptor of the SpILDLT0 routine. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_invalid_handle \p handle pointer is invalid. !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr pointer is invalid. interface rocsparse_spildlt0_descr_create function rocsparse_spildlt0_descr_create_(handle,p_spildlt0_descr,p_error) & bind(c, name="rocsparse_spildlt0_descr_create") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spildlt0_descr_create_ type(c_ptr),value :: handle type(c_ptr) :: p_spildlt0_descr type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Destroy SpILDLT0 descriptor. !> !> \details !> \p rocsparse_spildlt0_descr_destroy destroys the descriptor of the configuration of the !> sparse Incomplete \f$LDL^H\f$ of level 0. !> !> @param[in] handle - the handle to the rocSPARSE library context. !> @param[in] spildlt0_descr - descriptor of the SpILDLT0 routine. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> \retval rocsparse_status_invalid_handle \p handle pointer is invalid. !> \retval rocsparse_status_success the operation completed successfully. interface rocsparse_spildlt0_descr_destroy function rocsparse_spildlt0_descr_destroy_(handle,spildlt0_descr,p_error) & bind(c, name="rocsparse_spildlt0_descr_destroy") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spildlt0_descr_destroy_ type(c_ptr),value :: handle type(c_ptr),value :: spildlt0_descr type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Set the requested `rocsparse_spildlt0_input` data in the SpILDLT0 descriptor. !> !> \note !> - `rocsparse_spildlt0_input_alg` is `rocsparse_spildlt0_alg`. It can only be set before !> applying any phase. !> - `rocsparse_spildlt0_input_compute_datatype` is `rocsparse_datatype`. It can only be set !> before applying any phase. For now, it must be of value type of A. !> - `rocsparse_spildlt0_input_analysis_policy` is `rocsparse_analysis_policy`. It can only be !> set before applying any phase. !> - `rocsparse_spildlt0_input_singularity_tolerance` is a device/host double pointer. Its !> device mode is determined from the `rocsparse_handle`. !> - `rocsparse_spildlt0_input_boost_enable` is an \p int32_t. !> - `rocsparse_spildlt0_input_boost_value` is a pointer to a scalar of value type A. Its device !> mode is determined from the `rocsparse_handle`. !> - `rocsparse_spildlt0_input_boost_tolerance` is a double pointer. Its device mode is !> determined from the `rocsparse_handle`. !> - `rocsparse_spildlt0_input_diag` is an \b optional device pointer (void*) to a dense array !> in device memory of \p m * \p batch_count real-valued entries that receives a copy of the !> diagonal \f$D\f$ (\p m entries per batch, batch \p b at offset \p b * \p m). !> \f$D\f$ is always real, even for complex matrices, so for \p s and \p c variants this !> is \p float* and for \p d and \p z variants this is \p double*. !> It is optional: \f$D\f$ is always stored in-place on the (implicit unit) diagonal of !> the \f$L\f$ factor and can be read back from there after !> `rocsparse_spildlt0_stage_compute`. If set, it must be set before calling \ref !> rocsparse_spildlt0 with stage `rocsparse_spildlt0_stage_compute`. !> !> @param[in] handle - the pointer to the handle to the rocSPARSE library context. !> @param[inout] spildlt0_descr - the pointer to the SpILDLT0 descriptor. !> @param[in] spildlt0_input - value of `rocsparse_spildlt0_input`. !> @param[in] input - input data. !> @param[in] input_size_in_bytes - input data size in bytes. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p data is invalid. !> \retval rocsparse_status_invalid_value if \p input is invalid. !> \retval rocsparse_status_invalid_size if \p data_size_in_bytes is invalid. interface rocsparse_spildlt0_set_input function rocsparse_spildlt0_set_input_(handle,spildlt0_descr,spildlt0_input,input, & input_size_in_bytes,p_error) & bind(c, name="rocsparse_spildlt0_set_input") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spildlt0_set_input_ type(c_ptr),value :: handle type(c_ptr),value :: spildlt0_descr integer(kind(rocsparse_spildlt0_input_alg)),value :: spildlt0_input type(c_ptr),value :: input integer(c_size_t),value :: input_size_in_bytes type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Get the requested `rocsparse_spildlt0_output` data from the SpILDLT0 descriptor. !> \note !> - `rocsparse_spildlt0_output_singularity` is `rocsparse_singularity`. !> - `rocsparse_spildlt0_output_singularity_position` is \p int64_t. !> @param[in] handle - the pointer to the handle to the rocSPARSE library context. !> @param[inout] spildlt0_descr - the pointer to the SpILDLT0 descriptor. !> @param[in] spildlt0_output - value of `rocsparse_spildlt0_output`. !> @param[out] output - output data. !> @param[in] output_size_in_bytes - output data size in bytes. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p data is invalid. !> \retval rocsparse_status_invalid_value if \p output is invalid. !> \retval rocsparse_status_invalid_size if \p data_size_in_bytes is invalid. interface rocsparse_spildlt0_get_output function rocsparse_spildlt0_get_output_(handle,spildlt0_descr,spildlt0_output,output, & output_size_in_bytes,p_error) & bind(c, name="rocsparse_spildlt0_get_output") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spildlt0_get_output_ type(c_ptr),value :: handle type(c_ptr),value :: spildlt0_descr integer(kind(rocsparse_spildlt0_output_singularity)),value :: spildlt0_output type(c_ptr),value :: output integer(c_size_t),value :: output_size_in_bytes type(c_ptr) :: p_error end function end interface !> \ingroup aux_module !> \brief Get the fields of the sparse COO matrix descriptor. !> \details !> \p rocsparse_coo_get gets the fields of the sparse COO matrix descriptor. !> !> @param[in] descr - the pointer to the sparse COO matrix descriptor. !> @param[out] rows - number of rows in the sparse COO matrix. !> @param[out] cols - number of columns in the sparse COO matrix. !> @param[out] nnz - number of non-zeros in sparse COO matrix. !> @param[out] coo_row_ind - row indices of the COO matrix. Must be an array of length \p nnz. !> @param[out] coo_col_ind - column indices of the COO matrix. Must be an array of length \p !> nnz. !> @param[out] coo_val - values of the COO matrix. Must be an array of length \p nnz. !> @param[out] idx_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[out] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[out] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p coo_row_ind, \p coo_col_ind, or \p !> coo_val is invalid. !> \retval rocsparse_status_invalid_size if \p rows, \p cols, or \p nnz is invalid. !> \retval rocsparse_status_invalid_value if \p idx_type, \p idx_base, or \p data_type is !> invalid. interface rocsparse_coo_get function rocsparse_coo_get_(descr,rows,cols,nnz,coo_row_ind,coo_col_ind,coo_val,idx_type, & idx_base,data_type) & bind(c, name="rocsparse_coo_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coo_get_ type(c_ptr),value :: descr integer(c_int64_t) :: rows integer(c_int64_t) :: cols integer(c_int64_t) :: nnz type(c_ptr) :: coo_row_ind type(c_ptr) :: coo_col_ind type(c_ptr) :: coo_val type(c_ptr),value :: idx_type type(c_ptr),value :: idx_base type(c_ptr),value :: data_type end function end interface interface rocsparse_const_coo_get function rocsparse_const_coo_get_(descr,rows,cols,nnz,coo_row_ind,coo_col_ind,coo_val, & idx_type,idx_base,data_type) & bind(c, name="rocsparse_const_coo_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_const_coo_get_ type(c_ptr),value :: descr integer(c_int64_t) :: rows integer(c_int64_t) :: cols integer(c_int64_t) :: nnz type(c_ptr) :: coo_row_ind type(c_ptr) :: coo_col_ind type(c_ptr) :: coo_val type(c_ptr),value :: idx_type type(c_ptr),value :: idx_base type(c_ptr),value :: data_type end function end interface !> \ingroup aux_module !> \brief Get the fields of the sparse COO AoS matrix descriptor. !> \details !> \p rocsparse_coo_aos_get gets the fields of the sparse COO AoS matrix descriptor. !> !> @param[in] descr - the pointer to the sparse COO AoS matrix descriptor. !> @param[out] rows - number of rows in the sparse COO AoS matrix. !> @param[out] cols - number of columns in the sparse COO AoS matrix. !> @param[out] nnz - number of non-zeros in the sparse COO AoS matrix. !> @param[out] coo_ind - indices of the COO AoS matrix. Must be an array of !> length \p nnz. !> @param[out] coo_val - values of the COO AoS matrix. Must be an array of length \p nnz. !> @param[out] idx_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[out] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[out] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p coo_ind, or \p coo_val is invalid. !> \retval rocsparse_status_invalid_size if \p rows, \p cols, or \p nnz is invalid. !> \retval rocsparse_status_invalid_value if \p idx_type, \p idx_base, or \p data_type is !> invalid. interface rocsparse_coo_aos_get function rocsparse_coo_aos_get_(descr,rows,cols,nnz,coo_ind,coo_val,idx_type,idx_base, & data_type) & bind(c, name="rocsparse_coo_aos_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coo_aos_get_ type(c_ptr),value :: descr integer(c_int64_t) :: rows integer(c_int64_t) :: cols integer(c_int64_t) :: nnz type(c_ptr) :: coo_ind type(c_ptr) :: coo_val type(c_ptr),value :: idx_type type(c_ptr),value :: idx_base type(c_ptr),value :: data_type end function end interface interface rocsparse_const_coo_aos_get function rocsparse_const_coo_aos_get_(descr,rows,cols,nnz,coo_ind,coo_val,idx_type,idx_base, & data_type) & bind(c, name="rocsparse_const_coo_aos_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_const_coo_aos_get_ type(c_ptr),value :: descr integer(c_int64_t) :: rows integer(c_int64_t) :: cols integer(c_int64_t) :: nnz type(c_ptr) :: coo_ind type(c_ptr) :: coo_val type(c_ptr),value :: idx_type type(c_ptr),value :: idx_base type(c_ptr),value :: data_type end function end interface !> \ingroup aux_module !> \brief Get the fields of the sparse CSR matrix descriptor. !> \details !> \p rocsparse_csr_get gets the fields of the sparse CSR matrix descriptor. !> !> @param[in] descr - the pointer to the sparse CSR matrix descriptor. !> @param[out] rows - number of rows in the CSR matrix. !> @param[out] cols - number of columns in the CSR matrix. !> @param[out] nnz - number of non-zeros in the CSR matrix. !> @param[out] csr_row_ptr - row offsets of the CSR matrix. Must be an array of length \p !> rows+1. !> @param[out] csr_col_ind - column indices of the CSR matrix. Must be an array of length \p !> nnz. !> @param[out] csr_val - values of the CSR matrix. Must be an array of length \p nnz. !> @param[out] row_ptr_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[out] col_ind_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[out] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[out] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p csr_row_ptr, \p csr_col_ind, or \p !> csr_val is invalid. !> \retval rocsparse_status_invalid_size if \p rows, \p cols, or \p nnz is invalid. !> \retval rocsparse_status_invalid_value if \p row_ptr_type, \p col_ind_type, \p idx_base, or !> \p data_type is invalid. interface rocsparse_csr_get function rocsparse_csr_get_(descr,rows,cols,nnz,csr_row_ptr,csr_col_ind,csr_val,row_ptr_type, & col_ind_type,idx_base,data_type) & bind(c, name="rocsparse_csr_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr_get_ type(c_ptr),value :: descr integer(c_int64_t) :: rows integer(c_int64_t) :: cols integer(c_int64_t) :: nnz type(c_ptr) :: csr_row_ptr type(c_ptr) :: csr_col_ind type(c_ptr) :: csr_val type(c_ptr),value :: row_ptr_type type(c_ptr),value :: col_ind_type type(c_ptr),value :: idx_base type(c_ptr),value :: data_type end function end interface interface rocsparse_const_csr_get function rocsparse_const_csr_get_(descr,rows,cols,nnz,csr_row_ptr,csr_col_ind,csr_val, & row_ptr_type,col_ind_type,idx_base,data_type) & bind(c, name="rocsparse_const_csr_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_const_csr_get_ type(c_ptr),value :: descr integer(c_int64_t) :: rows integer(c_int64_t) :: cols integer(c_int64_t) :: nnz type(c_ptr) :: csr_row_ptr type(c_ptr) :: csr_col_ind type(c_ptr) :: csr_val type(c_ptr),value :: row_ptr_type type(c_ptr),value :: col_ind_type type(c_ptr),value :: idx_base type(c_ptr),value :: data_type end function end interface !> \ingroup aux_module !> \brief Get the fields of the sparse CSC matrix descriptor. !> \details !> \p rocsparse_csc_get gets the fields of the sparse CSC matrix descriptor. !> !> @param[in] descr - the pointer to the sparse CSC matrix descriptor. !> @param[out] rows - number of rows in the CSC matrix. !> @param[out] cols - number of columns in the CSC matrix !> @param[out] nnz - number of non-zeros in the CSC matrix. !> @param[out] csc_col_ptr - column offsets of the CSC matrix. Must be an array of length \p !> cols+1. !> @param[out] csc_row_ind - row indices of the CSC matrix. Must be an array of length \p nnz. !> @param[out] csc_val - values of the CSC matrix. Must be an array of length \p nnz. !> @param[out] col_ptr_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[out] row_ind_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[out] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[out] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p csc_col_ptr, \p csc_row_ind, or \p !> csr_val is invalid. !> \retval rocsparse_status_invalid_size if \p rows, \p cols, or \p nnz is invalid. !> \retval rocsparse_status_invalid_value if \p col_ptr_type, \p row_ind_type, \p idx_base, or !> \p data_type is invalid. interface rocsparse_csc_get function rocsparse_csc_get_(descr,rows,cols,nnz,csc_col_ptr,csc_row_ind,csc_val,col_ptr_type, & row_ind_type,idx_base,data_type) & bind(c, name="rocsparse_csc_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csc_get_ type(c_ptr),value :: descr integer(c_int64_t) :: rows integer(c_int64_t) :: cols integer(c_int64_t) :: nnz type(c_ptr) :: csc_col_ptr type(c_ptr) :: csc_row_ind type(c_ptr) :: csc_val type(c_ptr),value :: col_ptr_type type(c_ptr),value :: row_ind_type type(c_ptr),value :: idx_base type(c_ptr),value :: data_type end function end interface interface rocsparse_const_csc_get function rocsparse_const_csc_get_(descr,rows,cols,nnz,csc_col_ptr,csc_row_ind,csc_val, & col_ptr_type,row_ind_type,idx_base,data_type) & bind(c, name="rocsparse_const_csc_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_const_csc_get_ type(c_ptr),value :: descr integer(c_int64_t) :: rows integer(c_int64_t) :: cols integer(c_int64_t) :: nnz type(c_ptr) :: csc_col_ptr type(c_ptr) :: csc_row_ind type(c_ptr) :: csc_val type(c_ptr),value :: col_ptr_type type(c_ptr),value :: row_ind_type type(c_ptr),value :: idx_base type(c_ptr),value :: data_type end function end interface !> \ingroup aux_module !> \brief Get the fields of the sparse ELL matrix descriptor. !> \details !> \p rocsparse_ell_get gets the fields of the sparse ELL matrix descriptor. !> !> @param[in] descr - the pointer to the sparse ELL matrix descriptor. !> @param[out] rows - number of rows in the ELL matrix. !> @param[out] cols - number of columns in the ELL matrix. !> @param[out] ell_col_ind - column indices of the ELL matrix. Must be an array of length \p !> rows*ell_width. !> @param[out] ell_val - values of the ELL matrix. Must be an array of length \p rows*ell_width. !> @param[out] ell_width - width of the ELL matrix. !> @param[out] idx_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[out] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[out] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p ell_col_ind, or \p ell_val is !> invalid. !> \retval rocsparse_status_invalid_size if \p rows, \p cols, or \p ell_width is invalid. !> \retval rocsparse_status_invalid_value if \p idx_type, \p idx_base, or \p data_type is !> invalid. interface rocsparse_ell_get function rocsparse_ell_get_(descr,rows,cols,ell_col_ind,ell_val,ell_width,idx_type,idx_base, & data_type) & bind(c, name="rocsparse_ell_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ell_get_ type(c_ptr),value :: descr integer(c_int64_t) :: rows integer(c_int64_t) :: cols type(c_ptr) :: ell_col_ind type(c_ptr) :: ell_val type(c_ptr),value :: ell_width type(c_ptr),value :: idx_type type(c_ptr),value :: idx_base type(c_ptr),value :: data_type end function end interface interface rocsparse_const_ell_get function rocsparse_const_ell_get_(descr,rows,cols,ell_col_ind,ell_val,ell_width,idx_type, & idx_base,data_type) & bind(c, name="rocsparse_const_ell_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_const_ell_get_ type(c_ptr),value :: descr integer(c_int64_t) :: rows integer(c_int64_t) :: cols type(c_ptr) :: ell_col_ind type(c_ptr) :: ell_val type(c_ptr),value :: ell_width type(c_ptr),value :: idx_type type(c_ptr),value :: idx_base type(c_ptr),value :: data_type end function end interface !> \ingroup aux_module !> \brief Get the fields of the sparse blocked ELL matrix descriptor. !> \details !> \p rocsparse_bell_get gets the fields of the sparse blocked ELL matrix descriptor. !> !> @param[in] descr - the pointer to the sparse blocked ELL matrix descriptor. !> @param[out] rows - number of rows in the blocked ELL matrix. !> @param[out] cols - number of columns in the blocked ELL matrix. !> @param[out] ell_block_dir - `rocsparse_direction_row` or `rocsparse_direction_column`. !> @param[out] ell_block_dim - block dimension of the sparse blocked ELL matrix. !> @param[out] ell_cols - column indices of the blocked ELL matrix. Must be an array of length !> \p rows*ell_width. !> @param[out] ell_col_ind - column indices of the blocked ELL matrix. Must be an array of !> length \p rows*ell_width. !> @param[out] ell_val - values of the blocked ELL matrix. Must be an array of length \p !> rows*ell_width. !> @param[out] idx_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[out] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[out] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p ell_cols, \p ell_col_ind, or \p !> ell_val is invalid. !> \retval rocsparse_status_invalid_size if \p rows, \p cols, or \p ell_block_dim is invalid. !> \retval rocsparse_status_invalid_value if \p ell_block_dir, \p idx_type, \p idx_base, or \p !> data_type is invalid. interface rocsparse_bell_get function rocsparse_bell_get_(descr,rows,cols,ell_block_dir,ell_block_dim,ell_cols,ell_col_ind, & ell_val,idx_type,idx_base,data_type) & bind(c, name="rocsparse_bell_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_bell_get_ type(c_ptr),value :: descr integer(c_int64_t) :: rows integer(c_int64_t) :: cols type(c_ptr),value :: ell_block_dir type(c_ptr),value :: ell_block_dim type(c_ptr),value :: ell_cols type(c_ptr) :: ell_col_ind type(c_ptr) :: ell_val type(c_ptr),value :: idx_type type(c_ptr),value :: idx_base type(c_ptr),value :: data_type end function end interface interface rocsparse_const_bell_get function rocsparse_const_bell_get_(descr,rows,cols,ell_block_dir,ell_block_dim,ell_cols, & ell_col_ind,ell_val,idx_type,idx_base,data_type) & bind(c, name="rocsparse_const_bell_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_const_bell_get_ type(c_ptr),value :: descr integer(c_int64_t) :: rows integer(c_int64_t) :: cols type(c_ptr),value :: ell_block_dir type(c_ptr),value :: ell_block_dim type(c_ptr),value :: ell_cols type(c_ptr) :: ell_col_ind type(c_ptr) :: ell_val type(c_ptr),value :: idx_type type(c_ptr),value :: idx_base type(c_ptr),value :: data_type end function end interface !> \ingroup aux_module !> \brief Get the fields of the sparse sliced ELL matrix descriptor. !> \details !> \p rocsparse_sell_get gets the fields of the sparse sliced ELL matrix descriptor. !> !> @param[in] descr - the pointer to the sparse sliced ELL matrix descriptor. !> @param[out] rows - number of rows in the sliced ELL matrix. !> @param[out] cols - number of columns in the sliced ELL matrix. !> @param[out] nnz - number of non-zeros in the sliced ELL matrix. !> @param[out] sell_slice_size - slice size in the sliced ELL matrix. !> @param[out] sell_colval_size - actual number of elements stored in the sliced ELL matrix. !> @param[out] sell_slice_offsets - slice offsets array in the sliced ELL matrix. Must be an !> array of length \p nslices + 1 !> where \p nslices=(rows-1)/sell_slice_size+1. !> @param[out] sell_col_ind - column indices of the sliced ELL matrix. Must be an array of !> length \p sell_colval_size. !> @param[out] sell_val - values of the sliced ELL matrix. Must be an array of length \p !> sell_colval_size. !> @param[out] sell_slice_offsets_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[out] sell_col_ind_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[out] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[out] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p sell_slice_offsets, \p sell_col_ind, !> or \p sell_val is invalid. !> \retval rocsparse_status_invalid_size if \p rows, \p cols, \p nnz, \p sell_colval_size, or \p !> sell_slice_size is invalid. !> \retval rocsparse_status_invalid_value if \p sell_slice_offsets_type, \p sell_col_ind_type, !> \p idx_base, or \p data_type is invalid. interface rocsparse_sell_get function rocsparse_sell_get_(descr,rows,cols,nnz,sell_slice_size,sell_colval_size, & sell_slice_offsets,sell_col_ind,sell_val,sell_slice_offsets_type,sell_col_ind_type, & idx_base,data_type) & bind(c, name="rocsparse_sell_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sell_get_ type(c_ptr),value :: descr integer(c_int64_t) :: rows integer(c_int64_t) :: cols integer(c_int64_t) :: nnz type(c_ptr),value :: sell_slice_size type(c_ptr),value :: sell_colval_size type(c_ptr) :: sell_slice_offsets type(c_ptr) :: sell_col_ind type(c_ptr) :: sell_val type(c_ptr),value :: sell_slice_offsets_type type(c_ptr),value :: sell_col_ind_type type(c_ptr),value :: idx_base type(c_ptr),value :: data_type end function end interface interface rocsparse_const_sell_get function rocsparse_const_sell_get_(descr,rows,cols,nnz,sell_slice_size,sell_colval_size, & sell_slice_offsets,sell_col_ind,sell_val,sell_slice_offsets_type,sell_col_ind_type, & idx_base,data_type) & bind(c, name="rocsparse_const_sell_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_const_sell_get_ type(c_ptr),value :: descr integer(c_int64_t) :: rows integer(c_int64_t) :: cols integer(c_int64_t) :: nnz type(c_ptr),value :: sell_slice_size type(c_ptr),value :: sell_colval_size type(c_ptr) :: sell_slice_offsets type(c_ptr) :: sell_col_ind type(c_ptr) :: sell_val type(c_ptr),value :: sell_slice_offsets_type type(c_ptr),value :: sell_col_ind_type type(c_ptr),value :: idx_base type(c_ptr),value :: data_type end function end interface !> \ingroup aux_module !> \brief Get the fields of the sparse BSR matrix descriptor. !> \details !> \p rocsparse_bsr_get gets the fields of the sparse BSR matrix descriptor. !> !> @param[in] descr - the pointer to the sparse BSR matrix descriptor. !> @param[out] brows - number of block rows in the BSR matrix. !> @param[out] bcols - number of block columns in the BSR matrix. !> @param[out] bnnz - number of non-zero blocks in the BSR matrix. !> @param[out] block_dir - storage layout of the dense block matrices. !> @param[out] block_dim - block dimension. !> @param[out] bsr_row_ptr - row offsets of the BSR matrix. Must be an array of length \p !> brows+1. !> @param[out] bsr_col_ind - column indices of the BSR matrix. Must be an array of length \p !> bnnz. !> @param[out] bsr_val - values of the BSR matrix (must be array of length \p bnnz * \p !> block_dim * \p block_dim ). !> @param[out] row_ptr_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[out] col_ind_type - `rocsparse_indextype_i32` or `rocsparse_indextype_i64`. !> @param[out] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[out] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p brows, \p bcols, \p bnnz, !> \p block_dir, \p block_dim, \p bsr_row_ptr, \p bsr_col_ind, \p bsr_val, !> \p row_ptr_type, \p col_ind_type, \p idx_base, or \p data_type is invalid. !> \retval rocsparse_status_not_initialized if \p descr has not been initialized. interface rocsparse_bsr_get function rocsparse_bsr_get_(descr,brows,bcols,bnnz,block_dir,block_dim,bsr_row_ptr, & bsr_col_ind,bsr_val,row_ptr_type,col_ind_type,idx_base,data_type) & bind(c, name="rocsparse_bsr_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_bsr_get_ type(c_ptr),value :: descr type(c_ptr),value :: brows type(c_ptr),value :: bcols type(c_ptr),value :: bnnz type(c_ptr),value :: block_dir type(c_ptr),value :: block_dim type(c_ptr) :: bsr_row_ptr type(c_ptr) :: bsr_col_ind type(c_ptr) :: bsr_val type(c_ptr),value :: row_ptr_type type(c_ptr),value :: col_ind_type type(c_ptr),value :: idx_base type(c_ptr),value :: data_type end function end interface interface rocsparse_const_bsr_get function rocsparse_const_bsr_get_(descr,brows,bcols,bnnz,block_dir,block_dim,bsr_row_ptr, & bsr_col_ind,bsr_val,row_ptr_type,col_ind_type,idx_base,data_type) & bind(c, name="rocsparse_const_bsr_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_const_bsr_get_ type(c_ptr),value :: descr type(c_ptr),value :: brows type(c_ptr),value :: bcols type(c_ptr),value :: bnnz type(c_ptr),value :: block_dir type(c_ptr),value :: block_dim type(c_ptr) :: bsr_row_ptr type(c_ptr) :: bsr_col_ind type(c_ptr) :: bsr_val type(c_ptr),value :: row_ptr_type type(c_ptr),value :: col_ind_type type(c_ptr),value :: idx_base type(c_ptr),value :: data_type end function end interface !> \ingroup aux_module !> \brief Set the row indices, column indices, and values array in the sparse COO matrix !> descriptor. !> !> @param[inout] descr - the pointer to the sparse matrix descriptor. !> @param[in] coo_row_ind - row indices of the COO matrix. Must be an array of length \p nnz. !> @param[in] coo_col_ind - column indices of the COO matrix. Must be an array of length \p nnz. !> @param[in] coo_val - values of the COO matrix. Must be an array of length \p nnz. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p coo_row_ind, \p coo_col_ind, or \p !> coo_val is invalid. interface rocsparse_coo_set_pointers function rocsparse_coo_set_pointers_(descr,coo_row_ind,coo_col_ind,coo_val) & bind(c, name="rocsparse_coo_set_pointers") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coo_set_pointers_ type(c_ptr),value :: descr type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind type(c_ptr),value :: coo_val end function end interface !> \ingroup aux_module !> \brief Set the indices and values array in the sparse COO AoS matrix !> descriptor. !> !> @param[inout] descr - the pointer to the sparse matrix descriptor. !> @param[in] coo_ind - indices of the COO matrix. Must be an array of length \p !> nnz. !> @param[in] coo_val - values of the COO matrix. Must be an array of length \p nnz. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p coo_ind, or \p coo_val is invalid. interface rocsparse_coo_aos_set_pointers function rocsparse_coo_aos_set_pointers_(descr,coo_ind,coo_val) & bind(c, name="rocsparse_coo_aos_set_pointers") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coo_aos_set_pointers_ type(c_ptr),value :: descr type(c_ptr),value :: coo_ind type(c_ptr),value :: coo_val end function end interface !> \ingroup aux_module !> \brief Set the row offsets, column indices, and values array in the sparse CSR matrix !> descriptor. !> !> @param[inout] descr - the pointer to the sparse matrix descriptor. !> @param[in] csr_row_ptr - row offsets of the CSR matrix. Must be an array of length \p rows+1. !> @param[in] csr_col_ind - column indices of the CSR matrix. Must be an array of length \p nnz. !> @param[in] csr_val - values of the CSR matrix. Must be an array of length \p nnz. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p coo_ind, or \p coo_val is invalid. interface rocsparse_csr_set_pointers function rocsparse_csr_set_pointers_(descr,csr_row_ptr,csr_col_ind,csr_val) & bind(c, name="rocsparse_csr_set_pointers") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr_set_pointers_ type(c_ptr),value :: descr type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: csr_val end function end interface !> \ingroup aux_module !> \brief Set the column offsets, row indices, and values array in the sparse CSC matrix !> descriptor. !> !> @param[inout] descr - the pointer to the sparse matrix descriptor. !> @param[in] csc_col_ptr - column offsets of the CSC matrix. Must be an array of length \p !> cols+1. !> @param[in] csc_row_ind - row indices of the CSC matrix. Must be an array of length \p nnz. !> @param[in] csc_val - values of the CSC matrix. Must be an array of length \p nnz. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p csc_col_ptr, \p csc_row_ind, or \p !> csc_val is invalid. interface rocsparse_csc_set_pointers function rocsparse_csc_set_pointers_(descr,csc_col_ptr,csc_row_ind,csc_val) & bind(c, name="rocsparse_csc_set_pointers") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csc_set_pointers_ type(c_ptr),value :: descr type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind type(c_ptr),value :: csc_val end function end interface !> \ingroup aux_module !> \brief Set the column indices and values array in the sparse ELL matrix descriptor. !> !> @param[inout] descr - the pointer to the sparse matrix descriptor. !> @param[in] ell_col_ind - column indices of the ELL matrix. Must be an array of length \p !> rows*ell_width. !> @param[in] ell_val - values of the ELL matrix. Must be an array of length \p rows*ell_width. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p ell_col_ind, or \p ell_val is !> invalid. interface rocsparse_ell_set_pointers function rocsparse_ell_set_pointers_(descr,ell_col_ind,ell_val) & bind(c, name="rocsparse_ell_set_pointers") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ell_set_pointers_ type(c_ptr),value :: descr type(c_ptr),value :: ell_col_ind type(c_ptr),value :: ell_val end function end interface !> \ingroup aux_module !> \brief Set the row offsets, column indices, and values array in the sparse BSR matrix !> descriptor !> !> @param[inout] descr - the pointer to the sparse matrix descriptor. !> @param[in] bsr_row_ptr - row offsets of the BSR matrix. Must be an array of length \p rows+1. !> @param[in] bsr_col_ind - column indices of the BSR matrix. Must be an array of length \p !> nnzb. !> @param[in] bsr_val - values of the BSR matrix. Must be an array of length \p !> nnzb*block_dim*block_dim. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p bsr_row_ptr, \p bsr_col_ind, or \p !> bsr_val is invalid. interface rocsparse_bsr_set_pointers function rocsparse_bsr_set_pointers_(descr,bsr_row_ptr,bsr_col_ind,bsr_val) & bind(c, name="rocsparse_bsr_set_pointers") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_bsr_set_pointers_ type(c_ptr),value :: descr type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind type(c_ptr),value :: bsr_val end function end interface !> \ingroup aux_module !> \brief Set the column indices and values array in the sparse Blocked ELL matrix descriptor !> !> @param[inout] descr - the pointer to the sparse matrix descriptor. !> @param[in] bell_col_ind - column indices of the Blocked ELL matrix. Must be an array of !> length \p mb*ell_cols/ell_block_size. !> @param[in] bell_val - values of the Blocked ELL matrix. Must be an array of length \p !> m*ell_cols. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr, \p bell_col_ind, or \p bell_val is !> invalid. interface rocsparse_bell_set_pointers function rocsparse_bell_set_pointers_(descr,bell_col_ind,bell_val) & bind(c, name="rocsparse_bell_set_pointers") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_bell_set_pointers_ type(c_ptr),value :: descr type(c_ptr),value :: bell_col_ind type(c_ptr),value :: bell_val end function end interface !> \ingroup aux_module !> \brief Get the number of rows, columns, and non-zeros from the sparse matrix descriptor. !> !> @param[in] descr - the pointer to the sparse matrix descriptor. !> @param[out] rows - number of rows in the sparse matrix. !> @param[out] cols - number of columns in the sparse matrix. !> @param[out] nnz - number of non-zeros in sparse matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr is invalid. !> \retval rocsparse_status_invalid_size if \p rows, \p cols, or \p nnz is invalid. interface rocsparse_spmat_get_size function rocsparse_spmat_get_size_(descr,rows,cols,nnz) bind(c, name="rocsparse_spmat_get_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spmat_get_size_ type(c_ptr),value :: descr integer(c_int64_t) :: rows integer(c_int64_t) :: cols integer(c_int64_t) :: nnz end function end interface !> \ingroup aux_module !> \brief Get the sparse matrix format from the sparse matrix descriptor. !> !> @param[in] descr - the pointer to the sparse matrix descriptor. !> @param[out] myFormat - `rocsparse_format_coo`, `rocsparse_format_coo_aos`, !> `rocsparse_format_csr`, `rocsparse_format_csc`, or !> `rocsparse_format_ell` !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr is invalid. !> \retval rocsparse_status_invalid_value if \p format is invalid. interface rocsparse_spmat_get_format function rocsparse_spmat_get_format_(descr,myFormat) bind(c, name="rocsparse_spmat_get_format") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spmat_get_format_ type(c_ptr),value :: descr type(c_ptr),value :: myFormat end function end interface !> \ingroup aux_module !> \brief Get the sparse matrix index base from the sparse matrix descriptor. !> !> @param[in] descr - the pointer to the sparse matrix descriptor. !> @param[out] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr is invalid. !> \retval rocsparse_status_invalid_value if \p idx_base is invalid. interface rocsparse_spmat_get_index_base function rocsparse_spmat_get_index_base_(descr,idx_base) & bind(c, name="rocsparse_spmat_get_index_base") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spmat_get_index_base_ type(c_ptr),value :: descr type(c_ptr),value :: idx_base end function end interface !> \ingroup aux_module !> \brief Get the values array from the sparse matrix descriptor. !> !> @param[in] descr - the pointer to the sparse matrix descriptor. !> @param[out] values - values array of the sparse matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p values is invalid. interface rocsparse_spmat_get_values function rocsparse_spmat_get_values_(descr,values) bind(c, name="rocsparse_spmat_get_values") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spmat_get_values_ type(c_ptr),value :: descr type(c_ptr) :: values end function end interface interface rocsparse_const_spmat_get_values function rocsparse_const_spmat_get_values_(descr,values) & bind(c, name="rocsparse_const_spmat_get_values") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_const_spmat_get_values_ type(c_ptr),value :: descr type(c_ptr) :: values end function end interface !> \ingroup aux_module !> \brief Set the values array in the sparse matrix descriptor. !> !> @param[inout] descr - the pointer to the sparse matrix descriptor. !> @param[in] values - values array of the sparse matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p values is invalid. interface rocsparse_spmat_set_values function rocsparse_spmat_set_values_(descr,values) bind(c, name="rocsparse_spmat_set_values") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spmat_set_values_ type(c_ptr),value :: descr type(c_ptr),value :: values end function end interface !> \ingroup aux_module !> \brief Get the number of non-zeros from the sparse matrix descriptor. !> !> \note The returned number of non-zeros is the number of elements of the array of values of !> the sparse matrix. !> !> @param[in] descr - the pointer to the sparse matrix descriptor. !> @param[out] nnz - the number of non-zeros of the sparse matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p nnz is invalid. interface rocsparse_spmat_get_nnz function rocsparse_spmat_get_nnz_(descr,nnz) bind(c, name="rocsparse_spmat_get_nnz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spmat_get_nnz_ type(c_ptr),value :: descr integer(c_int64_t) :: nnz end function end interface !> \ingroup aux_module !> \brief Set the number of non-zeros in the sparse matrix descriptor. !> !> \note In the case of a sparse matrix with the format `rocsparse_format_bsr`, \p nnz is the !> number of blocks. !> \note In the case of a sparse matrix with the format `rocsparse_format_ell`, the operation !> will return an error. !> \note In the case of a sparse matrix with the format `rocsparse_format_bell`, the operation !> will return an error. !> !> @param[in] descr - the pointer to the sparse matrix descriptor. !> @param[in] nnz - number of non-zeros of the sparse matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr is invalid. !> \retval rocsparse_status_invalid_size if \p nnz is invalid. interface rocsparse_spmat_set_nnz function rocsparse_spmat_set_nnz_(descr,nnz) bind(c, name="rocsparse_spmat_set_nnz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spmat_set_nnz_ type(c_ptr),value :: descr integer(c_int64_t),value :: nnz end function end interface !> \ingroup aux_module !> \brief Get the strided batch count from the sparse matrix descriptor. !> !> @param[in] descr - the pointer to the sparse matrix descriptor. !> @param[out] batch_count - batch_count of the sparse matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr is invalid. !> \retval rocsparse_status_invalid_size if \p batch_count is invalid. interface rocsparse_spmat_get_strided_batch function rocsparse_spmat_get_strided_batch_(descr,batch_count) & bind(c, name="rocsparse_spmat_get_strided_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spmat_get_strided_batch_ type(c_ptr),value :: descr type(c_ptr),value :: batch_count end function end interface !> \ingroup aux_module !> \brief Set the strided batch count in the sparse matrix descriptor. !> !> @param[in] descr - the pointer to the sparse matrix descriptor. !> @param[in] batch_count - batch_count of the sparse matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr is invalid. !> \retval rocsparse_status_invalid_size if \p batch_count is invalid. interface rocsparse_spmat_set_strided_batch function rocsparse_spmat_set_strided_batch_(descr,batch_count) & bind(c, name="rocsparse_spmat_set_strided_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spmat_set_strided_batch_ type(c_ptr),value :: descr integer(c_int),value :: batch_count end function end interface !> \ingroup aux_module !> \brief Set the batch count and batch stride in the sparse COO matrix descriptor !> !> @param[inout] descr - the pointer to the sparse COO matrix descriptor. !> @param[in] batch_count - batch_count of the sparse COO matrix. !> @param[in] batch_stride - batch stride of the sparse COO matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr is invalid. !> \retval rocsparse_status_invalid_size if \p batch_count or \p batch_stride is invalid. interface rocsparse_coo_set_strided_batch function rocsparse_coo_set_strided_batch_(descr,batch_count,batch_stride) & bind(c, name="rocsparse_coo_set_strided_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coo_set_strided_batch_ type(c_ptr),value :: descr integer(c_int),value :: batch_count integer(c_int64_t),value :: batch_stride end function end interface !> \ingroup aux_module !> \brief Set the batch count, row offset batch stride, and the column indices batch stride in !> the sparse CSR matrix descriptor. !> !> @param[inout] descr - the pointer to the sparse CSR matrix descriptor. !> @param[in] batch_count - batch_count of the sparse CSR matrix. !> @param[in] offsets_batch_stride - row offset batch stride of the sparse CSR matrix. !> @param[in] columns_values_batch_stride - column indices batch stride of the sparse CSR !> matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr is invalid. !> \retval rocsparse_status_invalid_size if \p batch_count, \p offsets_batch_stride, or \p !> columns_values_batch_stride is invalid. interface rocsparse_csr_set_strided_batch function rocsparse_csr_set_strided_batch_(descr,batch_count,offsets_batch_stride, & columns_values_batch_stride) & bind(c, name="rocsparse_csr_set_strided_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr_set_strided_batch_ type(c_ptr),value :: descr integer(c_int),value :: batch_count integer(c_int64_t),value :: offsets_batch_stride integer(c_int64_t),value :: columns_values_batch_stride end function end interface !> \ingroup aux_module !> \brief Set the batch count, column offset batch stride, and the row indices batch stride in !> the sparse CSC matrix descriptor. !> !> @param[inout] descr - the pointer to the sparse CSC matrix descriptor. !> @param[in] batch_count - batch_count of the sparse CSC matrix. !> @param[in] offsets_batch_stride - column offset batch stride of the sparse CSC matrix. !> @param[in] rows_values_batch_stride - row indices batch stride of the sparse CSC matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr is invalid. !> \retval rocsparse_status_invalid_size if \p batch_count, \p offsets_batch_stride, or \p !> rows_values_batch_stride is invalid. interface rocsparse_csc_set_strided_batch function rocsparse_csc_set_strided_batch_(descr,batch_count,offsets_batch_stride, & rows_values_batch_stride) & bind(c, name="rocsparse_csc_set_strided_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csc_set_strided_batch_ type(c_ptr),value :: descr integer(c_int),value :: batch_count integer(c_int64_t),value :: offsets_batch_stride integer(c_int64_t),value :: rows_values_batch_stride end function end interface !> \ingroup aux_module !> \brief Get the requested attribute data from the sparse matrix descriptor. !> !> @param[in] descr - the pointer to the sparse matrix descriptor. !> @param[in] attribute - `rocsparse_spmat_fill_mode`, `rocsparse_spmat_diag_type`, !> `rocsparse_spmat_matrix_type`, or `rocsparse_spmat_storage_mode`. !> @param[out] myData - attribute data. !> @param[in] data_size - attribute data size. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p data is invalid. !> \retval rocsparse_status_invalid_value if \p attribute is invalid. !> \retval rocsparse_status_invalid_size if \p data_size is invalid. interface rocsparse_spmat_get_attribute function rocsparse_spmat_get_attribute_(descr,attribute,myData,data_size) & bind(c, name="rocsparse_spmat_get_attribute") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spmat_get_attribute_ type(c_ptr),value :: descr integer(kind(rocsparse_spmat_fill_mode)),value :: attribute type(c_ptr),value :: myData integer(c_size_t),value :: data_size end function end interface !> \ingroup aux_module !> \brief Set the requested attribute data in the sparse matrix descriptor. !> !> @param[inout] descr - the pointer to the sparse matrix descriptor. !> @param[in] attribute - `rocsparse_spmat_fill_mode`, `rocsparse_spmat_diag_type`, !> `rocsparse_spmat_matrix_type`, or `rocsparse_spmat_storage_mode`. !> @param[in] myData - attribute data. !> @param[in] data_size - attribute data size. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p data is invalid. !> \retval rocsparse_status_invalid_value if \p attribute is invalid. !> \retval rocsparse_status_invalid_size if \p data_size is invalid. interface rocsparse_spmat_set_attribute function rocsparse_spmat_set_attribute_(descr,attribute,myData,data_size) & bind(c, name="rocsparse_spmat_set_attribute") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spmat_set_attribute_ type(c_ptr),value :: descr integer(kind(rocsparse_spmat_fill_mode)),value :: attribute type(c_ptr),value :: myData integer(c_size_t),value :: data_size end function end interface !> \ingroup aux_module !> \brief Create a dense vector descriptor. !> \details !> \p rocsparse_create_dnvec_descr creates a dense vector descriptor. It should be !> destroyed at the end using rocsparse_destroy_dnvec_descr(). !> !> @param[out] descr - the pointer to the dense vector descriptor. !> @param[in] mySize - size of the dense vector. !> @param[in] values - non-zero values in the dense vector. Must be an array of length \p size. !> @param[in] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p values is invalid. !> \retval rocsparse_status_invalid_size if \p size is invalid. !> \retval rocsparse_status_invalid_value if \p data_type is invalid. interface rocsparse_create_dnvec_descr function rocsparse_create_dnvec_descr_(descr,mySize,values,data_type) & bind(c, name="rocsparse_create_dnvec_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_dnvec_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: mySize type(c_ptr),value :: values integer(kind(rocsparse_datatype_f16_r)),value :: data_type end function end interface interface rocsparse_create_const_dnvec_descr function rocsparse_create_const_dnvec_descr_(descr,mySize,values,data_type) & bind(c, name="rocsparse_create_const_dnvec_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_const_dnvec_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: mySize type(c_ptr),value :: values integer(kind(rocsparse_datatype_f16_r)),value :: data_type end function end interface !> \ingroup aux_module !> \brief Destroy a dense vector descriptor. !> !> \details !> \p rocsparse_destroy_dnvec_descr destroys a dense vector descriptor and releases all !> resources used by the descriptor. !> !> @param[in] descr - the matrix descriptor. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr is invalid. interface rocsparse_destroy_dnvec_descr function rocsparse_destroy_dnvec_descr_(descr) bind(c, name="rocsparse_destroy_dnvec_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_destroy_dnvec_descr_ type(c_ptr),value :: descr end function end interface !> \ingroup aux_module !> \brief Get the fields of the dense vector descriptor. !> \details !> \p rocsparse_dnvec_get gets the fields of the dense vector descriptor. !> !> @param[in] descr - the pointer to the dense vector descriptor. !> @param[out] mySize - size of the dense vector. !> @param[out] values - non-zero values in the dense vector. Must be an array of length \p size. !> @param[out] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p values is invalid. !> \retval rocsparse_status_invalid_size if \p size is invalid. !> \retval rocsparse_status_invalid_value if \p data_type is invalid. interface rocsparse_dnvec_get function rocsparse_dnvec_get_(descr,mySize,values,data_type) bind(c, name="rocsparse_dnvec_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dnvec_get_ type(c_ptr),value :: descr type(c_ptr),value :: mySize type(c_ptr) :: values type(c_ptr),value :: data_type end function end interface interface rocsparse_const_dnvec_get function rocsparse_const_dnvec_get_(descr,mySize,values,data_type) & bind(c, name="rocsparse_const_dnvec_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_const_dnvec_get_ type(c_ptr),value :: descr type(c_ptr),value :: mySize type(c_ptr) :: values type(c_ptr),value :: data_type end function end interface !> \ingroup aux_module !> \brief Get the values array from a dense vector descriptor. !> !> @param[in] descr - the matrix descriptor. !> @param[out] values - non-zero values in the dense vector. Must be an array of length \p size. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr or \p values is invalid. interface rocsparse_dnvec_get_values function rocsparse_dnvec_get_values_(descr,values) bind(c, name="rocsparse_dnvec_get_values") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dnvec_get_values_ type(c_ptr),value :: descr type(c_ptr) :: values end function end interface interface rocsparse_const_dnvec_get_values function rocsparse_const_dnvec_get_values_(descr,values) & bind(c, name="rocsparse_const_dnvec_get_values") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_const_dnvec_get_values_ type(c_ptr),value :: descr type(c_ptr) :: values end function end interface !> \ingroup aux_module !> \brief Set the values array in a dense vector descriptor. !> !> @param[inout] descr - the matrix descriptor. !> @param[in] values - non-zero values in the dense vector. Must be an array of length \p size. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr or \p values is invalid. interface rocsparse_dnvec_set_values function rocsparse_dnvec_set_values_(descr,values) bind(c, name="rocsparse_dnvec_set_values") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dnvec_set_values_ type(c_ptr),value :: descr type(c_ptr),value :: values end function end interface !> \ingroup aux_module !> \brief Create a dense matrix descriptor. !> \details !> \p rocsparse_create_dnmat_descr creates a dense matrix descriptor. It should be !> destroyed at the end using rocsparse_destroy_dnmat_descr(). !> !> @param[out] descr - the pointer to the dense matrix descriptor. !> @param[in] rows - number of rows in the dense matrix. !> @param[in] cols - number of columns in the dense matrix. !> @param[in] ld - leading dimension of the dense matrix. !> @param[in] values - non-zero values in the dense vector. Must be an array of length !> \p ld*rows if \p order=rocsparse_order_column or \p ld*cols if \p !> order=rocsparse_order_row. !> @param[in] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> @param[in] order - `rocsparse_order_row` or `rocsparse_order_column`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p values is invalid. !> \retval rocsparse_status_invalid_size if \p rows, \p cols, or \p ld is invalid. !> \retval rocsparse_status_invalid_value if \p data_type or \p order is invalid. interface rocsparse_create_dnmat_descr function rocsparse_create_dnmat_descr_(descr,rows,cols,ld,values,data_type,order) & bind(c, name="rocsparse_create_dnmat_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_dnmat_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: ld type(c_ptr),value :: values integer(kind(rocsparse_datatype_f16_r)),value :: data_type integer(kind(rocsparse_order_row)),value :: order end function end interface interface rocsparse_create_const_dnmat_descr function rocsparse_create_const_dnmat_descr_(descr,rows,cols,ld,values,data_type,order) & bind(c, name="rocsparse_create_const_dnmat_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_const_dnmat_descr_ type(c_ptr) :: descr integer(c_int64_t),value :: rows integer(c_int64_t),value :: cols integer(c_int64_t),value :: ld type(c_ptr),value :: values integer(kind(rocsparse_datatype_f16_r)),value :: data_type integer(kind(rocsparse_order_row)),value :: order end function end interface !> \ingroup aux_module !> \brief Destroy a dense matrix descriptor. !> !> \details !> \p rocsparse_destroy_dnmat_descr destroys a dense matrix descriptor and releases all !> resources used by the descriptor. !> !> @param[in] descr - the matrix descriptor. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr is invalid. interface rocsparse_destroy_dnmat_descr function rocsparse_destroy_dnmat_descr_(descr) bind(c, name="rocsparse_destroy_dnmat_descr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_destroy_dnmat_descr_ type(c_ptr),value :: descr end function end interface !> \ingroup aux_module !> \brief Get the fields of the dense matrix descriptor. !> !> @param[in] descr - the pointer to the dense matrix descriptor. !> @param[out] rows - number of rows in the dense matrix. !> @param[out] cols - number of columns in the dense matrix. !> @param[out] ld - leading dimension of the dense matrix. !> @param[out] values - non-zero values in the dense matrix. Must be an array of length !> \p ld*rows if \p order=rocsparse_order_column or \p ld*cols if \p !> order=rocsparse_order_row. !> @param[out] data_type - `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, or `rocsparse_datatype_f64_c`. !> @param[out] order - `rocsparse_order_row` or `rocsparse_order_column`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p values is invalid. !> \retval rocsparse_status_invalid_size if \p rows, \p cols, or \p ld is invalid. !> \retval rocsparse_status_invalid_value if \p data_type or \p order is invalid. interface rocsparse_dnmat_get function rocsparse_dnmat_get_(descr,rows,cols,ld,values,data_type,order) & bind(c, name="rocsparse_dnmat_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dnmat_get_ type(c_ptr),value :: descr integer(c_int64_t) :: rows integer(c_int64_t) :: cols type(c_ptr),value :: ld type(c_ptr) :: values type(c_ptr),value :: data_type type(c_ptr),value :: order end function end interface interface rocsparse_const_dnmat_get function rocsparse_const_dnmat_get_(descr,rows,cols,ld,values,data_type,order) & bind(c, name="rocsparse_const_dnmat_get") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_const_dnmat_get_ type(c_ptr),value :: descr integer(c_int64_t) :: rows integer(c_int64_t) :: cols type(c_ptr),value :: ld type(c_ptr) :: values type(c_ptr),value :: data_type type(c_ptr),value :: order end function end interface !> \ingroup aux_module !> \brief Get the values array from the dense matrix descriptor. !> !> @param[in] descr - the pointer to the dense matrix descriptor. !> @param[out] values - non-zero values in the dense matrix. Must be an array of length !> \p ld*rows if \p order=rocsparse_order_column or \p ld*cols if \p !> order=rocsparse_order_row. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr or \p values is invalid. interface rocsparse_dnmat_get_values function rocsparse_dnmat_get_values_(descr,values) bind(c, name="rocsparse_dnmat_get_values") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dnmat_get_values_ type(c_ptr),value :: descr type(c_ptr) :: values end function end interface interface rocsparse_const_dnmat_get_values function rocsparse_const_dnmat_get_values_(descr,values) & bind(c, name="rocsparse_const_dnmat_get_values") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_const_dnmat_get_values_ type(c_ptr),value :: descr type(c_ptr) :: values end function end interface !> \ingroup aux_module !> \brief Set the values array in a dense matrix descriptor. !> !> @param[inout] descr - the matrix descriptor. !> @param[in] values - non-zero values in the dense matrix. Must be an array of length !> \p ld*rows if \p order=rocsparse_order_column or \p ld*cols if \p !> order=rocsparse_order_row. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer \p descr or \p values is invalid. interface rocsparse_dnmat_set_values function rocsparse_dnmat_set_values_(descr,values) bind(c, name="rocsparse_dnmat_set_values") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dnmat_set_values_ type(c_ptr),value :: descr type(c_ptr),value :: values end function end interface !> \ingroup aux_module !> \brief Get the batch count and batch stride from the dense matrix descriptor. !> !> @param[in] descr - the pointer to the dense matrix descriptor. !> @param[out] batch_count - the batch count in the dense matrix. !> @param[out] batch_stride - the batch stride in the dense matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr is invalid. !> \retval rocsparse_status_invalid_size if \p batch_count or \p batch_stride is invalid. interface rocsparse_dnmat_get_strided_batch function rocsparse_dnmat_get_strided_batch_(descr,batch_count,batch_stride) & bind(c, name="rocsparse_dnmat_get_strided_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dnmat_get_strided_batch_ type(c_ptr),value :: descr type(c_ptr),value :: batch_count type(c_ptr),value :: batch_stride end function end interface !> \ingroup aux_module !> \brief Set the batch count and batch stride in the dense matrix descriptor. !> !> @param[inout] descr - the pointer to the dense matrix descriptor. !> @param[in] batch_count - the batch count in the dense matrix. !> @param[in] batch_stride - the batch stride in the dense matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr is invalid. !> \retval rocsparse_status_invalid_size if \p batch_count or \p batch_stride is invalid. interface rocsparse_dnmat_set_strided_batch function rocsparse_dnmat_set_strided_batch_(descr,batch_count,batch_stride) & bind(c, name="rocsparse_dnmat_set_strided_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dnmat_set_strided_batch_ type(c_ptr),value :: descr integer(c_int),value :: batch_count integer(c_int64_t),value :: batch_stride end function end interface !> \ingroup aux_module !> \brief Get the batch count and batch stride from the dense vector descriptor. !> !> @param[in] descr - the pointer to the dense vector descriptor. !> @param[out] batch_count - the batch count in the dense vector. !> @param[out] batch_stride - the batch stride in the dense vector. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr is invalid. !> \retval rocsparse_status_invalid_size if \p batch_count or \p batch_stride is invalid. interface rocsparse_dnvec_get_strided_batch function rocsparse_dnvec_get_strided_batch_(descr,batch_count,batch_stride) & bind(c, name="rocsparse_dnvec_get_strided_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dnvec_get_strided_batch_ type(c_ptr),value :: descr type(c_ptr),value :: batch_count type(c_ptr),value :: batch_stride end function end interface !> \ingroup aux_module !> \brief Set the batch count and batch stride in the dense vector descriptor. !> !> @param[inout] descr - the pointer to the dense vector descriptor. !> @param[in] batch_count - the batch count in the dense vector. !> @param[in] batch_stride - the batch stride in the dense vector. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_pointer if \p descr is invalid. !> \retval rocsparse_status_invalid_size if \p batch_count or \p batch_stride is invalid. interface rocsparse_dnvec_set_strided_batch function rocsparse_dnvec_set_strided_batch_(descr,batch_count,batch_stride) & bind(c, name="rocsparse_dnvec_set_strided_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dnvec_set_strided_batch_ type(c_ptr),value :: descr integer(c_int),value :: batch_count integer(c_int64_t),value :: batch_stride end function end interface !> \ingroup aux_module !> \brief Enable debug kernel launch. !> \details If the debug kernel launch is enabled, then HIP errors are checked before and !> after every kernel launch. !> \note This routine ignores the environment variable \p ROCSPARSE_DEBUG_KERNEL_LAUNCH. interface rocsparse_enable_debug_kernel_launch subroutine rocsparse_enable_debug_kernel_launch_() & bind(c, name="rocsparse_enable_debug_kernel_launch") use iso_c_binding use hipfort_rocsparse_enums implicit none end subroutine end interface !> \ingroup aux_module !> \brief Disable debug kernel launch. !> \note This routine ignores the environment variable \p ROCSPARSE_DEBUG_KERNEL_LAUNCH. interface rocsparse_disable_debug_kernel_launch subroutine rocsparse_disable_debug_kernel_launch_() & bind(c, name="rocsparse_disable_debug_kernel_launch") use iso_c_binding use hipfort_rocsparse_enums implicit none end subroutine end interface !> \ingroup aux_module !> \details Query whether debugging for kernel launch has been enabled. See \ref !> rocsparse_enable_debug_kernel_launch. !> \return 1 if enabled, 0 otherwise. interface rocsparse_state_debug_kernel_launch function rocsparse_state_debug_kernel_launch_() & bind(c, name="rocsparse_state_debug_kernel_launch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(c_int) :: rocsparse_state_debug_kernel_launch_ end function end interface !> \ingroup aux_module !> \brief Enable debug arguments. !> \details If the debug arguments is enabled, then messages are displayed when errors occur !> during argument checking. !> It provides information to the user depending on the verbosity setup for !> \ref rocsparse_enable_debug_arguments_verbose, \ref rocsparse_disable_debug_arguments_verbose, !> and \ref rocsparse_state_debug_arguments_verbose. !> \note This routine ignores the environment variable \p ROCSPARSE_DEBUG_ARGUMENTS. !> \note This routine enables debug arguments verbose with \ref !> rocsparse_enable_debug_arguments_verbose. interface rocsparse_enable_debug_arguments subroutine rocsparse_enable_debug_arguments_() bind(c, name="rocsparse_enable_debug_arguments") use iso_c_binding use hipfort_rocsparse_enums implicit none end subroutine end interface !> \ingroup aux_module !> \brief Disable debug arguments. !> \note This routine ignores the environment variable \p ROCSPARSE_DEBUG_ARGUMENTS. !> \note This routine disables debug arguments. interface rocsparse_disable_debug_arguments subroutine rocsparse_disable_debug_arguments_() & bind(c, name="rocsparse_disable_debug_arguments") use iso_c_binding use hipfort_rocsparse_enums implicit none end subroutine end interface !> \ingroup aux_module !> \details Query whether debugging arguments have been enabled. See \ref !> rocsparse_enable_debug_arguments. !> \return 1 if enabled, 0 otherwise. interface rocsparse_state_debug_arguments function rocsparse_state_debug_arguments_() bind(c, name="rocsparse_state_debug_arguments") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(c_int) :: rocsparse_state_debug_arguments_ end function end interface !> \ingroup aux_module !> \brief Enable debug arguments verbose. !> \details If the debug arguments (verbose) is enabled, then messages are displayed when errors !> occur during argument checking. !> It provides information to the user depending on the verbosity setup. !> \note This routine ignores the environment variable \p ROCSPARSE_DEBUG_ARGUMENTS_VERBOSE. interface rocsparse_enable_debug_arguments_verbose subroutine rocsparse_enable_debug_arguments_verbose_() & bind(c, name="rocsparse_enable_debug_arguments_verbose") use iso_c_binding use hipfort_rocsparse_enums implicit none end subroutine end interface !> \ingroup aux_module !> \brief Disable debug arguments verbose mode. !> \note This routine ignores the environment variable \p ROCSPARSE_DEBUG_ARGUMENTS_VERBOSE. interface rocsparse_disable_debug_arguments_verbose subroutine rocsparse_disable_debug_arguments_verbose_() & bind(c, name="rocsparse_disable_debug_arguments_verbose") use iso_c_binding use hipfort_rocsparse_enums implicit none end subroutine end interface !> \ingroup aux_module !> \details Query whether debugging arguments in verbose mode has been enabled. See \ref !> rocsparse_enable_debug_arguments_verbose. !> \return 1 if enabled, 0 otherwise. interface rocsparse_state_debug_arguments_verbose function rocsparse_state_debug_arguments_verbose_() & bind(c, name="rocsparse_state_debug_arguments_verbose") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(c_int) :: rocsparse_state_debug_arguments_verbose_ end function end interface !> \ingroup aux_module !> \brief Enable debug. !> \details If the debug is enabled, then code traces are generated when unsuccessful status !> returns occur. It provides information to the user depending on the verbosity setup !> (\ref rocsparse_enable_debug_verbose, \ref rocsparse_disable_debug_verbose, and \ref !> rocsparse_state_debug_verbose). !> \note This routine ignores the environment variable ROCSPARSE_DEBUG. !> \note \ref rocsparse_enable_debug_verbose and \ref rocsparse_enable_debug_arguments are !> called. interface rocsparse_enable_debug subroutine rocsparse_enable_debug_() bind(c, name="rocsparse_enable_debug") use iso_c_binding use hipfort_rocsparse_enums implicit none end subroutine end interface !> \ingroup aux_module !> \brief Disable debug. !> \note This routine disables debug arguments with \ref rocsparse_disable_debug_arguments. !> \note This routine ignores the environment variable \p ROCSPARSE_DEBUG. interface rocsparse_disable_debug subroutine rocsparse_disable_debug_() bind(c, name="rocsparse_disable_debug") use iso_c_binding use hipfort_rocsparse_enums implicit none end subroutine end interface !> \ingroup aux_module !> \details Query whether debug has been enabled. See \ref rocsparse_enable_debug. !> \return 1 if enabled, 0 otherwise. interface rocsparse_state_debug function rocsparse_state_debug_() bind(c, name="rocsparse_state_debug") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(c_int) :: rocsparse_state_debug_ end function end interface !> \ingroup aux_module !> \brief Enable debug warnings !> \details When the debug warnings are enabled, some specific warnings are printed during !> execution. !> \note This routine ignores the environment variable \p ROCSPARSE_DEBUG_WARNINGS. interface rocsparse_enable_debug_warnings subroutine rocsparse_enable_debug_warnings_() bind(c, name="rocsparse_enable_debug_warnings") use iso_c_binding use hipfort_rocsparse_enums implicit none end subroutine end interface !> \ingroup aux_module !> \brief Disable debug warnings !> \note This routine ignores the environment variable \p ROCSPARSE_DEBUG_WARNINGS. interface rocsparse_disable_debug_warnings subroutine rocsparse_disable_debug_warnings_() bind(c, name="rocsparse_disable_debug_warnings") use iso_c_binding use hipfort_rocsparse_enums implicit none end subroutine end interface !> \ingroup aux_module !> \brief Enable debug verbose. !> \details Debug in verbose mode displays a stack of code traces showing where the code handles !> an unsuccessful status. !> \note This routine enables debug arguments in verbose mode with \ref !> rocsparse_enable_debug_arguments_verbose. !> \note This routine ignores the environment variable \p ROCSPARSE_DEBUG_VERBOSE. interface rocsparse_enable_debug_verbose subroutine rocsparse_enable_debug_verbose_() bind(c, name="rocsparse_enable_debug_verbose") use iso_c_binding use hipfort_rocsparse_enums implicit none end subroutine end interface !> \ingroup aux_module !> \brief Disable debug verbose. !> \note This routine disables debug arguments verbose with \ref !> rocsparse_disable_debug_arguments. !> \note This routine ignores the environment variable \p ROCSPARSE_DEBUG_VERBOSE. interface rocsparse_disable_debug_verbose subroutine rocsparse_disable_debug_verbose_() bind(c, name="rocsparse_disable_debug_verbose") use iso_c_binding use hipfort_rocsparse_enums implicit none end subroutine end interface !> \ingroup aux_module !> \details Query whether debug has been enabled in verbose mode. See \ref !> rocsparse_enable_debug_verbose. !> \return 1 if enabled, 0 otherwise. interface rocsparse_state_debug_verbose function rocsparse_state_debug_verbose_() bind(c, name="rocsparse_state_debug_verbose") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(c_int) :: rocsparse_state_debug_verbose_ end function end interface !> \ingroup aux_module !> \brief Enable debug to force host asserts. !> \details Debug for force host assert forces the evaluation of asserts on the host when the !> compiler directive \p NDEBUG is used. interface rocsparse_enable_debug_force_host_assert subroutine rocsparse_enable_debug_force_host_assert_() & bind(c, name="rocsparse_enable_debug_force_host_assert") use iso_c_binding use hipfort_rocsparse_enums implicit none end subroutine end interface !> \ingroup aux_module !> \brief Disable debug to force host asserts. interface rocsparse_disable_debug_force_host_assert subroutine rocsparse_disable_debug_force_host_assert_() & bind(c, name="rocsparse_disable_debug_force_host_assert") use iso_c_binding use hipfort_rocsparse_enums implicit none end subroutine end interface !> \ingroup aux_module !> \details Query whether the debug command to force host asserts has been enabled. See \ref !> rocsparse_enable_debug_force_host_assert. !> \return 1 if enabled, 0 otherwise. interface rocsparse_state_debug_force_host_assert function rocsparse_state_debug_force_host_assert_() & bind(c, name="rocsparse_state_debug_force_host_assert") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(c_int) :: rocsparse_state_debug_force_host_assert_ end function end interface !> \ingroup conv_module !> \brief Convert a sparse BSR matrix into a sparse CSR matrix. !> !> \details !> \p rocsparse_bsr2csr converts a BSR matrix into a CSR matrix. It is assumed !> that \p csr_val, \p csr_col_ind, and \p csr_row_ptr are allocated. The allocation size !> for \p csr_row_ptr is \p m+1 where: !> \f[ !> m = mb * block\_dim \\% !> n = nb * block\_dim !> \f] !> Allocation for \p csr_val and \p csr_col_ind is computed by the !> the number of blocks in the BSR matrix multiplied by the block dimension squared: !> \f[ !> nnz = nnzb * block\_dim * block\_dim !> \f] !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - the storage format of the blocks, `rocsparse_direction_row` or !> `rocsparse_direction_column`. !> @param[in] mb - number of block rows in the sparse BSR matrix. !> @param[in] nb - number of block columns in the sparse BSR matrix. !> @param[in] bsr_descr - descriptor of the sparse BSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] bsr_val - array of \p nnzb*block_dim*block_dim containing the values of the sparse !> BSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse BSR matrix. !> @param[in] bsr_col_ind - array of \p nnzb elements containing the block column indices of the !> sparse BSR matrix. !> @param[in] block_dim - size of the blocks in the sparse BSR matrix. !> @param[in] csr_descr - descriptor of the sparse CSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] csr_val - array of \p nnzb*block_dim*block_dim elements containing the values of !> the sparse CSR matrix. !> @param[out] csr_row_ptr - array of \p m+1 where \p m=mb*block_dim elements that point to the !> start of every row of the !> sparse CSR matrix. !> @param[out] csr_col_ind - array of \p nnzb*block_dim*block_dim elements containing the column !> indices of the sparse CSR matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nb, or \p block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p bsr_val, !> \p bsr_row_ptr, \p bsr_col_ind, \p csr_val, \p csr_row_ptr, or !> \p csr_col_ind pointer is invalid. !> !> \par Example !> This example converts a BSR matrix into an CSR matrix. interface rocsparse_sbsr2csr function rocsparse_sbsr2csr_(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) & bind(c, name="rocsparse_sbsr2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsr2csr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sbsr2csr_assumed_rank #else module procedure & rocsparse_sbsr2csr_rank_0,& rocsparse_sbsr2csr_rank_1 #endif #endif end interface interface rocsparse_dbsr2csr function rocsparse_dbsr2csr_(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) & bind(c, name="rocsparse_dbsr2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsr2csr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dbsr2csr_assumed_rank #else module procedure & rocsparse_dbsr2csr_rank_0,& rocsparse_dbsr2csr_rank_1 #endif #endif end interface interface rocsparse_cbsr2csr function rocsparse_cbsr2csr_(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) & bind(c, name="rocsparse_cbsr2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsr2csr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cbsr2csr_assumed_rank #else module procedure & rocsparse_cbsr2csr_rank_0,& rocsparse_cbsr2csr_rank_1 #endif #endif end interface interface rocsparse_zbsr2csr function rocsparse_zbsr2csr_(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) & bind(c, name="rocsparse_zbsr2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsr2csr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zbsr2csr_assumed_rank #else module procedure & rocsparse_zbsr2csr_rank_0,& rocsparse_zbsr2csr_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Pads a value to the diagonal of the last block (if the last block is a diagonal block) !> in the sparse BSR matrix !> when the matrix expands outside \p m x \p m. !> !> \details When converting from a CSR matrix to a BSR matrix, the resulting BSR matrix will be !> larger when \p m < \p mb * \p block_dim. !> In these situations, the CSR to BSR conversion will expand the BSR matrix to have zeros when !> outside \p m x \p m. This routine !> converts the resulting BSR matrix to one that has a value on the last diagonal blocks !> diagonal if this last block is a diagonal !> block in the BSR matrix. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse BSR matrix. !> @param[in] mb - number of block rows of the sparse BSR matrix. !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix. !> @param[in] block_dim - block dimension of the sparse BSR matrix. !> @param[in] myValue - scalar value that is set on the diagonal of the last block when the !> matrix expands outside of \p m x \p m. !> @param[in] bsr_descr - descriptor of the sparse BSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[inout] bsr_val - array of \p nnzb blocks of the sparse BSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of !> the sparse BSR matrix. !> @param[in] bsr_col_ind - array of \p nnzb elements containing the block column indices of the !> sparse !> BSR matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p mb, \p nnzb, or \p block_dim is !> invalid. !> \retval rocsparse_status_invalid_pointer \p bsr_descr, \p bsr_val, !> \p bsr_row_ind, or \p bsr_col_ind pointer is invalid. interface rocsparse_sbsrpad_value function rocsparse_sbsrpad_value_(handle,m,mb,nnzb,block_dim,myValue,bsr_descr,bsr_val, & bsr_row_ptr,bsr_col_ind) & bind(c, name="rocsparse_sbsrpad_value") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrpad_value_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: mb integer(c_int),value :: nnzb integer(c_int),value :: block_dim real(c_float),value :: myValue type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind end function end interface interface rocsparse_dbsrpad_value function rocsparse_dbsrpad_value_(handle,m,mb,nnzb,block_dim,myValue,bsr_descr,bsr_val, & bsr_row_ptr,bsr_col_ind) & bind(c, name="rocsparse_dbsrpad_value") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrpad_value_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: mb integer(c_int),value :: nnzb integer(c_int),value :: block_dim real(c_double),value :: myValue type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind end function end interface interface rocsparse_cbsrpad_value function rocsparse_cbsrpad_value_(handle,m,mb,nnzb,block_dim,myValue,bsr_descr,bsr_val, & bsr_row_ptr,bsr_col_ind) & bind(c, name="rocsparse_cbsrpad_value") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrpad_value_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: mb integer(c_int),value :: nnzb integer(c_int),value :: block_dim complex(c_float_complex),value :: myValue type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind end function end interface interface rocsparse_zbsrpad_value function rocsparse_zbsrpad_value_(handle,m,mb,nnzb,block_dim,myValue,bsr_descr,bsr_val, & bsr_row_ptr,bsr_col_ind) & bind(c, name="rocsparse_zbsrpad_value") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrpad_value_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: mb integer(c_int),value :: nnzb integer(c_int),value :: block_dim complex(c_double_complex),value :: myValue type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind end function end interface !> \ingroup conv_module !> \brief Convert a sparse COO matrix into a sparse CSR matrix. !> !> \details !> \p rocsparse_coo2csr converts the COO array containing the row indices into a !> CSR array of row offsets that point to the start of every row. !> It is assumed that the COO row index array is sorted. !> !> \p rocsparse_coo2csr can also be used to convert a COO array containing the column !> indices into a CSC array of column offsets that point to the start of every column. !> In this case it is assumed that the COO column index array is sorted instead. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] coo_row_ind - array of \p nnz elements containing the row indices of the sparse !> COO !> matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[out] csr_row_ptr - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p coo_row_ind or \p csr_row_ptr !> pointer is invalid. !> !> \par Example !> This example converts a COO matrix into a CSR matrix. interface rocsparse_coo2csr function rocsparse_coo2csr_(handle,coo_row_ind,nnz,m,csr_row_ptr,idx_base) & bind(c, name="rocsparse_coo2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coo2csr_ type(c_ptr),value :: handle type(c_ptr),value :: coo_row_ind integer(c_int),value :: nnz integer(c_int),value :: m type(c_ptr),value :: csr_row_ptr integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_coo2csr_assumed_rank #else module procedure & rocsparse_coo2csr_rank_0,& rocsparse_coo2csr_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief !> This function converts the sparse matrix in COO format into a column-oriented dense matrix. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the column-oriented dense matrix \p A. !> @param[in] n - number of columns of the column-oriented dense matrix \p A. !> @param[in] nnz - number of non-zero entries of the sparse COO matrix. !> @param[in] descr - the descriptor of the column-oriented dense matrix \p A. The supported !> matrix type is !> `rocsparse_matrix_type_general` and also any valid value of the !> `rocsparse_index_base`. !> @param[in] coo_val - array of \p nnz non-zero elements of matrix \p A. !> @param[in] coo_row_ind - integer array of \p nnz row indices of the non-zero elements of !> matrix \p A. !> @param[in] coo_col_ind - integer array of \p nnz column indices of the non-zero elements of !> matrix \p A. !> @param[out] A - array of dimensions (\p ld, \p n). !> !> @param[out] ld - leading dimension of column-oriented dense matrix \p A. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, \p nnz, or \p ld is invalid. !> \retval rocsparse_status_invalid_pointer \p A, \p coo_val, \p coo_col_ind, or \p coo_row_ind !> pointer is invalid. !> !> \par Example interface rocsparse_scoo2dense function rocsparse_scoo2dense_(handle,m,n,nnz,descr,coo_val,coo_row_ind,coo_col_ind,A,ld) & bind(c, name="rocsparse_scoo2dense") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scoo2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scoo2dense_assumed_rank #else module procedure & rocsparse_scoo2dense_rank_0,& rocsparse_scoo2dense_rank_1,& rocsparse_scoo2dense_full_rank #endif #endif end interface interface rocsparse_dcoo2dense function rocsparse_dcoo2dense_(handle,m,n,nnz,descr,coo_val,coo_row_ind,coo_col_ind,A,ld) & bind(c, name="rocsparse_dcoo2dense") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcoo2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcoo2dense_assumed_rank #else module procedure & rocsparse_dcoo2dense_rank_0,& rocsparse_dcoo2dense_rank_1,& rocsparse_dcoo2dense_full_rank #endif #endif end interface interface rocsparse_ccoo2dense function rocsparse_ccoo2dense_(handle,m,n,nnz,descr,coo_val,coo_row_ind,coo_col_ind,A,ld) & bind(c, name="rocsparse_ccoo2dense") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccoo2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccoo2dense_assumed_rank #else module procedure & rocsparse_ccoo2dense_rank_0,& rocsparse_ccoo2dense_rank_1,& rocsparse_ccoo2dense_full_rank #endif #endif end interface interface rocsparse_zcoo2dense function rocsparse_zcoo2dense_(handle,m,n,nnz,descr,coo_val,coo_row_ind,coo_col_ind,A,ld) & bind(c, name="rocsparse_zcoo2dense") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcoo2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcoo2dense_assumed_rank #else module procedure & rocsparse_zcoo2dense_rank_0,& rocsparse_zcoo2dense_rank_1,& rocsparse_zcoo2dense_full_rank #endif #endif end interface !> \ingroup conv_module !> \details !> \p rocsparse_coosort_buffer_size returns the size of the temporary storage buffer that is !> required by `rocsparse_coosort_by_row`() and `rocsparse_coosort_by_column`(). The !> temporary storage buffer has to be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse COO matrix. !> @param[in] n - number of columns of the sparse COO matrix. !> @param[in] nnz - number of non-zero entries of the sparse COO matrix. !> @param[in] coo_row_ind - array of \p nnz elements containing the row indices of the sparse !> COO matrix. !> @param[in] coo_col_ind - array of \p nnz elements containing the column indices of the sparse !> COO matrix. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> `rocsparse_coosort_by_row`() and `rocsparse_coosort_by_column`(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p coo_row_ind, \p coo_col_ind, or !> \p buffer_size pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_coosort_buffer_size function rocsparse_coosort_buffer_size_(handle,m,n,nnz,coo_row_ind,coo_col_ind,buffer_size) & bind(c, name="rocsparse_coosort_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coosort_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_coosort_buffer_size_assumed_rank #else module procedure & rocsparse_coosort_buffer_size_rank_0,& rocsparse_coosort_buffer_size_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Sort a sparse COO matrix by row. !> !> \details !> \p rocsparse_coosort_by_row sorts a matrix in COO format by row. The sorted !> permutation vector \p perm can be used to obtain the sorted \p coo_val array. In this !> case, \p perm must be initialized as the identity permutation. See !> `rocsparse_create_identity_permutation`(). !> !> \p rocsparse_coosort_by_row requires an extra temporary storage buffer that has to be !> allocated by the user. Storage buffer size can be determined by !> `rocsparse_coosort_buffer_size`(). !> !> \note !> \p perm can be \p NULL if a sorted permutation vector is not required. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse COO matrix. !> @param[in] n - number of columns of the sparse COO matrix. !> @param[in] nnz - number of non-zero entries of the sparse COO matrix. !> @param[inout] coo_row_ind - array of \p nnz elements containing the row indices of the sparse !> COO matrix. !> @param[inout] coo_col_ind - array of \p nnz elements containing the column indices of the !> sparse !> COO matrix. !> @param[inout] perm - array of \p nnz integers containing the unsorted map indices, which can !> be !> \p NULL. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. The size is returned !> by !> `rocsparse_coosort_buffer_size`(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p coo_row_ind, \p coo_col_ind, or !> \p temp_buffer pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> !> \par Example !> The following example sorts a \f$3 \times 3\f$ COO matrix by row indices. interface rocsparse_coosort_by_row function rocsparse_coosort_by_row_(handle,m,n,nnz,coo_row_ind,coo_col_ind,perm,temp_buffer) & bind(c, name="rocsparse_coosort_by_row") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coosort_by_row_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind type(c_ptr),value :: perm type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_coosort_by_row_assumed_rank #else module procedure & rocsparse_coosort_by_row_rank_0,& rocsparse_coosort_by_row_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Sort a sparse COO matrix by column. !> !> \details !> \p rocsparse_coosort_by_column sorts a matrix in COO format by column. The sorted !> permutation vector \p perm can be used to obtain the sorted \p coo_val array. In this !> case, \p perm must be initialized as the identity permutation. See !> `rocsparse_create_identity_permutation`(). !> !> \p rocsparse_coosort_by_column requires an extra temporary storage buffer that has to be !> allocated by the user. Storage buffer size can be determined by !> `rocsparse_coosort_buffer_size`(). !> !> \note !> \p perm can be \p NULL if a sorted permutation vector is not required. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse COO matrix. !> @param[in] n - number of columns of the sparse COO matrix. !> @param[in] nnz - number of non-zero entries of the sparse COO matrix. !> @param[inout] coo_row_ind - array of \p nnz elements containing the row indices of the sparse !> COO matrix. !> @param[inout] coo_col_ind - array of \p nnz elements containing the column indices of the !> sparse !> COO matrix. !> @param[inout] perm - array of \p nnz integers containing the unsorted map indices, which can !> be !> \p NULL. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. The size is returned !> by !> `rocsparse_coosort_buffer_size`(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p coo_row_ind, \p coo_col_ind, or !> \p temp_buffer pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> !> \par Example !> The following example sorts a \f$3 \times 3\f$ COO matrix by column indices. interface rocsparse_coosort_by_column function rocsparse_coosort_by_column_(handle,m,n,nnz,coo_row_ind,coo_col_ind,perm,temp_buffer) & bind(c, name="rocsparse_coosort_by_column") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coosort_by_column_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind type(c_ptr),value :: perm type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_coosort_by_column_assumed_rank #else module procedure & rocsparse_coosort_by_column_rank_0,& rocsparse_coosort_by_column_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief !> This function converts the sparse matrix in CSC format into a column-oriented dense matrix. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the column-oriented dense matrix \p A. !> @param[in] n - number of columns of the column-oriented dense matrix \p A. !> @param[in] descr - the descriptor of the column-oriented dense matrix \p A. The supported !> matrix type is !> `rocsparse_matrix_type_general` and also any valid value of the !> `rocsparse_index_base`. !> @param[in] csc_val - array of nnz ( = \p csc_col_ptr[n] - \p csc_col_ptr[0] ) non-zero !> elements of matrix \p A. !> @param[in] csc_col_ptr - integer array of \p n+1 elements that contains the start of every !> column and the end of the last !> column plus one. !> @param[in] csc_row_ind - integer array of nnz ( = \p csc_col_ptr[n] - \p csc_col_ptr[0] ) !> column indices of the non-zero !> elements of matrix \p A. !> @param[out] A - array of dimensions (\p ld, \p n). !> @param[out] ld - leading dimension of column-oriented dense matrix \p A. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p ld is invalid. !> \retval rocsparse_status_invalid_pointer \p A, \p csc_val, \p csc_col_ptr, or \p csc_row_ind !> pointer is invalid. !> !> \par Example interface rocsparse_scsc2dense function rocsparse_scsc2dense_(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A,ld) & bind(c, name="rocsparse_scsc2dense") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsc2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: csc_val type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsc2dense_assumed_rank #else module procedure & rocsparse_scsc2dense_rank_0,& rocsparse_scsc2dense_rank_1,& rocsparse_scsc2dense_full_rank #endif #endif end interface interface rocsparse_dcsc2dense function rocsparse_dcsc2dense_(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A,ld) & bind(c, name="rocsparse_dcsc2dense") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsc2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: csc_val type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsc2dense_assumed_rank #else module procedure & rocsparse_dcsc2dense_rank_0,& rocsparse_dcsc2dense_rank_1,& rocsparse_dcsc2dense_full_rank #endif #endif end interface interface rocsparse_ccsc2dense function rocsparse_ccsc2dense_(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A,ld) & bind(c, name="rocsparse_ccsc2dense") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsc2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: csc_val type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsc2dense_assumed_rank #else module procedure & rocsparse_ccsc2dense_rank_0,& rocsparse_ccsc2dense_rank_1,& rocsparse_ccsc2dense_full_rank #endif #endif end interface interface rocsparse_zcsc2dense function rocsparse_zcsc2dense_(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A,ld) & bind(c, name="rocsparse_zcsc2dense") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsc2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: csc_val type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsc2dense_assumed_rank #else module procedure & rocsparse_zcsc2dense_rank_0,& rocsparse_zcsc2dense_rank_1,& rocsparse_zcsc2dense_full_rank #endif #endif end interface !> \ingroup conv_module !> \details !> \p rocsparse_cscsort_buffer_size returns the size of the temporary storage buffer !> required by `rocsparse_cscsort`(). The temporary storage buffer must be allocated by !> the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSC matrix. !> @param[in] n - number of columns of the sparse CSC matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSC matrix. !> @param[in] csc_col_ptr - array of \p n+1 elements that point to the start of every column of !> the sparse CSC matrix. !> @param[in] csc_row_ind - array of \p nnz elements containing the row indices of the sparse !> CSC matrix. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> `rocsparse_cscsort`(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p csc_col_ptr, \p csc_row_ind, or !> \p buffer_size pointer is invalid. interface rocsparse_cscsort_buffer_size function rocsparse_cscsort_buffer_size_(handle,m,n,nnz,csc_col_ptr,csc_row_ind,buffer_size) & bind(c, name="rocsparse_cscsort_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cscsort_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cscsort_buffer_size_assumed_rank #else module procedure & rocsparse_cscsort_buffer_size_rank_0,& rocsparse_cscsort_buffer_size_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Sort a sparse CSC matrix. !> !> \details !> \p rocsparse_cscsort sorts a matrix in CSC format. The sorted permutation vector !> \p perm can be used to obtain the sorted \p csc_val array. In this case, \p perm must be !> initialized as the identity permutation. For more information, see !> `rocsparse_create_identity_permutation` (). !> !> \p rocsparse_cscsort requires an extra temporary storage buffer that has to be allocated by !> the user. The storage buffer size can be determined by `rocsparse_cscsort_buffer_size`(). !> !> \note !> \p perm can be \p NULL if a sorted permutation vector is not required. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSC matrix. !> @param[in] n - number of columns of the sparse CSC matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSC matrix. !> @param[in] descr - descriptor of the sparse CSC matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csc_col_ptr - array of \p n+1 elements that point to the start of every column of !> the sparse CSC matrix. !> @param[inout] csc_row_ind - array of \p nnz elements containing the row indices of the sparse !> CSC matrix. !> @param[inout] perm - array of \p nnz integers containing the unsorted map indices, which can !> be !> \p NULL. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. The size is returned !> by !> `rocsparse_cscsort_buffer_size`(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p csc_col_ptr, \p csc_row_ind, !> or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> The following example sorts a \f$3 \times 3\f$ CSC matrix. interface rocsparse_cscsort function rocsparse_cscsort_(handle,m,n,nnz,descr,csc_col_ptr,csc_row_ind,perm,temp_buffer) & bind(c, name="rocsparse_cscsort") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cscsort_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind type(c_ptr),value :: perm type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cscsort_assumed_rank #else module procedure & rocsparse_cscsort_rank_0,& rocsparse_cscsort_rank_1 #endif #endif end interface !> \ingroup conv_module !> \details !> This function takes a sparse CSR matrix as input and computes the block row offset array, \p !> bsr_row_ptr, !> and the total number of non-zero blocks, \p bsr_nnz, that will result from converting the CSR !> format input !> matrix to a BSR format output matrix. This function is the first step in the conversion and !> is used in !> conjunction with \ref rocsparse_scsr2bsr "rocsparse_Xcsr2bsr()". !> !> \note !> The routine supports asynchronous execution if the pointer mode is set to device. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> !> @param[in] dir - direction that specifies whether to count non-zero elements by !> `rocsparse_direction_row` or by !> `rocsparse_direction_column`. !> !> @param[in] m - number of rows of the sparse CSR matrix. !> !> @param[in] n - number of columns of the sparse CSR matrix. !> !> @param[in] csr_descr - descriptor of the sparse CSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csr_row_ptr - integer array containing \p m+1 elements that point to the start of !> each row of the CSR matrix. !> !> @param[in] csr_col_ind - integer array of the column indices for each non-zero element in the !> CSR matrix. !> !> @param[in] block_dim - the block dimension of the BSR matrix. Between 1 and min(m, n). !> !> @param[in] bsr_descr - descriptor of the sparse BSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] bsr_row_ptr - integer array containing \p mb+1 elements that point to the start !> of each block row of the BSR matrix. !> !> @param[out] bsr_nnz - total number of non-zero elements in device or host memory. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p csr_row_ptr, \p csr_col_ind, \p bsr_row_ptr, or !> \p bsr_nnz !> pointer is invalid. interface rocsparse_csr2bsr_nnz function rocsparse_csr2bsr_nnz_(handle,dir,m,n,csr_descr,csr_row_ptr,csr_col_ind,block_dim, & bsr_descr,bsr_row_ptr,bsr_nnz) & bind(c, name="rocsparse_csr2bsr_nnz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2bsr_nnz_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_nnz end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_csr2bsr_nnz_assumed_rank #else module procedure & rocsparse_csr2bsr_nnz_rank_0,& rocsparse_csr2bsr_nnz_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse CSR matrix into a sparse BSR matrix. !> !> \details !> \p rocsparse_csr2bsr converts a CSR matrix into a BSR matrix. It is assumed !> that \p bsr_val, \p bsr_col_ind, and \p bsr_row_ptr are allocated. The allocation size !> for \p bsr_row_ptr is computed as \p mb+1, where \p mb is the number of block rows !> and \p nb is the number of block columns in the BSR matrix: !> \f[ !> mb = (m + block\_dim - 1) / block\_dim \\% !> nb = (n + block\_dim - 1) / block\_dim !> \f] !> The allocation size for \p bsr_val and \p bsr_col_ind is computed using !> `rocsparse_csr2bsr_nnz` (), !> which also fills in \p bsr_row_ptr. !> !> Converting from a sparse CSR matrix to a sparse BSR matrix requires two steps. First, !> allocate the \p bsr_row_ptr array to have length \p mb+1 and pass this to the function !> `rocsparse_csr2bsr_nnz`. This will fill the \p bsr_row_ptr array and also compute the total !> number of non-zero blocks in the BSR matrix. Now that the total number of non-zero blocks is !> known, !> allocate the \p bsr_col_ind and \p bsr_val arrays. Finally, call !> \p rocsparse_csr2bsr to complete the conversion. See the example below. !> !> \p rocsparse_csr2bsr requires extra temporary storage that is allocated internally if \p !> block_dim>16. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - the storage format of the blocks, `rocsparse_direction_row` or !> `rocsparse_direction_column`. !> @param[in] m - number of rows in the sparse CSR matrix. !> @param[in] n - number of columns in the sparse CSR matrix. !> @param[in] csr_descr - descriptor of the sparse CSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csr_val - array of \p nnz elements containing the values of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[in] block_dim - size of the blocks in the sparse BSR matrix. !> @param[in] bsr_descr - descriptor of the sparse BSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] bsr_val - array of \p nnzb*block_dim*block_dim containing the values of the !> sparse BSR matrix. !> @param[out] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block !> row of the !> sparse BSR matrix. !> @param[out] bsr_col_ind - array of \p nnzb elements containing the block column indices of !> the sparse BSR matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p bsr_val, !> \p bsr_row_ptr, \p bsr_col_ind, \p csr_val, \p csr_row_ptr, or !> \p csr_col_ind pointer is invalid. !> !> \par Example !> This example converts a CSR matrix into an BSR matrix. interface rocsparse_scsr2bsr function rocsparse_scsr2bsr_(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & block_dim,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind) & bind(c, name="rocsparse_scsr2bsr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2bsr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsr2bsr_assumed_rank #else module procedure & rocsparse_scsr2bsr_rank_0,& rocsparse_scsr2bsr_rank_1 #endif #endif end interface interface rocsparse_dcsr2bsr function rocsparse_dcsr2bsr_(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & block_dim,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind) & bind(c, name="rocsparse_dcsr2bsr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2bsr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsr2bsr_assumed_rank #else module procedure & rocsparse_dcsr2bsr_rank_0,& rocsparse_dcsr2bsr_rank_1 #endif #endif end interface interface rocsparse_ccsr2bsr function rocsparse_ccsr2bsr_(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & block_dim,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind) & bind(c, name="rocsparse_ccsr2bsr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2bsr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsr2bsr_assumed_rank #else module procedure & rocsparse_ccsr2bsr_rank_0,& rocsparse_ccsr2bsr_rank_1 #endif #endif end interface interface rocsparse_zcsr2bsr function rocsparse_zcsr2bsr_(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & block_dim,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind) & bind(c, name="rocsparse_zcsr2bsr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2bsr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsr2bsr_assumed_rank #else module procedure & rocsparse_zcsr2bsr_rank_0,& rocsparse_zcsr2bsr_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse CSR matrix into a sparse COO matrix. !> !> \details !> \p rocsparse_csr2coo converts the CSR array containing the row offsets that point !> to the start of every row into a COO array of row indices. !> !> \p rocsparse_csr2coo can also be used to convert a CSC array containing the column offsets !> into a COO array of column indices. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row !> of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[out] coo_row_ind - array of \p nnz elements containing the row indices of the sparse !> COO !> matrix. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p csr_row_ptr or \p coo_row_ind !> pointer is invalid. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> !> \par Example !> This example converts a CSR matrix into a COO matrix. interface rocsparse_csr2coo function rocsparse_csr2coo_(handle,csr_row_ptr,nnz,m,coo_row_ind,idx_base) & bind(c, name="rocsparse_csr2coo") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2coo_ type(c_ptr),value :: handle type(c_ptr),value :: csr_row_ptr integer(c_int),value :: nnz integer(c_int),value :: m type(c_ptr),value :: coo_row_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_csr2coo_assumed_rank #else module procedure & rocsparse_csr2coo_rank_0,& rocsparse_csr2coo_rank_1 #endif #endif end interface !> \ingroup conv_module !> \details !> \p rocsparse_csr2csc_buffer_size returns the size of the temporary storage buffer !> required by \ref rocsparse_scsr2csc "rocsparse_Xcsr2csc()". !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[in] copy_values - `rocsparse_action_symbolic` or `rocsparse_action_numeric`. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> \ref rocsparse_scsr2csc "rocsparse_Xcsr2csc()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p csr_row_ptr, \p csr_col_ind, or !> \p buffer_size pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_csr2csc_buffer_size function rocsparse_csr2csc_buffer_size_(handle,m,n,nnz,csr_row_ptr,csr_col_ind,copy_values, & buffer_size) & bind(c, name="rocsparse_csr2csc_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2csc_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(kind(rocsparse_action_symbolic)),value :: copy_values integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_csr2csc_buffer_size_assumed_rank #else module procedure & rocsparse_csr2csc_buffer_size_rank_0,& rocsparse_csr2csc_buffer_size_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse CSR matrix into a sparse CSC matrix. !> !> \details !> \p rocsparse_csr2csc converts a CSR matrix into a CSC matrix. The resulting matrix can also !> be seen as the transpose of the input matrix. \p rocsparse_csr2csc can also be used to !> convert !> a CSC matrix into a CSR matrix. !> !> The conversion of a sparse matrix from CSR to CSC format involves two steps. First, !> call \ref rocsparse_csr2csc_buffer_size to determine the size of the required !> tempory storage buffer. Then allocate this buffer. Secondly, call !> \p rocsparse_csr2csc to complete the conversion. After the conversion is complete, !> free the temporary buffer. !> !> Both \ref rocsparse_csr2csc_buffer_size and \p rocsparse_csr2csc take a `rocsparse_action` !> parameter as input. This \p copy_values parameter decides whether \p csc_row_ind and \p !> csc_val !> are filled during conversion (`rocsparse_action_numeric`) or whether only \p csc_row_ind is !> filled !> (`rocsparse_action_symbolic`). Using `rocsparse_action_symbolic` can be useful, for example, !> if only !> the sparsity pattern is required. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[out] csc_val - array of \p nnz elements of the sparse CSC matrix. !> @param[out] csc_row_ind - array of \p nnz elements containing the row indices of the sparse !> CSC !> matrix. !> @param[out] csc_col_ptr - array of \p n+1 elements that point to the start of every column of !> the !> sparse CSC matrix. !> @param[in] copy_values - `rocsparse_action_symbolic` or `rocsparse_action_numeric`. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. The size is returned !> by !> rocsparse_csr2csc_buffer_size(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p csr_val, \p csr_row_ptr, !> \p csr_col_ind, \p csc_val, \p csc_row_ind, \p csc_col_ptr, or !> \p temp_buffer pointer is invalid. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> \retval rocsparse_status_internal_error an internal error occurred. !> !> \par Example !> This example computes the transpose of a CSR matrix. !> \code{.c} !> // 1 2 0 3 0 !> // A = 0 4 5 0 0 !> // 6 0 0 7 8 !> !> rocsparse_int m_A = 3; !> rocsparse_int n_A = 5; !> rocsparse_int nnz_A = 8; !> !> csr_row_ptr_A[m_A + 1] = {0, 3, 5, 8}; // device memory !> csr_col_ind_A[nnz_A] = {0, 1, 3, 1, 2, 0, 3, 4}; // device memory !> csr_val_A[nnz_A] = {1, 2, 3, 4, 5, 6, 7, 8}; // device memory !> !> // Allocate memory for transposed CSR matrix !> rocsparse_int m_T = n_A; !> rocsparse_int n_T = m_A; !> rocsparse_int nnz_T = nnz_A; !> !> rocsparse_int* csr_row_ptr_T; !> rocsparse_int* csr_col_ind_T; !> float* csr_val_T; !> !> hipMalloc((void**)&csr_row_ptr_T, sizeof(rocsparse_int) * (m_T + 1)); !> hipMalloc((void**)&csr_col_ind_T, sizeof(rocsparse_int) * nnz_T); !> hipMalloc((void**)&csr_val_T, sizeof(float) * nnz_T); !> !> // Obtain the temporary buffer size !> size_t buffer_size; !> rocsparse_csr2csc_buffer_size(handle, !> m_A, !> n_A, !> nnz_A, !> csr_row_ptr_A, !> csr_col_ind_A, !> rocsparse_action_numeric, !> &buffer_size); !> !> // Allocate temporary buffer !> void* temp_buffer; !> hipMalloc(&temp_buffer, buffer_size); !> !> rocsparse_scsr2csc(handle, !> m_A, !> n_A, !> nnz_A, !> csr_val_A, !> csr_row_ptr_A, !> csr_col_ind_A, !> csr_val_T, !> csr_col_ind_T, !> csr_row_ptr_T, !> rocsparse_action_numeric, !> rocsparse_index_base_zero, !> temp_buffer); !> \endcode !> !> \par Example !> This example computes the symbolic transpose of A interface rocsparse_scsr2csc function rocsparse_scsr2csc_(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind,csc_val, & csc_row_ind,csc_col_ptr,copy_values,idx_base,temp_buffer) & bind(c, name="rocsparse_scsr2csc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: csc_val type(c_ptr),value :: csc_row_ind type(c_ptr),value :: csc_col_ptr integer(kind(rocsparse_action_symbolic)),value :: copy_values integer(kind(rocsparse_index_base_zero)),value :: idx_base type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsr2csc_assumed_rank #else module procedure & rocsparse_scsr2csc_rank_0,& rocsparse_scsr2csc_rank_1 #endif #endif end interface interface rocsparse_dcsr2csc function rocsparse_dcsr2csc_(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind,csc_val, & csc_row_ind,csc_col_ptr,copy_values,idx_base,temp_buffer) & bind(c, name="rocsparse_dcsr2csc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: csc_val type(c_ptr),value :: csc_row_ind type(c_ptr),value :: csc_col_ptr integer(kind(rocsparse_action_symbolic)),value :: copy_values integer(kind(rocsparse_index_base_zero)),value :: idx_base type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsr2csc_assumed_rank #else module procedure & rocsparse_dcsr2csc_rank_0,& rocsparse_dcsr2csc_rank_1 #endif #endif end interface interface rocsparse_ccsr2csc function rocsparse_ccsr2csc_(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind,csc_val, & csc_row_ind,csc_col_ptr,copy_values,idx_base,temp_buffer) & bind(c, name="rocsparse_ccsr2csc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: csc_val type(c_ptr),value :: csc_row_ind type(c_ptr),value :: csc_col_ptr integer(kind(rocsparse_action_symbolic)),value :: copy_values integer(kind(rocsparse_index_base_zero)),value :: idx_base type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsr2csc_assumed_rank #else module procedure & rocsparse_ccsr2csc_rank_0,& rocsparse_ccsr2csc_rank_1 #endif #endif end interface interface rocsparse_zcsr2csc function rocsparse_zcsr2csc_(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind,csc_val, & csc_row_ind,csc_col_ptr,copy_values,idx_base,temp_buffer) & bind(c, name="rocsparse_zcsr2csc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: csc_val type(c_ptr),value :: csc_row_ind type(c_ptr),value :: csc_col_ptr integer(kind(rocsparse_action_symbolic)),value :: copy_values integer(kind(rocsparse_index_base_zero)),value :: idx_base type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsr2csc_assumed_rank #else module procedure & rocsparse_zcsr2csc_rank_0,& rocsparse_zcsr2csc_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse CSR matrix into a compressed sparse CSR matrix. !> !> \details !> \p rocsparse_csr2csr_compress converts a CSR matrix into a compressed CSR matrix by !> removing entries in the input CSR matrix that are below a non-negative threshold \p tol. !> !> Compressing a CSR matrix involves two steps. First, use !> \ref rocsparse_snnz_compress "rocsparse_Xnnz_compress()" to determine how many entries will !> be in the final compressed CSR matrix. Then call \p rocsparse_csr2csr_compress to finish !> the compression and fill in the column indices and values arrays of the compressed CSR !> matrix. !> !> \note !> In the case of complex matrices, only the magnitude of the real part of \p tol is used. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] descr_A - matrix descriptor for the CSR matrix. !> @param[in] csr_val_A - array of \p nnz_A elements of the sparse CSR matrix. !> @param[in] csr_row_ptr_A - array of \p m+1 elements that point to the start of every row of !> the !> uncompressed sparse CSR matrix. !> @param[in] csr_col_ind_A - array of \p nnz_A elements containing the column indices of the !> uncompressed !> sparse CSR matrix. !> @param[in] nnz_A - number of elements in the column indices and values arrays of the !> uncompressed !> sparse CSR matrix. !> @param[in] nnz_per_row - array of length \p m containing the number of entries that will be !> kept per row in !> the final compressed CSR matrix. !> @param[out] csr_val_C - array of \p nnz_C elements of the compressed sparse CSC matrix. !> @param[out] csr_row_ptr_C - array of \p m+1 elements that point to the start of every column !> of the compressed !> sparse CSR matrix. !> @param[out] csr_col_ind_C - array of \p nnz_C elements containing the row indices of the !> compressed !> sparse CSR matrix. !> @param[in] tol - the non-negative tolerance used for compression. If \p tol is complex, then !> only the magnitude !> of the real part is used. Entries in the input uncompressed CSR array that are !> below the tolerance !> are removed in the output-compressed CSR matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz_A is invalid. !> \retval rocsparse_status_invalid_value \p tol is invalid. !> \retval rocsparse_status_invalid_pointer \p csr_val_A, \p csr_row_ptr_A, !> \p csr_col_ind_A, \p csr_val_C, \p csr_row_ptr_C, \p csr_col_ind_C, or !> \p nnz_per_row pointer is invalid. !> !> \par Example !> This example demonstrates how to compress a CSR matrix. interface rocsparse_scsr2csr_compress function rocsparse_scsr2csr_compress_(handle,m,n,descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,nnz_A,nnz_per_row,csr_val_C,csr_row_ptr_C,csr_col_ind_C,tol) & bind(c, name="rocsparse_scsr2csr_compress") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2csr_compress_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A integer(c_int),value :: nnz_A type(c_ptr),value :: nnz_per_row type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C real(c_float),value :: tol end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsr2csr_compress_assumed_rank #else module procedure & rocsparse_scsr2csr_compress_rank_0,& rocsparse_scsr2csr_compress_rank_1 #endif #endif end interface interface rocsparse_dcsr2csr_compress function rocsparse_dcsr2csr_compress_(handle,m,n,descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,nnz_A,nnz_per_row,csr_val_C,csr_row_ptr_C,csr_col_ind_C,tol) & bind(c, name="rocsparse_dcsr2csr_compress") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2csr_compress_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A integer(c_int),value :: nnz_A type(c_ptr),value :: nnz_per_row type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C real(c_double),value :: tol end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsr2csr_compress_assumed_rank #else module procedure & rocsparse_dcsr2csr_compress_rank_0,& rocsparse_dcsr2csr_compress_rank_1 #endif #endif end interface interface rocsparse_ccsr2csr_compress function rocsparse_ccsr2csr_compress_(handle,m,n,descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,nnz_A,nnz_per_row,csr_val_C,csr_row_ptr_C,csr_col_ind_C,tol) & bind(c, name="rocsparse_ccsr2csr_compress") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2csr_compress_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A integer(c_int),value :: nnz_A type(c_ptr),value :: nnz_per_row type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C complex(c_float_complex),value :: tol end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsr2csr_compress_assumed_rank #else module procedure & rocsparse_ccsr2csr_compress_rank_0,& rocsparse_ccsr2csr_compress_rank_1 #endif #endif end interface interface rocsparse_zcsr2csr_compress function rocsparse_zcsr2csr_compress_(handle,m,n,descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,nnz_A,nnz_per_row,csr_val_C,csr_row_ptr_C,csr_col_ind_C,tol) & bind(c, name="rocsparse_zcsr2csr_compress") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2csr_compress_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A integer(c_int),value :: nnz_A type(c_ptr),value :: nnz_per_row type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C complex(c_double_complex),value :: tol end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsr2csr_compress_assumed_rank #else module procedure & rocsparse_zcsr2csr_compress_rank_0,& rocsparse_zcsr2csr_compress_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief !> This function converts the sparse matrix in CSR format into a column-oriented dense matrix. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the column-oriented dense matrix \p A. !> @param[in] n - number of columns of the column-oriented dense matrix \p A. !> @param[in] descr - the descriptor of the column-oriented dense matrix \p A. The supported !> matrix type is !> `rocsparse_matrix_type_general` and also any valid value of the !> `rocsparse_index_base`. !> @param[in] csr_val - array of nnz ( = \p csr_row_ptr[m] - \p csr_row_ptr[0] ) non-zero !> elements of matrix \p A. !> @param[in] csr_row_ptr - integer array of \p m+1 elements that contains the start of every !> row and the end of the last !> row plus one. !> @param[in] csr_col_ind - integer array of nnz ( = \p csr_row_ptr[m] - \p csr_row_ptr[0] ) !> column indices of the non-zero !> elements of matrix \p A. !> @param[out] A - array of dimensions (\p ld, \p n). !> @param[out] ld - leading dimension of column-oriented dense matrix \p A. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p ld is invalid. !> \retval rocsparse_status_invalid_pointer \p A, \p csr_val, \p csr_row_ptr, or \p csr_col_ind !> pointer is invalid. !> !> \par Example interface rocsparse_scsr2dense function rocsparse_scsr2dense_(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A,ld) & bind(c, name="rocsparse_scsr2dense") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsr2dense_assumed_rank #else module procedure & rocsparse_scsr2dense_rank_0,& rocsparse_scsr2dense_rank_1,& rocsparse_scsr2dense_full_rank #endif #endif end interface interface rocsparse_dcsr2dense function rocsparse_dcsr2dense_(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A,ld) & bind(c, name="rocsparse_dcsr2dense") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsr2dense_assumed_rank #else module procedure & rocsparse_dcsr2dense_rank_0,& rocsparse_dcsr2dense_rank_1,& rocsparse_dcsr2dense_full_rank #endif #endif end interface interface rocsparse_ccsr2dense function rocsparse_ccsr2dense_(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A,ld) & bind(c, name="rocsparse_ccsr2dense") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsr2dense_assumed_rank #else module procedure & rocsparse_ccsr2dense_rank_0,& rocsparse_ccsr2dense_rank_1,& rocsparse_ccsr2dense_full_rank #endif #endif end interface interface rocsparse_zcsr2dense function rocsparse_zcsr2dense_(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A,ld) & bind(c, name="rocsparse_zcsr2dense") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2dense_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: A integer(c_int),value :: ld end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsr2dense_assumed_rank #else module procedure & rocsparse_zcsr2dense_rank_0,& rocsparse_zcsr2dense_rank_1,& rocsparse_zcsr2dense_full_rank #endif #endif end interface !> \ingroup conv_module !> \details !> \p rocsparse_csr2ell_width computes the maximum of the per row non-zero elements !> over all rows, the \p ell_width, for a given CSR matrix. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] csr_descr - descriptor of the sparse CSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] ell_descr - descriptor of the sparse ELL matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] ell_width - pointer to the number of non-zero elements per row in ELL storage !> format. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m is invalid. !> \retval rocsparse_status_invalid_pointer \p csr_descr, \p csr_row_ptr, or !> \p ell_width pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_csr2ell_width function rocsparse_csr2ell_width_(handle,m,csr_descr,csr_row_ptr,ell_descr,ell_width) & bind(c, name="rocsparse_csr2ell_width") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2ell_width_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: ell_descr type(c_ptr),value :: ell_width end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_csr2ell_width_assumed_rank #else module procedure & rocsparse_csr2ell_width_rank_0,& rocsparse_csr2ell_width_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse CSR matrix into a sparse ELL matrix. !> !> \details !> \p rocsparse_csr2ell converts a CSR matrix into an ELL matrix. It is assumed, !> that \p ell_val and \p ell_col_ind are allocated. Allocation size is computed by the !> number of rows times the number of ELL non-zero elements per row, such that !> \f$\text{nnz}_{\text{ELL}} = m \cdot \text{ell_width}\f$. The number of ELL !> non-zero elements per row is obtained by rocsparse_csr2ell_width(). !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] csr_descr - descriptor of the sparse CSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csr_val - array containing the values of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csr_col_ind - array containing the column indices of the sparse CSR matrix. !> @param[in] ell_descr - descriptor of the sparse ELL matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] ell_width - number of non-zero elements per row in ELL storage format. !> @param[out] ell_val - array of \p m times \p ell_width elements of the sparse ELL matrix. !> @param[out] ell_col_ind - array of \p m times \p ell_width elements containing the column !> indices !> of the sparse ELL matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p ell_width is invalid. !> \retval rocsparse_status_invalid_pointer \p csr_descr, \p csr_val, !> \p csr_row_ptr, \p csr_col_ind, \p ell_descr, \p ell_val, or !> \p ell_col_ind pointer is invalid. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> This example converts a CSR matrix into an ELL matrix. interface rocsparse_scsr2ell function rocsparse_scsr2ell_(handle,m,csr_descr,csr_val,csr_row_ptr,csr_col_ind,ell_descr, & ell_width,ell_val,ell_col_ind) & bind(c, name="rocsparse_scsr2ell") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2ell_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: ell_descr integer(c_int),value :: ell_width type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsr2ell_assumed_rank #else module procedure & rocsparse_scsr2ell_rank_0,& rocsparse_scsr2ell_rank_1 #endif #endif end interface interface rocsparse_dcsr2ell function rocsparse_dcsr2ell_(handle,m,csr_descr,csr_val,csr_row_ptr,csr_col_ind,ell_descr, & ell_width,ell_val,ell_col_ind) & bind(c, name="rocsparse_dcsr2ell") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2ell_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: ell_descr integer(c_int),value :: ell_width type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsr2ell_assumed_rank #else module procedure & rocsparse_dcsr2ell_rank_0,& rocsparse_dcsr2ell_rank_1 #endif #endif end interface interface rocsparse_ccsr2ell function rocsparse_ccsr2ell_(handle,m,csr_descr,csr_val,csr_row_ptr,csr_col_ind,ell_descr, & ell_width,ell_val,ell_col_ind) & bind(c, name="rocsparse_ccsr2ell") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2ell_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: ell_descr integer(c_int),value :: ell_width type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsr2ell_assumed_rank #else module procedure & rocsparse_ccsr2ell_rank_0,& rocsparse_ccsr2ell_rank_1 #endif #endif end interface interface rocsparse_zcsr2ell function rocsparse_zcsr2ell_(handle,m,csr_descr,csr_val,csr_row_ptr,csr_col_ind,ell_descr, & ell_width,ell_val,ell_col_ind) & bind(c, name="rocsparse_zcsr2ell") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2ell_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: ell_descr integer(c_int),value :: ell_width type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsr2ell_assumed_rank #else module procedure & rocsparse_zcsr2ell_rank_0,& rocsparse_zcsr2ell_rank_1 #endif #endif end interface !> \ingroup conv_module !> \details !> \p rocsparse_csr2gebsr_buffer_size returns the size of the temporary buffer that is required !> by \ref rocsparse_csr2gebsr_nnz and \ref rocsparse_scsr2gebsr "rocsparse_Xcsr2gebsr()". The !> temporary storage buffer must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> !> @param[in] dir - direction that specifies whether to count non-zero elements by !> `rocsparse_direction_row` or by !> `rocsparse_direction_column`. !> !> @param[in] m - number of rows of the sparse CSR matrix. !> !> @param[in] n - number of columns of the sparse CSR matrix. !> !> @param[in] csr_descr - descriptor of the sparse CSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> !> @param[in] csr_val - array of \p nnz elements containing the values of the sparse CSR matrix. !> !> @param[in] csr_row_ptr - integer array containing \p m+1 elements that point to the start of !> each row of the CSR matrix. !> !> @param[in] csr_col_ind - integer array of the column indices for each non-zero element in the !> CSR matrix. !> !> @param[in] row_block_dim - the row block dimension of the general BSR matrix. Between 1 and !> \p m. !> !> @param[in] col_block_dim - the col block dimension of the general BSR matrix. Between 1 and !> \p n. !> !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by \ref !> rocsparse_csr2gebsr_nnz !> and \ref rocsparse_scsr2gebsr "rocsparse_Xcsr2gebsr()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, \p row_block_dim, or \p col_block_dim is !> invalid. !> \retval rocsparse_status_invalid_pointer \p csr_val, \p csr_row_ptr, \p csr_col_ind, or \p !> buffer_size !> pointer is invalid. interface rocsparse_scsr2gebsr_buffer_size function rocsparse_scsr2gebsr_buffer_size_(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,row_block_dim,col_block_dim,buffer_size) & bind(c, name="rocsparse_scsr2gebsr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2gebsr_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsr2gebsr_buffer_size_assumed_rank #else module procedure & rocsparse_scsr2gebsr_buffer_size_rank_0,& rocsparse_scsr2gebsr_buffer_size_rank_1 #endif #endif end interface interface rocsparse_dcsr2gebsr_buffer_size function rocsparse_dcsr2gebsr_buffer_size_(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,row_block_dim,col_block_dim,buffer_size) & bind(c, name="rocsparse_dcsr2gebsr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2gebsr_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsr2gebsr_buffer_size_assumed_rank #else module procedure & rocsparse_dcsr2gebsr_buffer_size_rank_0,& rocsparse_dcsr2gebsr_buffer_size_rank_1 #endif #endif end interface interface rocsparse_ccsr2gebsr_buffer_size function rocsparse_ccsr2gebsr_buffer_size_(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,row_block_dim,col_block_dim,buffer_size) & bind(c, name="rocsparse_ccsr2gebsr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2gebsr_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsr2gebsr_buffer_size_assumed_rank #else module procedure & rocsparse_ccsr2gebsr_buffer_size_rank_0,& rocsparse_ccsr2gebsr_buffer_size_rank_1 #endif #endif end interface interface rocsparse_zcsr2gebsr_buffer_size function rocsparse_zcsr2gebsr_buffer_size_(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,row_block_dim,col_block_dim,buffer_size) & bind(c, name="rocsparse_zcsr2gebsr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2gebsr_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsr2gebsr_buffer_size_assumed_rank #else module procedure & rocsparse_zcsr2gebsr_buffer_size_rank_0,& rocsparse_zcsr2gebsr_buffer_size_rank_1 #endif #endif end interface !> \ingroup conv_module !> \details !> This function takes a sparse CSR matrix as input and computes the block row offset array, \p !> bsr_row_ptr, !> and the total number of non-zero blocks, \p bsr_nnz_devhost, that will result from converting !> the CSR format !> input matrix to a general BSR format output matrix. This function is the second step in the !> conversion and !> is used in conjunction with \ref rocsparse_scsr2gebsr_buffer_size !> "rocsparse_Xcsr2gebsr_buffer_size()" and !> \ref rocsparse_scsr2gebsr "rocsparse_Xcsr2gebsr()". !> !> \p rocsparse_csr2gebsr_nnz accepts both host and device pointers for \p bsr_nnz_devhost, !> which can be set by !> calling \ref rocsparse_set_pointer_mode prior to calling \p rocsparse_csr2gebsr_nnz. !> !> \note !> This function is blocking with respect to the host. !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - direction that specifies whether to count non-zero elements by !> `rocsparse_direction_row` or by !> `rocsparse_direction_column`. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] csr_descr - descriptor of the sparse CSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csr_row_ptr - integer array containing \p m+1 elements that point to the start of !> each row of the CSR matrix. !> !> @param[in] csr_col_ind - integer array of the column indices for each non-zero element in the !> CSR matrix. !> !> @param[in] bsr_descr - descriptor of the sparse general BSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] bsr_row_ptr - integer array containing \p mb+1 elements that point to the start !> of each block row of the !> general BSR matrix. !> @param[in] row_block_dim - the row block dimension of the general BSR matrix. Between \f$1\f$ !> and \f$\min(m, n)\f$. !> @param[in] col_block_dim - the col block dimension of the general BSR matrix. Between \f$1\f$ !> and \f$\min(m, n)\f$. !> @param[out] bsr_nnz_devhost - total number of non-zero elements in device or host memory. !> @param[in] temp_buffer - buffer allocated by the user. Its size is determined by calling !> \ref rocsparse_scsr2gebsr_buffer_size "rocsparse_Xcsr2gebsr_buffer_size()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, \p row_block_dim, or \p col_block_dim is !> invalid. !> \retval rocsparse_status_invalid_pointer \p csr_row_ptr, \p csr_col_ind, \p bsr_row_ptr, or !> \p bsr_nnz_devhost !> pointer is invalid. interface rocsparse_csr2gebsr_nnz function rocsparse_csr2gebsr_nnz_(handle,dir,m,n,csr_descr,csr_row_ptr,csr_col_ind,bsr_descr, & bsr_row_ptr,row_block_dim,col_block_dim,bsr_nnz_devhost,temp_buffer) & bind(c, name="rocsparse_csr2gebsr_nnz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2gebsr_nnz_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_row_ptr integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsr_nnz_devhost type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_csr2gebsr_nnz_assumed_rank #else module procedure & rocsparse_csr2gebsr_nnz_rank_0,& rocsparse_csr2gebsr_nnz_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse CSR matrix into a sparse general BSR matrix. !> !> \details !> \p rocsparse_csr2gebsr converts a CSR matrix into a general BSR matrix. It is assumed !> that \p bsr_val, \p bsr_col_ind, and \p bsr_row_ptr are allocated. The allocation size !> for \p bsr_row_ptr is computed as \p mb+1, where \p mb is the number of block rows !> and \p nb is the number of block columns in the general BSR matrix: !> \f[ !> mb = (m + row\_block\_dim - 1) / row\_block\_dim \\% !> nb = (n + col\_block\_dim - 1) / col\_block\_dim !> \f] !> The allocation size for \p bsr_val and \p bsr_col_ind is computed using !> `rocsparse_csr2bsr_nnz` (), !> which also fills in \p bsr_row_ptr. !> !> Converting from a sparse CSR matrix to a sparse general BSR matrix requires three steps. !> First, !> call \ref rocsparse_scsr2gebsr_buffer_size "rocsparse_Xcsr2gebsr_buffer_size()" !> to determine the size of the required temporary storage buffer. After this has been !> determined, !> allocate this buffer. Also now allocate the \p bsr_row_ptr array to have length !> \p mb+1 and pass it to the function \ref rocsparse_csr2gebsr_nnz. This will fill the \p !> bsr_row_ptr !> array and also compute the total number of non-zero blocks in the general BSR matrix. Now !> that the total !> number of non-zero blocks is known, allocate the \p bsr_col_ind and \p bsr_val arrays. !> Finally, call \p rocsparse_csr2gebsr to complete the conversion. See the example below. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - the storage format of the blocks, `rocsparse_direction_row` or !> `rocsparse_direction_column`. !> @param[in] m - number of rows in the sparse CSR matrix. !> @param[in] n - number of columns in the sparse CSR matrix. !> @param[in] csr_descr - descriptor of the sparse CSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csr_val - array of \p nnz elements containing the values of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[in] bsr_descr - descriptor of the sparse BSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] bsr_val - array of \p nnzb* \p row_block_dim* \p col_block_dim containing the !> values of the sparse BSR matrix. !> @param[out] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block !> row of the !> sparse BSR matrix. !> @param[out] bsr_col_ind - array of \p nnzb elements containing the block column indices of !> the sparse BSR matrix. !> @param[in] row_block_dim - row size of the blocks in the sparse general BSR matrix. !> @param[in] col_block_dim - col size of the blocks in the sparse general BSR matrix. !> @param[in] temp_buffer - buffer allocated by the user. Its size is determined by calling !> \ref rocsparse_scsr2gebsr_buffer_size "rocsparse_Xcsr2gebsr_buffer_size()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, \p row_block_dim, or \p col_block_dim is !> invalid. !> \retval rocsparse_status_invalid_pointer \p bsr_val, !> \p bsr_row_ptr, \p bsr_col_ind, \p csr_val, \p csr_row_ptr, or !> \p csr_col_ind pointer is invalid. !> !> \par Example !> This example converts a CSR matrix into an BSR matrix. interface rocsparse_scsr2gebsr function rocsparse_scsr2gebsr_(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,temp_buffer) & bind(c, name="rocsparse_scsr2gebsr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2gebsr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsr2gebsr_assumed_rank #else module procedure & rocsparse_scsr2gebsr_rank_0,& rocsparse_scsr2gebsr_rank_1 #endif #endif end interface interface rocsparse_dcsr2gebsr function rocsparse_dcsr2gebsr_(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,temp_buffer) & bind(c, name="rocsparse_dcsr2gebsr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2gebsr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsr2gebsr_assumed_rank #else module procedure & rocsparse_dcsr2gebsr_rank_0,& rocsparse_dcsr2gebsr_rank_1 #endif #endif end interface interface rocsparse_ccsr2gebsr function rocsparse_ccsr2gebsr_(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,temp_buffer) & bind(c, name="rocsparse_ccsr2gebsr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2gebsr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsr2gebsr_assumed_rank #else module procedure & rocsparse_ccsr2gebsr_rank_0,& rocsparse_ccsr2gebsr_rank_1 #endif #endif end interface interface rocsparse_zcsr2gebsr function rocsparse_zcsr2gebsr_(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,temp_buffer) & bind(c, name="rocsparse_zcsr2gebsr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2gebsr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsr2gebsr_assumed_rank #else module procedure & rocsparse_zcsr2gebsr_rank_0,& rocsparse_zcsr2gebsr_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse CSR matrix into a sparse HYB matrix. !> !> \details !> \p rocsparse_csr2hyb converts a CSR matrix into a HYB matrix. It is assumed !> that \p hyb has been initialized with `rocsparse_create_hyb_mat`(). !> !> \note !> This function requires a significant amount of storage for the HYB matrix, !> depending on the matrix structure. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] descr - descriptor of the sparse CSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csr_val - array containing the values of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csr_col_ind - array containing the column indices of the sparse CSR matrix. !> @param[out] hyb - sparse matrix in HYB format. !> @param[in] user_ell_width - width of the ELL part of the HYB matrix (only required if !> \p partition_type == `rocsparse_hyb_partition_user`). !> @param[in] partition_type - `rocsparse_hyb_partition_auto` (recommended), !> `rocsparse_hyb_partition_user`, or !> `rocsparse_hyb_partition_max`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p user_ell_width is invalid. !> \retval rocsparse_status_invalid_value \p partition_type is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p hyb, \p csr_val, !> \p csr_row_ptr, or \p csr_col_ind pointer is invalid. !> \retval rocsparse_status_memory_error the buffer for the HYB matrix could not be !> allocated. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> This example converts a CSR matrix into a HYB matrix using user-defined partitioning. interface rocsparse_scsr2hyb function rocsparse_scsr2hyb_(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,hyb, & user_ell_width,partition_type) & bind(c, name="rocsparse_scsr2hyb") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2hyb_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: hyb integer(c_int),value :: user_ell_width integer(kind(rocsparse_hyb_partition_auto)),value :: partition_type end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsr2hyb_assumed_rank #else module procedure & rocsparse_scsr2hyb_rank_0,& rocsparse_scsr2hyb_rank_1 #endif #endif end interface interface rocsparse_dcsr2hyb function rocsparse_dcsr2hyb_(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,hyb, & user_ell_width,partition_type) & bind(c, name="rocsparse_dcsr2hyb") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2hyb_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: hyb integer(c_int),value :: user_ell_width integer(kind(rocsparse_hyb_partition_auto)),value :: partition_type end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsr2hyb_assumed_rank #else module procedure & rocsparse_dcsr2hyb_rank_0,& rocsparse_dcsr2hyb_rank_1 #endif #endif end interface interface rocsparse_ccsr2hyb function rocsparse_ccsr2hyb_(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,hyb, & user_ell_width,partition_type) & bind(c, name="rocsparse_ccsr2hyb") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2hyb_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: hyb integer(c_int),value :: user_ell_width integer(kind(rocsparse_hyb_partition_auto)),value :: partition_type end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsr2hyb_assumed_rank #else module procedure & rocsparse_ccsr2hyb_rank_0,& rocsparse_ccsr2hyb_rank_1 #endif #endif end interface interface rocsparse_zcsr2hyb function rocsparse_zcsr2hyb_(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,hyb, & user_ell_width,partition_type) & bind(c, name="rocsparse_zcsr2hyb") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2hyb_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: hyb integer(c_int),value :: user_ell_width integer(kind(rocsparse_hyb_partition_auto)),value :: partition_type end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsr2hyb_assumed_rank #else module procedure & rocsparse_zcsr2hyb_rank_0,& rocsparse_zcsr2hyb_rank_1 #endif #endif end interface !> \ingroup conv_module !> \details !> \p rocsparse_csrsort_buffer_size returns the size of the temporary storage buffer !> required by `rocsparse_csrsort`(). The temporary storage buffer must be allocated by !> the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> `rocsparse_csrsort`(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p csr_row_ptr, \p csr_col_ind, or !> \p buffer_size pointer is invalid. interface rocsparse_csrsort_buffer_size function rocsparse_csrsort_buffer_size_(handle,m,n,nnz,csr_row_ptr,csr_col_ind,buffer_size) & bind(c, name="rocsparse_csrsort_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrsort_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_csrsort_buffer_size_assumed_rank #else module procedure & rocsparse_csrsort_buffer_size_rank_0,& rocsparse_csrsort_buffer_size_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Sort a sparse CSR matrix !> !> \details !> \p rocsparse_csrsort sorts a matrix in CSR format. The sorted permutation vector !> \p perm can be used to obtain the sorted \p csr_val array. In this case, \p perm must be !> initialized as the identity permutation. For more information, see !> `rocsparse_create_identity_permutation` (). !> !> \p rocsparse_csrsort requires an extra temporary storage buffer that has to be allocated by !> the user. The storage buffer size can be determined by `rocsparse_csrsort_buffer_size`(). !> !> \note !> \p perm can be \p NULL if a sorted permutation vector is not required. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descr - descriptor of the sparse CSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[inout] csr_col_ind - array of \p nnz elements containing the column indices of the !> sparse !> CSR matrix. !> @param[inout] perm - array of \p nnz integers containing the unsorted map indices, which can !> be !> \p NULL. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. The size is returned !> by !> `rocsparse_csrsort_buffer_size`(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p csr_row_ptr, \p csr_col_ind, !> or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> The following example sorts a \f$3 \times 3\f$ CSR matrix. interface rocsparse_csrsort function rocsparse_csrsort_(handle,m,n,nnz,descr,csr_row_ptr,csr_col_ind,perm,temp_buffer) & bind(c, name="rocsparse_csrsort") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrsort_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: perm type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_csrsort_assumed_rank #else module procedure & rocsparse_csrsort_rank_0,& rocsparse_csrsort_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief !> This function converts the matrix \f$A\f$ in column-oriented dense format into a sparse !> matrix in COO format. !> All the parameters are assumed to have been preallocated by the user, and the arrays are !> filled in based on \p nnz_per_rows, which can be pre-computed with \ref rocsparse_snnz !> "rocsparse_Xnnz()". !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the column-oriented dense matrix \p A. !> @param[in] n - number of columns of the column-oriented dense matrix \p A. !> @param[in] descr - the descriptor of the column-oriented dense matrix \p A. The supported !> matrix type is !> `rocsparse_matrix_type_general` and also any valid value of the !> `rocsparse_index_base`. !> @param[in] A - column-oriented dense matrix of dimensions (\p ld, \p n). !> @param[in] ld - leading dimension of column-oriented dense matrix \p A. !> @param[in] nnz_per_rows - array of size \p n containing the number of non-zero elements per !> row. !> @param[out] coo_val !> array of nnz nonzero elements of matrix \p A. !> @param[out] coo_row_ind - integer array of nnz row indices of the non-zero elements of matrix !> \p A. !> @param[out] coo_col_ind - integer array of nnz column indices of the non-zero elements of !> matrix \p A. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p ld is invalid. !> \retval rocsparse_status_invalid_pointer \p A, \p nnz_per_rows, \p coo_val, \p coo_col_ind, !> or \p coo_row_ind !> pointer is invalid. !> !> \par Example interface rocsparse_sdense2coo function rocsparse_sdense2coo_(handle,m,n,descr,A,ld,nnz_per_rows,coo_val,coo_row_ind, & coo_col_ind) & bind(c, name="rocsparse_sdense2coo") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sdense2coo_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnz_per_rows type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sdense2coo_assumed_rank #else module procedure & rocsparse_sdense2coo_rank_0,& rocsparse_sdense2coo_rank_1,& rocsparse_sdense2coo_full_rank #endif #endif end interface interface rocsparse_ddense2coo function rocsparse_ddense2coo_(handle,m,n,descr,A,ld,nnz_per_rows,coo_val,coo_row_ind, & coo_col_ind) & bind(c, name="rocsparse_ddense2coo") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ddense2coo_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnz_per_rows type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ddense2coo_assumed_rank #else module procedure & rocsparse_ddense2coo_rank_0,& rocsparse_ddense2coo_rank_1,& rocsparse_ddense2coo_full_rank #endif #endif end interface interface rocsparse_cdense2coo function rocsparse_cdense2coo_(handle,m,n,descr,A,ld,nnz_per_rows,coo_val,coo_row_ind, & coo_col_ind) & bind(c, name="rocsparse_cdense2coo") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdense2coo_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnz_per_rows type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cdense2coo_assumed_rank #else module procedure & rocsparse_cdense2coo_rank_0,& rocsparse_cdense2coo_rank_1,& rocsparse_cdense2coo_full_rank #endif #endif end interface interface rocsparse_zdense2coo function rocsparse_zdense2coo_(handle,m,n,descr,A,ld,nnz_per_rows,coo_val,coo_row_ind, & coo_col_ind) & bind(c, name="rocsparse_zdense2coo") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdense2coo_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnz_per_rows type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zdense2coo_assumed_rank #else module procedure & rocsparse_zdense2coo_rank_0,& rocsparse_zdense2coo_rank_1,& rocsparse_zdense2coo_full_rank #endif #endif end interface !> \ingroup conv_module !> \brief !> !> This function converts the matrix \f$A\f$ in column-oriented dense format into a sparse !> matrix in CSC format. !> All the parameters are assumed to have been preallocated by the user, and the arrays are !> filled in based on \p nnz_per_columns, which can be pre-computed with \ref rocsparse_snnz !> "rocsparse_Xnnz()". !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the column-oriented dense matrix \p A. !> @param[in] n - number of columns of the column-oriented dense matrix \p A. !> @param[in] descr - the descriptor of the column-oriented dense matrix \p A. The supported !> matrix type is !> `rocsparse_matrix_type_general` and also any valid value of the !> `rocsparse_index_base`. !> @param[in] A - column-oriented dense matrix of dimensions (\p ld, \p n). !> @param[in] ld - leading dimension of the column-oriented dense matrix \p A. !> @param[in] nnz_per_columns - array of size \p n containing the number of non-zero elements !> per column. !> @param[out] csc_val - array of nnz ( = \p csc_col_ptr[n] - \p csc_col_ptr[0] ) non-zero !> elements of matrix \p A. !> @param[out] csc_col_ptr - integer array of \p n+1 elements that contains the start of every !> column and the end of the last column !> plus one. !> @param[out] csc_row_ind - integer array of nnz ( = \p csc_col_ptr[n] - \p csc_col_ptr[0] ) !> column indices of the non-zero elements !> of matrix \p A. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p ld is invalid. !> \retval rocsparse_status_invalid_pointer \p A, \p nnz_per_columns, \p csc_val, \p !> csc_col_ptr, or \p csc_row_ind !> pointer is invalid. !> !> \par Example interface rocsparse_sdense2csc function rocsparse_sdense2csc_(handle,m,n,descr,A,ld,nnz_per_columns,csc_val,csc_col_ptr, & csc_row_ind) & bind(c, name="rocsparse_sdense2csc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sdense2csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnz_per_columns type(c_ptr),value :: csc_val type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sdense2csc_assumed_rank #else module procedure & rocsparse_sdense2csc_rank_0,& rocsparse_sdense2csc_rank_1,& rocsparse_sdense2csc_full_rank #endif #endif end interface interface rocsparse_ddense2csc function rocsparse_ddense2csc_(handle,m,n,descr,A,ld,nnz_per_columns,csc_val,csc_col_ptr, & csc_row_ind) & bind(c, name="rocsparse_ddense2csc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ddense2csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnz_per_columns type(c_ptr),value :: csc_val type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ddense2csc_assumed_rank #else module procedure & rocsparse_ddense2csc_rank_0,& rocsparse_ddense2csc_rank_1,& rocsparse_ddense2csc_full_rank #endif #endif end interface interface rocsparse_cdense2csc function rocsparse_cdense2csc_(handle,m,n,descr,A,ld,nnz_per_columns,csc_val,csc_col_ptr, & csc_row_ind) & bind(c, name="rocsparse_cdense2csc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdense2csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnz_per_columns type(c_ptr),value :: csc_val type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cdense2csc_assumed_rank #else module procedure & rocsparse_cdense2csc_rank_0,& rocsparse_cdense2csc_rank_1,& rocsparse_cdense2csc_full_rank #endif #endif end interface interface rocsparse_zdense2csc function rocsparse_zdense2csc_(handle,m,n,descr,A,ld,nnz_per_columns,csc_val,csc_col_ptr, & csc_row_ind) & bind(c, name="rocsparse_zdense2csc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdense2csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnz_per_columns type(c_ptr),value :: csc_val type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zdense2csc_assumed_rank #else module procedure & rocsparse_zdense2csc_rank_0,& rocsparse_zdense2csc_rank_1,& rocsparse_zdense2csc_full_rank #endif #endif end interface !> \ingroup conv_module !> \brief !> This function converts the matrix \f$A\f$ in column-oriented dense format into a sparse !> matrix in CSR format. !> All the parameters are assumed to have been preallocated by the user, and the arrays are !> filled in based !> on nnz_per_row, which can be pre-computed with \ref rocsparse_snnz "rocsparse_Xnnz()". !> !> \note !> This function is blocking with respect to the host. !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the column-oriented dense matrix \p A. !> @param[in] n - number of columns of the column-oriented dense dense matrix \p A. !> @param[in] descr - the descriptor of the column-oriented dense matrix \p A. The supported !> matrix type is !> `rocsparse_matrix_type_general` and also any valid value of the !> `rocsparse_index_base`. !> @param[in] A - column-oriented dense matrix of dimensions (\p ld, \p n). !> @param[in] ld - leading dimension of column-oriented dense matrix \p A. !> @param[in] nnz_per_rows - array of size \p n containing the number of non-zero elements per !> row. !> @param[out] csr_val - array of nnz ( = \p csr_row_ptr[m] - \p csr_row_ptr[0] ) non-zero !> elements of matrix \p A. !> @param[out] csr_row_ptr - integer array of \p m+1 elements that contains the start of every !> row and the end of the last row plus one. !> @param[out] csr_col_ind - integer array of nnz ( = \p csr_row_ptr[m] - \p csr_row_ptr[0] ) !> column indices of the non-zero elements of !> matrix \p A. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p ld is invalid. !> \retval rocsparse_status_invalid_pointer \p A, \p nnz_per_rows, \p csr_val, \p csr_row_ptr, !> or \p csr_col_ind !> pointer is invalid. !> !> \par Example interface rocsparse_sdense2csr function rocsparse_sdense2csr_(handle,m,n,descr,A,ld,nnz_per_rows,csr_val,csr_row_ptr, & csr_col_ind) & bind(c, name="rocsparse_sdense2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sdense2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnz_per_rows type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sdense2csr_assumed_rank #else module procedure & rocsparse_sdense2csr_rank_0,& rocsparse_sdense2csr_rank_1,& rocsparse_sdense2csr_full_rank #endif #endif end interface interface rocsparse_ddense2csr function rocsparse_ddense2csr_(handle,m,n,descr,A,ld,nnz_per_rows,csr_val,csr_row_ptr, & csr_col_ind) & bind(c, name="rocsparse_ddense2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ddense2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnz_per_rows type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ddense2csr_assumed_rank #else module procedure & rocsparse_ddense2csr_rank_0,& rocsparse_ddense2csr_rank_1,& rocsparse_ddense2csr_full_rank #endif #endif end interface interface rocsparse_cdense2csr function rocsparse_cdense2csr_(handle,m,n,descr,A,ld,nnz_per_rows,csr_val,csr_row_ptr, & csr_col_ind) & bind(c, name="rocsparse_cdense2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdense2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnz_per_rows type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cdense2csr_assumed_rank #else module procedure & rocsparse_cdense2csr_rank_0,& rocsparse_cdense2csr_rank_1,& rocsparse_cdense2csr_full_rank #endif #endif end interface interface rocsparse_zdense2csr function rocsparse_zdense2csr_(handle,m,n,descr,A,ld,nnz_per_rows,csr_val,csr_row_ptr, & csr_col_ind) & bind(c, name="rocsparse_zdense2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdense2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnz_per_rows type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zdense2csr_assumed_rank #else module procedure & rocsparse_zdense2csr_rank_0,& rocsparse_zdense2csr_rank_1,& rocsparse_zdense2csr_full_rank #endif #endif end interface !> \ingroup conv_module !> \details !> This function takes a sparse ELL matrix as input and computes the row offset array, \p !> csr_row_ptr, !> and the total number of non-zeros, \p csr_nnz, that will result from converting the ELL !> format input !> matrix to a CSR format output matrix. This function is the first step in the conversion and !> is used in !> conjunction with \ref rocsparse_sell2csr "rocsparse_Xell2csr()". It is assumed that \p !> csr_row_ptr has !> been allocated with size \p m+1. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse ELL matrix. !> @param[in] n - number of columns of the sparse ELL matrix. !> @param[in] ell_descr - descriptor of the sparse ELL matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] ell_width - number of non-zero elements per row in ELL storage format. !> @param[in] ell_col_ind - array of \p m times \p ell_width elements containing the column !> indices !> of the sparse ELL matrix. !> @param[in] csr_descr - descriptor of the sparse CSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] csr_row_ptr - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix. !> @param[out] csr_nnz - pointer to the total number of non-zero elements in CSR storage !> format. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p ell_width is invalid. !> \retval rocsparse_status_invalid_pointer \p ell_descr, \p ell_col_ind, !> \p csr_descr, \p csr_row_ptr, or \p csr_nnz pointer is invalid. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_ell2csr_nnz function rocsparse_ell2csr_nnz_(handle,m,n,ell_descr,ell_width,ell_col_ind,csr_descr, & csr_row_ptr,csr_nnz) & bind(c, name="rocsparse_ell2csr_nnz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ell2csr_nnz_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: ell_descr integer(c_int),value :: ell_width type(c_ptr),value :: ell_col_ind type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_nnz end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ell2csr_nnz_assumed_rank #else module procedure & rocsparse_ell2csr_nnz_rank_0,& rocsparse_ell2csr_nnz_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse ELL matrix into a sparse CSR matrix. !> !> \details !> \p rocsparse_ell2csr converts a ELL matrix into a CSR matrix. It is assumed !> that \p csr_row_ptr has already been filled and that \p csr_val and \p csr_col_ind !> are allocated by the user. The allocation size for \p csr_row_ptr is computed as !> \p m+1. The allocation size for \p csr_val and \p csr_col_ind is computed using !> `rocsparse_ell2csr_nnz`() which also fills in \p csr_row_ptr. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse ELL matrix. !> @param[in] n - number of columns of the sparse ELL matrix. !> @param[in] ell_descr - descriptor of the sparse ELL matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] ell_width - number of non-zero elements per row in ELL storage format. !> @param[in] ell_val - array of \p m times \p ell_width elements of the sparse ELL matrix. !> @param[in] ell_col_ind - array of \p m times \p ell_width elements containing the column !> indices !> of the sparse ELL matrix. !> @param[in] csr_descr - descriptor of the sparse CSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] csr_val - array containing the values of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[out] csr_col_ind - array containing the column indices of the sparse CSR matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p ell_width is invalid. !> \retval rocsparse_status_invalid_pointer \p csr_descr, \p csr_val, !> \p csr_row_ptr, \p csr_col_ind, \p ell_descr, \p ell_val, or !> \p ell_col_ind pointer is invalid. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> This example converts an ELL matrix into a CSR matrix. interface rocsparse_sell2csr function rocsparse_sell2csr_(handle,m,n,ell_descr,ell_width,ell_val,ell_col_ind,csr_descr, & csr_val,csr_row_ptr,csr_col_ind) & bind(c, name="rocsparse_sell2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sell2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: ell_descr integer(c_int),value :: ell_width type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sell2csr_assumed_rank #else module procedure & rocsparse_sell2csr_rank_0,& rocsparse_sell2csr_rank_1 #endif #endif end interface interface rocsparse_dell2csr function rocsparse_dell2csr_(handle,m,n,ell_descr,ell_width,ell_val,ell_col_ind,csr_descr, & csr_val,csr_row_ptr,csr_col_ind) & bind(c, name="rocsparse_dell2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dell2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: ell_descr integer(c_int),value :: ell_width type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dell2csr_assumed_rank #else module procedure & rocsparse_dell2csr_rank_0,& rocsparse_dell2csr_rank_1 #endif #endif end interface interface rocsparse_cell2csr function rocsparse_cell2csr_(handle,m,n,ell_descr,ell_width,ell_val,ell_col_ind,csr_descr, & csr_val,csr_row_ptr,csr_col_ind) & bind(c, name="rocsparse_cell2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cell2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: ell_descr integer(c_int),value :: ell_width type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cell2csr_assumed_rank #else module procedure & rocsparse_cell2csr_rank_0,& rocsparse_cell2csr_rank_1 #endif #endif end interface interface rocsparse_zell2csr function rocsparse_zell2csr_(handle,m,n,ell_descr,ell_width,ell_val,ell_col_ind,csr_descr, & csr_val,csr_row_ptr,csr_col_ind) & bind(c, name="rocsparse_zell2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zell2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: ell_descr integer(c_int),value :: ell_width type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zell2csr_assumed_rank #else module procedure & rocsparse_zell2csr_rank_0,& rocsparse_zell2csr_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse general BSR matrix into a sparse CSR matrix. !> !> \details !> \p rocsparse_gebsr2csr converts a BSR matrix into a CSR matrix. The input matrix is assumed !> to be allocated such that array \p bsr_row_ptr has length \p mb+1, \p bsr_col_ind has length !> \p nnzb, and !> \p bsr_val has length \p nnzb*row_block_dim*col_block_dim. The output matrix is assumed to be !> allocated such that array \p csr_row_ptr has length \p m+1, \p csr_col_ind has length \p nnz, !> and !> \p csr_val has length \p nnz where: !> \f[ !> m = mb * row\_block\_dim \\% !> n = nb * col\_block\_dim \\% !> nnz = nnzb * row\_block\_dim * col\_block\_dim !> \f] !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - the storage format of the blocks, `rocsparse_direction_row` or !> `rocsparse_direction_column`. !> @param[in] mb - number of block rows in the sparse general BSR matrix. !> @param[in] nb - number of block columns in the sparse general BSR matrix. !> @param[in] bsr_descr - descriptor of the sparse general BSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] bsr_val - array of \p nnzb*row_block_dim*col_block_dim containing the values of !> the sparse BSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse BSR matrix. !> @param[in] bsr_col_ind - array of \p nnzb elements containing the block column indices of the !> sparse BSR matrix. !> @param[in] row_block_dim - row size of the blocks in the sparse general BSR matrix. !> @param[in] col_block_dim - column size of the blocks in the sparse general BSR matrix. !> @param[in] csr_descr - descriptor of the sparse CSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] csr_val - array of \p nnzb*row_block_dim*col_block_dim elements containing the !> values of the sparse CSR matrix. !> @param[out] csr_row_ptr - array of \p m+1 where \p m=mb*row_block_dim elements that point to !> the start of every row of the !> sparse CSR matrix. !> @param[out] csr_col_ind - array of \p nnzb*block_dim*block_dim elements containing the column !> indices of the sparse CSR matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nb, or \p block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p bsr_val, !> \p bsr_row_ptr, \p bsr_col_ind, \p csr_val, \p csr_row_ptr, or !> \p csr_col_ind pointer is invalid. !> !> \par Example !> This example converts a general BSR matrix into an CSR matrix. interface rocsparse_sgebsr2csr function rocsparse_sgebsr2csr_(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind, & row_block_dim,col_block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) & bind(c, name="rocsparse_sgebsr2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsr2csr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sgebsr2csr_assumed_rank #else module procedure & rocsparse_sgebsr2csr_rank_0,& rocsparse_sgebsr2csr_rank_1 #endif #endif end interface interface rocsparse_dgebsr2csr function rocsparse_dgebsr2csr_(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind, & row_block_dim,col_block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) & bind(c, name="rocsparse_dgebsr2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsr2csr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dgebsr2csr_assumed_rank #else module procedure & rocsparse_dgebsr2csr_rank_0,& rocsparse_dgebsr2csr_rank_1 #endif #endif end interface interface rocsparse_cgebsr2csr function rocsparse_cgebsr2csr_(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind, & row_block_dim,col_block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) & bind(c, name="rocsparse_cgebsr2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsr2csr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cgebsr2csr_assumed_rank #else module procedure & rocsparse_cgebsr2csr_rank_0,& rocsparse_cgebsr2csr_rank_1 #endif #endif end interface interface rocsparse_zgebsr2csr function rocsparse_zgebsr2csr_(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind, & row_block_dim,col_block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) & bind(c, name="rocsparse_zgebsr2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsr2csr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb type(c_ptr),value :: bsr_descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: csr_descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zgebsr2csr_assumed_rank #else module procedure & rocsparse_zgebsr2csr_rank_0,& rocsparse_zgebsr2csr_rank_1 #endif #endif end interface !> \ingroup conv_module !> \details !> \p rocsparse_gebsr2gebsc_buffer_size returns the size of the temporary storage buffer !> required by \ref rocsparse_sgebsr2gebsc "rocsparse_Xgebsr2gebsc()". !> The temporary storage buffer must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] mb - number of rows of the sparse general BSR matrix. !> @param[in] nb - number of columns of the sparse general BSR matrix. !> @param[in] nnzb - number of non-zero entries of the sparse general BSR matrix. !> @param[in] bsr_val - array of \p nnzb*row_block_dim*col_block_dim containing the values of !> the sparse general BSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every row of !> the !> sparse general BSR matrix. !> @param[in] bsr_col_ind - array of \p nnzb elements containing the column indices of the !> sparse !> general BSR matrix. !> @param[in] row_block_dim - row size of the blocks in the sparse general BSR matrix. !> @param[in] col_block_dim - col size of the blocks in the sparse general BSR matrix. !> @param[out] p_buffer_size - number of bytes of the temporary storage buffer required by !> rocsparse_sgebsr2gebsc(), rocsparse_dgebsr2gebsc(), rocsparse_cgebsr2gebsc(), and !> rocsparse_zgebsr2gebsc(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nb, or \p nnzb is invalid. !> \retval rocsparse_status_invalid_pointer \p bsr_row_ptr, \p bsr_col_ind, or !> \p p_buffer_size pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_sgebsr2gebsc_buffer_size function rocsparse_sgebsr2gebsc_buffer_size_(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,p_buffer_size) & bind(c, name="rocsparse_sgebsr2gebsc_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsr2gebsc_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: p_buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sgebsr2gebsc_buffer_size_assumed_rank #else module procedure & rocsparse_sgebsr2gebsc_buffer_size_rank_0,& rocsparse_sgebsr2gebsc_buffer_size_rank_1 #endif #endif end interface interface rocsparse_dgebsr2gebsc_buffer_size function rocsparse_dgebsr2gebsc_buffer_size_(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,p_buffer_size) & bind(c, name="rocsparse_dgebsr2gebsc_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsr2gebsc_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: p_buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dgebsr2gebsc_buffer_size_assumed_rank #else module procedure & rocsparse_dgebsr2gebsc_buffer_size_rank_0,& rocsparse_dgebsr2gebsc_buffer_size_rank_1 #endif #endif end interface interface rocsparse_cgebsr2gebsc_buffer_size function rocsparse_cgebsr2gebsc_buffer_size_(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,p_buffer_size) & bind(c, name="rocsparse_cgebsr2gebsc_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsr2gebsc_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: p_buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cgebsr2gebsc_buffer_size_assumed_rank #else module procedure & rocsparse_cgebsr2gebsc_buffer_size_rank_0,& rocsparse_cgebsr2gebsc_buffer_size_rank_1 #endif #endif end interface interface rocsparse_zgebsr2gebsc_buffer_size function rocsparse_zgebsr2gebsc_buffer_size_(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,p_buffer_size) & bind(c, name="rocsparse_zgebsr2gebsc_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsr2gebsc_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: p_buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zgebsr2gebsc_buffer_size_assumed_rank #else module procedure & rocsparse_zgebsr2gebsc_buffer_size_rank_0,& rocsparse_zgebsr2gebsc_buffer_size_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse general BSR matrix into a sparse general BSC matrix. !> !> \details !> \p rocsparse_gebsr2gebsc converts a general BSR matrix into a general BSC matrix. The !> resulting !> matrix can also be seen as the transpose of the input matrix. \p rocsparse_gebsr2gebsc can !> also !> be used to convert a general BSC matrix into a general BSR matrix. !> !> The conversion of a sparse matrix from general BSR to general BSC format involves two steps. !> First, !> call \ref rocsparse_sgebsr2gebsc_buffer_size "rocsparse_Xgebsr2gebsc_buffer_size()" to !> determine the size of the required tempory storage buffer. Then allocate this buffer. !> Secondly, !> call \p rocsparse_gebsr2gebsc to complete the conversion. After the conversion is complete, !> the !> user must free the temporary buffer. !> !> \p rocsparse_gebsr2gebsc takes a `rocsparse_action` parameter as input. This \p copy_values !> parameter !> decides whether \p bsc_row_ind and \p bsc_val are filled during conversion !> (`rocsparse_action_numeric`) !> or whether only \p bsc_row_ind is filled (`rocsparse_action_symbolic`). Using !> `rocsparse_action_symbolic` can be useful, for example, if only the sparsity pattern is !> required. !> !> \note !> The resulting matrix can also be seen as the transpose of the input matrix. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] mb - number of rows of the sparse general BSR matrix. !> @param[in] nb - number of columns of the sparse general BSR matrix. !> @param[in] nnzb - number of non-zero entries of the sparse general BSR matrix. !> @param[in] bsr_val - array of \p nnzb * \p row_block_dim * \p col_block_dim elements of the !> sparse general BSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every row of !> the !> sparse general BSR matrix. !> @param[in] bsr_col_ind - array of \p nnz elements containing the column indices of the sparse !> general BSR matrix. !> @param[in] row_block_dim - row size of the blocks in the sparse general BSR matrix. !> @param[in] col_block_dim - col size of the blocks in the sparse general BSR matrix. !> @param[out] bsc_val - array of \p nnz elements of the sparse BSC matrix. !> @param[out] bsc_row_ind - array of \p nnz elements containing the row indices of the sparse !> BSC !> matrix. !> @param[out] bsc_col_ptr - array of \p nb+1 elements that point to the start of every column !> of the !> sparse BSC matrix. !> @param[in] copy_values - `rocsparse_action_symbolic` or `rocsparse_action_numeric`. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. The size is returned !> by !> \ref rocsparse_sgebsr2gebsc_buffer_size !> "rocsparse_Xgebsr2gebsc_buffer_size()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nb, or \p nnzb is invalid. !> \retval rocsparse_status_invalid_pointer \p bsr_val, \p bsr_row_ptr, !> \p bsr_col_ind, \p bsc_val, \p bsc_row_ind, \p bsc_col_ptr, or !> \p temp_buffer pointer is invalid. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> \retval rocsparse_status_internal_error an internal error occurred. !> !> \par Example !> This example computes the transpose of a general BSR matrix. interface rocsparse_sgebsr2gebsc function rocsparse_sgebsr2gebsc_(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr,bsr_col_ind, & row_block_dim,col_block_dim,bsc_val,bsc_row_ind,bsc_col_ptr,copy_values,idx_base, & temp_buffer) & bind(c, name="rocsparse_sgebsr2gebsc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsr2gebsc_ type(c_ptr),value :: handle integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsc_val type(c_ptr),value :: bsc_row_ind type(c_ptr),value :: bsc_col_ptr integer(kind(rocsparse_action_symbolic)),value :: copy_values integer(kind(rocsparse_index_base_zero)),value :: idx_base type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sgebsr2gebsc_assumed_rank #else module procedure & rocsparse_sgebsr2gebsc_rank_0,& rocsparse_sgebsr2gebsc_rank_1 #endif #endif end interface interface rocsparse_dgebsr2gebsc function rocsparse_dgebsr2gebsc_(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr,bsr_col_ind, & row_block_dim,col_block_dim,bsc_val,bsc_row_ind,bsc_col_ptr,copy_values,idx_base, & temp_buffer) & bind(c, name="rocsparse_dgebsr2gebsc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsr2gebsc_ type(c_ptr),value :: handle integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsc_val type(c_ptr),value :: bsc_row_ind type(c_ptr),value :: bsc_col_ptr integer(kind(rocsparse_action_symbolic)),value :: copy_values integer(kind(rocsparse_index_base_zero)),value :: idx_base type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dgebsr2gebsc_assumed_rank #else module procedure & rocsparse_dgebsr2gebsc_rank_0,& rocsparse_dgebsr2gebsc_rank_1 #endif #endif end interface interface rocsparse_cgebsr2gebsc function rocsparse_cgebsr2gebsc_(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr,bsr_col_ind, & row_block_dim,col_block_dim,bsc_val,bsc_row_ind,bsc_col_ptr,copy_values,idx_base, & temp_buffer) & bind(c, name="rocsparse_cgebsr2gebsc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsr2gebsc_ type(c_ptr),value :: handle integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsc_val type(c_ptr),value :: bsc_row_ind type(c_ptr),value :: bsc_col_ptr integer(kind(rocsparse_action_symbolic)),value :: copy_values integer(kind(rocsparse_index_base_zero)),value :: idx_base type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cgebsr2gebsc_assumed_rank #else module procedure & rocsparse_cgebsr2gebsc_rank_0,& rocsparse_cgebsr2gebsc_rank_1 #endif #endif end interface interface rocsparse_zgebsr2gebsc function rocsparse_zgebsr2gebsc_(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr,bsr_col_ind, & row_block_dim,col_block_dim,bsc_val,bsc_row_ind,bsc_col_ptr,copy_values,idx_base, & temp_buffer) & bind(c, name="rocsparse_zgebsr2gebsc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsr2gebsc_ type(c_ptr),value :: handle integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsc_val type(c_ptr),value :: bsc_row_ind type(c_ptr),value :: bsc_col_ptr integer(kind(rocsparse_action_symbolic)),value :: copy_values integer(kind(rocsparse_index_base_zero)),value :: idx_base type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zgebsr2gebsc_assumed_rank #else module procedure & rocsparse_zgebsr2gebsc_rank_0,& rocsparse_zgebsr2gebsc_rank_1 #endif #endif end interface !> \ingroup conv_module !> \details !> \p rocsparse_gebsr2gebsr_buffer_size returns the size of the temporary storage buffer that is !> required by !> `rocsparse_gebsr2gebsr_nnz` () and \ref rocsparse_sgebsr2gebsr "rocsparse_Xgebsr2gebsr()". !> The temporary !> storage buffer must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - the storage format of the blocks, `rocsparse_direction_row` or !> `rocsparse_direction_column`. !> @param[in] mb - number of block rows of the general BSR sparse matrix \f$A\f$. !> @param[in] nb - number of block columns of the general BSR sparse matrix \f$A\f$. !> @param[in] nnzb - number of blocks in the general BSR sparse matrix \f$A\f$. !> @param[in] descr_A - the descriptor of the general BSR sparse matrix \f$A\f$. The supported !> matrix type is !> `rocsparse_matrix_type_general` and also any valid value of the !> `rocsparse_index_base`. !> @param[in] bsr_val_A - array of \p nnzb*row_block_dim_A*col_block_dim_A containing the values !> of the sparse general BSR !> matrix \f$A\f$. !> @param[in] bsr_row_ptr_A - array of \p mb+1 elements that point to the start of every block !> row of the !> sparse general BSR matrix \f$A\f$. !> @param[in] bsr_col_ind_A - array of \p nnzb elements containing the block column indices of !> the sparse general BSR matrix \f$A\f$. !> @param[in] row_block_dim_A - row size of the blocks in the sparse general BSR matrix \f$A\f$. !> @param[in] col_block_dim_A - column size of the blocks in the sparse general BSR matrix !> \f$A\f$. !> @param[in] row_block_dim_C - row size of the blocks in the sparse general BSR matrix \f$C\f$. !> @param[in] col_block_dim_C - column size of the blocks in the sparse general BSR matrix !> \f$C\f$. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> `rocsparse_gebsr2gebsr_nnz` () and !> \ref rocsparse_sgebsr2gebsr "rocsparse_Xgebsr2gebsr()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nb, \p nnzb, \p row_block_dim_A, !> \p col_block_dim_A, \p row_block_dim_C, or \p col_block_dim_C is invalid. !> \retval rocsparse_status_invalid_pointer \p bsr_row_ptr_A, \p bsr_col_ind_A, !> \p descr_A, or \p buffer_size pointer is invalid. interface rocsparse_sgebsr2gebsr_buffer_size function rocsparse_sgebsr2gebsr_buffer_size_(handle,dir,mb,nb,nnzb,descr_A,bsr_val_A, & bsr_row_ptr_A,bsr_col_ind_A,row_block_dim_A,col_block_dim_A,row_block_dim_C, & col_block_dim_C,buffer_size) & bind(c, name="rocsparse_sgebsr2gebsr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsr2gebsr_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descr_A type(c_ptr),value :: bsr_val_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A integer(c_int),value :: row_block_dim_A integer(c_int),value :: col_block_dim_A integer(c_int),value :: row_block_dim_C integer(c_int),value :: col_block_dim_C integer(c_size_t) :: buffer_size end function end interface interface rocsparse_dgebsr2gebsr_buffer_size function rocsparse_dgebsr2gebsr_buffer_size_(handle,dir,mb,nb,nnzb,descr_A,bsr_val_A, & bsr_row_ptr_A,bsr_col_ind_A,row_block_dim_A,col_block_dim_A,row_block_dim_C, & col_block_dim_C,buffer_size) & bind(c, name="rocsparse_dgebsr2gebsr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsr2gebsr_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descr_A type(c_ptr),value :: bsr_val_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A integer(c_int),value :: row_block_dim_A integer(c_int),value :: col_block_dim_A integer(c_int),value :: row_block_dim_C integer(c_int),value :: col_block_dim_C integer(c_size_t) :: buffer_size end function end interface interface rocsparse_cgebsr2gebsr_buffer_size function rocsparse_cgebsr2gebsr_buffer_size_(handle,dir,mb,nb,nnzb,descr_A,bsr_val_A, & bsr_row_ptr_A,bsr_col_ind_A,row_block_dim_A,col_block_dim_A,row_block_dim_C, & col_block_dim_C,buffer_size) & bind(c, name="rocsparse_cgebsr2gebsr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsr2gebsr_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descr_A type(c_ptr),value :: bsr_val_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A integer(c_int),value :: row_block_dim_A integer(c_int),value :: col_block_dim_A integer(c_int),value :: row_block_dim_C integer(c_int),value :: col_block_dim_C integer(c_size_t) :: buffer_size end function end interface interface rocsparse_zgebsr2gebsr_buffer_size function rocsparse_zgebsr2gebsr_buffer_size_(handle,dir,mb,nb,nnzb,descr_A,bsr_val_A, & bsr_row_ptr_A,bsr_col_ind_A,row_block_dim_A,col_block_dim_A,row_block_dim_C, & col_block_dim_C,buffer_size) & bind(c, name="rocsparse_zgebsr2gebsr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsr2gebsr_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descr_A type(c_ptr),value :: bsr_val_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A integer(c_int),value :: row_block_dim_A integer(c_int),value :: col_block_dim_A integer(c_int),value :: row_block_dim_C integer(c_int),value :: col_block_dim_C integer(c_size_t) :: buffer_size end function end interface !> \ingroup conv_module !> \details !> This function takes a sparse general BSR matrix as input and computes the block row offset !> array, \p bsr_row_ptr_C, !> and the total number of non-zero blocks, \p nnz_total_dev_host_ptr, that result from !> converting the general BSR !> format input matrix to a general BSR format output matrix. The input and output matrices can !> have different row and !> column block dimensions. \p rocsparse_gebsr2gebsr_nnz is the second step in the conversion !> and is used in conjunction with !> \ref rocsparse_sgebsr2gebsr_buffer_size "rocsparse_Xgebsr2gebsr_buffer_size()" and !> \ref rocsparse_sgebsr2gebsr "rocsparse_Xgebsr2gebsr()". !> !> \p rocsparse_gebsr2gebsr_nnz accepts both host and device pointers for \p !> nnz_total_dev_host_ptr, which can be set by !> calling \ref rocsparse_set_pointer_mode prior to calling \p rocsparse_gebsr2gebsr_nnz. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - the storage format of the blocks, `rocsparse_direction_row` or !> `rocsparse_direction_column`. !> @param[in] mb - number of block rows of the general BSR sparse matrix \f$A\f$. !> @param[in] nb - number of block columns of the general BSR sparse matrix \f$A\f$. !> @param[in] nnzb - number of blocks in the general BSR sparse matrix \f$A\f$. !> @param[in] descr_A - the descriptor of the general BSR sparse matrix \f$A\f$. The supported !> matrix type is !> `rocsparse_matrix_type_general` and also any valid value of the !> `rocsparse_index_base`. !> @param[in] bsr_row_ptr_A - array of \p mb+1 elements that point to the start of every block !> row of the !> sparse general BSR matrix \f$A\f$. !> @param[in] bsr_col_ind_A - array of \p nnzb elements containing the block column indices of !> the sparse general BSR matrix \f$A\f$. !> @param[in] row_block_dim_A - row size of the blocks in the sparse general BSR matrix \f$A\f$. !> @param[in] col_block_dim_A - column size of the blocks in the sparse general BSR matrix !> \f$A\f$. !> @param[in] descr_C - the descriptor of the general BSR sparse matrix \f$C\f$. The supported !> matrix type is !> `rocsparse_matrix_type_general` and also any valid value of the !> `rocsparse_index_base`. !> @param[in] bsr_row_ptr_C - array of \p mb_C+1 elements that point to the start of every block !> row of the !> sparse general BSR matrix \f$C\f$ where \p !> mb_C=(m+row_block_dim_C-1)/row_block_dim_C. !> @param[in] row_block_dim_C - row size of the blocks in the sparse general BSR matrix \f$C\f$. !> @param[in] col_block_dim_C - column size of the blocks in the sparse general BSR matrix !> \f$C\f$. !> @param[out] nnz_total_dev_host_ptr - total number of non-zero blocks in general BSR sparse !> matrix \f$C\f$ stored using device or host memory. !> @param[out] temp_buffer - buffer allocated by the user whose size is determined by calling !> \ref rocsparse_sgebsr2gebsr_buffer_size !> "rocsparse_Xgebsr2gebsr_buffer_size()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nb, \p nnzb, \p row_block_dim_A, !> \p col_block_dim_A, \p row_block_dim_C, or \p col_block_dim_C is invalid. !> \retval rocsparse_status_invalid_pointer \p bsr_row_ptr_A, \p bsr_col_ind_A, !> \p bsr_row_ptr_C, \p descr_A, \p descr_C, or \p temp_buffer pointer is invalid. interface rocsparse_gebsr2gebsr_nnz function rocsparse_gebsr2gebsr_nnz_(handle,dir,mb,nb,nnzb,descr_A,bsr_row_ptr_A,bsr_col_ind_A, & row_block_dim_A,col_block_dim_A,descr_C,bsr_row_ptr_C,row_block_dim_C,col_block_dim_C, & nnz_total_dev_host_ptr,temp_buffer) & bind(c, name="rocsparse_gebsr2gebsr_nnz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_gebsr2gebsr_nnz_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descr_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A integer(c_int),value :: row_block_dim_A integer(c_int),value :: col_block_dim_A type(c_ptr),value :: descr_C type(c_ptr),value :: bsr_row_ptr_C integer(c_int),value :: row_block_dim_C integer(c_int),value :: col_block_dim_C integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr),value :: temp_buffer end function end interface !> \ingroup conv_module !> \brief !> This function converts the general BSR sparse matrix \f$A\f$ to another general BSR sparse !> matrix \f$C\f$. !> !> \details !> \p rocsparse_gebsr2gebsr converts a general BSR matrix \f$A\f$ into a general BSR matrix !> \f$C\f$. The input !> and output matrices can have different row and column block dimensions. The input matrix !> \f$A\f$ is assumed !> to be allocated such that array \p bsr_row_ptr_A has length \p mb+1, \p bsr_col_ind_A has !> length \p nnzb, and !> \p bsr_val_A has length \p nnzb*row_block_dim_A*col_block_dim_A. The output matrix \f$C\f$ is !> assumed to be !> allocated such that array \p bsr_row_ptr_C has length \p mb_C+1, \p bsr_col_ind_C has length !> \p nnzb_C, and !> \p bsr_val_C has length \p nnzb_C*row_block_dim_C*col_block_dim_C where: !> \f[ !> m = mb * row\_block\_dim\_A \\% !> n = nb * col\_block\_dim\_A !> \f] !> and !> \f[ !> mb\_C = (m + row\_block\_dim\_C - 1) / row\_block\_dim\_C \\% !> nb\_C = (n + col\_block\_dim\_C - 1) / col\_block\_dim\_C !> \f] !> The number of non-zero blocks in the output sparse \f$C\f$ matrix (i.e. \p nnzb_C) is !> computed using !> `rocsparse_gebsr2gebsr_nnz`() which also fills in the \p bsr_row_ptr_C array. !> !> Converting from a sparse general BSR matrix to a sparse general BSR matrix requires three !> steps. First, !> call \ref rocsparse_sgebsr2gebsr_buffer_size "rocsparse_Xgebsr2gebsr_buffer_size()" !> to determine the size of the required temporary storage buffer. After this has been !> determined, !> allocate this buffer. Also allocate the \p bsr_row_ptr_C array to have length !> \p mb_C+1 and pass it to the function `rocsparse_gebsr2gebsr_nnz`. This will fill the \p !> bsr_row_ptr_C !> array and also compute the total number of non-zero blocks in the general BSR output \f$C\f$ !> matrix. Now that !> the total number of non-zero blocks is known, allocate the \p bsr_col_ind_C and \p bsr_val_C !> arrays. !> Finally, call \p rocsparse_gebsr2gebsr to complete the conversion. After the conversion is !> complete, !> the temporary storage buffer can be deallocated. See the example below. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - the storage format of the blocks, `rocsparse_direction_row` or !> `rocsparse_direction_column`. !> @param[in] mb - number of block rows of the general BSR sparse matrix \f$A\f$. !> @param[in] nb - number of block columns of the general BSR sparse matrix \f$A\f$. !> @param[in] nnzb - number of blocks in the general BSR sparse matrix \f$A\f$. !> @param[in] descr_A - the descriptor of the general BSR sparse matrix \f$A\f$. The supported !> matrix type is !> `rocsparse_matrix_type_general` and also any valid value of the !> `rocsparse_index_base`. !> @param[in] bsr_val_A - array of \p nnzb*row_block_dim_A*col_block_dim_A containing the values !> of the sparse general BSR matrix \f$A\f$. !> @param[in] bsr_row_ptr_A - array of \p mb+1 elements that point to the start of every block !> row of the !> sparse general BSR matrix \f$A\f$. !> @param[in] bsr_col_ind_A - array of \p nnzb elements containing the block column indices of !> the sparse general BSR matrix \f$A\f$. !> @param[in] row_block_dim_A - row size of the blocks in the sparse general BSR matrix \f$A\f$. !> @param[in] col_block_dim_A - column size of the blocks in the sparse general BSR matrix !> \f$A\f$. !> @param[in] descr_C - the descriptor of the general BSR sparse matrix \f$C\f$. The supported !> matrix type is !> `rocsparse_matrix_type_general` and also any valid value of the !> `rocsparse_index_base`. !> @param[in] bsr_val_C - array of \p nnzb_C*row_block_dim_C*col_block_dim_C containing the !> values of the sparse general BSR matrix \f$C\f$. !> @param[in] bsr_row_ptr_C - array of \p mb_C+1 elements that point to the start of every block !> row of the !> sparse general BSR matrix \f$C\f$. !> @param[in] bsr_col_ind_C - array of \p nnzb_C elements containing the block column indices of !> the sparse general BSR matrix \f$C\f$. !> @param[in] row_block_dim_C - row size of the blocks in the sparse general BSR matrix \f$C\f$. !> @param[in] col_block_dim_C - column size of the blocks in the sparse general BSR matrix !> \f$C\f$. !> @param[out] temp_buffer - buffer allocated by the user. Its size is determined by calling !> \ref rocsparse_sgebsr2gebsr_buffer_size !> "rocsparse_Xgebsr2gebsr_buffer_size()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nb, \p nnzb, \p row_block_dim_A, !> \p col_block_dim_A, \p row_block_dim_C, or \p col_block_dim_C is invalid. !> \retval rocsparse_status_invalid_pointer \p bsr_row_ptr_A, \p bsr_col_ind_A, \p bsr_val_A, !> \p bsr_row_ptr_C, \p bsr_col_ind_C, \p bsr_val_C, \p descr_A, \p descr_C, !> or \p temp_buffer pointer is invalid. !> !> \par Example !> This example converts a general BSR matrix into an general BSR matrix. interface rocsparse_sgebsr2gebsr function rocsparse_sgebsr2gebsr_(handle,dir,mb,nb,nnzb,descr_A,bsr_val_A,bsr_row_ptr_A, & bsr_col_ind_A,row_block_dim_A,col_block_dim_A,descr_C,bsr_val_C,bsr_row_ptr_C, & bsr_col_ind_C,row_block_dim_C,col_block_dim_C,temp_buffer) & bind(c, name="rocsparse_sgebsr2gebsr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsr2gebsr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descr_A type(c_ptr),value :: bsr_val_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A integer(c_int),value :: row_block_dim_A integer(c_int),value :: col_block_dim_A type(c_ptr),value :: descr_C type(c_ptr),value :: bsr_val_C type(c_ptr),value :: bsr_row_ptr_C type(c_ptr),value :: bsr_col_ind_C integer(c_int),value :: row_block_dim_C integer(c_int),value :: col_block_dim_C type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_dgebsr2gebsr function rocsparse_dgebsr2gebsr_(handle,dir,mb,nb,nnzb,descr_A,bsr_val_A,bsr_row_ptr_A, & bsr_col_ind_A,row_block_dim_A,col_block_dim_A,descr_C,bsr_val_C,bsr_row_ptr_C, & bsr_col_ind_C,row_block_dim_C,col_block_dim_C,temp_buffer) & bind(c, name="rocsparse_dgebsr2gebsr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsr2gebsr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descr_A type(c_ptr),value :: bsr_val_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A integer(c_int),value :: row_block_dim_A integer(c_int),value :: col_block_dim_A type(c_ptr),value :: descr_C type(c_ptr),value :: bsr_val_C type(c_ptr),value :: bsr_row_ptr_C type(c_ptr),value :: bsr_col_ind_C integer(c_int),value :: row_block_dim_C integer(c_int),value :: col_block_dim_C type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_cgebsr2gebsr function rocsparse_cgebsr2gebsr_(handle,dir,mb,nb,nnzb,descr_A,bsr_val_A,bsr_row_ptr_A, & bsr_col_ind_A,row_block_dim_A,col_block_dim_A,descr_C,bsr_val_C,bsr_row_ptr_C, & bsr_col_ind_C,row_block_dim_C,col_block_dim_C,temp_buffer) & bind(c, name="rocsparse_cgebsr2gebsr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsr2gebsr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descr_A type(c_ptr),value :: bsr_val_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A integer(c_int),value :: row_block_dim_A integer(c_int),value :: col_block_dim_A type(c_ptr),value :: descr_C type(c_ptr),value :: bsr_val_C type(c_ptr),value :: bsr_row_ptr_C type(c_ptr),value :: bsr_col_ind_C integer(c_int),value :: row_block_dim_C integer(c_int),value :: col_block_dim_C type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_zgebsr2gebsr function rocsparse_zgebsr2gebsr_(handle,dir,mb,nb,nnzb,descr_A,bsr_val_A,bsr_row_ptr_A, & bsr_col_ind_A,row_block_dim_A,col_block_dim_A,descr_C,bsr_val_C,bsr_row_ptr_C, & bsr_col_ind_C,row_block_dim_C,col_block_dim_C,temp_buffer) & bind(c, name="rocsparse_zgebsr2gebsr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsr2gebsr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descr_A type(c_ptr),value :: bsr_val_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A integer(c_int),value :: row_block_dim_A integer(c_int),value :: col_block_dim_A type(c_ptr),value :: descr_C type(c_ptr),value :: bsr_val_C type(c_ptr),value :: bsr_row_ptr_C type(c_ptr),value :: bsr_col_ind_C integer(c_int),value :: row_block_dim_C integer(c_int),value :: col_block_dim_C type(c_ptr),value :: temp_buffer end function end interface !> \ingroup conv_module !> \details !> \p rocsparse_hyb2csr_buffer_size returns the size of the temporary storage buffer !> required by \ref rocsparse_shyb2csr "rocsparse_Xhyb2csr()". The temporary storage !> buffer must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] descr - descriptor of the sparse HYB matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] hyb - sparse matrix in HYB format. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> \ref rocsparse_shyb2csr "rocsparse_Xhyb2csr()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p descr, \p hyb, \p csr_row_ptr, or !> \p buffer_size pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_hyb2csr_buffer_size function rocsparse_hyb2csr_buffer_size_(handle,descr,hyb,csr_row_ptr,buffer_size) & bind(c, name="rocsparse_hyb2csr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_hyb2csr_buffer_size_ type(c_ptr),value :: handle type(c_ptr),value :: descr type(c_ptr),value :: hyb type(c_ptr),value :: csr_row_ptr integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_hyb2csr_buffer_size_assumed_rank #else module procedure & rocsparse_hyb2csr_buffer_size_rank_0,& rocsparse_hyb2csr_buffer_size_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert a sparse HYB matrix into a sparse CSR matrix. !> !> \details !> \p rocsparse_hyb2csr converts a HYB matrix into a CSR matrix. This requires a HYB input !> structure, !> `rocsparse_hyb_mat`, which is created using `rocsparse_create_hyb_mat` and is filled with !> data !> using the conversion routine \ref rocsparse_scsr2hyb "rocsparse_Xcsr2hyb()". !> !> Converting back to a sparse CSR matrix from a sparse HYB matrix requires two steps. First, !> call !> `rocsparse_hyb2csr_buffer_size` to determine the size of the required temporary !> storage buffer. After this is determined, allocate this buffer. Finally, call !> \ref rocsparse_shyb2csr "rocsparse_Xhyb2csr()" to complete the conversion. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] descr - descriptor of the sparse HYB matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] hyb - sparse matrix in HYB format. !> @param[out] csr_val - array containing the values of the sparse CSR matrix. !> @param[out] csr_row_ptr - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix. !> @param[out] csr_col_ind - array containing the column indices of the sparse CSR matrix. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. The size is returned !> by !> `rocsparse_hyb2csr_buffer_size`(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p descr, \p hyb, \p csr_val, !> \p csr_row_ptr, \p csr_col_ind, or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> This example converts a HYB matrix into a CSR matrix. interface rocsparse_shyb2csr function rocsparse_shyb2csr_(handle,descr,hyb,csr_val,csr_row_ptr,csr_col_ind,temp_buffer) & bind(c, name="rocsparse_shyb2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_shyb2csr_ type(c_ptr),value :: handle type(c_ptr),value :: descr type(c_ptr),value :: hyb type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_shyb2csr_assumed_rank #else module procedure & rocsparse_shyb2csr_rank_0,& rocsparse_shyb2csr_rank_1 #endif #endif end interface interface rocsparse_dhyb2csr function rocsparse_dhyb2csr_(handle,descr,hyb,csr_val,csr_row_ptr,csr_col_ind,temp_buffer) & bind(c, name="rocsparse_dhyb2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dhyb2csr_ type(c_ptr),value :: handle type(c_ptr),value :: descr type(c_ptr),value :: hyb type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dhyb2csr_assumed_rank #else module procedure & rocsparse_dhyb2csr_rank_0,& rocsparse_dhyb2csr_rank_1 #endif #endif end interface interface rocsparse_chyb2csr function rocsparse_chyb2csr_(handle,descr,hyb,csr_val,csr_row_ptr,csr_col_ind,temp_buffer) & bind(c, name="rocsparse_chyb2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_chyb2csr_ type(c_ptr),value :: handle type(c_ptr),value :: descr type(c_ptr),value :: hyb type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_chyb2csr_assumed_rank #else module procedure & rocsparse_chyb2csr_rank_0,& rocsparse_chyb2csr_rank_1 #endif #endif end interface interface rocsparse_zhyb2csr function rocsparse_zhyb2csr_(handle,descr,hyb,csr_val,csr_row_ptr,csr_col_ind,temp_buffer) & bind(c, name="rocsparse_zhyb2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zhyb2csr_ type(c_ptr),value :: handle type(c_ptr),value :: descr type(c_ptr),value :: hyb type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zhyb2csr_assumed_rank #else module procedure & rocsparse_zhyb2csr_rank_0,& rocsparse_zhyb2csr_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Create the identity map. !> !> \details !> \p rocsparse_create_identity_permutation stores the identity map in \p p, such that !> \f$p = 0:1:(n-1)\f$. !> !> \code{.c} !> for(i = 0; i < n; ++i) !> { !> p[i] = i; !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] n - size of the map \p p. !> @param[out] p - array of \p n integers containing the map. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p n is invalid. !> \retval rocsparse_status_invalid_pointer \p p pointer is invalid. !> !> \par Example !> The following example creates an identity permutation. interface rocsparse_create_identity_permutation function rocsparse_create_identity_permutation_(handle,n,p) & bind(c, name="rocsparse_create_identity_permutation") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_identity_permutation_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: p end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_create_identity_permutation_assumed_rank #else module procedure & rocsparse_create_identity_permutation_rank_0,& rocsparse_create_identity_permutation_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Inverse a permutation vector. !> !> \details !> \p rocsparse_inverse_permutation computes !> !> \code{.c} !> for(i = 0; i < n; ++i) !> { !> q[p[i]- base] = i + base; !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] n - size of the permutation vector \p p. !> @param[in] p - array of \p n integers containing the permutation vector to inverse. !> @param[out] q - array of \p n integers containing the invsrse of the permutation vector. !> @param[in] base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p n is invalid. !> \retval rocsparse_status_invalid_pointer \p p pointer is invalid or \p q pointer is invalid. !> \retval rocsparse_status_invalid_value \p base is invalid. interface rocsparse_inverse_permutation function rocsparse_inverse_permutation_(handle,n,p,q,base) & bind(c, name="rocsparse_inverse_permutation") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_inverse_permutation_ type(c_ptr),value :: handle integer(c_int),value :: n type(c_ptr),value :: p type(c_ptr),value :: q integer(kind(rocsparse_index_base_zero)),value :: base end function end interface !> \ingroup conv_module !> \brief Create the identity map. !> !> \details !> \p rocsparse_set_identity_permutation stores the identity map in \p p, such that !> \f$p = 0:1:(n-1)\f$. !> !> \code{.c} !> for(i = 0; i < n; ++i) !> { !> p[i] = i; !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] n - size of the map \p p. !> @param[out] p - array of \p n integers containing the map. !> @param[in] indextype - the integer type of \p p. Can be \p rocsparse_indextype_i32 or \p !> rocsparse_indextype_i64. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p n is invalid. !> \retval rocsparse_status_not_implemented if \p indextype is rocsparse_indextype_u16. !> \retval rocsparse_status_invalid_pointer \p p pointer is invalid. !> !> \par Example !> The following example creates an identity permutation. !> \code{.c} !> int32_t size = 200; !> !> // Allocate memory to hold the identity map !> int32_t* perm; !> hipMalloc((void**)&perm, sizeof(int32_t) * size); !> !> // Fill perm with the identity permutation !> rocsparse_set_identity_permutation(handle, size, (void*)perm, rocsparse_indextype_i32); !> \endcode interface rocsparse_set_identity_permutation function rocsparse_set_identity_permutation_(handle,n,p,indextype) & bind(c, name="rocsparse_set_identity_permutation") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_set_identity_permutation_ type(c_ptr),value :: handle integer(c_int64_t),value :: n type(c_ptr),value :: p integer(kind(rocsparse_indextype_i32)),value :: indextype end function end interface !> \ingroup conv_module !> \details !> This function computes the number of non-zero elements per row or column and the total number !> of non-zero elements !> in a dense matrix. !> !> \note !> The routine supports asynchronous execution if the pointer mode is set to device. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - direction that specifies whether to count non-zero elements by !> `rocsparse_direction_row` or by !> `rocsparse_direction_column`. !> @param[in] m - number of rows of the dense matrix \p A. !> @param[in] n - number of columns of the dense matrix \p A. !> @param[in] descr - the descriptor of the dense matrix \p A. !> @param[in] A - array of dimensions (\p ld, \p n). !> @param[in] ld - leading dimension of dense array \p A. !> @param[out] nnz_per_row_columns - array of size \p m or \p n containing the number of !> non-zero elements per row or column, respectively. !> @param[out] nnz_total_dev_host_ptr - total number of non-zero elements in device or host !> memory. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p ld is invalid. !> \retval rocsparse_status_invalid_pointer \p A, \p nnz_per_row_columns, or \p !> nnz_total_dev_host_ptr !> pointer is invalid. !> !> \par Example interface rocsparse_snnz function rocsparse_snnz_(handle,dir,m,n,descr,A,ld,nnz_per_row_columns,nnz_total_dev_host_ptr) & bind(c, name="rocsparse_snnz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_snnz_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_snnz_assumed_rank #else module procedure & rocsparse_snnz_rank_0,& rocsparse_snnz_rank_1,& rocsparse_snnz_full_rank #endif #endif end interface interface rocsparse_dnnz function rocsparse_dnnz_(handle,dir,m,n,descr,A,ld,nnz_per_row_columns,nnz_total_dev_host_ptr) & bind(c, name="rocsparse_dnnz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dnnz_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dnnz_assumed_rank #else module procedure & rocsparse_dnnz_rank_0,& rocsparse_dnnz_rank_1,& rocsparse_dnnz_full_rank #endif #endif end interface interface rocsparse_cnnz function rocsparse_cnnz_(handle,dir,m,n,descr,A,ld,nnz_per_row_columns,nnz_total_dev_host_ptr) & bind(c, name="rocsparse_cnnz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cnnz_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cnnz_assumed_rank #else module procedure & rocsparse_cnnz_rank_0,& rocsparse_cnnz_rank_1,& rocsparse_cnnz_full_rank #endif #endif end interface interface rocsparse_znnz function rocsparse_znnz_(handle,dir,m,n,descr,A,ld,nnz_per_row_columns,nnz_total_dev_host_ptr) & bind(c, name="rocsparse_znnz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_znnz_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr type(c_ptr),value :: A integer(c_int),value :: ld type(c_ptr),value :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_znnz_assumed_rank #else module procedure & rocsparse_znnz_rank_0,& rocsparse_znnz_rank_1,& rocsparse_znnz_full_rank #endif #endif end interface !> \ingroup conv_module !> Given a sparse CSR matrix and a non-negative tolerance, this function computes how many !> entries would be left !> in each row of the matrix if elements less than the tolerance were removed. It also computes !> the total number !> of remaining elements in the matrix. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> !> @param[in] m - number of rows of the sparse CSR matrix. !> !> @param[in] descr_A - the descriptor of the sparse CSR matrix. !> !> @param[in] csr_val_A - array of \p nnz_A elements of the sparse CSR matrix. !> @param[in] csr_row_ptr_A - array of \p m+1 elements that point to the start of every row of !> the !> uncompressed sparse CSR matrix. !> @param[out] nnz_per_row - array of length \p m containing the number of entries that will be !> kept per row in !> the final compressed CSR matrix. !> @param[out] nnz_C - number of elements in the column indices and values arrays of the !> compressed !> sparse CSR matrix. It can be either a host or device pointer. !> @param[in] tol - the non-negative tolerance used for compression. If \p tol is complex, then !> only the magnitude !> of the real part is used. Entries in the input uncompressed CSR array that are !> below the tolerance !> are removed in the output compressed CSR matrix. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p n is invalid. !> \retval rocsparse_status_invalid_value \p tol is invalid. !> \retval rocsparse_status_invalid_pointer \p csr_val_A, \p csr_row_ptr_A, \p nnz_per_row, or !> \p nnz_C !> pointer is invalid. !> !> \par Example interface rocsparse_snnz_compress function rocsparse_snnz_compress_(handle,m,descr_A,csr_val_A,csr_row_ptr_A,nnz_per_row,nnz_C, & tol) & bind(c, name="rocsparse_snnz_compress") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_snnz_compress_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: nnz_per_row type(c_ptr),value :: nnz_C real(c_float),value :: tol end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_snnz_compress_assumed_rank #else module procedure & rocsparse_snnz_compress_rank_0,& rocsparse_snnz_compress_rank_1 #endif #endif end interface interface rocsparse_dnnz_compress function rocsparse_dnnz_compress_(handle,m,descr_A,csr_val_A,csr_row_ptr_A,nnz_per_row,nnz_C, & tol) & bind(c, name="rocsparse_dnnz_compress") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dnnz_compress_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: nnz_per_row type(c_ptr),value :: nnz_C real(c_double),value :: tol end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dnnz_compress_assumed_rank #else module procedure & rocsparse_dnnz_compress_rank_0,& rocsparse_dnnz_compress_rank_1 #endif #endif end interface interface rocsparse_cnnz_compress function rocsparse_cnnz_compress_(handle,m,descr_A,csr_val_A,csr_row_ptr_A,nnz_per_row,nnz_C, & tol) & bind(c, name="rocsparse_cnnz_compress") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cnnz_compress_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: nnz_per_row type(c_ptr),value :: nnz_C complex(c_float_complex),value :: tol end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cnnz_compress_assumed_rank #else module procedure & rocsparse_cnnz_compress_rank_0,& rocsparse_cnnz_compress_rank_1 #endif #endif end interface interface rocsparse_znnz_compress function rocsparse_znnz_compress_(handle,m,descr_A,csr_val_A,csr_row_ptr_A,nnz_per_row,nnz_C, & tol) & bind(c, name="rocsparse_znnz_compress") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_znnz_compress_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: nnz_per_row type(c_ptr),value :: nnz_C complex(c_double_complex),value :: tol end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_znnz_compress_assumed_rank #else module procedure & rocsparse_znnz_compress_rank_0,& rocsparse_znnz_compress_rank_1 #endif #endif end interface !> \ingroup conv_module !> \details !> \p rocsparse_prune_csr2csr_buffer_size returns the size of the temporary buffer that !> is required by \ref rocsparse_sprune_csr2csr_nnz "rocsparse_Xprune_csr2csr_nnz()" and !> \ref rocsparse_sprune_csr2csr "rocsparse_Xprune_csr2csr()". The temporary storage !> buffer must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows in the sparse CSR matrix. !> @param[in] n - number of columns in the sparse CSR matrix. !> @param[in] nnz_A - number of non-zeros in the sparse CSR matrix \f$A\f$. !> @param[in] csr_descr_A - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csr_val_A - array of \p nnz_A elements containing the values of the sparse CSR !> matrix \f$A\f$. !> @param[in] csr_row_ptr_A - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$A\f$. !> @param[in] csr_col_ind_A - array of \p nnz_A elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] threshold - pointer to the non-negative pruning threshold, which can exist in !> either host or device memory. !> @param[in] csr_descr_C - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csr_val_C - array of \p nnz_C elements containing the values of the sparse CSR !> matrix \f$C\f$. !> @param[in] csr_row_ptr_C - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$C\f$. !> @param[in] csr_col_ind_C - array of \p nnz_C elements containing the column indices of the !> sparse CSR matrix \f$C\f$. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> \ref rocsparse_sprune_csr2csr_nnz "rocsparse_Xprune_csr2csr_nnz()" and !> \ref rocsparse_sprune_csr2csr "rocsparse_Xprune_csr2csr()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p buffer_size pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_sprune_csr2csr_buffer_size function rocsparse_sprune_csr2csr_buffer_size_(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,threshold,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C, & buffer_size) & bind(c, name="rocsparse_sprune_csr2csr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz_A type(c_ptr),value :: csr_descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A real(c_float) :: threshold type(c_ptr),value :: csr_descr_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sprune_csr2csr_buffer_size_assumed_rank #else module procedure & rocsparse_sprune_csr2csr_buffer_size_rank_0,& rocsparse_sprune_csr2csr_buffer_size_rank_1 #endif #endif end interface interface rocsparse_dprune_csr2csr_buffer_size function rocsparse_dprune_csr2csr_buffer_size_(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,threshold,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C, & buffer_size) & bind(c, name="rocsparse_dprune_csr2csr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz_A type(c_ptr),value :: csr_descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A real(c_double) :: threshold type(c_ptr),value :: csr_descr_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dprune_csr2csr_buffer_size_assumed_rank #else module procedure & rocsparse_dprune_csr2csr_buffer_size_rank_0,& rocsparse_dprune_csr2csr_buffer_size_rank_1 #endif #endif end interface !> \ingroup conv_module !> \details !> \p rocsparse_prune_csr2csr_nnz computes the number of non-zero elements per row and the total !> number of non-zero elements in a sparse CSR matrix after elements less than the threshold are !> pruned from the matrix. !> !> \note The routine supports asynchronous execution if the pointer mode is set to device. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows in the sparse CSR matrix. !> @param[in] n - number of columns in the sparse CSR matrix. !> @param[in] nnz_A - number of non-zeros in the sparse CSR matrix \f$A\f$. !> @param[in] csr_descr_A - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csr_val_A - array of \p nnz_A elements containing the values of the sparse CSR !> matrix \f$A\f$. !> @param[in] csr_row_ptr_A - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$A\f$. !> @param[in] csr_col_ind_A - array of \p nnz_A elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] threshold - pointer to the non-negative pruning threshold which can exist in !> either host or device memory. !> @param[in] csr_descr_C - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] csr_row_ptr_C - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$C\f$. !> @param[out] nnz_total_dev_host_ptr - total number of non-zero elements in device or host !> memory. !> @param[out] temp_buffer - buffer allocated by the user. Its size is determined by calling !> \ref rocsparse_sprune_csr2csr_buffer_size !> "rocsparse_Xprune_csr2csr_buffer_size()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz_A is invalid. !> \retval rocsparse_status_invalid_pointer \p threshold, \p csr_descr_A, \p csr_descr_C, \p !> csr_val_A, !> \p csr_row_ptr_A, \p csr_col_ind_A, \p csr_row_ptr_C, \p nnz_total_dev_host_ptr, !> or \p temp_buffer pointer is invalid. interface rocsparse_sprune_csr2csr_nnz function rocsparse_sprune_csr2csr_nnz_(handle,m,n,nnz_A,csr_descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,threshold,csr_descr_C,csr_row_ptr_C,nnz_total_dev_host_ptr,temp_buffer) & bind(c, name="rocsparse_sprune_csr2csr_nnz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_nnz_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz_A type(c_ptr),value :: csr_descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A real(c_float) :: threshold type(c_ptr),value :: csr_descr_C type(c_ptr),value :: csr_row_ptr_C integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sprune_csr2csr_nnz_assumed_rank #else module procedure & rocsparse_sprune_csr2csr_nnz_rank_0,& rocsparse_sprune_csr2csr_nnz_rank_1 #endif #endif end interface interface rocsparse_dprune_csr2csr_nnz function rocsparse_dprune_csr2csr_nnz_(handle,m,n,nnz_A,csr_descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,threshold,csr_descr_C,csr_row_ptr_C,nnz_total_dev_host_ptr,temp_buffer) & bind(c, name="rocsparse_dprune_csr2csr_nnz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_nnz_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz_A type(c_ptr),value :: csr_descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A real(c_double) :: threshold type(c_ptr),value :: csr_descr_C type(c_ptr),value :: csr_row_ptr_C integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dprune_csr2csr_nnz_assumed_rank #else module procedure & rocsparse_dprune_csr2csr_nnz_rank_0,& rocsparse_dprune_csr2csr_nnz_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert and prune sparse CSR matrix \f$A\f$ into a sparse CSR matrix \f$C\f$. !> !> \details !> This function converts the sparse CSR matrix \f$A\f$ into a sparse CSR matrix \f$C\f$ by !> pruning values in \f$A\f$ !> that are less than a threshold. !> !> The conversion involves three steps. First, call !> \ref rocsparse_sprune_csr2csr_buffer_size "rocsparse_Xprune_csr2csr_buffer_size()" !> to determine the size of the temporary storage buffer. Allocate this buffer as well as the !> array !> \p csr_row_ptr_C to have \p m+1 elements. Then call !> \ref rocsparse_sprune_csr2csr_nnz "rocsparse_Xprune_csr2csr_nnz()", which fills !> in the \p csr_row_ptr_C array and stores the number of elements that are larger than the !> pruning threshold !> in \p nnz_total_dev_host_ptr. Now that the number of non-zeros larger than the pruning !> threshold is known, !> use this information to allocate the \p csr_col_ind_C and \p csr_val_C arrays and then call !> \p rocsparse_prune_csr2csr to complete the conversion. After the conversion is complete, the !> temporary storage !> buffer can be freed. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows in the sparse CSR matrix. !> @param[in] n - number of columns in the sparse CSR matrix. !> @param[in] nnz_A - number of non-zeros in the sparse CSR matrix \f$A\f$. !> @param[in] csr_descr_A - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csr_val_A - array of \p nnz_A elements containing the values of the sparse CSR !> matrix \f$A\f$. !> @param[in] csr_row_ptr_A - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$A\f$. !> @param[in] csr_col_ind_A - array of \p nnz_A elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] threshold - pointer to the non-negative pruning threshold, which can exist in !> either host or device memory. !> @param[in] csr_descr_C - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] csr_val_C - array of \p nnz_C elements containing the values of the sparse CSR !> matrix \f$C\f$. !> @param[in] csr_row_ptr_C - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$C\f$. !> @param[out] csr_col_ind_C - array of \p nnz_C elements containing the column indices of the !> sparse CSR matrix \f$C\f$. !> @param[in] temp_buffer - buffer allocated by the user. Its size is determined by calling !> \ref rocsparse_sprune_csr2csr_buffer_size !> "rocsparse_Xprune_csr2csr_buffer_size()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz_A is invalid. !> \retval rocsparse_status_invalid_pointer \p threshold, \p csr_descr_A, \p csr_descr_C, \p !> csr_val_A, !> \p csr_row_ptr_A, \p csr_col_ind_A, \p csr_val_C, \p csr_row_ptr_C, \p !> csr_col_ind_C, !> or \p temp_buffer pointer is invalid. !> !> \par Example interface rocsparse_sprune_csr2csr function rocsparse_sprune_csr2csr_(handle,m,n,nnz_A,csr_descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,threshold,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C,temp_buffer) & bind(c, name="rocsparse_sprune_csr2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz_A type(c_ptr),value :: csr_descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A real(c_float) :: threshold type(c_ptr),value :: csr_descr_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sprune_csr2csr_assumed_rank #else module procedure & rocsparse_sprune_csr2csr_rank_0,& rocsparse_sprune_csr2csr_rank_1 #endif #endif end interface interface rocsparse_dprune_csr2csr function rocsparse_dprune_csr2csr_(handle,m,n,nnz_A,csr_descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,threshold,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C,temp_buffer) & bind(c, name="rocsparse_dprune_csr2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz_A type(c_ptr),value :: csr_descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A real(c_double) :: threshold type(c_ptr),value :: csr_descr_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dprune_csr2csr_assumed_rank #else module procedure & rocsparse_dprune_csr2csr_rank_0,& rocsparse_dprune_csr2csr_rank_1 #endif #endif end interface !> \ingroup conv_module !> \details !> \p rocsparse_prune_csr2csr_by_percentage_buffer_size returns the size of the temporary buffer !> that !> is required by \ref rocsparse_sprune_csr2csr_nnz_by_percentage !> "rocsparse_Xprune_csr2csr_nnz_by_percentage()" !> and \ref rocsparse_sprune_csr2csr_by_percentage "rocsparse_Xprune_csr2csr_by_percentage()". !> The temporary !> storage buffer must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows in the sparse CSR matrix. !> @param[in] n - number of columns in the sparse CSR matrix. !> @param[in] nnz_A - number of non-zeros in the sparse CSR matrix \f$A\f$. !> @param[in] csr_descr_A - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csr_val_A - array of \p nnz_A elements containing the values of the sparse CSR !> matrix \f$A\f$. !> @param[in] csr_row_ptr_A - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$A\f$. !> @param[in] csr_col_ind_A - array of \p nnz_A elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] percentage - \p percentage>=0 and \p percentage<=100. !> @param[in] csr_descr_C - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csr_val_C - array of \p nnz_C elements containing the values of the sparse CSR !> matrix \f$C\f$. !> @param[in] csr_row_ptr_C - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$C\f$. !> @param[in] csr_col_ind_C - array of \p nnz_C elements containing the column indices of the !> sparse CSR matrix \f$C\f$. !> @param[in] myInfo - prune info structure. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> \ref rocsparse_sprune_csr2csr_nnz_by_percentage !> "rocsparse_Xprune_csr2csr_nnz_by_percentage()" and !> \ref rocsparse_sprune_csr2csr_by_percentage !> "rocsparse_Xprune_csr2csr_by_percentage()" !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p buffer_size pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_sprune_csr2csr_by_percentage_buffer_size function rocsparse_sprune_csr2csr_by_percentage_buffer_size_(handle,m,n,nnz_A,csr_descr_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,myInfo,buffer_size) & bind(c, name="rocsparse_sprune_csr2csr_by_percentage_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_by_percentage_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz_A type(c_ptr),value :: csr_descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A real(c_float),value :: percentage type(c_ptr),value :: csr_descr_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sprune_csr2csr_by_percentage_buffer_size_assumed_rank #else module procedure & rocsparse_sprune_csr2csr_by_percentage_buffer_size_rank_0,& rocsparse_sprune_csr2csr_by_percentage_buffer_size_rank_1 #endif #endif end interface interface rocsparse_dprune_csr2csr_by_percentage_buffer_size function rocsparse_dprune_csr2csr_by_percentage_buffer_size_(handle,m,n,nnz_A,csr_descr_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,myInfo,buffer_size) & bind(c, name="rocsparse_dprune_csr2csr_by_percentage_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_by_percentage_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz_A type(c_ptr),value :: csr_descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A real(c_double),value :: percentage type(c_ptr),value :: csr_descr_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dprune_csr2csr_by_percentage_buffer_size_assumed_rank #else module procedure & rocsparse_dprune_csr2csr_by_percentage_buffer_size_rank_0,& rocsparse_dprune_csr2csr_by_percentage_buffer_size_rank_1 #endif #endif end interface !> \ingroup conv_module !> \details !> \p rocsparse_prune_csr2csr_nnz_by_percentage computes the number of non-zero elements per row !> and the total !> number of non-zero elements in a sparse CSR matrix after a \p percentage of the smallest !> magnitude elements !> have been pruned from the sparse CSR input matrix. See !> \ref rocsparse_sprune_csr2csr_by_percentage "rocsparse_sprune_csr2csr_by_percentage()" for a !> more detailed !> description of how this pruning based on \p percentage works. !> !> \note The routine supports asynchronous execution if the pointer mode is set to device. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows in the sparse CSR matrix. !> @param[in] n - number of columns in the sparse CSR matrix. !> @param[in] nnz_A - number of non-zeros in the sparse CSR matrix \f$A\f$. !> @param[in] csr_descr_A - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csr_val_A - array of \p nnz_A elements containing the values of the sparse CSR !> matrix \f$A\f$. !> @param[in] csr_row_ptr_A - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$A\f$. !> @param[in] csr_col_ind_A - array of \p nnz_A elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] percentage - \p percentage>=0 and \p percentage<=100. !> @param[in] csr_descr_C - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] csr_row_ptr_C - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$C\f$. !> @param[out] nnz_total_dev_host_ptr - total number of non-zero elements in device or host !> memory. !> @param[in] myInfo - prune info structure. !> @param[out] temp_buffer - buffer allocated by the user. Its size is determined by calling !> \ref rocsparse_sprune_csr2csr_by_percentage_buffer_size !> "rocsparse_Xprune_csr2csr_by_percentage_buffer_size()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, \p nnz_A, or \p percentage is invalid. !> \retval rocsparse_status_invalid_pointer \p csr_descr_A, \p csr_descr_C, \p info, \p !> csr_val_A, !> \p csr_row_ptr_A, \p csr_col_ind_A, \p csr_row_ptr_C, \p nnz_total_dev_host_ptr, !> or \p temp_buffer pointer is invalid. interface rocsparse_sprune_csr2csr_nnz_by_percentage function rocsparse_sprune_csr2csr_nnz_by_percentage_(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_row_ptr_C,nnz_total_dev_host_ptr, & myInfo,temp_buffer) & bind(c, name="rocsparse_sprune_csr2csr_nnz_by_percentage") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_nnz_by_percentage_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz_A type(c_ptr),value :: csr_descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A real(c_float),value :: percentage type(c_ptr),value :: csr_descr_C type(c_ptr),value :: csr_row_ptr_C integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr),value :: myInfo type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sprune_csr2csr_nnz_by_percentage_assumed_rank #else module procedure & rocsparse_sprune_csr2csr_nnz_by_percentage_rank_0,& rocsparse_sprune_csr2csr_nnz_by_percentage_rank_1 #endif #endif end interface interface rocsparse_dprune_csr2csr_nnz_by_percentage function rocsparse_dprune_csr2csr_nnz_by_percentage_(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_row_ptr_C,nnz_total_dev_host_ptr, & myInfo,temp_buffer) & bind(c, name="rocsparse_dprune_csr2csr_nnz_by_percentage") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_nnz_by_percentage_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz_A type(c_ptr),value :: csr_descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A real(c_double),value :: percentage type(c_ptr),value :: csr_descr_C type(c_ptr),value :: csr_row_ptr_C integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr),value :: myInfo type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dprune_csr2csr_nnz_by_percentage_assumed_rank #else module procedure & rocsparse_dprune_csr2csr_nnz_by_percentage_rank_0,& rocsparse_dprune_csr2csr_nnz_by_percentage_rank_1 #endif #endif end interface !> \ingroup conv_module !> \brief Convert and prune by percentage a sparse CSR matrix \f$A\f$ into a sparse CSR matrix !> \f$C\f$. !> !> \details !> This function converts the sparse CSR matrix \f$A\f$ into a sparse CSR matrix \f$C\f$ by !> pruning values in \f$A\f$ !> that are less than a threshold. This threshold is determined by using a \p percentage and the !> following steps: !> !> Step 1: First, the \p csr_val_A array is sorted in ascending order using the absolute value !> of each entry: !> \f[ !> csr\_val\_A\_sorted = sort(abs(csr\_val\_A)) !> \f] !> !> Step 2: Next, use the \p percentage parameter to determine the threshold: !> \f[ !> pos = ceil(nnz\_A \times (percentage/100)) - 1 \\% !> pos = \min(pos, nnz\_A - 1) \\% !> pos = \max(pos, 0) \\% !> threshold = csr\_val\_A\_sorted[pos] !> \f] !> !> Step 3: Finally, use this threshold with the routine !> \ref rocsparse_sprune_csr2csr "rocsparse_Xprune_csr2csr()" to complete the conversion. !> !> The conversion involves three steps. First, call !> \ref rocsparse_sprune_csr2csr_by_percentage_buffer_size !> "rocsparse_Xprune_csr2csr_by_percentage_buffer_size()" !> to determine the size of the temporary storage buffer. Allocate this buffer as well as the !> array !> \p csr_row_ptr_C to have \p m+1 elements. Then call !> \ref rocsparse_sprune_csr2csr_nnz_by_percentage !> "rocsparse_Xprune_csr2csr_nnz_by_percentage()" which fills !> in the \p csr_row_ptr_C array and stores the number of elements that are larger than the !> pruning threshold !> in \p nnz_total_dev_host_ptr. Now that the number of non-zeros larger than the pruning !> threshold is known, !> use this information to allocate the \p csr_col_ind_C and \p csr_val_C arrays and then call !> \p rocsparse_prune_csr2csr_by_percentage to complete the conversion. After the conversion is !> complete, the !> temporary storage buffer can be freed. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows in the sparse CSR matrix. !> @param[in] n - number of columns in the sparse CSR matrix. !> @param[in] nnz_A - number of non-zeros in the sparse CSR matrix \f$A\f$. !> @param[in] csr_descr_A - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csr_val_A - array of \p nnz_A elements containing the values of the sparse CSR !> matrix \f$A\f$. !> @param[in] csr_row_ptr_A - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$A\f$. !> @param[in] csr_col_ind_A - array of \p nnz_A elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] percentage - \p percentage>=0 and \p percentage<=100. !> @param[in] csr_descr_C - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] csr_val_C - array of \p nnz_C elements containing the values of the sparse CSR !> matrix \f$C\f$. !> @param[in] csr_row_ptr_C - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$C\f$. !> @param[out] csr_col_ind_C - array of \p nnz_C elements containing the column indices of the !> sparse CSR matrix \f$C\f$. !> @param[in] myInfo - prune info structure. !> @param[in] temp_buffer - buffer allocated by the user. Its size is determined by calling !> \ref rocsparse_sprune_csr2csr_buffer_size !> "rocsparse_Xprune_csr2csr_buffer_size()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, \p nnz_A, or \p percentage is invalid. !> \retval rocsparse_status_invalid_pointer \p csr_descr_A, \p csr_descr_C, \p info, \p !> csr_val_A, !> \p csr_row_ptr_A, \p csr_col_ind_A, \p csr_val_C, \p csr_row_ptr_C, \p !> csr_col_ind_C, !> or \p temp_buffer pointer is invalid. !> !> \par Example interface rocsparse_sprune_csr2csr_by_percentage function rocsparse_sprune_csr2csr_by_percentage_(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C, & myInfo,temp_buffer) & bind(c, name="rocsparse_sprune_csr2csr_by_percentage") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_by_percentage_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz_A type(c_ptr),value :: csr_descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A real(c_float),value :: percentage type(c_ptr),value :: csr_descr_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C type(c_ptr),value :: myInfo type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sprune_csr2csr_by_percentage_assumed_rank #else module procedure & rocsparse_sprune_csr2csr_by_percentage_rank_0,& rocsparse_sprune_csr2csr_by_percentage_rank_1 #endif #endif end interface interface rocsparse_dprune_csr2csr_by_percentage function rocsparse_dprune_csr2csr_by_percentage_(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C, & myInfo,temp_buffer) & bind(c, name="rocsparse_dprune_csr2csr_by_percentage") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_by_percentage_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz_A type(c_ptr),value :: csr_descr_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A real(c_double),value :: percentage type(c_ptr),value :: csr_descr_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C type(c_ptr),value :: myInfo type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dprune_csr2csr_by_percentage_assumed_rank #else module procedure & rocsparse_dprune_csr2csr_by_percentage_rank_0,& rocsparse_dprune_csr2csr_by_percentage_rank_1 #endif #endif end interface !> \ingroup conv_module !> \details !> \p rocsparse_prune_dense2csr_buffer_size returns the size of the temporary buffer that !> is required by \ref rocsparse_sprune_dense2csr_nnz "rocsparse_Xprune_dense2csr_nnz()" and !> \ref rocsparse_sprune_dense2csr "rocsparse_Xprune_dense2csr()". The temporary storage !> buffer must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the dense matrix \p A. !> @param[in] n - number of columns of the dense matrix \p A. !> @param[in] A - array of dimensions (\p lda, \p n). !> @param[in] lda - leading dimension of dense array \p A. !> @param[in] threshold - pointer to the pruning non-negative threshold which can exist in !> either host or device memory. !> @param[in] descr - the descriptor of the dense matrix \p A, the supported matrix type is !> `rocsparse_matrix_type_general` and !> also any valid value of the `rocsparse_index_base`. !> @param[in] csr_val - array of nnz ( = \p csr_row_ptr[m] - \p csr_row_ptr[0] ) non-zero !> elements of matrix \p A. !> @param[in] csr_row_ptr - integer array of \p m+1 elements that contains the start of every !> row and the end of the last row plus one. !> @param[in] csr_col_ind - integer array of nnz ( = \p csr_row_ptr[m] - \p csr_row_ptr[0] ) !> column indices of the non-zero elements of matrix \p A. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> \ref rocsparse_sprune_dense2csr_nnz "rocsparse_Xprune_dense2csr_nnz()" and !> \ref rocsparse_sprune_dense2csr "rocsparse_Xprune_dense2csr()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p buffer_size pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_sprune_dense2csr_buffer_size function rocsparse_sprune_dense2csr_buffer_size_(handle,m,n,A,lda,threshold,descr,csr_val, & csr_row_ptr,csr_col_ind,buffer_size) & bind(c, name="rocsparse_sprune_dense2csr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_buffer_size_ 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 real(c_float) :: threshold type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sprune_dense2csr_buffer_size_assumed_rank #else module procedure & rocsparse_sprune_dense2csr_buffer_size_rank_0,& rocsparse_sprune_dense2csr_buffer_size_rank_1,& rocsparse_sprune_dense2csr_buffer_size_full_rank #endif #endif end interface interface rocsparse_dprune_dense2csr_buffer_size function rocsparse_dprune_dense2csr_buffer_size_(handle,m,n,A,lda,threshold,descr,csr_val, & csr_row_ptr,csr_col_ind,buffer_size) & bind(c, name="rocsparse_dprune_dense2csr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_buffer_size_ 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 real(c_double) :: threshold type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dprune_dense2csr_buffer_size_assumed_rank #else module procedure & rocsparse_dprune_dense2csr_buffer_size_rank_0,& rocsparse_dprune_dense2csr_buffer_size_rank_1,& rocsparse_dprune_dense2csr_buffer_size_full_rank #endif #endif end interface !> \ingroup conv_module !> \details !> \p rocsparse_prune_dense2csr_nnz computes the number of non-zero elements per row and the !> total !> number of non-zero elements in a sparse CSR matrix after elements less than the threshold are !> pruned from the matrix. !> !> \note !> The routine supports asynchronous execution if the pointer mode is set to device. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the dense matrix \p A. !> @param[in] n - number of columns of the dense matrix \p A. !> @param[in] A - array of dimensions (\p lda, \p n). !> @param[in] lda - leading dimension of dense array \p A. !> @param[in] threshold - pointer to the pruning non-negative threshold which can exist in !> either host or device memory. !> @param[in] descr - the descriptor of the dense matrix \p A. !> @param[out] csr_row_ptr - integer array of \p m+1 elements that contains the start of every !> row and the end of the last row plus one. !> @param[out] nnz_total_dev_host_ptr - total number of non-zero elements in device or host !> memory. !> @param[out] temp_buffer - buffer allocated by the user. Its size is determined by calling !> \ref rocsparse_sprune_dense2csr_buffer_size !> "rocsparse_Xprune_dense2csr_buffer_size()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p lda is invalid. !> \retval rocsparse_status_invalid_pointer \p A, \p threshold, \p descr, \p csr_row_ptr, !> \p nnz_total_dev_host_ptr, or \p temp_buffer pointer is invalid. interface rocsparse_sprune_dense2csr_nnz function rocsparse_sprune_dense2csr_nnz_(handle,m,n,A,lda,threshold,descr,csr_row_ptr, & nnz_total_dev_host_ptr,temp_buffer) & bind(c, name="rocsparse_sprune_dense2csr_nnz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_nnz_ 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 real(c_float) :: threshold type(c_ptr),value :: descr type(c_ptr),value :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sprune_dense2csr_nnz_assumed_rank #else module procedure & rocsparse_sprune_dense2csr_nnz_rank_0,& rocsparse_sprune_dense2csr_nnz_rank_1,& rocsparse_sprune_dense2csr_nnz_full_rank #endif #endif end interface interface rocsparse_dprune_dense2csr_nnz function rocsparse_dprune_dense2csr_nnz_(handle,m,n,A,lda,threshold,descr,csr_row_ptr, & nnz_total_dev_host_ptr,temp_buffer) & bind(c, name="rocsparse_dprune_dense2csr_nnz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_nnz_ 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 real(c_double) :: threshold type(c_ptr),value :: descr type(c_ptr),value :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dprune_dense2csr_nnz_assumed_rank #else module procedure & rocsparse_dprune_dense2csr_nnz_rank_0,& rocsparse_dprune_dense2csr_nnz_rank_1,& rocsparse_dprune_dense2csr_nnz_full_rank #endif #endif end interface !> \ingroup conv_module !> \brief Convert and prune dense matrix \f$A\f$ into a sparse CSR matrix \f$C\f$. !> !> \details !> This function converts the dense matrix \f$A\f$ into a sparse CSR matrix \f$C\f$ by pruning !> values in \f$A\f$ !> that are less than a threshold. !> !> The conversion involves three steps. First, call !> \ref rocsparse_sprune_dense2csr_buffer_size "rocsparse_Xprune_dense2csr_buffer_size()" !> to determine the size of the temporary storage buffer. Allocate this buffer as well as the !> array !> \p csr_row_ptr to have \p m+1 elements. Then call !> \ref rocsparse_sprune_dense2csr_nnz "rocsparse_Xprune_dense2csr_nnz()", which fills !> in the \p csr_row_ptr array and stores the number of elements that are larger than the !> pruning \p threshold !> in \p nnz_total_dev_host_ptr. Now that the number of non-zeros larger than the pruning \p !> threshold is known, !> use this information to allocate the \p csr_col_ind and \p csr_val arrays and then call !> \p rocsparse_prune_dense2csr to complete the conversion. After the conversion is complete, !> the temporary storage !> buffer can be freed. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the dense matrix \p A. !> @param[in] n - number of columns of the dense matrix \p A. !> @param[in] A - array of dimensions (\p lda, \p n). !> @param[in] lda - leading dimension of dense array \p A. !> @param[in] threshold - pointer to the non-negative pruning threshold, which can exist in !> either host or device memory. !> @param[in] descr - the descriptor of the dense matrix \p A. The supported matrix type is !> `rocsparse_matrix_type_general` and !> also any valid value of the `rocsparse_index_base`. !> @param[out] csr_val - array of nnz ( = \p csr_row_ptr[m] - \p csr_row_ptr[0] ) non-zero !> elements of matrix \p A. !> @param[in] csr_row_ptr - integer array of \p m+1 elements that contains the start of every !> row and the end of the last row plus one. !> @param[out] csr_col_ind - integer array of nnz ( = \p csr_row_ptr[m] - \p csr_row_ptr[0] ) !> column indices of the non-zero elements of matrix \p A. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. The size is returned !> by !> \ref rocsparse_sprune_dense2csr_buffer_size !> "rocsparse_Xprune_dense2csr_buffer_size()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p lda is invalid. !> \retval rocsparse_status_invalid_pointer \p A, \p descr, \p threshold, \p csr_val, !> \p csr_row_ptr, \p csr_col_ind, or \p temp_buffer pointer is invalid. !> !> \par Example interface rocsparse_sprune_dense2csr function rocsparse_sprune_dense2csr_(handle,m,n,A,lda,threshold,descr,csr_val,csr_row_ptr, & csr_col_ind,temp_buffer) & bind(c, name="rocsparse_sprune_dense2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_ 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 real(c_float) :: threshold type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sprune_dense2csr_assumed_rank #else module procedure & rocsparse_sprune_dense2csr_rank_0,& rocsparse_sprune_dense2csr_rank_1,& rocsparse_sprune_dense2csr_full_rank #endif #endif end interface interface rocsparse_dprune_dense2csr function rocsparse_dprune_dense2csr_(handle,m,n,A,lda,threshold,descr,csr_val,csr_row_ptr, & csr_col_ind,temp_buffer) & bind(c, name="rocsparse_dprune_dense2csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_ 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 real(c_double) :: threshold type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dprune_dense2csr_assumed_rank #else module procedure & rocsparse_dprune_dense2csr_rank_0,& rocsparse_dprune_dense2csr_rank_1,& rocsparse_dprune_dense2csr_full_rank #endif #endif end interface !> \ingroup conv_module !> \details !> \p rocsparse_prune_dense2csr_by_percentage_buffer_size returns the size of the temporary !> buffer that !> is required by \ref rocsparse_sprune_dense2csr_nnz_by_percentage !> "rocsparse_Xprune_dense2csr_nnz_by_percentage()" !> and \ref rocsparse_sprune_dense2csr_by_percentage !> "rocsparse_Xprune_dense2csr_by_percentage()". The temporary !> storage buffer must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the dense matrix \p A. !> @param[in] n - number of columns of the dense matrix \p A. !> @param[in] A - array of dimensions (\p lda, \p n). !> @param[in] lda - leading dimension of dense array \p A. !> @param[in] percentage - \p percentage>=0 and \p percentage<=100. !> @param[in] descr - the descriptor of the dense matrix \p A. The supported matrix type is !> `rocsparse_matrix_type_general` !> and also any valid value of the `rocsparse_index_base`. !> @param[in] csr_val - array of nnz ( = \p csr_row_ptr[m] - \p csr_row_ptr[0] ) non-zero !> elements of matrix \p A. !> @param[in] csr_row_ptr - integer array of \p m+1 elements that contains the start of every !> row and the end of the last row plus one. !> @param[in] csr_col_ind - integer array of nnz ( = \p csr_row_ptr[m] - \p csr_row_ptr[0] ) !> column indices of the non-zero elements of matrix \p A. !> @param[in] myInfo - prune information structure. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> \ref rocsparse_sprune_dense2csr_nnz_by_percentage !> "rocsparse_Xprune_dense2csr_nnz_by_percentage()" and !> \ref rocsparse_sprune_dense2csr_by_percentage !> "rocsparse_Xprune_dense2csr_by_percentage()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p buffer_size pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_sprune_dense2csr_by_percentage_buffer_size function rocsparse_sprune_dense2csr_by_percentage_buffer_size_(handle,m,n,A,lda,percentage, & descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,buffer_size) & bind(c, name="rocsparse_sprune_dense2csr_by_percentage_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_by_percentage_buffer_size_ 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 real(c_float),value :: percentage type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sprune_dense2csr_by_percentage_buffer_si_assumed_rank #else module procedure & rocsparse_sprune_dense2csr_by_percentage_buffer_size_rank_0,& rocsparse_sprune_dense2csr_by_percentage_buffer_size_rank_1,& rocsparse_sprune_dense2csr_by_percentage_buffer_size_full_rank #endif #endif end interface interface rocsparse_dprune_dense2csr_by_percentage_buffer_size function rocsparse_dprune_dense2csr_by_percentage_buffer_size_(handle,m,n,A,lda,percentage, & descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,buffer_size) & bind(c, name="rocsparse_dprune_dense2csr_by_percentage_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_by_percentage_buffer_size_ 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 real(c_double),value :: percentage type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dprune_dense2csr_by_percentage_buffer_si_assumed_rank #else module procedure & rocsparse_dprune_dense2csr_by_percentage_buffer_size_rank_0,& rocsparse_dprune_dense2csr_by_percentage_buffer_size_rank_1,& rocsparse_dprune_dense2csr_by_percentage_buffer_size_full_rank #endif #endif end interface !> \ingroup conv_module !> \details !> \p rocsparse_sprune_dense2csr_nnz_by_percentage computes the number of non-zero elements per !> row and the total !> number of non-zero elements in a sparse CSR matrix after a \p percentage of the smallest !> magnitude elements !> have been pruned from the dense input matrix. See !> \ref rocsparse_sprune_dense2csr_by_percentage "rocsparse_sprune_dense2csr_by_percentage()" !> for a more detailed !> description of how this pruning based on \p percentage works. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the dense matrix \p A. !> @param[in] n - number of columns of the dense matrix \p A. !> @param[in] A - array of dimensions (\p lda, \p n). !> @param[in] lda - leading dimension of dense array \p A. !> @param[in] percentage - \p percentage>=0 and \p percentage<=100. !> @param[in] descr - the descriptor of the dense matrix \p A. !> @param[out] csr_row_ptr - integer array of \p m+1 elements that contains the start of every !> row and the end of the last row plus one. !> @param[out] nnz_total_dev_host_ptr - total number of non-zero elements in device or host !> memory. !> @param[in] myInfo - prune information structure. !> @param[out] temp_buffer - buffer allocated by the user. Its size is determined by calling !> \ref rocsparse_sprune_dense2csr_by_percentage_buffer_size !> "rocsparse_Xprune_dense2csr_by_percentage_buffer_size()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, \p lda, or \p percentage is invalid. !> \retval rocsparse_status_invalid_pointer \p A, \p descr, \p info, \p csr_row_ptr, !> \p nnz_total_dev_host_ptr, or \p temp_buffer pointer is invalid. interface rocsparse_sprune_dense2csr_nnz_by_percentage function rocsparse_sprune_dense2csr_nnz_by_percentage_(handle,m,n,A,lda,percentage,descr, & csr_row_ptr,nnz_total_dev_host_ptr,myInfo,temp_buffer) & bind(c, name="rocsparse_sprune_dense2csr_nnz_by_percentage") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_nnz_by_percentage_ 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 real(c_float),value :: percentage type(c_ptr),value :: descr type(c_ptr),value :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr),value :: myInfo type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sprune_dense2csr_nnz_by_percentage_assumed_rank #else module procedure & rocsparse_sprune_dense2csr_nnz_by_percentage_rank_0,& rocsparse_sprune_dense2csr_nnz_by_percentage_rank_1,& rocsparse_sprune_dense2csr_nnz_by_percentage_full_rank #endif #endif end interface interface rocsparse_dprune_dense2csr_nnz_by_percentage function rocsparse_dprune_dense2csr_nnz_by_percentage_(handle,m,n,A,lda,percentage,descr, & csr_row_ptr,nnz_total_dev_host_ptr,myInfo,temp_buffer) & bind(c, name="rocsparse_dprune_dense2csr_nnz_by_percentage") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_nnz_by_percentage_ 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 real(c_double),value :: percentage type(c_ptr),value :: descr type(c_ptr),value :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr),value :: myInfo type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dprune_dense2csr_nnz_by_percentage_assumed_rank #else module procedure & rocsparse_dprune_dense2csr_nnz_by_percentage_rank_0,& rocsparse_dprune_dense2csr_nnz_by_percentage_rank_1,& rocsparse_dprune_dense2csr_nnz_by_percentage_full_rank #endif #endif end interface !> \ingroup conv_module !> \brief !> This function converts the matrix \f$A\f$ in dense format into a sparse matrix in CSR format !> while pruning values !> based on percentage. !> !> \details !> This function converts the dense column-oriented matrix \f$A\f$ into a sparse CSR matrix !> \f$C\f$ by pruning values in \f$A\f$ !> that are less than a threshold. This threshold is determined by using a \p percentage and the !> following steps: !> !> Step 1: First, the \p A array is sorted in ascending order using the absolute value of each !> entry: !> \f[ !> A\_sorted = sort(abs(A)) !> \f] !> !> Step 2: Next, use the \p percentage parameter to determine the threshold: !> \f[ !> pos = ceil(m \times n \times (percentage/100)) - 1 \\% !> pos = \min(pos, m \times n - 1) \\% !> pos = \max(pos, 0) \\% !> threshold = A\_sorted[pos] !> \f] !> !> Step 3: Finally, use this threshold with the routine !> \ref rocsparse_sprune_dense2csr "rocsparse_Xprune_dense2csr()" to complete the conversion. !> !> The conversion involves three steps. First, call !> \ref rocsparse_sprune_dense2csr_by_percentage_buffer_size !> "rocsparse_Xprune_dense2csr_by_percentage_buffer_size()" !> to determine the size of the temporary storage buffer. Allocate this buffer as well as the !> array !> \p csr_row_ptr to have \p m+1 elements. Then call !> \ref rocsparse_sprune_dense2csr_nnz_by_percentage !> "rocsparse_Xprune_dense2csr_nnz_by_percentage()", which fills !> in the \p csr_row_ptr array and stores the number of elements that are larger than the !> pruning threshold !> in \p nnz_total_dev_host_ptr. Now that the number of non-zeros larger than the pruning !> threshold is known, !> use this information to allocate the \p csr_col_ind and \p csr_val arrays and then call !> \p rocsparse_prune_dense2csr_by_percentage to complete the conversion. After the conversion !> is complete, the !> temporary storage buffer can be freed. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the dense matrix \p A. !> @param[in] n - number of columns of the dense matrix \p A. !> @param[in] A - array of dimensions (\p lda, \p n). !> @param[in] lda - leading dimension of dense array \p A. !> @param[in] percentage - \p percentage>=0 and \p percentage<=100. !> @param[in] descr - the descriptor of the dense matrix \p A. The supported matrix type is !> `rocsparse_matrix_type_general` and !> also any valid value of the `rocsparse_index_base`. !> @param[out] csr_val - array of nnz ( = \p csr_row_ptr[m] - \p csr_row_ptr[0] ) non-zero !> elements of matrix \p A. !> @param[in] csr_row_ptr - integer array of \p m+1 elements that contains the start of every !> row and the end of the last row plus one. !> @param[out] csr_col_ind - integer array of nnz ( = \p csr_row_ptr[m] - \p csr_row_ptr[0] ) !> column indices of the non-zero elements of matrix \p A. !> @param[in] myInfo - prune information structure. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. The size is returned !> by !> \ref rocsparse_sprune_dense2csr_by_percentage_buffer_size !> "rocsparse_Xprune_dense2csr_by_percentage_buffer_size()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, \p lda, or \p percentage is invalid. !> \retval rocsparse_status_invalid_pointer \p A, \p descr, \p info, \p csr_val, !> \p csr_row_ptr, \p csr_col_ind, or \p temp_buffer pointer is invalid. !> !> \par Example interface rocsparse_sprune_dense2csr_by_percentage function rocsparse_sprune_dense2csr_by_percentage_(handle,m,n,A,lda,percentage,descr,csr_val, & csr_row_ptr,csr_col_ind,myInfo,temp_buffer) & bind(c, name="rocsparse_sprune_dense2csr_by_percentage") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_by_percentage_ 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 real(c_float),value :: percentage type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sprune_dense2csr_by_percentage_assumed_rank #else module procedure & rocsparse_sprune_dense2csr_by_percentage_rank_0,& rocsparse_sprune_dense2csr_by_percentage_rank_1,& rocsparse_sprune_dense2csr_by_percentage_full_rank #endif #endif end interface interface rocsparse_dprune_dense2csr_by_percentage function rocsparse_dprune_dense2csr_by_percentage_(handle,m,n,A,lda,percentage,descr,csr_val, & csr_row_ptr,csr_col_ind,myInfo,temp_buffer) & bind(c, name="rocsparse_dprune_dense2csr_by_percentage") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_by_percentage_ 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 real(c_double),value :: percentage type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dprune_dense2csr_by_percentage_assumed_rank #else module procedure & rocsparse_dprune_dense2csr_by_percentage_rank_0,& rocsparse_dprune_dense2csr_by_percentage_rank_1,& rocsparse_dprune_dense2csr_by_percentage_full_rank #endif #endif end interface !> \ingroup extra_module !> \details !> \p rocsparse_bsrgeam_nnzb computes the total BSR non-zero elements and the BSR row !> offsets that point to the start of every row of the sparse BSR matrix of the !> resulting matrix C. It is assumed that \p bsr_row_ptr_C has been allocated with !> size \p mb+1. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> Currently, only `rocsparse_matrix_type_general` is supported. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - direction that specifies whether to count non-zero elements by !> `rocsparse_direction_row` or by !> `rocsparse_direction_column` in the BSR matrices \f$A\f$, \f$B\f$, and !> \f$C\f$. !> @param[in] mb - number of block rows in the sparse BSR matrix \f$op(A)\f$ and \f$C\f$. !> @param[in] nb - number of block columns of the sparse BSR matrix \f$op(B)\f$ and !> \f$C\f$. !> @param[in] block_dim - the block dimension of the BSR matrix \f$A\f$. Between 1 and m where !> \p m=mb*block_dim. !> @param[in] descr_A - descriptor of the sparse BSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnzb_A - number of non-zero block entries of the sparse BSR matrix \f$A\f$. !> @param[in] bsr_row_ptr_A - array of \p mb+1 elements that point to the start of every block !> row of the !> sparse BSR matrix \f$A\f$. !> @param[in] bsr_col_ind_A - array of \p nnzb_A elements containing the column indices of the !> sparse BSR matrix \f$A\f$. !> @param[in] descr_B - descriptor of the sparse BSR matrix \f$B\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnzb_B - number of non-zero block entries of the sparse BSR matrix \f$B\f$. !> @param[in] bsr_row_ptr_B - array of \p mb+1 elements that point to the start of every block !> row of the !> sparse BSR matrix \f$B\f$. !> @param[in] bsr_col_ind_B - array of \p nnzb_B elements containing the block column indices of !> the !> sparse BSR matrix \f$B\f$. !> @param[in] descr_C - descriptor of the sparse BSR matrix \f$C\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] bsr_row_ptr_C - array of \p mb+1 elements that point to the start of every block !> row of the !> sparse BSR matrix \f$C\f$. !> @param[out] nnzb_C - pointer to the number of non-zero block entries of the sparse BSR !> matrix \f$C\f$. \p nnzb_C can be a host or device pointer. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nb, \p kb, \p nnzb_A, or \p nnzb_B is !> invalid. !> \retval rocsparse_status_invalid_pointer \p descr_A, \p bsr_row_ptr_A, !> \p bsr_col_ind_A, \p descr_B, \p bsr_row_ptr_B, \p bsr_col_ind_B, !> \p descr_C, \p bsr_row_ptr_C, or \p nnzb_C is invalid. !> \retval rocsparse_status_not_implemented !> \p rocsparse_matrix_type != `rocsparse_matrix_type_general`. interface rocsparse_bsrgeam_nnzb function rocsparse_bsrgeam_nnzb_(handle,dir,mb,nb,block_dim,descr_A,nnzb_A,bsr_row_ptr_A, & bsr_col_ind_A,descr_B,nnzb_B,bsr_row_ptr_B,bsr_col_ind_B,descr_C,bsr_row_ptr_C,nnzb_C) & bind(c, name="rocsparse_bsrgeam_nnzb") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_bsrgeam_nnzb_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: block_dim type(c_ptr),value :: descr_A integer(c_int),value :: nnzb_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnzb_B type(c_ptr),value :: bsr_row_ptr_B type(c_ptr),value :: bsr_col_ind_B type(c_ptr),value :: descr_C type(c_ptr),value :: bsr_row_ptr_C type(c_ptr),value :: nnzb_C end function end interface !> \ingroup extra_module !> \brief Sparse matrix sparse matrix addition using the BSR storage format. !> !> \details !> \p rocsparse_bsrgeam multiplies the scalar \f$\alpha\f$ with the sparse !> \f$m \times n\f$ matrix \f$A\f$, defined in BSR storage format, multiplies the !> scalar \f$\beta\f$ with the sparse \f$mb \times nb\f$ matrix \f$B\f$, defined in BSR !> storage format, and adds both resulting matrices to obtain the sparse !> \f$mb \times nb\f$ matrix \f$C\f$, defined in BSR storage format, such that !> \f[ !> C := \alpha \cdot A + \beta \cdot B. !> \f] !> !> It is assumed that \p bsr_row_ptr_C has already been filled and that \p bsr_val_C and !> \p bsr_col_ind_C are allocated by the user. \p bsr_row_ptr_C and the allocation size of !> \p bsr_col_ind_C and \p bsr_val_C is defined by the number of non-zero block elements of !> the sparse BSR matrix C. Both can be obtained by `rocsparse_bsrgeam_nnzb`(). !> !> \note Both scalars \f$\alpha\f$ and \f$beta\f$ have to be valid. !> !> \note Currently, only `rocsparse_matrix_type_general` is supported. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - direction that specifies whether to count non-zero elements by !> `rocsparse_direction_row` or by !> `rocsparse_direction_column` in the BSR matrices \f$A\f$, \f$B\f$, and !> \f$C\f$. !> @param[in] mb - number of rows of the sparse BSR matrix \f$A\f$, \f$B\f$, and \f$C\f$. !> @param[in] nb - number of columns of the sparse BSR matrix \f$A\f$, \f$B\f$, and \f$C\f$. !> @param[in] block_dim - the block dimension of the BSR matrix \f$A\f$. Between 1 and m where !> \p m=mb*block_dim. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr_A - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnzb_A - number of non-zero block entries of the sparse BSR matrix \f$A\f$. !> @param[in] bsr_val_A - array of \p nnzb_A block elements of the sparse BSR matrix \f$A\f$. !> @param[in] bsr_row_ptr_A - array of \p mb+1 block elements that point to the start of every !> block row of the !> sparse BSR matrix \f$A\f$. !> @param[in] bsr_col_ind_A - array of \p nnzb_A block elements containing the block column !> indices of the !> sparse BSR matrix \f$A\f$. !> @param[in] beta - scalar \f$\beta\f$. !> @param[in] descr_B - descriptor of the sparse BSR matrix \f$B\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnzb_B - number of non-zero block entries of the sparse BSR matrix \f$B\f$. !> @param[in] bsr_val_B - array of \p nnzb_B block elements of the sparse BSR matrix \f$B\f$. !> @param[in] bsr_row_ptr_B - array of \p mb+1 block elements that point to the start of every !> block row of the !> sparse BSR matrix \f$B\f$. !> @param[in] bsr_col_ind_B - array of \p nnzb_B block elements containing the block column !> indices of the !> sparse BSR matrix \f$B\f$. !> @param[in] descr_C - descriptor of the sparse BSR matrix \f$C\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] bsr_val_C - array of block elements of the sparse BSR matrix \f$C\f$. !> @param[in] bsr_row_ptr_C - array of \p mb+1 block elements that point to the start of every !> block row of the !> sparse BSR matrix \f$C\f$. !> @param[out] bsr_col_ind_C - array of block elements containing the block column indices of !> the !> sparse BSR matrix \f$C\f$. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nb, \p nnzb_A, or \p nnzb_B is invalid. !> \retval rocsparse_status_invalid_pointer \p alpha, \p descr_A, \p bsr_val_A, !> \p bsr_row_ptr_A, \p bsr_col_ind_A, \p beta, \p descr_B, \p bsr_val_B, !> \p bsr_row_ptr_B, \p bsr_col_ind_B, \p descr_C, \p csr_val_C, !> \p bsr_row_ptr_C, or \p bsr_col_ind_C is invalid. !> \retval rocsparse_status_not_implemented !> \p rocsparse_matrix_type != `rocsparse_matrix_type_general`. !> !> \par Example !> This example adds two CSR matrices. interface rocsparse_sbsrgeam function rocsparse_sbsrgeam_(handle,dir,mb,nb,block_dim,alpha,descr_A,nnzb_A,bsr_val_A, & bsr_row_ptr_A,bsr_col_ind_A,beta,descr_B,nnzb_B,bsr_val_B,bsr_row_ptr_B,bsr_col_ind_B, & descr_C,bsr_val_C,bsr_row_ptr_C,bsr_col_ind_C) & bind(c, name="rocsparse_sbsrgeam") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrgeam_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: block_dim real(c_float) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnzb_A type(c_ptr),value :: bsr_val_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A real(c_float) :: beta type(c_ptr),value :: descr_B integer(c_int),value :: nnzb_B type(c_ptr),value :: bsr_val_B type(c_ptr),value :: bsr_row_ptr_B type(c_ptr),value :: bsr_col_ind_B type(c_ptr),value :: descr_C type(c_ptr),value :: bsr_val_C type(c_ptr),value :: bsr_row_ptr_C type(c_ptr),value :: bsr_col_ind_C end function end interface interface rocsparse_dbsrgeam function rocsparse_dbsrgeam_(handle,dir,mb,nb,block_dim,alpha,descr_A,nnzb_A,bsr_val_A, & bsr_row_ptr_A,bsr_col_ind_A,beta,descr_B,nnzb_B,bsr_val_B,bsr_row_ptr_B,bsr_col_ind_B, & descr_C,bsr_val_C,bsr_row_ptr_C,bsr_col_ind_C) & bind(c, name="rocsparse_dbsrgeam") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrgeam_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: block_dim real(c_double) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnzb_A type(c_ptr),value :: bsr_val_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A real(c_double) :: beta type(c_ptr),value :: descr_B integer(c_int),value :: nnzb_B type(c_ptr),value :: bsr_val_B type(c_ptr),value :: bsr_row_ptr_B type(c_ptr),value :: bsr_col_ind_B type(c_ptr),value :: descr_C type(c_ptr),value :: bsr_val_C type(c_ptr),value :: bsr_row_ptr_C type(c_ptr),value :: bsr_col_ind_C end function end interface interface rocsparse_cbsrgeam function rocsparse_cbsrgeam_(handle,dir,mb,nb,block_dim,alpha,descr_A,nnzb_A,bsr_val_A, & bsr_row_ptr_A,bsr_col_ind_A,beta,descr_B,nnzb_B,bsr_val_B,bsr_row_ptr_B,bsr_col_ind_B, & descr_C,bsr_val_C,bsr_row_ptr_C,bsr_col_ind_C) & bind(c, name="rocsparse_cbsrgeam") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrgeam_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: block_dim complex(c_float_complex) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnzb_A type(c_ptr),value :: bsr_val_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A complex(c_float_complex) :: beta type(c_ptr),value :: descr_B integer(c_int),value :: nnzb_B type(c_ptr),value :: bsr_val_B type(c_ptr),value :: bsr_row_ptr_B type(c_ptr),value :: bsr_col_ind_B type(c_ptr),value :: descr_C type(c_ptr),value :: bsr_val_C type(c_ptr),value :: bsr_row_ptr_C type(c_ptr),value :: bsr_col_ind_C end function end interface interface rocsparse_zbsrgeam function rocsparse_zbsrgeam_(handle,dir,mb,nb,block_dim,alpha,descr_A,nnzb_A,bsr_val_A, & bsr_row_ptr_A,bsr_col_ind_A,beta,descr_B,nnzb_B,bsr_val_B,bsr_row_ptr_B,bsr_col_ind_B, & descr_C,bsr_val_C,bsr_row_ptr_C,bsr_col_ind_C) & bind(c, name="rocsparse_zbsrgeam") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrgeam_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: block_dim complex(c_double_complex) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnzb_A type(c_ptr),value :: bsr_val_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A complex(c_double_complex) :: beta type(c_ptr),value :: descr_B integer(c_int),value :: nnzb_B type(c_ptr),value :: bsr_val_B type(c_ptr),value :: bsr_row_ptr_B type(c_ptr),value :: bsr_col_ind_B type(c_ptr),value :: descr_C type(c_ptr),value :: bsr_val_C type(c_ptr),value :: bsr_row_ptr_C type(c_ptr),value :: bsr_col_ind_C end function end interface !> \ingroup extra_module !> \details !> \p rocsparse_bsrgemm_buffer_size returns the size of the temporary storage buffer !> that is required by `rocsparse_bsrgemm_nnzb` () and \ref rocsparse_sbsrgemm !> "rocsparse_Xbsrgemm()". !> The temporary storage buffer must be allocated by the user. !> !> \note !> This function is blocking with respect to the host. !> \note !> Currently, only \p trans_A == \p trans_B == `rocsparse_operation_none` is !> supported. !> \note !> Currently, only `rocsparse_matrix_type_general` is supported. !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - direction that specifies whether to count non-zero elements by !> `rocsparse_direction_row` or by !> `rocsparse_direction_column` in the BSR matrices \f$A\f$, \f$B\f$, \f$C\f$, !> and \f$D\f$. !> @param[in] trans_A - matrix \f$A\f$ operation type. !> @param[in] trans_B - matrix \f$B\f$ operation type. !> @param[in] mb - number of block rows in the sparse BSR matrix \f$op(A)\f$ and \f$C\f$. !> @param[in] nb - number of block columns of the sparse BSR matrix \f$op(B)\f$ and !> \f$C\f$. !> @param[in] kb - number of block columns of the sparse BSR matrix \f$op(A)\f$ and number of !> rows of the sparse BSR matrix \f$op(B)\f$. !> @param[in] block_dim - the block dimension of the BSR matrix \f$A\f$, \f$B\f$, \f$C\f$, and !> \f$D\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr_A - descriptor of the sparse BSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnzb_A - number of non-zero block entries of the sparse BSR matrix \f$A\f$. !> @param[in] bsr_row_ptr_A - array of \p mb+1 elements (\f$op(A) == A\f$, \p kb+1 otherwise) !> that point to the start of every block row of the sparse BSR matrix !> \f$op(A)\f$. !> @param[in] bsr_col_ind_A - array of \p nnzb_A elements containing the block column indices of !> the !> sparse BSR matrix \f$A\f$. !> @param[in] descr_B - descriptor of the sparse BSR matrix \f$B\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnzb_B - number of non-zero block entries of the sparse BSR matrix \f$B\f$. !> @param[in] bsr_row_ptr_B - array of \p kb+1 elements (\f$op(B) == B\f$, \p mb+1 otherwise) !> that point to the start of every block row of the sparse BSR matrix !> \f$op(B)\f$. !> @param[in] bsr_col_ind_B - array of \p nnzb_B elements containing the block column indices of !> the !> sparse BSR matrix \f$B\f$. !> @param[in] beta - scalar \f$\beta\f$. !> @param[in] descr_D - descriptor of the sparse BSR matrix \f$D\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnzb_D - number of non-zero block entries of the sparse BSR matrix \f$D\f$. !> @param[in] bsr_row_ptr_D - array of \p mb+1 elements that point to the start of every block !> row of the !> sparse BSR matrix \f$D\f$. !> @param[in] bsr_col_ind_D - array of \p nnzb_D elements containing the block column indices of !> the sparse !> BSR matrix \f$D\f$. !> @param[inout] info_C - structure that holds metadata for the sparse BSR matrix \f$C\f$. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> `rocsparse_bsrgemm_nnzb()`, rocsparse_sbsrgemm(), rocsparse_dbsrgemm(), !> rocsparse_cbsrgemm(), and rocsparse_zbsrgemm(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nb, \p kb, \p block_dim, \p nnzb_A, \p !> nnzb_B, or !> \p nnzb_D is invalid. !> \retval rocsparse_status_invalid_pointer \p alpha and \p beta are invalid, !> \p descr_A, \p bsr_row_ptr_A, \p bsr_col_ind_A, \p descr_B, !> \p bsr_row_ptr_B, or \p bsr_col_ind_B are invalid if \p alpha is valid, !> \p descr_D, \p bsr_row_ptr_D, or \p bsr_col_ind_D is invalid if \p beta is !> valid, or \p info_C or \p buffer_size are invalid. !> \retval rocsparse_status_not_implemented !> \p trans_A != `rocsparse_operation_none`, !> \p trans_B != `rocsparse_operation_none`, or !> \p rocsparse_matrix_type != `rocsparse_matrix_type_general`. interface rocsparse_sbsrgemm_buffer_size function rocsparse_sbsrgemm_buffer_size_(handle,dir,trans_A,trans_B,mb,nb,kb,block_dim,alpha, & descr_A,nnzb_A,bsr_row_ptr_A,bsr_col_ind_A,descr_B,nnzb_B,bsr_row_ptr_B,bsr_col_ind_B, & beta,descr_D,nnzb_D,bsr_row_ptr_D,bsr_col_ind_D,info_C,buffer_size) & bind(c, name="rocsparse_sbsrgemm_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrgemm_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: kb integer(c_int),value :: block_dim type(c_ptr),value :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnzb_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnzb_B type(c_ptr),value :: bsr_row_ptr_B type(c_ptr),value :: bsr_col_ind_B type(c_ptr),value :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnzb_D type(c_ptr),value :: bsr_row_ptr_D type(c_ptr),value :: bsr_col_ind_D type(c_ptr),value :: info_C integer(c_size_t) :: buffer_size end function end interface interface rocsparse_dbsrgemm_buffer_size function rocsparse_dbsrgemm_buffer_size_(handle,dir,trans_A,trans_B,mb,nb,kb,block_dim,alpha, & descr_A,nnzb_A,bsr_row_ptr_A,bsr_col_ind_A,descr_B,nnzb_B,bsr_row_ptr_B,bsr_col_ind_B, & beta,descr_D,nnzb_D,bsr_row_ptr_D,bsr_col_ind_D,info_C,buffer_size) & bind(c, name="rocsparse_dbsrgemm_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrgemm_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: kb integer(c_int),value :: block_dim type(c_ptr),value :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnzb_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnzb_B type(c_ptr),value :: bsr_row_ptr_B type(c_ptr),value :: bsr_col_ind_B type(c_ptr),value :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnzb_D type(c_ptr),value :: bsr_row_ptr_D type(c_ptr),value :: bsr_col_ind_D type(c_ptr),value :: info_C integer(c_size_t) :: buffer_size end function end interface interface rocsparse_cbsrgemm_buffer_size function rocsparse_cbsrgemm_buffer_size_(handle,dir,trans_A,trans_B,mb,nb,kb,block_dim,alpha, & descr_A,nnzb_A,bsr_row_ptr_A,bsr_col_ind_A,descr_B,nnzb_B,bsr_row_ptr_B,bsr_col_ind_B, & beta,descr_D,nnzb_D,bsr_row_ptr_D,bsr_col_ind_D,info_C,buffer_size) & bind(c, name="rocsparse_cbsrgemm_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrgemm_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: kb integer(c_int),value :: block_dim type(c_ptr),value :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnzb_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnzb_B type(c_ptr),value :: bsr_row_ptr_B type(c_ptr),value :: bsr_col_ind_B type(c_ptr),value :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnzb_D type(c_ptr),value :: bsr_row_ptr_D type(c_ptr),value :: bsr_col_ind_D type(c_ptr),value :: info_C integer(c_size_t) :: buffer_size end function end interface interface rocsparse_zbsrgemm_buffer_size function rocsparse_zbsrgemm_buffer_size_(handle,dir,trans_A,trans_B,mb,nb,kb,block_dim,alpha, & descr_A,nnzb_A,bsr_row_ptr_A,bsr_col_ind_A,descr_B,nnzb_B,bsr_row_ptr_B,bsr_col_ind_B, & beta,descr_D,nnzb_D,bsr_row_ptr_D,bsr_col_ind_D,info_C,buffer_size) & bind(c, name="rocsparse_zbsrgemm_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrgemm_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: kb integer(c_int),value :: block_dim type(c_ptr),value :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnzb_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnzb_B type(c_ptr),value :: bsr_row_ptr_B type(c_ptr),value :: bsr_col_ind_B type(c_ptr),value :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnzb_D type(c_ptr),value :: bsr_row_ptr_D type(c_ptr),value :: bsr_col_ind_D type(c_ptr),value :: info_C integer(c_size_t) :: buffer_size end function end interface !> \ingroup extra_module !> \details !> \p rocsparse_bsrgemm_nnzb computes the total BSR non-zero block elements and the BSR block !> row !> offsets that point to the start of every block row of the sparse BSR matrix of the !> resulting multiplied matrix C. It is assumed that \p bsr_row_ptr_C has been allocated !> with size \p mb+1. !> The required buffer size can be obtained by !> \ref rocsparse_sbsrgemm_buffer_size "rocsparse_Xbsrgemm_buffer_size()". !> !> \note !> This function is blocking with respect to the host. !> \note !> Currently, only \p trans_A == \p trans_B == `rocsparse_operation_none` is !> supported. !> \note !> Currently, only `rocsparse_matrix_type_general` is supported. !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - direction that specifies whether to count non-zero elements by !> `rocsparse_direction_row` or by !> `rocsparse_direction_column` in the BSR matrices \f$A\f$, \f$B\f$, \f$C\f$, !> and \f$D\f$. !> @param[in] trans_A - matrix \f$A\f$ operation type. !> @param[in] trans_B - matrix \f$B\f$ operation type. !> @param[in] mb - number of block rows in the sparse BSR matrix \f$op(A)\f$ and \f$C\f$. !> @param[in] nb - number of block columns of the sparse BSR matrix \f$op(B)\f$ and !> \f$C\f$. !> @param[in] kb - number of block columns of the sparse BSR matrix \f$op(A)\f$ and number of !> rows of the sparse BSR matrix \f$op(B)\f$. !> @param[in] block_dim - the block dimension of the BSR matrix \f$A\f$, \f$B\f$, \f$C\f$, and !> \f$D\f$. !> @param[in] descr_A - descriptor of the sparse BSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnzb_A - number of non-zero block entries of the sparse BSR matrix \f$A\f$. !> @param[in] bsr_row_ptr_A - array of \p mb+1 block elements (\f$op(A) == A\f$, \p kb+1 !> otherwise) !> that point to the start of every row of the sparse BSR matrix !> \f$op(A)\f$. !> @param[in] bsr_col_ind_A - array of \p nnzb_A block elements containing the block column !> indices of the !> sparse BSR matrix \f$A\f$. !> @param[in] descr_B - descriptor of the sparse BSR matrix \f$B\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnzb_B - number of non-zero block entries of the sparse BSR matrix \f$B\f$. !> @param[in] bsr_row_ptr_B - array of \p kb+1 block elements (\f$op(B) == B\f$, \p mb+1 !> otherwise) !> that point to the start of every block row of the sparse BSR matrix !> \f$op(B)\f$. !> @param[in] bsr_col_ind_B - array of \p nnzb_B block elements containing the block column !> indices of the !> sparse BSR matrix \f$B\f$. !> @param[in] descr_D - descriptor of the sparse BSR matrix \f$D\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnzb_D - number of non-zero block entries of the sparse BSR matrix \f$D\f$. !> @param[in] bsr_row_ptr_D - array of \p mb+1 block elements that point to the start of every !> block row of the !> sparse BSR matrix \f$D\f$. !> @param[in] bsr_col_ind_D - array of \p nnzb_D block elements containing the block column !> indices of the sparse !> BSR matrix \f$D\f$. !> @param[in] descr_C - descriptor of the sparse BSR matrix \f$C\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] bsr_row_ptr_C - array of \p mb+1 block elements that point to the start of every !> block row of the !> sparse BSR matrix \f$C\f$. !> @param[out] nnzb_C - pointer to the number of non-zero block entries of the sparse BSR !> matrix \f$C\f$. !> @param[in] info_C - structure that holds metadata for the sparse BSR matrix \f$C\f$. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. The size is returned !> by rocsparse_sbsrgemm_buffer_size(), !> rocsparse_dbsrgemm_buffer_size(), rocsparse_cbsrgemm_buffer_size(), or !> rocsparse_zbsrgemm_buffer_size(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nb, \p kb, \p block_dim, \p nnzb_A, \p !> nnzb_B, or !> \p nnzb_D is invalid. !> \retval rocsparse_status_invalid_pointer \p descr_A, \p bsr_row_ptr_A, !> \p bsr_col_ind_A, \p descr_B, \p bsr_row_ptr_B, \p bsr_col_ind_B, !> \p descr_D, \p bsr_row_ptr_D, \p bsr_col_ind_D, \p descr_C, !> \p bsr_row_ptr_C, \p nnzb_C, \p info_C, or \p temp_buffer is invalid. !> \retval rocsparse_status_memory_error additional buffer for long rows could not be !> allocated. !> \retval rocsparse_status_not_implemented !> \p trans_A != `rocsparse_operation_none`, !> \p trans_B != `rocsparse_operation_none`, or !> \p rocsparse_matrix_type != `rocsparse_matrix_type_general`. interface rocsparse_bsrgemm_nnzb function rocsparse_bsrgemm_nnzb_(handle,dir,trans_A,trans_B,mb,nb,kb,block_dim,descr_A,nnzb_A, & bsr_row_ptr_A,bsr_col_ind_A,descr_B,nnzb_B,bsr_row_ptr_B,bsr_col_ind_B,descr_D,nnzb_D, & bsr_row_ptr_D,bsr_col_ind_D,descr_C,bsr_row_ptr_C,nnzb_C,info_C,temp_buffer) & bind(c, name="rocsparse_bsrgemm_nnzb") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_bsrgemm_nnzb_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: kb integer(c_int),value :: block_dim type(c_ptr),value :: descr_A integer(c_int),value :: nnzb_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnzb_B type(c_ptr),value :: bsr_row_ptr_B type(c_ptr),value :: bsr_col_ind_B type(c_ptr),value :: descr_D integer(c_int),value :: nnzb_D type(c_ptr),value :: bsr_row_ptr_D type(c_ptr),value :: bsr_col_ind_D type(c_ptr),value :: descr_C type(c_ptr),value :: bsr_row_ptr_C type(c_ptr),value :: nnzb_C type(c_ptr),value :: info_C type(c_ptr),value :: temp_buffer end function end interface !> \ingroup extra_module !> \brief Sparse matrix sparse matrix multiplication using the BSR storage format. !> !> \details !> \p rocsparse_bsrgemm multiplies the scalar \f$\alpha\f$ with the sparse !> \f$mb \times kb\f$ matrix \f$A\f$, defined in BSR storage format, and the sparse !> \f$kb \times nb\f$ matrix \f$B\f$, defined in BSR storage format, and adds the result !> to the sparse \f$mb \times nb\f$ matrix \f$D\f$ that is multiplied by \f$\beta\f$. The !> final result is stored in the sparse \f$mb \times nb\f$ matrix \f$C\f$, defined in BSR !> storage format, such !> that !> \f[ !> C := \alpha \cdot op(A) \cdot op(B) + \beta \cdot D, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans_A == rocsparse_operation_none} \\% !> A^T, & \text{if trans_A == rocsparse_operation_transpose} \\% !> A^H, & \text{if trans_A == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if trans_B == rocsparse_operation_none} \\% !> B^T, & \text{if trans_B == rocsparse_operation_transpose} \\% !> B^H, & \text{if trans_B == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> !> \note !> This function does not produce deterministic results. !> !> It is assumed that \p bsr_row_ptr_C has already been filled and that \p bsr_val_C and !> \p bsr_col_ind_C are allocated by the user. \p bsr_row_ptr_C and the allocation size of !> \p bsr_col_ind_C and \p bsr_val_C is defined by the number of non-zero elements of !> the sparse BSR matrix C. Both can be obtained by `rocsparse_bsrgemm_nnzb`(). The !> required buffer size for the computation can be obtained by !> \ref rocsparse_sbsrgemm_buffer_size "rocsparse_Xbsrgemm_buffer_size()". !> !> \note If \f$\alpha == 0\f$, then \f$C = \beta \cdot D\f$ will be computed. !> \note If \f$\beta == 0\f$, then \f$C = \alpha \cdot op(A) \cdot op(B)\f$ will be computed. !> \note \f$\alpha == beta == 0\f$ is invalid. !> \note Currently, only \p trans_A == `rocsparse_operation_none` is supported. !> \note Currently, only \p trans_B == `rocsparse_operation_none` is supported. !> \note Currently, only `rocsparse_matrix_type_general` is supported. !> \note This function is blocking with respect to the host. !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - direction that specifies whether to count non-zero elements by !> `rocsparse_direction_row` or by !> `rocsparse_direction_column` in the BSR matrices \f$A\f$, \f$B\f$, \f$C\f$, !> and \f$D\f$. !> @param[in] trans_A - matrix \f$A\f$ operation type. !> @param[in] trans_B - matrix \f$B\f$ operation type. !> @param[in] mb - number of block rows of the sparse BSR matrix \f$op(A)\f$ and \f$C\f$. !> @param[in] nb - number of block columns of the sparse BSR matrix \f$op(B)\f$ and !> \f$C\f$. !> @param[in] kb - number of block columns of the sparse BSR matrix \f$op(A)\f$ and number of !> block rows of the sparse BSR matrix \f$op(B)\f$. !> @param[in] block_dim - the block dimension of the BSR matrix \f$A\f$, \f$B\f$, \f$C\f$, and !> \f$D\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr_A - descriptor of the sparse BSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnzb_A - number of non-zero block entries of the sparse BSR matrix \f$A\f$. !> @param[in] bsr_val_A - array of \p nnzb_A block elements of the sparse BSR matrix \f$A\f$. !> @param[in] bsr_row_ptr_A - array of \p mb+1 block elements (\f$op(A) == A\f$, \p kb+1 !> otherwise) !> that point to the start of every block row of the sparse BSR matrix !> \f$op(A)\f$. !> @param[in] bsr_col_ind_A - array of \p nnzb_A block elements containing the block column !> indices of the !> sparse BSR matrix \f$A\f$. !> @param[in] descr_B - descriptor of the sparse BSR matrix \f$B\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnzb_B - number of non-zero block entries of the sparse BSR matrix \f$B\f$. !> @param[in] bsr_val_B - array of \p nnzb_B block elements of the sparse BSR matrix \f$B\f$. !> @param[in] bsr_row_ptr_B - array of \p kb+1 block elements (\f$op(B) == B\f$, \p mb+1 !> otherwise) !> that point to the start of every block row of the sparse BSR matrix !> \f$op(B)\f$. !> @param[in] bsr_col_ind_B - array of \p nnzb_B block elements containing the block column !> indices of the !> sparse BSR matrix \f$B\f$. !> @param[in] beta - scalar \f$\beta\f$. !> @param[in] descr_D - descriptor of the sparse BSR matrix \f$D\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnzb_D - number of non-zero block entries of the sparse BSR matrix \f$D\f$. !> @param[in] bsr_val_D - array of \p nnzb_D block elements of the sparse BSR matrix \f$D\f$. !> @param[in] bsr_row_ptr_D - array of \p mb+1 block elements that point to the start of every !> block row of the !> sparse BSR matrix \f$D\f$. !> @param[in] bsr_col_ind_D - array of \p nnzb_D block elements containing the block column !> indices of the !> sparse BSR matrix \f$D\f$. !> @param[in] descr_C - descriptor of the sparse BSR matrix \f$C\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] bsr_val_C - array of \p nnzb_C elements of the sparse BSR matrix \f$C\f$. !> @param[in] bsr_row_ptr_C - array of \p mb+1 block elements that point to the start of every !> block row of the !> sparse BSR matrix \f$C\f$. !> @param[out] bsr_col_ind_C - array of \p nnzb_C block elements containing the block column !> indices of the !> sparse BSR matrix \f$C\f$. !> @param[in] info_C - structure that holds metadata for the sparse BSR matrix \f$C\f$. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. The size is returned !> by rocsparse_sbsrgemm_buffer_size(), !> rocsparse_dbsrgemm_buffer_size(), rocsparse_cbsrgemm_buffer_size(), or !> rocsparse_zbsrgemm_buffer_size(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nb, \p kb, \p block_dim, \p nnzb_A, \p !> nnzb_B, or !> \p nnzb_D is invalid. !> \retval rocsparse_status_invalid_pointer \p alpha and \p beta are invalid, !> \p descr_A, \p bsr_val_A, \p bsr_row_ptr_A, \p bsr_col_ind_A, \p descr_B, !> \p bsr_val_B, \p bsr_row_ptr_B, or \p bsr_col_ind_B are invalid if \p alpha !> is valid, \p descr_D, \p bsr_val_D, \p bsr_row_ptr_D, or \p bsr_col_ind_D is !> invalid if \p beta is valid, or \p bsr_val_C, \p bsr_row_ptr_C, !> \p bsr_col_ind_C, or \p info_C or \p temp_buffer are invalid. !> \retval rocsparse_status_memory_error additional buffer for long rows could not be !> allocated. !> \retval rocsparse_status_not_implemented !> \p trans_A != `rocsparse_operation_none`, !> \p trans_B != `rocsparse_operation_none`, or !> \p rocsparse_matrix_type != `rocsparse_matrix_type_general`. !> !> \par Example !> This example multiplies two BSR matrices with a scalar alpha and adds the result to !> another BSR matrix. interface rocsparse_sbsrgemm function rocsparse_sbsrgemm_(handle,dir,trans_A,trans_B,mb,nb,kb,block_dim,alpha,descr_A, & nnzb_A,bsr_val_A,bsr_row_ptr_A,bsr_col_ind_A,descr_B,nnzb_B,bsr_val_B,bsr_row_ptr_B, & bsr_col_ind_B,beta,descr_D,nnzb_D,bsr_val_D,bsr_row_ptr_D,bsr_col_ind_D,descr_C,bsr_val_C, & bsr_row_ptr_C,bsr_col_ind_C,info_C,temp_buffer) & bind(c, name="rocsparse_sbsrgemm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrgemm_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: kb integer(c_int),value :: block_dim real(c_float) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnzb_A type(c_ptr),value :: bsr_val_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnzb_B type(c_ptr),value :: bsr_val_B type(c_ptr),value :: bsr_row_ptr_B type(c_ptr),value :: bsr_col_ind_B real(c_float) :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnzb_D type(c_ptr),value :: bsr_val_D type(c_ptr),value :: bsr_row_ptr_D type(c_ptr),value :: bsr_col_ind_D type(c_ptr),value :: descr_C type(c_ptr),value :: bsr_val_C type(c_ptr),value :: bsr_row_ptr_C type(c_ptr),value :: bsr_col_ind_C type(c_ptr),value :: info_C type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_dbsrgemm function rocsparse_dbsrgemm_(handle,dir,trans_A,trans_B,mb,nb,kb,block_dim,alpha,descr_A, & nnzb_A,bsr_val_A,bsr_row_ptr_A,bsr_col_ind_A,descr_B,nnzb_B,bsr_val_B,bsr_row_ptr_B, & bsr_col_ind_B,beta,descr_D,nnzb_D,bsr_val_D,bsr_row_ptr_D,bsr_col_ind_D,descr_C,bsr_val_C, & bsr_row_ptr_C,bsr_col_ind_C,info_C,temp_buffer) & bind(c, name="rocsparse_dbsrgemm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrgemm_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: kb integer(c_int),value :: block_dim real(c_double) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnzb_A type(c_ptr),value :: bsr_val_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnzb_B type(c_ptr),value :: bsr_val_B type(c_ptr),value :: bsr_row_ptr_B type(c_ptr),value :: bsr_col_ind_B real(c_double) :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnzb_D type(c_ptr),value :: bsr_val_D type(c_ptr),value :: bsr_row_ptr_D type(c_ptr),value :: bsr_col_ind_D type(c_ptr),value :: descr_C type(c_ptr),value :: bsr_val_C type(c_ptr),value :: bsr_row_ptr_C type(c_ptr),value :: bsr_col_ind_C type(c_ptr),value :: info_C type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_cbsrgemm function rocsparse_cbsrgemm_(handle,dir,trans_A,trans_B,mb,nb,kb,block_dim,alpha,descr_A, & nnzb_A,bsr_val_A,bsr_row_ptr_A,bsr_col_ind_A,descr_B,nnzb_B,bsr_val_B,bsr_row_ptr_B, & bsr_col_ind_B,beta,descr_D,nnzb_D,bsr_val_D,bsr_row_ptr_D,bsr_col_ind_D,descr_C,bsr_val_C, & bsr_row_ptr_C,bsr_col_ind_C,info_C,temp_buffer) & bind(c, name="rocsparse_cbsrgemm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrgemm_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: kb integer(c_int),value :: block_dim complex(c_float_complex) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnzb_A type(c_ptr),value :: bsr_val_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnzb_B type(c_ptr),value :: bsr_val_B type(c_ptr),value :: bsr_row_ptr_B type(c_ptr),value :: bsr_col_ind_B complex(c_float_complex) :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnzb_D type(c_ptr),value :: bsr_val_D type(c_ptr),value :: bsr_row_ptr_D type(c_ptr),value :: bsr_col_ind_D type(c_ptr),value :: descr_C type(c_ptr),value :: bsr_val_C type(c_ptr),value :: bsr_row_ptr_C type(c_ptr),value :: bsr_col_ind_C type(c_ptr),value :: info_C type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_zbsrgemm function rocsparse_zbsrgemm_(handle,dir,trans_A,trans_B,mb,nb,kb,block_dim,alpha,descr_A, & nnzb_A,bsr_val_A,bsr_row_ptr_A,bsr_col_ind_A,descr_B,nnzb_B,bsr_val_B,bsr_row_ptr_B, & bsr_col_ind_B,beta,descr_D,nnzb_D,bsr_val_D,bsr_row_ptr_D,bsr_col_ind_D,descr_C,bsr_val_C, & bsr_row_ptr_C,bsr_col_ind_C,info_C,temp_buffer) & bind(c, name="rocsparse_zbsrgemm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrgemm_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: kb integer(c_int),value :: block_dim complex(c_double_complex) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnzb_A type(c_ptr),value :: bsr_val_A type(c_ptr),value :: bsr_row_ptr_A type(c_ptr),value :: bsr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnzb_B type(c_ptr),value :: bsr_val_B type(c_ptr),value :: bsr_row_ptr_B type(c_ptr),value :: bsr_col_ind_B complex(c_double_complex) :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnzb_D type(c_ptr),value :: bsr_val_D type(c_ptr),value :: bsr_row_ptr_D type(c_ptr),value :: bsr_col_ind_D type(c_ptr),value :: descr_C type(c_ptr),value :: bsr_val_C type(c_ptr),value :: bsr_row_ptr_C type(c_ptr),value :: bsr_col_ind_C type(c_ptr),value :: info_C type(c_ptr),value :: temp_buffer end function end interface !> \ingroup extra_module !> \details !> \p rocsparse_csrgeam_nnz computes the total CSR non-zero elements and the CSR row !> offsets that point to the start of every row of the sparse CSR matrix of the !> resulting matrix C. It is assumed that \p csr_row_ptr_C has been allocated with !> size \p m+1. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> Currently, only `rocsparse_matrix_type_general` is supported. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix \f$A\f$, \f$B\f$, and \f$C\f$. !> @param[in] n - number of columns of the sparse CSR matrix \f$A\f$, \f$B\f$, and \f$C\f$. !> @param[in] descr_A - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_A - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] csr_row_ptr_A - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$A\f$. !> @param[in] csr_col_ind_A - array of \p nnz_A elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] descr_B - descriptor of the sparse CSR matrix \f$B\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_B - number of non-zero entries of the sparse CSR matrix \f$B\f$. !> @param[in] csr_row_ptr_B - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$B\f$. !> @param[in] csr_col_ind_B - array of \p nnz_B elements containing the column indices of the !> sparse CSR matrix \f$B\f$. !> @param[in] descr_C - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] csr_row_ptr_C - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$C\f$. !> @param[out] nnz_C - pointer to the number of non-zero entries of the sparse CSR !> matrix \f$C\f$. \p nnz_C can be a host or device pointer. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, \p nnz_A, or \p nnz_B is invalid. !> \retval rocsparse_status_invalid_pointer \p descr_A, \p csr_row_ptr_A, !> \p csr_col_ind_A, \p descr_B, \p csr_row_ptr_B, \p csr_col_ind_B, !> \p descr_C, \p csr_row_ptr_C, or \p nnz_C is invalid. !> \retval rocsparse_status_not_implemented !> \p rocsparse_matrix_type != `rocsparse_matrix_type_general`. interface rocsparse_csrgeam_nnz function rocsparse_csrgeam_nnz_(handle,m,n,descr_A,nnz_A,csr_row_ptr_A,csr_col_ind_A,descr_B, & nnz_B,csr_row_ptr_B,csr_col_ind_B,descr_C,csr_row_ptr_C,nnz_C) & bind(c, name="rocsparse_csrgeam_nnz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrgeam_nnz_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: descr_A integer(c_int),value :: nnz_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnz_B type(c_ptr),value :: csr_row_ptr_B type(c_ptr),value :: csr_col_ind_B type(c_ptr),value :: descr_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: nnz_C end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_csrgeam_nnz_assumed_rank #else module procedure & rocsparse_csrgeam_nnz_rank_0,& rocsparse_csrgeam_nnz_rank_1 #endif #endif end interface !> \ingroup extra_module !> \brief Sparse matrix sparse matrix addition using the CSR storage format. !> !> \details !> \p rocsparse_csrgeam multiplies the scalar \f$\alpha\f$ with the sparse !> \f$m \times n\f$ matrix \f$A\f$, defined in CSR storage format, multiplies the !> scalar \f$\beta\f$ with the sparse \f$m \times n\f$ matrix \f$B\f$, defined in CSR !> storage format, and adds both resulting matrices to obtain the sparse !> \f$m \times n\f$ matrix \f$C\f$, defined in CSR storage format, such that !> \f[ !> C := \alpha \cdot A + \beta \cdot B. !> \f] !> !> It is assumed that \p csr_row_ptr_C has already been filled and that \p csr_val_C and !> \p csr_col_ind_C are allocated by the user. \p csr_row_ptr_C and the allocation size of !> \p csr_col_ind_C and \p csr_val_C is defined by the number of non-zero elements of !> the sparse CSR matrix C. Both can be obtained by `rocsparse_csrgeam_nnz`(). !> !> \note Both scalars \f$\alpha\f$ and \f$beta\f$ have to be valid. !> !> \note Currently, only `rocsparse_matrix_type_general` is supported. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix \f$A\f$, \f$B\f$, and \f$C\f$. !> @param[in] n - number of columns of the sparse CSR matrix \f$A\f$, \f$B\f$, and \f$C\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr_A - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_A - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] csr_val_A - array of \p nnz_A elements of the sparse CSR matrix \f$A\f$. !> @param[in] csr_row_ptr_A - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$A\f$. !> @param[in] csr_col_ind_A - array of \p nnz_A elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] beta - scalar \f$\beta\f$. !> @param[in] descr_B - descriptor of the sparse CSR matrix \f$B\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_B - number of non-zero entries of the sparse CSR matrix \f$B\f$. !> @param[in] csr_val_B - array of \p nnz_B elements of the sparse CSR matrix \f$B\f$. !> @param[in] csr_row_ptr_B - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$B\f$. !> @param[in] csr_col_ind_B - array of \p nnz_B elements containing the column indices of the !> sparse CSR matrix \f$B\f$. !> @param[in] descr_C - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] csr_val_C - array of elements of the sparse CSR matrix \f$C\f$. !> @param[in] csr_row_ptr_C - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$C\f$. !> @param[out] csr_col_ind_C - array of elements containing the column indices of the !> sparse CSR matrix \f$C\f$. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, \p nnz_A, or \p nnz_B is invalid. !> \retval rocsparse_status_invalid_pointer \p alpha, \p descr_A, \p csr_val_A, !> \p csr_row_ptr_A, \p csr_col_ind_A, \p beta, \p descr_B, \p csr_val_B, !> \p csr_row_ptr_B, \p csr_col_ind_B, \p descr_C, \p csr_val_C, !> \p csr_row_ptr_C, or \p csr_col_ind_C is invalid. !> \retval rocsparse_status_not_implemented !> \p rocsparse_matrix_type != `rocsparse_matrix_type_general`. !> !> \par Example !> This example adds two CSR matrices. interface rocsparse_scsrgeam function rocsparse_scsrgeam_(handle,m,n,alpha,descr_A,nnz_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,beta,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,descr_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C) & bind(c, name="rocsparse_scsrgeam") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrgeam_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnz_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A real(c_float) :: beta type(c_ptr),value :: descr_B integer(c_int),value :: nnz_B type(c_ptr),value :: csr_val_B type(c_ptr),value :: csr_row_ptr_B type(c_ptr),value :: csr_col_ind_B type(c_ptr),value :: descr_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsrgeam_assumed_rank #else module procedure & rocsparse_scsrgeam_rank_0,& rocsparse_scsrgeam_rank_1 #endif #endif end interface interface rocsparse_dcsrgeam function rocsparse_dcsrgeam_(handle,m,n,alpha,descr_A,nnz_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,beta,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,descr_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C) & bind(c, name="rocsparse_dcsrgeam") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrgeam_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnz_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A real(c_double) :: beta type(c_ptr),value :: descr_B integer(c_int),value :: nnz_B type(c_ptr),value :: csr_val_B type(c_ptr),value :: csr_row_ptr_B type(c_ptr),value :: csr_col_ind_B type(c_ptr),value :: descr_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsrgeam_assumed_rank #else module procedure & rocsparse_dcsrgeam_rank_0,& rocsparse_dcsrgeam_rank_1 #endif #endif end interface interface rocsparse_ccsrgeam function rocsparse_ccsrgeam_(handle,m,n,alpha,descr_A,nnz_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,beta,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,descr_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C) & bind(c, name="rocsparse_ccsrgeam") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrgeam_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnz_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A complex(c_float_complex) :: beta type(c_ptr),value :: descr_B integer(c_int),value :: nnz_B type(c_ptr),value :: csr_val_B type(c_ptr),value :: csr_row_ptr_B type(c_ptr),value :: csr_col_ind_B type(c_ptr),value :: descr_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsrgeam_assumed_rank #else module procedure & rocsparse_ccsrgeam_rank_0,& rocsparse_ccsrgeam_rank_1 #endif #endif end interface interface rocsparse_zcsrgeam function rocsparse_zcsrgeam_(handle,m,n,alpha,descr_A,nnz_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,beta,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,descr_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C) & bind(c, name="rocsparse_zcsrgeam") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrgeam_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnz_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A complex(c_double_complex) :: beta type(c_ptr),value :: descr_B integer(c_int),value :: nnz_B type(c_ptr),value :: csr_val_B type(c_ptr),value :: csr_row_ptr_B type(c_ptr),value :: csr_col_ind_B type(c_ptr),value :: descr_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsrgeam_assumed_rank #else module procedure & rocsparse_zcsrgeam_rank_0,& rocsparse_zcsrgeam_rank_1 #endif #endif end interface !> \ingroup extra_module !> \details !> \p rocsparse_csrgemm_buffer_size returns the size of the temporary storage buffer !> that is required by `rocsparse_csrgemm_nnz` () and \ref rocsparse_scsrgemm !> "rocsparse_Xcsrgemm()". !> The temporary storage buffer must be allocated by the user. !> !> \note !> Note that for matrix products with more than 4096 non-zero entries per row, !> an additional temporary storage buffer is allocated by the algorithm. !> \note !> Note that for matrix products with more than 8192 intermediate products per !> row, an additional temporary storage buffer is allocated by the algorithm. !> \note !> Currently, only \p trans_A == \p trans_B == `rocsparse_operation_none` is !> supported. !> \note !> Currently, only `rocsparse_matrix_type_general` is supported. !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans_A - matrix \f$A\f$ operation type. !> @param[in] trans_B - matrix \f$B\f$ operation type. !> @param[in] m - number of rows of the sparse CSR matrix \f$op(A)\f$ and \f$C\f$. !> @param[in] n - number of columns of the sparse CSR matrix \f$op(B)\f$ and !> \f$C\f$. !> @param[in] k - number of columns of the sparse CSR matrix \f$op(A)\f$ and number of !> rows of the sparse CSR matrix \f$op(B)\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr_A - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_A - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] csr_row_ptr_A - array of \p m+1 elements (\f$op(A) == A\f$, \p k+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(A)\f$. !> @param[in] csr_col_ind_A - array of \p nnz_A elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] descr_B - descriptor of the sparse CSR matrix \f$B\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_B - number of non-zero entries of the sparse CSR matrix \f$B\f$. !> @param[in] csr_row_ptr_B - array of \p k+1 elements (\f$op(B) == B\f$, \p m+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(B)\f$. !> @param[in] csr_col_ind_B - array of \p nnz_B elements containing the column indices of the !> sparse CSR matrix \f$B\f$. !> @param[in] beta - scalar \f$\beta\f$. !> @param[in] descr_D - descriptor of the sparse CSR matrix \f$D\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_D - number of non-zero entries of the sparse CSR matrix \f$D\f$. !> @param[in] csr_row_ptr_D - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$D\f$. !> @param[in] csr_col_ind_D - array of \p nnz_D elements containing the column indices of the !> sparse !> CSR matrix \f$D\f$. !> @param[inout] info_C - structure that holds metadata for the sparse CSR matrix \f$C\f$. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> `rocsparse_csrgemm_nnz`() and \ref rocsparse_scsrgemm "rocsparse_Xcsrgemm()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, \p k, \p nnz_A, \p nnz_B, or !> \p nnz_D is invalid. !> \retval rocsparse_status_invalid_pointer \p alpha and \p beta are invalid, !> \p descr_A, \p csr_row_ptr_A, \p csr_col_ind_A, \p descr_B, !> \p csr_row_ptr_B or \p csr_col_ind_B are invalid if \p alpha is valid, !> \p descr_D, \p csr_row_ptr_D, or \p csr_col_ind_D is invalid if \p beta is !> valid, \p info_C or \p buffer_size is invalid. !> \retval rocsparse_status_not_implemented !> \p trans_A != `rocsparse_operation_none`, !> \p trans_B != `rocsparse_operation_none`, or !> \p rocsparse_matrix_type != `rocsparse_matrix_type_general`. interface rocsparse_scsrgemm_buffer_size function rocsparse_scsrgemm_buffer_size_(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A, & csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,beta,descr_D,nnz_D, & csr_row_ptr_D,csr_col_ind_D,info_C,buffer_size) & bind(c, name="rocsparse_scsrgemm_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrgemm_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnz_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnz_B type(c_ptr),value :: csr_row_ptr_B type(c_ptr),value :: csr_col_ind_B real(c_float) :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnz_D type(c_ptr),value :: csr_row_ptr_D type(c_ptr),value :: csr_col_ind_D type(c_ptr),value :: info_C integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsrgemm_buffer_size_assumed_rank #else module procedure & rocsparse_scsrgemm_buffer_size_rank_0,& rocsparse_scsrgemm_buffer_size_rank_1 #endif #endif end interface interface rocsparse_dcsrgemm_buffer_size function rocsparse_dcsrgemm_buffer_size_(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A, & csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,beta,descr_D,nnz_D, & csr_row_ptr_D,csr_col_ind_D,info_C,buffer_size) & bind(c, name="rocsparse_dcsrgemm_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrgemm_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnz_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnz_B type(c_ptr),value :: csr_row_ptr_B type(c_ptr),value :: csr_col_ind_B real(c_double) :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnz_D type(c_ptr),value :: csr_row_ptr_D type(c_ptr),value :: csr_col_ind_D type(c_ptr),value :: info_C integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsrgemm_buffer_size_assumed_rank #else module procedure & rocsparse_dcsrgemm_buffer_size_rank_0,& rocsparse_dcsrgemm_buffer_size_rank_1 #endif #endif end interface interface rocsparse_ccsrgemm_buffer_size function rocsparse_ccsrgemm_buffer_size_(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A, & csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,beta,descr_D,nnz_D, & csr_row_ptr_D,csr_col_ind_D,info_C,buffer_size) & bind(c, name="rocsparse_ccsrgemm_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrgemm_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnz_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnz_B type(c_ptr),value :: csr_row_ptr_B type(c_ptr),value :: csr_col_ind_B complex(c_float_complex) :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnz_D type(c_ptr),value :: csr_row_ptr_D type(c_ptr),value :: csr_col_ind_D type(c_ptr),value :: info_C integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsrgemm_buffer_size_assumed_rank #else module procedure & rocsparse_ccsrgemm_buffer_size_rank_0,& rocsparse_ccsrgemm_buffer_size_rank_1 #endif #endif end interface interface rocsparse_zcsrgemm_buffer_size function rocsparse_zcsrgemm_buffer_size_(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A, & csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,beta,descr_D,nnz_D, & csr_row_ptr_D,csr_col_ind_D,info_C,buffer_size) & bind(c, name="rocsparse_zcsrgemm_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrgemm_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnz_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnz_B type(c_ptr),value :: csr_row_ptr_B type(c_ptr),value :: csr_col_ind_B complex(c_double_complex) :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnz_D type(c_ptr),value :: csr_row_ptr_D type(c_ptr),value :: csr_col_ind_D type(c_ptr),value :: info_C integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsrgemm_buffer_size_assumed_rank #else module procedure & rocsparse_zcsrgemm_buffer_size_rank_0,& rocsparse_zcsrgemm_buffer_size_rank_1 #endif #endif end interface !> \ingroup extra_module !> \brief Sparse matrix sparse matrix multiplication using the CSR storage format. !> !> \details !> \p rocsparse_csrgemm_nnz computes the total CSR non-zero elements and the CSR row !> offsets that point to the start of every row of the sparse CSR matrix of the !> resulting multiplied matrix C. It is assumed that \p csr_row_ptr_C has been allocated !> with size \p m+1. !> The required buffer size can be obtained by rocsparse_scsrgemm_buffer_size(), !> rocsparse_dcsrgemm_buffer_size(), rocsparse_ccsrgemm_buffer_size(), and !> rocsparse_zcsrgemm_buffer_size(), respectively. !> !> \note !> Note that for matrix products with more than 8192 intermediate products per !> row, an additional temporary storage buffer is allocated by the algorithm. !> \note !> This function supports unsorted CSR matrices as input, while output will be sorted. !> Note that matrices B and D can only be unsorted up to 8192 intermediate !> products per row. If this number is exceeded, `rocsparse_status_requires_sorted_storage` !> will be returned. !> \note !> This function is blocking with respect to the host. !> \note !> Currently, only \p trans_A == \p trans_B == `rocsparse_operation_none` is !> supported. !> \note !> Currently, only `rocsparse_matrix_type_general` is supported. !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans_A - matrix \f$A\f$ operation type. !> @param[in] trans_B - matrix \f$B\f$ operation type. !> @param[in] m - number of rows of the sparse CSR matrix \f$op(A)\f$ and \f$C\f$. !> @param[in] n - number of columns of the sparse CSR matrix \f$op(B)\f$ and !> \f$C\f$. !> @param[in] k - number of columns of the sparse CSR matrix \f$op(A)\f$ and number of !> rows of the sparse CSR matrix \f$op(B)\f$. !> @param[in] descr_A - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_A - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] csr_row_ptr_A - array of \p m+1 elements (\f$op(A) == A\f$, \p k+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(A)\f$. !> @param[in] csr_col_ind_A - array of \p nnz_A elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] descr_B - descriptor of the sparse CSR matrix \f$B\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_B - number of non-zero entries of the sparse CSR matrix \f$B\f$. !> @param[in] csr_row_ptr_B - array of \p k+1 elements (\f$op(B) == B\f$, \p m+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(B)\f$. !> @param[in] csr_col_ind_B - array of \p nnz_B elements containing the column indices of the !> sparse CSR matrix \f$B\f$. !> @param[in] descr_D - descriptor of the sparse CSR matrix \f$D\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_D - number of non-zero entries of the sparse CSR matrix \f$D\f$. !> @param[in] csr_row_ptr_D - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$D\f$. !> @param[in] csr_col_ind_D - array of \p nnz_D elements containing the column indices of the !> sparse !> CSR matrix \f$D\f$. !> @param[in] descr_C - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] csr_row_ptr_C - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$C\f$. !> @param[out] nnz_C - pointer to the number of non-zero entries of the sparse CSR !> matrix \f$C\f$. !> @param[in] info_C - structure that holds meta data for the sparse CSR matrix \f$C\f$. !> @param[in] temp_buffer - temporary storage buffer allocated by the user, size is returned !> by rocsparse_scsrgemm_buffer_size(), !> rocsparse_dcsrgemm_buffer_size(), rocsparse_ccsrgemm_buffer_size(), or !> rocsparse_zcsrgemm_buffer_size(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, \p k, \p nnz_A, \p nnz_B, or !> \p nnz_D is invalid. !> \retval rocsparse_status_invalid_pointer \p descr_A, \p csr_row_ptr_A, !> \p csr_col_ind_A, \p descr_B, \p csr_row_ptr_B, \p csr_col_ind_B, !> \p descr_D, \p csr_row_ptr_D, \p csr_col_ind_D, \p descr_C, !> \p csr_row_ptr_C, \p nnz_C, \p info_C, or \p temp_buffer is invalid. !> \retval rocsparse_status_memory_error additional buffer for long rows could not be !> allocated. !> \retval rocsparse_status_not_implemented !> \p trans_A != `rocsparse_operation_none`, !> \p trans_B != `rocsparse_operation_none`, or !> \p rocsparse_matrix_type != `rocsparse_matrix_type_general`. interface rocsparse_csrgemm_nnz function rocsparse_csrgemm_nnz_(handle,trans_A,trans_B,m,n,k,descr_A,nnz_A,csr_row_ptr_A, & csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,descr_D,nnz_D,csr_row_ptr_D, & csr_col_ind_D,descr_C,csr_row_ptr_C,nnz_C,info_C,temp_buffer) & bind(c, name="rocsparse_csrgemm_nnz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrgemm_nnz_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: descr_A integer(c_int),value :: nnz_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnz_B type(c_ptr),value :: csr_row_ptr_B type(c_ptr),value :: csr_col_ind_B type(c_ptr),value :: descr_D integer(c_int),value :: nnz_D type(c_ptr),value :: csr_row_ptr_D type(c_ptr),value :: csr_col_ind_D type(c_ptr),value :: descr_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: nnz_C type(c_ptr),value :: info_C type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_csrgemm_nnz_assumed_rank #else module procedure & rocsparse_csrgemm_nnz_rank_0,& rocsparse_csrgemm_nnz_rank_1 #endif #endif end interface !> \ingroup extra_module !> \brief Sparse matrix sparse matrix multiplication using the CSR storage format. !> !> \details !> \p rocsparse_csrgemm multiplies the scalar \f$\alpha\f$ with the sparse !> \f$m \times k\f$ matrix \f$A\f$, defined in CSR storage format, and the sparse !> \f$k \times n\f$ matrix \f$B\f$, defined in CSR storage format, and adds the result !> to the sparse \f$m \times n\f$ matrix \f$D\f$ that is multiplied by \f$\beta\f$. The !> final result is stored in the sparse \f$m \times n\f$ matrix \f$C\f$, defined in CSR !> storage format, such !> that !> \f[ !> C := \alpha \cdot op(A) \cdot op(B) + \beta \cdot D, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans_A == rocsparse_operation_none} \\% !> A^T, & \text{if trans_A == rocsparse_operation_transpose} \\% !> A^H, & \text{if trans_A == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if trans_B == rocsparse_operation_none} \\% !> B^T, & \text{if trans_B == rocsparse_operation_transpose} \\% !> B^H, & \text{if trans_B == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> !> \note !> This function does not produce deterministic results. !> !> It is assumed that \p csr_row_ptr_C has already been filled and that \p csr_val_C and !> \p csr_col_ind_C are allocated by the user. \p csr_row_ptr_C and the allocation size of !> \p csr_col_ind_C and \p csr_val_C are defined by the number of non-zero elements of !> the sparse CSR matrix C. Both can be obtained by using `rocsparse_csrgemm_nnz()`. The !> required buffer size for the computation can be obtained by !> rocsparse_scsrgemm_buffer_size(), rocsparse_dcsrgemm_buffer_size(), !> rocsparse_ccsrgemm_buffer_size(), and rocsparse_zcsrgemm_buffer_size(), respectively. !> !> \note If \f$\alpha == 0\f$, then \f$C = \beta \cdot D\f$ will be computed. !> \note If \f$\beta == 0\f$, then \f$C = \alpha \cdot op(A) \cdot op(B)\f$ will be computed. !> \note \f$\alpha == beta == 0\f$ is invalid. !> \note Currently, only \p trans_A == `rocsparse_operation_none` is supported. !> \note Currently, only \p trans_B == `rocsparse_operation_none` is supported. !> \note Currently, only `rocsparse_matrix_type_general` is supported. !> \note Note that for matrix products with more than 4096 non-zero entries per !> row, an additional temporary storage buffer is allocated by the algorithm. !> \note !> This function supports unsorted CSR matrices as input, while output will be sorted. !> Note that matrices B and D can only be unsorted up to 4096 non-zero entries !> per row. If this number is exceeded, `rocsparse_status_requires_sorted_storage` !> will be returned. !> \note !> This function is blocking with respect to the host. !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans_A - matrix \f$A\f$ operation type. !> @param[in] trans_B - matrix \f$B\f$ operation type. !> @param[in] m - number of rows of the sparse CSR matrix \f$op(A)\f$ and \f$C\f$. !> @param[in] n - number of columns of the sparse CSR matrix \f$op(B)\f$ and !> \f$C\f$. !> @param[in] k - number of columns of the sparse CSR matrix \f$op(A)\f$ and number of !> rows of the sparse CSR matrix \f$op(B)\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr_A - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_A - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] csr_val_A - array of \p nnz_A elements of the sparse CSR matrix \f$A\f$. !> @param[in] csr_row_ptr_A - array of \p m+1 elements (\f$op(A) == A\f$, \p k+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(A)\f$. !> @param[in] csr_col_ind_A - array of \p nnz_A elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] descr_B - descriptor of the sparse CSR matrix \f$B\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_B - number of non-zero entries of the sparse CSR matrix \f$B\f$. !> @param[in] csr_val_B - array of \p nnz_B elements of the sparse CSR matrix \f$B\f$. !> @param[in] csr_row_ptr_B - array of \p k+1 elements (\f$op(B) == B\f$, \p m+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(B)\f$. !> @param[in] csr_col_ind_B - array of \p nnz_B elements containing the column indices of the !> sparse CSR matrix \f$B\f$. !> @param[in] beta - scalar \f$\beta\f$. !> @param[in] descr_D - descriptor of the sparse CSR matrix \f$D\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_D - number of non-zero entries of the sparse CSR matrix \f$D\f$. !> @param[in] csr_val_D - array of \p nnz_D elements of the sparse CSR matrix \f$D\f$. !> @param[in] csr_row_ptr_D - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$D\f$. !> @param[in] csr_col_ind_D - array of \p nnz_D elements containing the column indices of the !> sparse CSR matrix \f$D\f$. !> @param[in] descr_C - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[out] csr_val_C - array of \p nnz_C elements of the sparse CSR matrix \f$C\f$. !> @param[in] csr_row_ptr_C - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$C\f$. !> @param[out] csr_col_ind_C - array of \p nnz_C elements containing the column indices of the !> sparse CSR matrix \f$C\f$. !> @param[in] info_C - structure that holds meta data for the sparse CSR matrix \f$C\f$. !> @param[in] temp_buffer - temporary storage buffer allocated by the user, size is returned !> by rocsparse_scsrgemm_buffer_size(), !> rocsparse_dcsrgemm_buffer_size(), rocsparse_ccsrgemm_buffer_size(), or !> rocsparse_zcsrgemm_buffer_size(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, \p k, \p nnz_A, \p nnz_B, or !> \p nnz_D is invalid. !> \retval rocsparse_status_invalid_pointer \p alpha and \p beta are invalid, !> \p descr_A, \p csr_val_A, \p csr_row_ptr_A, \p csr_col_ind_A, \p descr_B, !> \p csr_val_B, \p csr_row_ptr_B, or \p csr_col_ind_B are invalid if \p alpha !> is valid, \p descr_D, \p csr_val_D, \p csr_row_ptr_D, or \p csr_col_ind_D are !> invalid if \p beta is valid, or \p csr_val_C, \p csr_row_ptr_C, !> \p csr_col_ind_C, \p info_C, or \p temp_buffer are invalid. !> \retval rocsparse_status_memory_error additional buffer for long rows could not be !> allocated. !> \retval rocsparse_status_not_implemented !> \p trans_A != `rocsparse_operation_none`, !> \p trans_B != `rocsparse_operation_none`, or !> \p rocsparse_matrix_type != `rocsparse_matrix_type_general`. !> !> \par Example !> This example multiplies two CSR matrices with a scalar alpha and adds the result to !> another CSR matrix. !> \code{.c} !> // Initialize scalar multipliers !> float alpha = 2.0f; !> float beta = 1.0f; !> !> // Create matrix descriptors !> rocsparse_mat_descr descr_A; !> rocsparse_mat_descr descr_B; !> rocsparse_mat_descr descr_C; !> rocsparse_mat_descr descr_D; !> !> rocsparse_create_mat_descr(&descr_A); !> rocsparse_create_mat_descr(&descr_B); !> rocsparse_create_mat_descr(&descr_C); !> rocsparse_create_mat_descr(&descr_D); !> !> // Create matrix info structure !> rocsparse_mat_info info_C; !> rocsparse_create_mat_info(&info_C); !> !> // Set pointer mode !> rocsparse_set_pointer_mode(handle, rocsparse_pointer_mode_host); !> !> // Query rocsparse for the required buffer size !> size_t buffer_size; !> !> rocsparse_scsrgemm_buffer_size(handle, !> rocsparse_operation_none, !> rocsparse_operation_none, !> m, !> n, !> k, !> &alpha, !> descr_A, !> nnz_A, !> csr_row_ptr_A, !> csr_col_ind_A, !> descr_B, !> nnz_B, !> csr_row_ptr_B, !> csr_col_ind_B, !> &beta, !> descr_D, !> nnz_D, !> csr_row_ptr_D, !> csr_col_ind_D, !> info_C, !> &buffer_size); !> !> // Allocate buffer !> void* buffer; !> hipMalloc(&buffer, buffer_size); !> !> // Obtain number of total non-zero entries in C and row pointers of C !> rocsparse_int nnz_C; !> hipMalloc((void**)&csr_row_ptr_C, sizeof(rocsparse_int) * (m + 1)); !> !> rocsparse_csrgemm_nnz(handle, !> rocsparse_operation_none, !> rocsparse_operation_none, !> m, !> n, !> k, !> descr_A, !> nnz_A, !> csr_row_ptr_A, !> csr_col_ind_A, !> descr_B, !> nnz_B, !> csr_row_ptr_B, !> csr_col_ind_B, !> descr_D, !> nnz_D, !> csr_row_ptr_D, !> csr_col_ind_D, !> descr_C, !> csr_row_ptr_C, !> &nnz_C, !> info_C, !> buffer); !> !> // Compute column indices and values of C !> hipMalloc((void**)&csr_col_ind_C, sizeof(rocsparse_int) * nnz_C); !> hipMalloc((void**)&csr_val_C, sizeof(float) * nnz_C); !> !> rocsparse_scsrgemm(handle, !> rocsparse_operation_none, !> rocsparse_operation_none, !> m, !> n, !> k, !> &alpha, !> descr_A, !> nnz_A, !> csr_val_A, !> csr_row_ptr_A, !> csr_col_ind_A, !> descr_B, !> nnz_B, !> csr_val_B, !> csr_row_ptr_B, !> csr_col_ind_B, !> &beta, !> descr_D, !> nnz_D, !> csr_val_D, !> csr_row_ptr_D, !> csr_col_ind_D, !> descr_C, !> csr_val_C, !> csr_row_ptr_C, !> csr_col_ind_C, !> info_C, !> buffer); !> \endcode interface rocsparse_scsrgemm function rocsparse_scsrgemm_(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,beta, & descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,info_C,temp_buffer) & bind(c, name="rocsparse_scsrgemm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrgemm_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnz_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnz_B type(c_ptr),value :: csr_val_B type(c_ptr),value :: csr_row_ptr_B type(c_ptr),value :: csr_col_ind_B real(c_float) :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnz_D type(c_ptr),value :: csr_val_D type(c_ptr),value :: csr_row_ptr_D type(c_ptr),value :: csr_col_ind_D type(c_ptr),value :: descr_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C type(c_ptr),value :: info_C type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsrgemm_assumed_rank #else module procedure & rocsparse_scsrgemm_rank_0,& rocsparse_scsrgemm_rank_1 #endif #endif end interface interface rocsparse_dcsrgemm function rocsparse_dcsrgemm_(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,beta, & descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,info_C,temp_buffer) & bind(c, name="rocsparse_dcsrgemm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrgemm_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnz_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnz_B type(c_ptr),value :: csr_val_B type(c_ptr),value :: csr_row_ptr_B type(c_ptr),value :: csr_col_ind_B real(c_double) :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnz_D type(c_ptr),value :: csr_val_D type(c_ptr),value :: csr_row_ptr_D type(c_ptr),value :: csr_col_ind_D type(c_ptr),value :: descr_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C type(c_ptr),value :: info_C type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsrgemm_assumed_rank #else module procedure & rocsparse_dcsrgemm_rank_0,& rocsparse_dcsrgemm_rank_1 #endif #endif end interface interface rocsparse_ccsrgemm function rocsparse_ccsrgemm_(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,beta, & descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,info_C,temp_buffer) & bind(c, name="rocsparse_ccsrgemm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrgemm_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnz_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnz_B type(c_ptr),value :: csr_val_B type(c_ptr),value :: csr_row_ptr_B type(c_ptr),value :: csr_col_ind_B complex(c_float_complex) :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnz_D type(c_ptr),value :: csr_val_D type(c_ptr),value :: csr_row_ptr_D type(c_ptr),value :: csr_col_ind_D type(c_ptr),value :: descr_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C type(c_ptr),value :: info_C type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsrgemm_assumed_rank #else module procedure & rocsparse_ccsrgemm_rank_0,& rocsparse_ccsrgemm_rank_1 #endif #endif end interface interface rocsparse_zcsrgemm function rocsparse_zcsrgemm_(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,beta, & descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,info_C,temp_buffer) & bind(c, name="rocsparse_zcsrgemm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrgemm_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnz_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnz_B type(c_ptr),value :: csr_val_B type(c_ptr),value :: csr_row_ptr_B type(c_ptr),value :: csr_col_ind_B complex(c_double_complex) :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnz_D type(c_ptr),value :: csr_val_D type(c_ptr),value :: csr_row_ptr_D type(c_ptr),value :: csr_col_ind_D type(c_ptr),value :: descr_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C type(c_ptr),value :: info_C type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsrgemm_assumed_rank #else module procedure & rocsparse_zcsrgemm_rank_0,& rocsparse_zcsrgemm_rank_1 #endif #endif end interface !> \ingroup extra_module !> \brief Sparse matrix sparse matrix symbolic multiplication using the CSR storage format. !> !> \details !> \p rocsparse_csrgemm_symbolic multiplies two sparsity patterns and adds an extra one: \f[ opA !> \cdot op(B) + D \f] !> with \f$m \times k\f$ matrix \f$A\f$, defined in CSR storage format, the sparse !> \f$k \times n\f$ matrix \f$B\f$, defined in CSR storage format, and the sparse \f$m \times !> n\f$ matrix \f$D\f$. !> The final result is stored in the sparse \f$m \times n\f$ matrix \f$C\f$, defined in CSR !> storage format, such !> that !> \f[ !> C := op(A) \cdot op(B) + D, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans_A == rocsparse_operation_none} \\% !> A^T, & \text{if trans_A == rocsparse_operation_transpose} \\% !> A^H, & \text{if trans_A == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if trans_B == rocsparse_operation_none} \\% !> B^T, & \text{if trans_B == rocsparse_operation_transpose} \\% !> B^H, & \text{if trans_B == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> !> It is assumed that \p csr_row_ptr_C has already been filled and that !> \p csr_col_ind_C is allocated by the user. \p csr_row_ptr_C and the allocation size of !> \p csr_col_ind_C are defined by the number of non-zero elements of !> the sparse CSR matrix C. Both can be obtained by using `rocsparse_csrgemm_nnz()`. The !> required buffer size for the computation can be obtained by !> rocsparse_scsrgemm_buffer_size(), rocsparse_dcsrgemm_buffer_size(), !> rocsparse_ccsrgemm_buffer_size(), and rocsparse_zcsrgemm_buffer_size(), respectively. !> !> \note Currently, only \p trans_A == `rocsparse_operation_none` is supported. !> \note Currently, only \p trans_B == `rocsparse_operation_none` is supported. !> \note Currently, only `rocsparse_matrix_type_general` is supported. !> \note Note that for matrix products with more than 4096 non-zero entries per !> row, an additional temporary storage buffer is allocated by the algorithm. !> \note This function is blocking with respect to the host. !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans_A - matrix \f$A\f$ operation type. !> @param[in] trans_B - matrix \f$B\f$ operation type. !> @param[in] m - number of rows of the sparse CSR matrix \f$op(A)\f$ and \f$C\f$. !> @param[in] n - number of columns of the sparse CSR matrix \f$op(B)\f$ and !> \f$C\f$. !> @param[in] k - number of columns of the sparse CSR matrix \f$op(A)\f$ and number of !> rows of the sparse CSR matrix \f$op(B)\f$. !> @param[in] descr_A - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_A - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] csr_row_ptr_A - array of \p m+1 elements (\f$op(A) == A\f$, \p k+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(A)\f$. !> @param[in] csr_col_ind_A - array of \p nnz_A elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] descr_B - descriptor of the sparse CSR matrix \f$B\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_B - number of non-zero entries of the sparse CSR matrix \f$B\f$. !> @param[in] csr_row_ptr_B - array of \p k+1 elements (\f$op(B) == B\f$, \p m+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(B)\f$. !> @param[in] csr_col_ind_B - array of \p nnz_B elements containing the column indices of the !> sparse CSR matrix \f$B\f$. !> @param[in] descr_D - descriptor of the sparse CSR matrix \f$D\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_D - number of non-zero entries of the sparse CSR matrix \f$D\f$. !> @param[in] csr_row_ptr_D - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$D\f$. !> @param[in] csr_col_ind_D - array of \p nnz_D elements containing the column indices of the !> sparse CSR matrix \f$D\f$. !> @param[in] descr_C - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_C - number of non-zero entries of the sparse CSR matrix \f$C\f$. !> @param[in] csr_row_ptr_C - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$C\f$. !> @param[out] csr_col_ind_C - array of \p nnz_C elements containing the column indices of the !> sparse CSR matrix \f$C\f$. !> @param[in] info_C - structure that holds metadata for the sparse CSR matrix \f$C\f$. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. The size is returned !> by rocsparse_scsrgemm_buffer_size(), !> rocsparse_dcsrgemm_buffer_size(), rocsparse_ccsrgemm_buffer_size(), or !> rocsparse_zcsrgemm_buffer_size(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, \p k, \p nnz_A, \p nnz_B, or !> \p nnz_D is invalid. !> \retval rocsparse_status_invalid_pointer !> \p descr_A, \p csr_row_ptr_A, \p csr_col_ind_A, \p descr_B, !> \p csr_row_ptr_B, \p csr_col_ind_B, \p descr_D, \p csr_row_ptr_D, \p csr_col_ind_D !> \p csr_row_ptr_C, !> \p csr_col_ind_C, \p info_C, or \p temp_buffer is invalid. !> \retval rocsparse_status_memory_error additional buffer for long rows could not be !> allocated. !> \retval rocsparse_status_not_implemented !> \p trans_A != `rocsparse_operation_none`, !> \p trans_B != `rocsparse_operation_none`, or !> \p rocsparse_matrix_type != `rocsparse_matrix_type_general`. !> !> \par Example !> This example multiplies symbolically two CSR matrices and adds the result to !> another CSR matrix. !> \code{.c} !> // Initialize scalar multipliers !> float alpha = 2.0f; !> float beta = 1.0f; !> !> // Create matrix descriptors !> rocsparse_mat_descr descr_A; !> rocsparse_mat_descr descr_B; !> rocsparse_mat_descr descr_C; !> rocsparse_mat_descr descr_D; !> !> rocsparse_create_mat_descr(&descr_A); !> rocsparse_create_mat_descr(&descr_B); !> rocsparse_create_mat_descr(&descr_C); !> rocsparse_create_mat_descr(&descr_D); !> !> // Create matrix info structure !> rocsparse_mat_info info_C; !> rocsparse_create_mat_info(&info_C); !> !> // Set pointer mode !> rocsparse_set_pointer_mode(handle, rocsparse_pointer_mode_host); !> !> // Query rocsparse for the required buffer size !> size_t buffer_size; !> !> rocsparse_scsrgemm_buffer_size(handle, !> rocsparse_operation_none, !> rocsparse_operation_none, !> m, !> n, !> k, !> &alpha, !> descr_A, !> nnz_A, !> csr_row_ptr_A, !> csr_col_ind_A, !> descr_B, !> nnz_B, !> csr_row_ptr_B, !> csr_col_ind_B, !> &beta, !> descr_D, !> nnz_D, !> csr_row_ptr_D, !> csr_col_ind_D, !> info_C, !> &buffer_size); !> !> // Allocate buffer !> void* buffer; !> hipMalloc(&buffer, buffer_size); !> !> // Obtain number of total non-zero entries in C and row pointers of C !> rocsparse_int nnz_C; !> hipMalloc((void**)&csr_row_ptr_C, sizeof(rocsparse_int) * (m + 1)); !> !> rocsparse_csrgemm_nnz(handle, !> rocsparse_operation_none, !> rocsparse_operation_none, !> m, !> n, !> k, !> descr_A, !> nnz_A, !> csr_row_ptr_A, !> csr_col_ind_A, !> descr_B, !> nnz_B, !> csr_row_ptr_B, !> csr_col_ind_B, !> descr_D, !> nnz_D, !> csr_row_ptr_D, !> csr_col_ind_D, !> descr_C, !> csr_row_ptr_C, !> &nnz_C, !> info_C, !> buffer); !> !> // Compute column indices of C !> hipMalloc((void**)&csr_col_ind_C, sizeof(rocsparse_int) * nnz_C); !> !> rocsparse_csrgemm_symbolic(handle, !> rocsparse_operation_none, !> rocsparse_operation_none, !> m, !> n, !> k, !> descr_A, !> nnz_A, !> csr_row_ptr_A, !> csr_col_ind_A, !> descr_B, !> nnz_B, !> csr_row_ptr_B, !> csr_col_ind_B, !> descr_D, !> nnz_D, !> csr_row_ptr_D, !> csr_col_ind_D, !> descr_C, !> nnz_C, !> csr_row_ptr_C, !> csr_col_ind_C, !> info_C, !> buffer); !> \endcode interface rocsparse_csrgemm_symbolic function rocsparse_csrgemm_symbolic_(handle,trans_A,trans_B,m,n,k,descr_A,nnz_A,csr_row_ptr_A, & csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,descr_D,nnz_D,csr_row_ptr_D, & csr_col_ind_D,descr_C,nnz_C,csr_row_ptr_C,csr_col_ind_C,info_C,temp_buffer) & bind(c, name="rocsparse_csrgemm_symbolic") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrgemm_symbolic_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k type(c_ptr),value :: descr_A integer(c_int),value :: nnz_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnz_B type(c_ptr),value :: csr_row_ptr_B type(c_ptr),value :: csr_col_ind_B type(c_ptr),value :: descr_D integer(c_int),value :: nnz_D type(c_ptr),value :: csr_row_ptr_D type(c_ptr),value :: csr_col_ind_D type(c_ptr),value :: descr_C integer(c_int),value :: nnz_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C type(c_ptr),value :: info_C type(c_ptr),value :: temp_buffer end function end interface !> \ingroup extra_module !> \brief Sparse matrix sparse matrix numeric multiplication using the CSR storage format. !> !> \details !> \p rocsparse_csrgemm_numeric multiplies the scalar \f$\alpha\f$ with the sparse !> \f$m \times k\f$ matrix \f$A\f$, defined in CSR storage format, and the sparse !> \f$k \times n\f$ matrix \f$B\f$, defined in CSR storage format, and adds the result !> to the sparse \f$m \times n\f$ matrix \f$D\f$ that is multiplied by \f$\beta\f$. The !> final result is stored in the sparse \f$m \times n\f$ matrix \f$C\f$, predefined in CSR !> storage format, such !> that !> \f[ !> C := \alpha \cdot op(A) \cdot op(B) + \beta \cdot D, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans_A == rocsparse_operation_none} \\% !> A^T, & \text{if trans_A == rocsparse_operation_transpose} \\% !> A^H, & \text{if trans_A == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if trans_B == rocsparse_operation_none} \\% !> B^T, & \text{if trans_B == rocsparse_operation_transpose} \\% !> B^H, & \text{if trans_B == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> !> \note !> This function does not produce deterministic results. !> !> The symbolic part of the csr matrix C can be obtained by rocsparse_csrgemm_symbolic(). !> It is assumed that \p csr_row_ptr_C and \p csr_col_ind_C have already been filled and that \p !> csr_val_C is allocated by the user. \p csr_row_ptr_C and the allocation size of !> \p csr_col_ind_C and \p csr_val_C are defined by the number of non-zero elements of !> the sparse CSR matrix C. Both can be obtained by `rocsparse_csrgemm_nnz()`. The !> required buffer size for the computation can be obtained by !> rocsparse_scsrgemm_buffer_size(), rocsparse_dcsrgemm_buffer_size(), !> rocsparse_ccsrgemm_buffer_size(), and rocsparse_zcsrgemm_buffer_size(), respectively. !> !> \note If \f$\alpha == 0\f$, then \f$C = \beta \cdot D\f$ will be computed. !> \note If \f$\beta == 0\f$, then \f$C = \alpha \cdot op(A) \cdot op(B)\f$ will be computed. !> \note \f$\alpha == beta == 0\f$ is invalid. !> \note Currently, only \p trans_A == `rocsparse_operation_none` is supported. !> \note Currently, only \p trans_B == `rocsparse_operation_none` is supported. !> \note Currently, only `rocsparse_matrix_type_general` is supported. !> \note Note that for matrix products with more than 4096 non-zero entries per !> row, an additional temporary storage buffer is allocated by the algorithm. !> \note This function is blocking with respect to the host. !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans_A - matrix \f$A\f$ operation type. !> @param[in] trans_B - matrix \f$B\f$ operation type. !> @param[in] m - number of rows of the sparse CSR matrix \f$op(A)\f$ and \f$C\f$. !> @param[in] n - number of columns of the sparse CSR matrix \f$op(B)\f$ and !> \f$C\f$. !> @param[in] k - number of columns of the sparse CSR matrix \f$op(A)\f$ and number of !> rows of the sparse CSR matrix \f$op(B)\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr_A - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_A - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] csr_val_A - array of \p nnz_A elements of the sparse CSR matrix \f$A\f$. !> @param[in] csr_row_ptr_A - array of \p m+1 elements (\f$op(A) == A\f$, \p k+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(A)\f$. !> @param[in] csr_col_ind_A - array of \p nnz_A elements containing the column indices of the !> sparse CSR matrix \f$A\f$. !> @param[in] descr_B - descriptor of the sparse CSR matrix \f$B\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_B - number of non-zero entries of the sparse CSR matrix \f$B\f$. !> @param[in] csr_val_B - array of \p nnz_B elements of the sparse CSR matrix \f$B\f$. !> @param[in] csr_row_ptr_B - array of \p k+1 elements (\f$op(B) == B\f$, \p m+1 otherwise) !> that point to the start of every row of the sparse CSR matrix !> \f$op(B)\f$. !> @param[in] csr_col_ind_B - array of \p nnz_B elements containing the column indices of the !> sparse CSR matrix \f$B\f$. !> @param[in] beta - scalar \f$\beta\f$. !> @param[in] descr_D - descriptor of the sparse CSR matrix \f$D\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_D - number of non-zero entries of the sparse CSR matrix \f$D\f$. !> @param[in] csr_val_D - array of \p nnz_D elements of the sparse CSR matrix \f$D\f$. !> @param[in] csr_row_ptr_D - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$D\f$. !> @param[in] csr_col_ind_D - array of \p nnz_D elements containing the column indices of the !> sparse CSR matrix \f$D\f$. !> @param[in] descr_C - descriptor of the sparse CSR matrix \f$C\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] nnz_C - number of non-zero entries of the sparse CSR matrix \f$C\f$. !> @param[out] csr_val_C - array of \p nnz_C elements of the sparse CSR matrix \f$C\f$. !> @param[in] csr_row_ptr_C - array of \p m+1 elements that point to the start of every row of !> the !> sparse CSR matrix \f$C\f$. !> @param[in] csr_col_ind_C - array of \p nnz_C elements containing the column indices of the !> sparse CSR matrix \f$C\f$. !> @param[in] info_C - structure that holds metadata for the sparse CSR matrix \f$C\f$. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. The size is returned !> by rocsparse_scsrgemm_buffer_size(), !> rocsparse_dcsrgemm_buffer_size(), rocsparse_ccsrgemm_buffer_size(), or !> rocsparse_zcsrgemm_buffer_size(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, \p k, \p nnz_A, \p nnz_B, or !> \p nnz_D is invalid. !> \retval rocsparse_status_invalid_pointer \p alpha and \p beta are invalid, !> \p descr_A, \p csr_val_A, \p csr_row_ptr_A, \p csr_col_ind_A, \p descr_B, !> \p csr_val_B, \p csr_row_ptr_B, or \p csr_col_ind_B are invalid if \p alpha !> is valid, \p descr_D, \p csr_val_D, \p csr_row_ptr_D, or \p csr_col_ind_D is !> invalid if \p beta is valid, or \p csr_val_C, \p csr_row_ptr_C, !> \p csr_col_ind_C, \p info_C, or \p temp_buffer is invalid. !> \retval rocsparse_status_memory_error additional buffer for long rows could not be !> allocated. !> \retval rocsparse_status_not_implemented !> \p trans_A != `rocsparse_operation_none`, !> \p trans_B != `rocsparse_operation_none`, or !> \p rocsparse_matrix_type != `rocsparse_matrix_type_general`. !> !> \par Example !> This example multiplies two CSR matrices with a scalar alpha and adds the result to !> another CSR matrix. !> \code{.c} !> // Initialize scalar multipliers !> float alpha = 2.0f; !> float beta = 1.0f; !> !> // Create matrix descriptors !> rocsparse_mat_descr descr_A; !> rocsparse_mat_descr descr_B; !> rocsparse_mat_descr descr_C; !> rocsparse_mat_descr descr_D; !> !> rocsparse_create_mat_descr(&descr_A); !> rocsparse_create_mat_descr(&descr_B); !> rocsparse_create_mat_descr(&descr_C); !> rocsparse_create_mat_descr(&descr_D); !> !> // Create matrix info structure !> rocsparse_mat_info info_C; !> rocsparse_create_mat_info(&info_C); !> !> // Set pointer mode !> rocsparse_set_pointer_mode(handle, rocsparse_pointer_mode_host); !> !> // Query rocsparse for the required buffer size !> size_t buffer_size; !> !> rocsparse_scsrgemm_buffer_size(handle, !> rocsparse_operation_none, !> rocsparse_operation_none, !> m, !> n, !> k, !> &alpha, !> descr_A, !> nnz_A, !> csr_row_ptr_A, !> csr_col_ind_A, !> descr_B, !> nnz_B, !> csr_row_ptr_B, !> csr_col_ind_B, !> &beta, !> descr_D, !> nnz_D, !> csr_row_ptr_D, !> csr_col_ind_D, !> info_C, !> &buffer_size); !> !> // Allocate buffer !> void* buffer; !> hipMalloc(&buffer, buffer_size); !> !> // Obtain number of total non-zero entries in C and row pointers of C !> rocsparse_int nnz_C; !> hipMalloc((void**)&csr_row_ptr_C, sizeof(rocsparse_int) * (m + 1)); !> !> rocsparse_csrgemm_nnz(handle, !> rocsparse_operation_none, !> rocsparse_operation_none, !> m, !> n, !> k, !> descr_A, !> nnz_A, !> csr_row_ptr_A, !> csr_col_ind_A, !> descr_B, !> nnz_B, !> csr_row_ptr_B, !> csr_col_ind_B, !> descr_D, !> nnz_D, !> csr_row_ptr_D, !> csr_col_ind_D, !> descr_C, !> csr_row_ptr_C, !> &nnz_C, !> info_C, !> buffer); !> !> // Compute column indices and values of C !> hipMalloc((void**)&csr_col_ind_C, sizeof(rocsparse_int) * nnz_C); !> rocsparse_csrgemm_symbolic(handle, !> rocsparse_operation_none, !> rocsparse_operation_none, !> m, !> n, !> k, !> descr_A, !> nnz_A, !> csr_row_ptr_A, !> csr_col_ind_A, !> descr_B, !> nnz_B, !> csr_row_ptr_B, !> csr_col_ind_B, !> descr_D, !> nnz_D, !> csr_row_ptr_D, !> csr_col_ind_D, !> descr_C, !> nnz_C, !> csr_row_ptr_C, !> csr_col_ind_C, !> info_C, !> buffer); !> hipMalloc((void**)&csr_val_C, sizeof(float) * nnz_C); !> !> rocsparse_scsrgemm_numeric(handle, !> rocsparse_operation_none, !> rocsparse_operation_none, !> m, !> n, !> k, !> &alpha, !> descr_A, !> nnz_A, !> csr_val_A, !> csr_row_ptr_A, !> csr_col_ind_A, !> descr_B, !> nnz_B, !> csr_val_B, !> csr_row_ptr_B, !> csr_col_ind_B, !> &beta, !> descr_D, !> nnz_D, !> csr_val_D, !> csr_row_ptr_D, !> csr_col_ind_D, !> descr_C, !> nnz_C, !> csr_val_C, !> csr_row_ptr_C, !> csr_col_ind_C, !> info_C, !> buffer); !> \endcode interface rocsparse_scsrgemm_numeric function rocsparse_scsrgemm_numeric_(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B, & beta,descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,nnz_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C,info_C,temp_buffer) & bind(c, name="rocsparse_scsrgemm_numeric") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrgemm_numeric_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_float) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnz_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnz_B type(c_ptr),value :: csr_val_B type(c_ptr),value :: csr_row_ptr_B type(c_ptr),value :: csr_col_ind_B real(c_float) :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnz_D type(c_ptr),value :: csr_val_D type(c_ptr),value :: csr_row_ptr_D type(c_ptr),value :: csr_col_ind_D type(c_ptr),value :: descr_C integer(c_int),value :: nnz_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C type(c_ptr),value :: info_C type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_dcsrgemm_numeric function rocsparse_dcsrgemm_numeric_(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B, & beta,descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,nnz_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C,info_C,temp_buffer) & bind(c, name="rocsparse_dcsrgemm_numeric") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrgemm_numeric_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k real(c_double) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnz_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnz_B type(c_ptr),value :: csr_val_B type(c_ptr),value :: csr_row_ptr_B type(c_ptr),value :: csr_col_ind_B real(c_double) :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnz_D type(c_ptr),value :: csr_val_D type(c_ptr),value :: csr_row_ptr_D type(c_ptr),value :: csr_col_ind_D type(c_ptr),value :: descr_C integer(c_int),value :: nnz_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C type(c_ptr),value :: info_C type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_ccsrgemm_numeric function rocsparse_ccsrgemm_numeric_(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B, & beta,descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,nnz_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C,info_C,temp_buffer) & bind(c, name="rocsparse_ccsrgemm_numeric") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrgemm_numeric_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_float_complex) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnz_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnz_B type(c_ptr),value :: csr_val_B type(c_ptr),value :: csr_row_ptr_B type(c_ptr),value :: csr_col_ind_B complex(c_float_complex) :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnz_D type(c_ptr),value :: csr_val_D type(c_ptr),value :: csr_row_ptr_D type(c_ptr),value :: csr_col_ind_D type(c_ptr),value :: descr_C integer(c_int),value :: nnz_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C type(c_ptr),value :: info_C type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_zcsrgemm_numeric function rocsparse_zcsrgemm_numeric_(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B, & beta,descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,nnz_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C,info_C,temp_buffer) & bind(c, name="rocsparse_zcsrgemm_numeric") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrgemm_numeric_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k complex(c_double_complex) :: alpha type(c_ptr),value :: descr_A integer(c_int),value :: nnz_A type(c_ptr),value :: csr_val_A type(c_ptr),value :: csr_row_ptr_A type(c_ptr),value :: csr_col_ind_A type(c_ptr),value :: descr_B integer(c_int),value :: nnz_B type(c_ptr),value :: csr_val_B type(c_ptr),value :: csr_row_ptr_B type(c_ptr),value :: csr_col_ind_B complex(c_double_complex) :: beta type(c_ptr),value :: descr_D integer(c_int),value :: nnz_D type(c_ptr),value :: csr_val_D type(c_ptr),value :: csr_row_ptr_D type(c_ptr),value :: csr_col_ind_D type(c_ptr),value :: descr_C integer(c_int),value :: nnz_C type(c_ptr),value :: csr_val_C type(c_ptr),value :: csr_row_ptr_C type(c_ptr),value :: csr_col_ind_C type(c_ptr),value :: info_C type(c_ptr),value :: temp_buffer end function end interface !> \ingroup generic_module !> \brief Scale a sparse vector and add it to a scaled dense vector. !> !> \details !> \p rocsparse_axpby multiplies the sparse vector \f$x\f$ with scalar \f$\alpha\f$ and !> adds the result to the dense vector \f$y\f$ that is multiplied with scalar !> \f$\beta\f$, such that !> !> \f[ !> y := \alpha \cdot x + \beta \cdot y !> \f] !> !> \code{.c} !> for(i = 0; i < size; ++i) !> { !> y[i] = beta * y[i] !> } !> for(i = 0; i < nnz; ++i) !> { !> y[x_ind[i]] += alpha * x_val[i] !> } !> \endcode !> !> \p rocsparse_axpby supports the following uniform-precision data types for the sparse and !> dense vectors \p x and !> \p y and compute types for the scalars \f$\alpha\f$ and \f$\beta\f$. !> !> \par Uniform Precisions: !> !> !>
Uniform Precisions
X / Y / compute_type !>
rocsparse_datatype_f32_r !>
rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_c !>
!> !> \par Mixed Precisions: !> !> !>
Mixed Precisions
X / Y compute_type !>
rocsparse_datatype_f16_r rocsparse_datatype_f32_r !>
rocsparse_datatype_bf16_r rocsparse_datatype_f32_r !>
!> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> \note !> This routine does not support batched computation. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] x - sparse matrix descriptor. !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] y - dense matrix descriptor. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p alpha, \p x, \p beta, or \p y pointer is !> invalid. !> !> \par Example interface rocsparse_axpby function rocsparse_axpby_(handle,alpha,x,beta,y) bind(c, name="rocsparse_axpby") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_axpby_ type(c_ptr),value :: handle type(c_ptr),value :: alpha type(c_ptr),value :: x type(c_ptr),value :: beta type(c_ptr),value :: y end function end interface !> \ingroup generic_module !> \brief Check matrix to see if it is valid. !> !> \details !> \p rocsparse_check_spmat checks whether the input matrix is valid. !> !> \p rocsparse_check_spmat requires two steps to complete. First, call \p rocsparse_check_spmat !> with the stage parameter set to `rocsparse_check_spmat_stage_buffer_size`, which determines !> the !> size of the temporary buffer needed in the second step. Allocate this buffer and call !> \p rocsparse_check_spmat with the stage parameter set to !> `rocsparse_check_spmat_stage_compute`, !> which checks the input matrix for errors. Any detected errors in the input matrix are !> reported in the !> \p data_status (passed to the function as a host pointer). !> !> \par Uniform Precisions: !> !> !>
Uniform Precisions
A !>
rocsparse_datatype_f32_r !>
rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_c !>
!> !> \note !> This function writes the required allocation size (in bytes) to \p buffer_size and !> returns without performing the checking operation when \p stage is equal to !> `rocsparse_check_spmat_stage_buffer_size`. !> !> \note !> The sparse matrix formats currently supported are: \p rocsparse_format_coo, \p !> rocsparse_format_csr, !> \p rocsparse_format_csc, \p rocsparse_format_ell, and \p rocsparse_format_bsr. !> !> \note check_spmat requires two stages to complete. The first stage !> `rocsparse_check_spmat_stage_buffer_size` will return the size of the temporary storage !> buffer !> that is required for subsequent calls to \ref rocsparse_check_spmat. !> In the final stage `rocsparse_check_spmat_stage_compute`, the actual computation is !> performed. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> \note !> This routine does not support batched computation. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] mat - matrix descriptor. !> @param[out] data_status - modified to indicate the status of the data. !> @param[in] stage - check_matrix stage for the matrix computation. !> @param[out] buffer_size - number of bytes of the temporary storage buffer. buffer_size is set !> when !> \p temp_buffer is nullptr. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. When a nullptr is !> passed, !> the required allocation size (in bytes) is written to \p buffer_size and !> function returns without performing the checking operation. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p mat, \p buffer_size, \p temp_buffer, or \p !> data_status pointer !> is invalid. !> \retval rocsparse_status_invalid_value the value of \p stage is incorrect. !> !> \par Example !> This example checks whether a matrix is upper triangular. The matrix passed to !> \ref rocsparse_check_spmat is invalid because it contains an entry in the lower triangular !> part of the matrix. interface rocsparse_check_spmat function rocsparse_check_spmat_(handle,mat,data_status,stage,buffer_size,temp_buffer) & bind(c, name="rocsparse_check_spmat") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_check_spmat_ type(c_ptr),value :: handle type(c_ptr),value :: mat type(c_ptr),value :: data_status integer(kind(rocsparse_check_spmat_stage_buffer_size)),value :: stage integer(c_size_t) :: buffer_size type(c_ptr),value :: temp_buffer end function end interface !> \ingroup generic_module !> \brief Dense matrix to sparse matrix conversion. !> !> \details !> \p rocsparse_dense_to_sparse performs the conversion of a dense matrix to a sparse matrix in !> CSR, CSC, or COO format. !> !> \p rocsparse_dense_to_sparse requires multiple steps to complete. First, call \p !> rocsparse_dense_to_sparse !> with \p nullptr passed into \p temp_buffer: !> \code{.c} !> // Call dense_to_sparse to get required buffer size !> size_t buffer_size = 0; !> rocsparse_dense_to_sparse(handle, !> matA, !> matB, !> rocsparse_dense_to_sparse_alg_default, !> &buffer_size, !> nullptr); !> \endcode !> After this is called, the \p buffer_size will be filled with the size of the required buffer !> that must be allocated. !> Next, call \p rocsparse_dense_to_sparse with the newly allocated \p temp_buffer and \p !> nullptr passed into !> \p buffer_size: !> \code{.c} !> // Call dense_to_sparse to perform analysis !> rocsparse_dense_to_sparse(handle, !> matA, !> matB, !> rocsparse_dense_to_sparse_alg_default, !> nullptr, !> temp_buffer); !> \endcode !> This will determine the number of non-zeros that will exist in the sparse matrix, which can !> be queried using the !> \ref rocsparse_spmat_get_size routine. With this, allocate the sparse matrix device arrays !> and !> set them on the sparse matrix descriptor using \ref rocsparse_csr_set_pointers (CSR format), !> \ref rocsparse_csc_set_pointers (for CSC format), or \ref rocsparse_coo_set_pointers (for COO !> format). Finally, the !> conversion is completed by calling \p rocsparse_dense_to_sparse with both the \p buffer_size !> and \p temp_buffer : !> \code{.c} !> // Call dense_to_sparse to complete conversion !> rocsparse_dense_to_sparse(handle, !> matA, !> matB, !> rocsparse_dense_to_sparse_alg_default, !> &buffer_size, !> temp_buffer); !> \endcode !> Currently, \p rocsparse_dense_to_sparse only supports the algorithm !> `rocsparse_dense_to_sparse_alg_default`. !> See the full example below. !> !> \p rocsparse_dense_to_sparse supports `rocsparse_datatype_f16_r`, !> `rocsparse_datatype_bf16_r`, `rocsparse_datatype_f32_r`, !> `rocsparse_datatype_f64_r`, `rocsparse_datatype_f32_c`, and `rocsparse_datatype_f64_c` for !> values arrays in the sparse matrix !> (stored in CSR, CSC, or COO format) and the dense matrix. For the row/column offset and !> row/column index arrays of the sparse matrix, !> \p rocsparse_dense_to_sparse supports the precisions `rocsparse_indextype_i32` and !> `rocsparse_indextype_i64`. !> !> \par Uniform Precisions: !> !> !>
Uniform Precisions
A / B !>
rocsparse_datatype_f16_r !>
rocsparse_datatype_bf16_r !>
rocsparse_datatype_f32_r !>
rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_c !>
!> !> \note !> This function writes the required allocation size (in bytes) to \p buffer_size and !> returns without performing the dense to sparse operation, when a nullptr is passed for !> \p temp_buffer. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> \note !> This routine does not support batched computation. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] mat_A - dense matrix descriptor. !> @param[in] mat_B - sparse matrix descriptor. !> @param[in] alg - algorithm for the dense to sparse computation. !> @param[out] buffer_size - number of bytes of the temporary storage buffer. buffer_size is set !> when !> \p temp_buffer is nullptr. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. When a nullptr is !> passed, !> the required allocation size (in bytes) is written to \p buffer_size and the !> function returns without performing the dense to sparse operation. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p mat_A, \p mat_B, or \p buffer_size !> pointer is invalid. !> !> \par Example interface rocsparse_dense_to_sparse function rocsparse_dense_to_sparse_(handle,mat_A,mat_B,alg,buffer_size,temp_buffer) & bind(c, name="rocsparse_dense_to_sparse") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dense_to_sparse_ type(c_ptr),value :: handle type(c_ptr),value :: mat_A type(c_ptr),value :: mat_B integer(kind(rocsparse_dense_to_sparse_alg_default)),value :: alg integer(c_size_t) :: buffer_size type(c_ptr),value :: temp_buffer end function end interface !> \ingroup generic_module !> \details !> \p rocsparse_extract_buffer_size calculates the required buffer size in bytes for a given !> stage \p stage. !> This routine is used in conjunction with \ref rocsparse_extract_nnz and \ref !> rocsparse_extract to extract !> a lower or upper triangular sparse matrix from an input sparse matrix. See \ref !> rocsparse_extract for more !> details. !> !> \note !> This routine is asynchronous with respect to the host. !> This routine supports execution in a hipGraph context. !> !> \note !> This routine does not support batched computation. !> !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] descr - descriptor of the extract algorithm. !> @param[in] source - source sparse matrix descriptor. !> @param[in] target - target sparse matrix descriptor. !> @param[in] stage - stage of the extract computation. !> @param[out] buffer_size_in_bytes - size in bytes of the buffer. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value if \p stage is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p source, \p target, or \p !> buffer_size_in_bytes !> pointer is invalid. interface rocsparse_extract_buffer_size function rocsparse_extract_buffer_size_(handle,descr,source,target,stage,buffer_size_in_bytes) & bind(c, name="rocsparse_extract_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_extract_buffer_size_ type(c_ptr),value :: handle type(c_ptr),value :: descr type(c_ptr),value :: source type(c_ptr),value :: target integer(kind(rocsparse_extract_stage_analysis)),value :: stage integer(c_size_t) :: buffer_size_in_bytes end function end interface !> \ingroup generic_module !> \details !> \p rocsparse_extract_nnz returns the number of non-zeros in the extracted matrix. The value !> is !> available after the analysis phase `rocsparse_extract_stage_analysis` has been executed. This !> routine !> is used in conjunction with \ref rocsparse_extract_buffer_size and \ref rocsparse_extract to !> extract a lower !> or upper triangular sparse matrix from an input sparse matrix. See \ref rocsparse_extract for !> more !> details. !> !> \note !> This routine is asynchronous with respect to the host. !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] descr - descriptor of the extract algorithm. !> @param[out] nnz - the number of non-zeros. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p descr or \p nnz pointer is invalid. interface rocsparse_extract_nnz function rocsparse_extract_nnz_(handle,descr,nnz) bind(c, name="rocsparse_extract_nnz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_extract_nnz_ type(c_ptr),value :: handle type(c_ptr),value :: descr integer(c_int64_t) :: nnz end function end interface !> \ingroup generic_module !> \brief Sparse matrix extraction. !> !> \details !> \p rocsparse_extract performs the extraction of the lower or upper part of a sparse matrix !> into a new matrix. !> !> \p rocsparse_extract requires multiple steps to complete. First, create the source and target !> sparse matrix !> descriptors. For example, in the case of CSR matrix format, this might look like: !> \code{.c} !> // Build Source !> rocsparse_spmat_descr source; !> rocsparse_create_csr_descr(&source, !> M, !> N, !> nnz, !> dsource_row_ptr, !> dsource_col_ind, !> dsource_val, !> rocsparse_indextype_i32, !> rocsparse_indextype_i32, !> rocsparse_index_base_zero, !> rocsparse_datatype_f32_r); !> !> // Build target !> void * dtarget_row_ptr; !> hipMalloc(&dtarget_row_ptr, sizeof(int32_t) * (M + 1)); !> rocsparse_spmat_descr target; !> rocsparse_create_csr_descr(&target, !> M, !> N, !> 0, !> dtarget_row_ptr, !> nullptr, !> nullptr, !> rocsparse_indextype_i32, !> rocsparse_indextype_i32, !> rocsparse_index_base_zero, !> rocsparse_datatype_f32_r); !> \endcode !> Next, create the extraction descriptor and call \ref rocsparse_extract_buffer_size with the !> stage !> `rocsparse_extract_stage_analysis` to determine the amount of temporary storage required. !> Allocate this temporary storage buffer and pass it to \p rocsparse_extract with the stage !> `rocsparse_extract_stage_analysis`. !> \code{.c} !> // Create descriptor !> rocsparse_extract_descr descr; !> rocsparse_create_extract_descr(&descr, !> source, !> target, !> rocsparse_extract_alg_default); !> !> // Analysis phase !> size_t buffer_size; !> rocsparse_extract_buffer_size(handle, !> descr, !> source, !> target, !> rocsparse_extract_stage_analysis, !> &buffer_size); !> void* dbuffer = nullptr; !> hipMalloc(&dbuffer, buffer_size); !> rocsparse_extract(handle, !> descr, !> source, !> target, !> rocsparse_extract_stage_analysis, !> buffer_size, !> dbuffer); !> hipFree(dbuffer); !> \endcode !> Then calls \ref rocsparse_extract_nnz to determine the number of non-zeros that will exist in !> the !> target matrix. After this is determined, allocate the column indices and values arrays of the !> target sparse !> matrix: !> \code{.c} !> int64_t target_nnz; !> rocsparse_extract_nnz(handle, descr, &target_nnz); !> !> void* dtarget_col_ind, !> void* dtarget_val; !> hipMalloc(&dtarget_col_ind, sizeof(int32_t) * target_nnz); !> hipMalloc(&dtarget_val, sizeof(float) * target_nnz); !> rocsparse_csr_set_pointers(target, dtarget_row_ptr, dtarget_col_ind, dtarget_val); !> \endcode !> Finally, call \ref rocsparse_extract_buffer_size with the stage !> `rocsparse_extract_stage_compute` !> to determine the size of the temporary user-allocated storage needed for the computation of !> the column indices and values !> in the sparse target. Allocate this buffer and complete the conversion by calling \p !> rocsparse_extract using !> the `rocsparse_extract_stage_compute` stage: !> \code{.c} !> // Calculation phase !> rocsparse_extract_buffer_size(handle, !> descr, !> source, !> target, !> rocsparse_extract_stage_compute, !> &buffer_size); !> hipMalloc(&dbuffer, buffer_size); !> rocsparse_extract(handle, !> descr, !> source, !> target, !> rocsparse_extract_stage_compute, !> buffer_size, !> dbuffer); !> hipFree(dbuffer); !> \endcode !> The target row pointer, column indices, and values arrays will now be filled with the upper !> or lower part of the source matrix. !> !> The source and the target matrices must have the same format (see `rocsparse_format` ) and !> the same storage mode (see !> `rocsparse_storage_mode` ). The attributes of the target matrix, the fill mode !> `rocsparse_fill_mode`, and the diagonal !> type `rocsparse_diag_type` are used to parameterize the algorithm. These can be set on the !> target matrix using !> \ref rocsparse_spmat_set_attribute. See the full example below. !> !> \note !> This routine is asynchronous with respect to the host. !> This routine supports execution in a hipGraph context. !> \note !> Supported formats are `rocsparse_format_csr` and `rocsparse_format_csc`. !> !> \note !> This routine does not support batched computation. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] descr - descriptor of the extract algorithm. !> @param[in] source - sparse matrix descriptor. !> @param[in] target - sparse matrix descriptor. !> @param[in] stage - stage of the extract computation. !> @param[in] buffer_size_in_bytes - size in bytes of the \p buffer. !> @param[in] buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value if \p stage is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p source, \p target, or \p buffer !> pointer is invalid. !> \par Example !> This example extracts the lower part of CSR matrix into a CSR matrix. interface rocsparse_extract function rocsparse_extract_(handle,descr,source,target,stage,buffer_size_in_bytes,buffer) & bind(c, name="rocsparse_extract") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_extract_ type(c_ptr),value :: handle type(c_ptr),value :: descr type(c_ptr),value :: source type(c_ptr),value :: target integer(kind(rocsparse_extract_stage_analysis)),value :: stage integer(c_size_t),value :: buffer_size_in_bytes type(c_ptr),value :: buffer end function end interface !> \ingroup generic_module !> \brief Gather elements from a dense vector and store them in a sparse vector. !> !> \details !> \p rocsparse_gather gathers the elements from the dense vector \f$y\f$ and stores !> them in the sparse vector \f$x\f$. !> !> \code{.c} !> for(i = 0; i < nnz; ++i) !> { !> x_val[i] = y[x_ind[i]]; !> } !> \endcode !> !> \p rocsparse_gather supports the following uniform-precision data types for the sparse and !> dense vectors \p x and !> \p y. !> !> \par Uniform Precisions: !> !> !>
Uniform Precisions
X / Y !>
rocsparse_datatype_i8_r !>
rocsparse_datatype_f16_r !>
rocsparse_datatype_bf16_r !>
rocsparse_datatype_f32_r !>
rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_c !>
!> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> \note !> This routine does not support batched computation. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] y - dense vector \f$y\f$. !> @param[out] x - sparse vector \f$x\f$. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p x or \p y pointer is invalid. !> !> \par Example interface rocsparse_gather function rocsparse_gather_(handle,y,x) bind(c, name="rocsparse_gather") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_gather_ type(c_ptr),value :: handle type(c_ptr),value :: y type(c_ptr),value :: x end function end interface !> \ingroup generic_module !> \brief Apply Givens rotation to a dense and a sparse vector. !> !> \details !> \p rocsparse_rot applies the Givens rotation matrix \f$G\f$ to the sparse vector !> \f$x\f$ and the dense vector \f$y\f$, where !> \f[ !> G = \begin{pmatrix} c & s \\ -s & c \end{pmatrix} !> \f] !> !> \code{.c} !> for(i = 0; i < nnz; ++i) !> { !> x_tmp = x_val[i]; !> y_tmp = y[x_ind[i]]; !> !> x_val[i] = c * x_tmp + s * y_tmp; !> y[x_ind[i]] = c * y_tmp - s * x_tmp; !> } !> \endcode !> !> \p rocsparse_rot supports the following uniform-precision data types for the sparse and dense !> vectors \p x and !> \p y and compute types for the scalars \f$c\f$ and \f$s\f$. !> !> \par Uniform Precisions: !> !> !>
Uniform Precisions
X / Y / compute_type !>
rocsparse_datatype_f32_r !>
rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_c !>
!> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> \note !> This routine does not support batched computation. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] c - pointer to the cosine element of \f$G\f$, which can be on host or device. !> @param[in] s - pointer to the sine element of \f$G\f$, which can be on host or device. !> @param[inout] x - sparse vector \f$x\f$. !> @param[inout] y - dense vector \f$y\f$. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p c, \p s, \p x, or \p y pointer is !> invalid. !> \par Example interface rocsparse_rot function rocsparse_rot_(handle,c,s,x,y) bind(c, name="rocsparse_rot") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_rot_ type(c_ptr),value :: handle type(c_ptr),value :: c type(c_ptr),value :: s type(c_ptr),value :: x type(c_ptr),value :: y end function end interface !> \ingroup generic_module !> \brief Scatter elements from a sparse vector into a dense vector. !> !> \details !> \p rocsparse_scatter scatters the elements from the sparse vector \f$x\f$ into the dense !> vector \f$y\f$. !> !> \code{.c} !> for(i = 0; i < nnz; ++i) !> { !> y[x_ind[i]] = x_val[i]; !> } !> \endcode !> !> \p rocsparse_scatter supports the following uniform-precision data types for the sparse and !> dense vectors \p x and !> \p y. !> !> \par Uniform Precisions: !> !> !>
Uniform Precisions
X / Y !>
rocsparse_datatype_i8_r !>
rocsparse_datatype_f16_r !>
rocsparse_datatype_bf16_r !>
rocsparse_datatype_f32_r !>
rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_c !>
!> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> \note !> This routine does not support batched computation. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] x - sparse vector \f$x\f$. !> @param[out] y - dense vector \f$y\f$. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p x or \p y pointer is invalid. !> !> \par Example interface rocsparse_scatter function rocsparse_scatter_(handle,x,y) bind(c, name="rocsparse_scatter") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scatter_ type(c_ptr),value :: handle type(c_ptr),value :: x type(c_ptr),value :: y end function end interface !> \ingroup generic_module !> \details !> \p rocsparse_sddmm_buffer_size returns the size of the required buffer to execute the SDDMM !> operation from a given configuration. !> This routine is used in conjunction with `rocsparse_sddmm_preprocess` () and !> `rocsparse_sddmm` (). !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] opA - dense matrix \f$A\f$ operation type. !> @param[in] opB - dense matrix \f$B\f$ operation type. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] mat_A - dense matrix \f$A\f$ descriptor. !> @param[in] mat_B - dense matrix \f$B\f$ descriptor. !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] mat_C - sparse matrix \f$C\f$ descriptor. !> @param[in] compute_type - floating point precision for the SDDMM computation. !> @param[in] alg - specification of the algorithm to use. !> @param[out] buffer_size - number of bytes of the temporary storage buffer. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_value the value of \p opA or \p opB is incorrect. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p alpha and \p beta are invalid, !> or the \p mat_A, \p mat_B, \p mat_C, or \p buffer_size pointer is invalid. !> \retval rocsparse_status_not_implemented !> \p opA == `rocsparse_operation_conjugate_transpose` or !> \p opB == `rocsparse_operation_conjugate_transpose`. interface rocsparse_sddmm_buffer_size function rocsparse_sddmm_buffer_size_(handle,opA,opB,alpha,mat_A,mat_B,beta,mat_C, & compute_type,alg,buffer_size) & bind(c, name="rocsparse_sddmm_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sddmm_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: opA integer(kind(rocsparse_operation_none)),value :: opB type(c_ptr),value :: alpha type(c_ptr),value :: mat_A type(c_ptr),value :: mat_B type(c_ptr),value :: beta type(c_ptr),value :: mat_C integer(kind(rocsparse_datatype_f16_r)),value :: compute_type integer(kind(rocsparse_sddmm_alg_default)),value :: alg integer(c_size_t) :: buffer_size end function end interface !> \ingroup generic_module !> \details !> \p rocsparse_sddmm_preprocess executes a part of the algorithm that can be calculated once in !> the context of multiple !> calls of the `rocsparse_sddmm` with the same sparsity pattern. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] opA - dense matrix \f$A\f$ operation type. !> @param[in] opB - dense matrix \f$B\f$ operation type. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] mat_A - dense matrix \f$A\f$ descriptor. !> @param[in] mat_B - dense matrix \f$B\f$ descriptor. !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] mat_C - sparse matrix \f$C\f$ descriptor. !> @param[in] compute_type - floating point precision for the SDDMM computation. !> @param[in] alg - specification of the algorithm to use. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> The size must be greater or equal to the size obtained with \ref rocsparse_sddmm_buffer_size. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_value the value of \p opA or \p opB is incorrect. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p alpha and \p beta are invalid, or the !> \p mat_A, \p mat_B, \p mat_C, or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_not_implemented !> \p opA == `rocsparse_operation_conjugate_transpose` or !> \p opB == `rocsparse_operation_conjugate_transpose`. interface rocsparse_sddmm_preprocess function rocsparse_sddmm_preprocess_(handle,opA,opB,alpha,mat_A,mat_B,beta,mat_C,compute_type, & alg,temp_buffer) & bind(c, name="rocsparse_sddmm_preprocess") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sddmm_preprocess_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: opA integer(kind(rocsparse_operation_none)),value :: opB type(c_ptr),value :: alpha type(c_ptr),value :: mat_A type(c_ptr),value :: mat_B type(c_ptr),value :: beta type(c_ptr),value :: mat_C integer(kind(rocsparse_datatype_f16_r)),value :: compute_type integer(kind(rocsparse_sddmm_alg_default)),value :: alg type(c_ptr),value :: temp_buffer end function end interface !> \ingroup generic_module !> \brief Sampled Dense-Dense Matrix Multiplication. !> !> \details !> \p rocsparse_sddmm multiplies the scalar \f$\alpha\f$ with the dense !> \f$m \times k\f$ matrix \f$op(A)\f$, the dense \f$k \times n\f$ matrix \f$op(B)\f$, filtered !> by the sparsity pattern !> of the \f$m \times n\f$ sparse matrix \f$C\f$ and adds the result to \f$C\f$ scaled by !> \f$\beta\f$. The final result is stored in the sparse \f$m \times n\f$ matrix \f$C\f$, !> such that !> \f[ !> C := \alpha ( op(A) \cdot op(B) ) \circ spy(C) + \beta C, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if op(A) == rocsparse_operation_none} \\% !> A^T, & \text{if op(A) == rocsparse_operation_transpose} \\% !> \end{array} !> \right. !> \f], !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if op(B) == rocsparse_operation_none} \\% !> B^T, & \text{if op(B) == rocsparse_operation_transpose} \\% !> \end{array} !> \right. !> \f] !> and !> \f[ !> spy(C)_{ij} = \left\{ !> \begin{array}{ll} !> 1, & \text{ if C_{ij} != 0} \\% !> 0, & \text{ otherwise} \\% !> \end{array} !> \right. !> \f] !> !> Computing the above sampled dense-dense multiplication requires three steps to complete. !> First, call !> \ref rocsparse_sddmm_buffer_size to determine the size of the required temporary storage !> buffer. Next, !> allocate this buffer and call `rocsparse_sddmm_preprocess`, which performs any analysis of !> the input matrices !> that might be required. Finally, call \p rocsparse_sddmm to complete the computation. After !> all calls to !> \p rocsparse_sddmm are complete, the temporary buffer can be deallocated. !> !> \p rocsparse_sddmm supports different algorithms which can provide better performance for !> different matrices. !> !> !> !> !> !>
Algorithms
Algorithms Deterministic Preprocessing Notes !>
rocsparse_sddmm_alg_default Yes No Uses the sparsity !> pattern of matrix C to perform a limited set of dot products.
rocsparse_sddmm_alg_dense Yes No Explicitly converts the !> matrix C into a dense matrix to perform a dense matrix multiply and add.
!> !> Currently, \p rocsparse_sddmm only supports the uniform precisions indicated in the table !> below. For the sparse matrix \f$C\f$, \p rocsparse_sddmm supports the index types !> `rocsparse_indextype_i32` and `rocsparse_indextype_i64`. !> !> \par Uniform Precisions: !> !> !>
Uniform Precisions
A / B / C / compute_type !>
rocsparse_datatype_f16_r !>
rocsparse_datatype_f32_r !>
rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_c !>
!> !> \par Mixed Precisions: !> !> !>
Mixed Precisions
A / B C compute_type !>
rocsparse_datatype_f16_r rocsparse_datatype_f32_r rocsparse_datatype_f32_r !>
rocsparse_datatype_f16_r rocsparse_datatype_f16_r rocsparse_datatype_f32_r !>
rocsparse_datatype_bf16_r rocsparse_datatype_f32_r rocsparse_datatype_f32_r !>
rocsparse_datatype_bf16_r rocsparse_datatype_bf16_r rocsparse_datatype_f32_r !>
!> !> \note !> The sparse matrix formats currently supported are: `rocsparse_format_csr`, !> `rocsparse_format_csc`, `rocsparse_format_coo`, `rocsparse_format_coo_aos`, !> and `rocsparse_format_ell`. !> !> \note \p opA == `rocsparse_operation_conjugate_transpose` is not supported. !> \note \p opB == `rocsparse_operation_conjugate_transpose` is not supported. !> !> \note !> This routine supports execution in a hipGraph context only when \p alg == !> `rocsparse_sddmm_alg_default`. !> !> \note !> This routine does not support batched computation. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] opA - dense matrix \f$A\f$ operation type. !> @param[in] opB - dense matrix \f$B\f$ operation type. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] mat_A - dense matrix \f$A\f$ descriptor. !> @param[in] mat_B - dense matrix \f$B\f$ descriptor. !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] mat_C - sparse matrix \f$C\f$ descriptor. !> @param[in] compute_type - floating point precision for the SDDMM computation. !> @param[in] alg - specification of the algorithm to use. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> The size must be greater or equal to the size obtained with \ref rocsparse_sddmm_buffer_size. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_value the value of \p opA, \p opB, \p compute\_type, or \p !> alg is incorrect. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p alpha and \p beta are invalid, or the !> \p mat_A, \p mat_B, \p mat_C, or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_not_implemented !> \p opA == `rocsparse_operation_conjugate_transpose` or !> \p opB == `rocsparse_operation_conjugate_transpose`. !> !> \par Example !> This example performs a sampled dense-dense matrix product, \f$C := \alpha ( A \cdot B ) !> \circ spy(C) + \beta C\f$ !> where \f$\circ\f$ is the Hadamard product. interface rocsparse_sddmm function rocsparse_sddmm_(handle,opA,opB,alpha,mat_A,mat_B,beta,mat_C,compute_type,alg, & temp_buffer) & bind(c, name="rocsparse_sddmm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sddmm_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: opA integer(kind(rocsparse_operation_none)),value :: opB type(c_ptr),value :: alpha type(c_ptr),value :: mat_A type(c_ptr),value :: mat_B type(c_ptr),value :: beta type(c_ptr),value :: mat_C integer(kind(rocsparse_datatype_f16_r)),value :: compute_type integer(kind(rocsparse_sddmm_alg_default)),value :: alg type(c_ptr),value :: temp_buffer end function end interface !> \ingroup generic_module !> \brief Sparse matrix to dense matrix conversion. !> !> \details !> \p rocsparse_sparse_to_dense performs the conversion of a sparse matrix in CSR, CSC, or COO !> format to a dense matrix. !> !> \p rocsparse_sparse_to_dense requires multiple steps to complete. First, call \p !> rocsparse_sparse_to_dense !> with \p nullptr passed into \p temp_buffer: !> \code{.c} !> // Call sparse_to_dense to get required buffer size !> size_t buffer_size = 0; !> rocsparse_sparse_to_dense(handle, !> matA, !> matB, !> rocsparse_sparse_to_dense_alg_default, !> &buffer_size, !> nullptr); !> \endcode !> After this is called, the \p buffer_size will be filled with the size of the required buffer !> that must be allocated. !> Finally, the conversion is completed by calling \p rocsparse_sparse_to_dense with both the \p !> buffer_size and \p temp_buffer: !> \code{.c} !> // Call dense_to_sparse to complete conversion !> rocsparse_sparse_to_dense(handle, !> matA, !> matB, !> rocsparse_sparse_to_dense_alg_default, !> &buffer_size, !> temp_buffer); !> \endcode !> Currently, \p rocsparse_sparse_to_dense only supports the algorithm !> `rocsparse_sparse_to_dense_alg_default`. !> See the full example below. !> !> \p rocsparse_sparse_to_dense supports `rocsparse_datatype_f16_r`, !> `rocsparse_datatype_bf16_r`, `rocsparse_datatype_f32_r`, !> `rocsparse_datatype_f64_r`, `rocsparse_datatype_f32_c`, and `rocsparse_datatype_f64_c` for !> values arrays in the sparse matrix !> (stored in CSR, CSC, or COO format) and the dense matrix. For the row/column offset and !> row/column index arrays of the !> sparse matrix, \p rocsparse_sparse_to_dense supports the precisions `rocsparse_indextype_i32` !> and !> `rocsparse_indextype_i64`. !> !> \par Uniform Precisions: !> !> !>
Uniform Precisions
A / B !>
rocsparse_datatype_f16_r !>
rocsparse_datatype_bf16_r !>
rocsparse_datatype_f32_r !>
rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_c !>
!> !> \note !> This function writes the required allocation size (in bytes) to \p buffer_size and !> returns without performing the sparse to dense operation when NULL is passed for !> \p temp_buffer. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> \note !> This routine does not support batched computation. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] mat_A - sparse matrix descriptor. !> @param[in] mat_B - dense matrix descriptor. !> @param[in] alg - algorithm for the sparse to dense computation. !> @param[out] buffer_size - number of bytes of the temporary storage buffer. buffer_size is set !> when !> \p temp_buffer is nullptr. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. When a nullptr is !> passed, !> the required allocation size (in bytes) is written to \p buffer_size and the !> function returns without performing the sparse to dense operation. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p mat_A, \p mat_B, or \p buffer_size !> pointer is invalid. !> !> \par Example interface rocsparse_sparse_to_dense function rocsparse_sparse_to_dense_(handle,mat_A,mat_B,alg,buffer_size,temp_buffer) & bind(c, name="rocsparse_sparse_to_dense") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sparse_to_dense_ type(c_ptr),value :: handle type(c_ptr),value :: mat_A type(c_ptr),value :: mat_B integer(kind(rocsparse_sparse_to_dense_alg_default)),value :: alg integer(c_size_t) :: buffer_size type(c_ptr),value :: temp_buffer end function end interface !> \ingroup generic_module !> \details !> \p rocsparse_sparse_to_sparse_buffer_size calculates the required buffer size in bytes for a !> given stage \p stage. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] descr - descriptor of the sparse_to_sparse algorithm. !> @param[in] source - source sparse matrix descriptor. !> @param[in] target - target sparse matrix descriptor. !> @param[in] stage - stage of the sparse_to_sparse computation. !> @param[out] buffer_size_in_bytes - size in bytes of the \p buffer !> !> \note !> This routine does not support batched computation. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value if any required enumeration is invalid. !> \retval rocsparse_status_invalid_pointer \p mat_A, \p mat_B, or \p buffer_size_in_bytes !> pointer is invalid. interface rocsparse_sparse_to_sparse_buffer_size function rocsparse_sparse_to_sparse_buffer_size_(handle,descr,source,target,stage, & buffer_size_in_bytes) & bind(c, name="rocsparse_sparse_to_sparse_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sparse_to_sparse_buffer_size_ type(c_ptr),value :: handle type(c_ptr),value :: descr type(c_ptr),value :: source type(c_ptr),value :: target integer(kind(rocsparse_sparse_to_sparse_stage_analysis)),value :: stage integer(c_size_t) :: buffer_size_in_bytes end function end interface !> \ingroup generic_module !> \brief Sparse matrix to sparse matrix conversion. !> !> \details !> \p rocsparse_sparse_to_sparse performs the conversion of a sparse matrix to a sparse matrix. !> !> \note !> The required allocation size (in bytes) to \p buffer_size_in_bytes must be obtained from \ref !> rocsparse_sparse_to_sparse_buffer_size !> for each stage. The required buffer size can be different between stages. !> !> \note !> The `rocsparse_format_bell` and `rocsparse_format_sell` formats are not supported. !> !> \note !> This routine does not support batched computation. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] descr - descriptor of the sparse_to_sparse algorithm. !> @param[in] source - sparse matrix descriptor. !> @param[in] target - sparse matrix descriptor. !> @param[in] stage - stage of the sparse_to_sparse computation. !> @param[in] buffer_size_in_bytes - size in bytes of the \p buffer. !> @param[in] buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \par Example !> This example converts a CSR matrix into an ELL matrix. interface rocsparse_sparse_to_sparse function rocsparse_sparse_to_sparse_(handle,descr,source,target,stage,buffer_size_in_bytes, & buffer) & bind(c, name="rocsparse_sparse_to_sparse") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sparse_to_sparse_ type(c_ptr),value :: handle type(c_ptr),value :: descr type(c_ptr),value :: source type(c_ptr),value :: target integer(kind(rocsparse_sparse_to_sparse_stage_analysis)),value :: stage integer(c_size_t),value :: buffer_size_in_bytes type(c_ptr),value :: buffer end function end interface !> \ingroup generic_module !> \details !> \p rocsparse_spgeam_buffer_size returns the size of the required buffer to execute the given !> stage of the SpGEAM operation. !> This routine is used in conjunction with `rocsparse_spgeam` (). See `rocsparse_spgeam` for a !> full description and example. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] descr - SpGEAM descriptor. !> @param[in] mat_A - sparse matrix \f$A\f$ descriptor. !> @param[in] mat_B - sparse matrix \f$B\f$ descriptor. !> @param[in] mat_C - sparse matrix \f$C\f$ descriptor. !> @param[in] stage - SpGEAM stage for the SpGEAM computation. !> @param[out] buffer_size - number of bytes of the temporary storage buffer. !> @param[out] error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p mat_A, \p mat_B, \p descr, or \p buffer_size !> pointer is invalid. interface rocsparse_spgeam_buffer_size function rocsparse_spgeam_buffer_size_(handle,descr,mat_A,mat_B,mat_C,stage,buffer_size,error) & bind(c, name="rocsparse_spgeam_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spgeam_buffer_size_ type(c_ptr),value :: handle type(c_ptr),value :: descr type(c_ptr),value :: mat_A type(c_ptr),value :: mat_B type(c_ptr),value :: mat_C integer(kind(rocsparse_spgeam_stage_analysis)),value :: stage integer(c_size_t) :: buffer_size type(c_ptr) :: error end function end interface !> \ingroup generic_module !> \brief Sparse matrix sparse matrix addition. !> !> \details !> \p rocsparse_spgeam multiplies the scalar \f$\alpha\f$ with the sparse \f$m \times n\f$ CSR !> matrix \f$op(A)\f$ !> and adds it to \f$\beta\f$ multiplied by the sparse \f$m \times n\f$ matrix \f$op(B)\f$. The !> final result is !> stored in the sparse \f$m \times n\f$ matrix \f$C\f$, !> such that !> \f[ !> C := \alpha op(A) + \beta op(B), !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans_A == rocsparse_operation_none} !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if trans_B == rocsparse_operation_none} !> \end{array} !> \right. !> \f] !> !> \p rocsparse_spgeam requires multiple steps to complete. First, create a !> `rocsparse_spgeam_descr` by !> calling \ref rocsparse_create_spgeam_descr. Set the SpGEAM algorithm (currently only !> `rocsparse_spgeam_alg_default` supported) as well as the compute type and the transpose !> operation type for the sparse !> matrices \f$op(A)\f$ and \f$op(B)\f$ using \ref rocsparse_spgeam_set_input. Next, calculate !> the total non-zeros !> that will exist in the sparse matrix \f$C\f$. To do so, call \ref !> rocsparse_spgeam_buffer_size with the stage set !> to `rocsparse_spgeam_stage_analysis`. This will fill the \p buffer_size parameter, allowing !> allocation of this buffer. !> After the buffer has been allocated, call \p rocsparse_spgeam with the same stage !> `rocsparse_spgeam_stage_analysis`. !> The total non-zeros and the row offset array for \f$C\f$ have now been calculated and are !> stored internally in the !> `rocsparse_spgeam_descr`. Now, retrieve the non-zero count using \ref !> rocsparse_spgeam_get_output and then !> allocate the \f$C\f$ matrix. To complete the computation, repeat the process (this time !> passing the stage !> `rocsparse_spgeam_stage_compute` ) by calling \ref rocsparse_spgeam_buffer_size to determine !> the required buffer size, then !> allocate the buffer, and finally call \p rocsparse_spgeam. The user-allocated buffers can be !> freed after each call to !> \p rocsparse_spgeam. After the computation is complete and the SpGEAM descriptor is no longer !> needed, call !> \ref rocsparse_destroy_spgeam_descr. See the full code example below. !> !> The stage `rocsparse_spgeam_stage_compute` computes the symbolic part and the numeric of the !> resulting matrix C. To perform multiple operations involving matrices of same sparsity !> patterns but with different numerical values, the symbolic stages !> (`rocsparse_spgeam_stage_symbolic_analysis` and `rocsparse_spgeam_stage_symbolic_compute` ) !> and the numeric stages (`rocsparse_spgeam_stage_numeric_analysis` and !> `rocsparse_spgeam_stage_numeric_compute` ) can be used to separate the symbolic calculation !> from the numeric calculation. !> !> \note The stages `rocsparse_spgeam_stage_analysis` and `rocsparse_spgeam_stage_compute` !> cannot be mixed with the stages `rocsparse_spgeam_stage_symbolic_analysis`, !> `rocsparse_spgeam_stage_symbolic_compute`, `rocsparse_spgeam_stage_numeric_analysis`, and !> `rocsparse_spgeam_stage_numeric_compute`. !> \note The stage `rocsparse_spgeam_stage_analysis` must precede the stage !> `rocsparse_spgeam_stage_compute`. !> \note The stage `rocsparse_spgeam_stage_symbolic_analysis` must precede the stage !> `rocsparse_spgeam_stage_symbolic_compute`. !> \note The stage `rocsparse_spgeam_stage_numeric_analysis` must precede the stage !> `rocsparse_spgeam_stage_numeric_compute`. !> \note The symbolic stages are not required to perform the numeric stages. !> \note The stage `rocsparse_spgeam_stage_numeric_analysis` must be reapplied if the numeric !> values of the input matrices \p mat_A and \p mat_B have changed between subsequent calls of !> the stage `rocsparse_spgeam_stage_numeric_compute`. !> !> \p rocsparse_spgeam supports multiple combinations of index types, data types, and compute !> types. The tables below indicate !> the currently supported different index and data types that can be used for the sparse !> matrices \f$op(A)\f$, \f$op(B)\f$, and !> \f$C\f$, and the compute type for \f$\alpha\f$ and \f$\beta\f$. The advantage of using !> different index and data types is to save on !> memory bandwidth and storage when a user application allows, while performing the actual !> computation in a higher precision. !> !> \note !> This routine does not support batched computation. !> !> \par Uniform Precisions: !> !> !>
Uniform Precisions
A / B / C / compute_type !>
rocsparse_datatype_f32_r !>
rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_c !>
!> !> \par Uniform Index Types: !> !> !> !> !>
CSR Uniform Index Types
CSR Row offset CSR Column indices !>
rocsparse_indextype_i32 rocsparse_indextype_i32
rocsparse_indextype_i64 rocsparse_indextype_i64
!> !> \par Mixed Index Types: !> !> !> !>
CSR Mixed Index Types
CSR Row offset CSR Column indices !>
rocsparse_indextype_i64 rocsparse_indextype_i32
!> !> In general, when adding two sparse matrices together, it is possible that the resulting !> matrix will require !> a larger index representation to store correctly. For example, when adding \f$A + B\f$ using !> `rocsparse_indextype_i32` index types for the row pointer and column indices arrays, it might !> be the case that the row pointer !> of the resulting \f$C\f$ matrix would require index type `rocsparse_indextype_i64`. This is !> currently not supported. In this !> scenario, store the \f$A\f$, \f$B\f$, and \f$C\f$ matrices using the higher index precision. !> !> Additionally, all three matrices \f$A\f$, \f$B\f$, and \f$C\f$ must use the same index types. !> For example, if \f$A\f$ uses the !> index type `rocsparse_indextype_i32` for the row offset array and the index type !> `rocsparse_indextype_i32` for the column !> indices array, then both \f$B\f$ and \f$C\f$ must also use these same index types for their !> respective row offset and column index !> arrays. In the scenario where \f$C\f$ requires a larger index type for the row offset array, !> store all three !> matrices using the larger index type `rocsparse_indextype_i64` for the row offsets array. !> !> \note Currently only CSR format is supported. !> \note Currently, only \p trans_A == `rocsparse_operation_none` is supported. !> \note Currently, only \p trans_B == `rocsparse_operation_none` is supported. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] descr - SpGEAM descriptor. !> @param[in] mat_A - sparse matrix \f$A\f$ descriptor. !> @param[in] mat_B - sparse matrix \f$B\f$ descriptor. !> @param[out] mat_C - sparse matrix \f$C\f$ descriptor. !> @param[in] stage - SpGEAM stage for the SpGEAM computation. !> @param[out] buffer_size - number of bytes of the temporary storage buffer. \p buffer_size is !> determined by calling \ref rocsparse_spgeam_buffer_size. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> @param[out] error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p mat_A, \p mat_B, \p mat_C, \p descr, or \p !> buffer_size pointer is invalid. !> !> \par First Example !> !> !> \par Second Example interface rocsparse_spgeam function rocsparse_spgeam_(handle,descr,mat_A,mat_B,mat_C,stage,buffer_size,temp_buffer,error) & bind(c, name="rocsparse_spgeam") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spgeam_ type(c_ptr),value :: handle type(c_ptr),value :: descr type(c_ptr),value :: mat_A type(c_ptr),value :: mat_B type(c_ptr),value :: mat_C integer(kind(rocsparse_spgeam_stage_analysis)),value :: stage integer(c_size_t),value :: buffer_size type(c_ptr),value :: temp_buffer type(c_ptr) :: error end function end interface !> \ingroup generic_module !> \brief Sparse matrix sparse matrix multiplication. !> !> \details !> \p rocsparse_spgemm multiplies the scalar \f$\alpha\f$ with the sparse !> \f$m \times k\f$ matrix \f$op(A)\f$ and the sparse \f$k \times n\f$ matrix \f$op(B)\f$ and !> adds the result to the sparse \f$m \times n\f$ matrix \f$D\f$ that is multiplied by !> \f$\beta\f$. The final result is stored in the sparse \f$m \times n\f$ matrix \f$C\f$, !> such that !> \f[ !> C := \alpha \cdot op(A) \cdot op(B) + \beta \cdot D, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans_A == rocsparse_operation_none} !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if trans_B == rocsparse_operation_none} !> \end{array} !> \right. !> \f] !> !> \p rocsparse_spgemm requires three stages to complete. First, pass the !> `rocsparse_spgemm_stage_buffer_size` !> stage to determine the size of the required temporary storage buffer. Next, allocate this !> buffer and call !> \p rocsparse_spgemm again with the `rocsparse_spgemm_stage_nnz` stage, which will determine !> the number of non-zeros !> in \f$C\f$. This stage will also fill in the row pointer array of \f$C\f$. Now that the !> number of non-zeros in \f$C\f$ !> is known, allocate space for the column indices and values arrays of \f$C\f$. Finally, call !> \p rocsparse_spgemm with the `rocsparse_spgemm_stage_compute` stage to perform the actual !> computation, which fills in !> the column indices and values arrays of \f$C\f$. After all calls to \p rocsparse_spgemm are !> complete, the temporary buffer !> can be deallocated. !> !> Alternatively, it is possible to perform sparse matrix products multiple times with matrices !> having the same sparsity !> pattern with different values. In this scenario, the process begins like before. First, call !> \p rocsparse_spgemm !> with stage `rocsparse_spgemm_stage_buffer_size` to determine the required buffer size. Then !> allocate this buffer !> and call \p rocsparse_spgemm with the stage `rocsparse_spgemm_stage_nnz` to determine the !> number of non-zeros in \f$C\f$ !> and allocate the \f$C\f$ column indices and values arrays. Now, however, call \p !> rocsparse_spgemm with the !> `rocsparse_spgemm_stage_symbolic` stage, which will fill in the column indices array of !> \f$C\f$ but not the values array. !> It is then possible to repeatedly change the values of \f$A\f$, \f$B\f$, and \f$D\f$ and call !> \p rocsparse_spgemm with !> the `rocsparse_spgemm_stage_numeric` stage, which fills the values array of \f$C\f$. The use !> of the extra !> `rocsparse_spgemm_stage_symbolic` and `rocsparse_spgemm_stage_numeric` stages allows users to !> compute the sparsity pattern !> of \f$C\f$ once, but compute the values multiple times. !> !> \p rocsparse_spgemm supports multiple combinations of data types and compute types. The !> tables below indicate the currently !> supported different data types that can be used for the sparse matrices \f$op(A)\f$, !> \f$op(B)\f$, \f$C\f$, and \f$D\f$, !> and the compute type for \f$\alpha\f$ and \f$\beta\f$. The advantage of using different data !> types is to save on !> memory bandwidth and storage when a user application allows, while performing the actual !> computation in a higher precision. !> !> \par Uniform Precisions: !> !> !>
Uniform Precisions
A / B / C / D / compute_type !>
rocsparse_datatype_f16_r !>
rocsparse_datatype_bf16_r !>
rocsparse_datatype_f32_r !>
rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_c !>
!> !> \p rocsparse_spgemm supports `rocsparse_indextype_i32` and `rocsparse_indextype_i64` index !> precisions for storing the row !> pointer and column indices arrays of the sparse matrices. !> !> In general, when multiplying two sparse matrices together, it is possible that the resulting !> matrix will require a !> larger index representation to store correctly. For example, when multiplying \f$A \times !> B\f$ using !> `rocsparse_indextype_i32` index types for the row pointer and column indices arrays, it might !> be the case that the row pointer !> of the resulting \f$C\f$ matrix would require index precision `rocsparse_indextype_i64`. This !> is currently not supported. !> In this scenario, the \f$A\f$ and \f$B\f$ matrices need to be stored using the higher index !> precision. !> !> \note !> This function does not produce deterministic results. !> !> \note SpGEMM requires three stages to complete. The first stage, !> `rocsparse_spgemm_stage_buffer_size`, will return the size of the temporary storage buffer !> that is required for subsequent calls to \ref rocsparse_spgemm. The second stage, !> `rocsparse_spgemm_stage_nnz`, will determine the number of non-zero elements of the !> resulting \f$C\f$ matrix. If the sparsity pattern of \f$C\f$ is already known, this !> stage can be skipped. In the final stage, `rocsparse_spgemm_stage_compute`, the actual !> computation is performed. !> \note If \f$\alpha == 0\f$, then \f$C = \beta \cdot D\f$ will be computed. !> \note If \f$\beta == 0\f$, then \f$C = \alpha \cdot op(A) \cdot op(B)\f$ will be !> computed. !> \note Currently only CSR and BSR formats are supported. !> \note If `rocsparse_spgemm_stage_symbolic` is selected, then only the symbolic computation is !> performed. !> \note If `rocsparse_spgemm_stage_numeric` is selected, then only the numeric computation is !> performed. !> \note For the `rocsparse_spgemm_stage_symbolic` and `rocsparse_spgemm_stage_numeric` stages, !> only the !> CSR matrix format is currently supported. !> \note \f$\alpha == beta == 0\f$ is invalid. !> \note It is permissible to pass the same sparse matrix for \f$C\f$ and \f$D\f$ if both !> matrices have the same sparsity pattern. !> \note Currently, only \p trans_A == `rocsparse_operation_none` is supported. !> \note Currently, only \p trans_B == `rocsparse_operation_none` is supported. !> \note This function is non-blocking and executed asynchronously with respect to the !> host. It can return before the actual computation has finished. !> \note Note that for rare matrix products with more than 4096 non-zero entries !> per row, an additional temporary storage buffer is allocated by the algorithm. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> \note !> This routine does not support batched computation. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans_A - sparse matrix \f$A\f$ operation type. !> @param[in] trans_B - sparse matrix \f$B\f$ operation type. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] A - sparse matrix \f$A\f$ descriptor. !> @param[in] B - sparse matrix \f$B\f$ descriptor. !> @param[in] beta - scalar \f$\beta\f$. !> @param[in] D - sparse matrix \f$D\f$ descriptor. !> @param[out] C - sparse matrix \f$C\f$ descriptor. !> @param[in] compute_type - floating point precision for the SpGEMM computation. !> @param[in] alg - SpGEMM algorithm for the SpGEMM computation. !> @param[in] stage - SpGEMM stage for the SpGEMM computation. !> @param[out] buffer_size - number of bytes of the temporary storage buffer. buffer_size is set !> when !> \p temp_buffer is nullptr. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. When a nullptr is !> passed, !> the required allocation size (in bytes) is written to \p buffer_size and the !> function returns without performing the SpGEMM operation. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p alpha and \p beta are invalid, or the !> \p A, \p B, \p D, \p C, or \p buffer_size pointer is invalid. !> \retval rocsparse_status_memory_error additional buffer for long rows could not be !> allocated. !> \retval rocsparse_status_not_implemented !> \p trans_A != `rocsparse_operation_none` or !> \p trans_B != `rocsparse_operation_none`. !> !> \par Example interface rocsparse_spgemm function rocsparse_spgemm_(handle,trans_A,trans_B,alpha,A,B,beta,D,C,compute_type,alg,stage, & buffer_size,temp_buffer) & bind(c, name="rocsparse_spgemm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spgemm_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B type(c_ptr),value :: alpha type(c_ptr),value :: A type(c_ptr),value :: B type(c_ptr),value :: beta type(c_ptr),value :: D type(c_ptr),value :: C integer(kind(rocsparse_datatype_f16_r)),value :: compute_type integer(kind(rocsparse_spgemm_alg_default)),value :: alg integer(kind(rocsparse_spgemm_stage_buffer_size)),value :: stage integer(c_size_t) :: buffer_size type(c_ptr),value :: temp_buffer end function end interface !> \ingroup generic_module !> \brief Incomplete Cholesky factorization with 0 fill-ins and no pivoting. !> \details !> \p rocsparse_spic0_buffer_size returns the size of the non-persistent buffer !> that is required by \ref rocsparse_spic0 and must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> \note !> This routine only supports uniform batched computation, that is, the same sparsity pattern !> but batched values of the matrices. !> !> \note !> Supported formats are `rocsparse_format_csr` and `rocsparse_format_bsr`. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] spic0_descr - Spic0 descriptor. !> @param[in] A - descriptor of the matrix to factorize. !> @param[in] P - descriptor of the factorization. In-place \p P = \p A is allowed. !> @param[in] spic0_stage - stage for the Spic0 computation. !> @param[out] p_buffer_size_in_bytes - number of bytes of the buffer. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if error descriptor is not required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_not_implemented the sparse format is invalid or the preconditioner !> \p P is not identical to the matrix to factorize \p A. !> \retval rocsparse_status_invalid_value the \p spic0_stage value is invalid. !> \retval rocsparse_status_invalid_pointer \p spic0_descr, \p A, \p P, or \p !> p_buffer_size_in_bytes pointer is invalid. interface rocsparse_spic0_buffer_size function rocsparse_spic0_buffer_size_(handle,spic0_descr,A,P,spic0_stage, & p_buffer_size_in_bytes,p_error) & bind(c, name="rocsparse_spic0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spic0_buffer_size_ type(c_ptr),value :: handle type(c_ptr),value :: spic0_descr type(c_ptr),value :: A type(c_ptr),value :: P integer(kind(rocsparse_spic0_stage_analysis)),value :: spic0_stage type(c_ptr),value :: p_buffer_size_in_bytes type(c_ptr) :: p_error end function end interface !> \ingroup generic_module !> \brief Incomplete Cholesky factorization with 0 fill-ins and no pivoting. !> !> \details !> \p rocsparse_spic0 computes the incomplete Cholesky factorization with 0 fill-ins !> and no pivoting of a sparse \f$m \times m\f$ matrix \f$A\f$, such that !> \f[ !> A \approx LL^T !> \f] !> where the lower triangular matrix \f$L\f$ is computed using: !> \f[ !> L_{ij} = \left\{ !> \begin{array}{ll} !> \sqrt{A_{jj} - \sum_{k=0}^{j-1}(L_{jk})^{2}}, & \text{if i == j} \\% !> \frac{1}{L_{jj}}(A_{ij} - \sum_{k=0}^{j-1}L_{ik} \times L_{jk}), & \text{if i > j} !> \end{array} !> \right. !> \f] !> for each entry found in the matrix \f$A\f$. !> !> Performing the above operation requires two stages, the stage !> `rocsparse_spic0_stage_analysis` and the stage `rocsparse_spic0_stage_compute`. !> The stage `rocsparse_spic0_stage_analysis` is required to perform the stage !> `rocsparse_spic0_stage_compute` and only needs to be called once for a given sparse matrix !> \f$A\f$, while the stage `rocsparse_spic0_stage_compute` can be repeatedly used with !> different matrices \f$A\f$ that have the same sparsity pattern. !> !> \p rocsparse_spic0 supports the following !> data types for \p A : `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, and `rocsparse_datatype_f64_c`. !> !> \note The descriptor \p spic0_descr needs to be configured with \ref !> rocsparse_spic0_set_input. !> \note !> The sparse matrix formats currently supported are `rocsparse_format_csr` and !> `rocsparse_format_bsr`. !> !> \note !> the `rocsparse_spic0_stage_compute` stage is non-blocking !> and executed asynchronously with respect to the host. It can return before the actual !> computation has finished. !> The `rocsparse_spic0_stage_analysis` stage is blocking with respect to the host. !> !> \note !> Only the `rocsparse_spic0_stage_compute` stage !> supports execution in a hipGraph context. The `rocsparse_spic0_stage_analysis` stage does not !> support hipGraph. !> !> \note !> This routine only supports uniform strided batched computation, that is, the same sparsity !> pattern but strided batched values of the matrices. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] spic0_descr - Spic0 descriptor !> @param[in] A - descriptor of the matrix to factorize. !> @param[out] P - descriptor of the factorization. In-place \p P = \p A is allowed. !> @param[in] spic0_stage - stage for the Spic0 computation. !> @param[in] buffer_size_in_bytes - number of bytes of the buffer. !> @param[in] buffer - buffer allocated by the user. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_not_implemented the sparse format is invalid or the preconditioner !> \p P is not identical to the matrix to factorize \p A. !> \retval rocsparse_status_invalid_value the \p spic0_stage value is invalid. !> \retval rocsparse_status_invalid_pointer \p spic0_descr, \p A, \p P, or \p !> buffer_size_in_bytes pointer is invalid. !> !> \par Example interface rocsparse_spic0 function rocsparse_spic0_(handle,spic0_descr,A,P,spic0_stage,buffer_size_in_bytes,buffer, & p_error) & bind(c, name="rocsparse_spic0") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spic0_ type(c_ptr),value :: handle type(c_ptr),value :: spic0_descr type(c_ptr),value :: A type(c_ptr),value :: P integer(kind(rocsparse_spic0_stage_analysis)),value :: spic0_stage integer(c_size_t),value :: buffer_size_in_bytes type(c_ptr),value :: buffer type(c_ptr) :: p_error end function end interface !> \ingroup generic_module !> \brief Incomplete \f$LDL^H\f$ factorization with 0 fill-ins and no pivoting. !> \details !> \p rocsparse_spildlt0_buffer_size returns the size of the non-persistent buffer !> that is required by \ref rocsparse_spildlt0 and must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> \note !> Supported format is `rocsparse_format_csr`. !> !> \note !> This routine only supports uniform strided batched computation, that is, the same sparsity !> pattern but strided batched values of the matrices. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] spildlt0_descr - SpILDLT0 descriptor. !> @param[in] A - descriptor of the matrix to factorize. !> @param[in] P - descriptor of the factorization. In-place \p P = \p A is allowed. !> @param[in] spildlt0_stage - stage for the SpILDLT0 computation. !> @param[out] p_buffer_size_in_bytes - number of bytes of the buffer. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if error descriptor is not required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_not_implemented the sparse format is invalid or the preconditioner !> \p P is not identical to the matrix to factorize \p A. !> \retval rocsparse_status_invalid_value the \p spildlt0_stage value is invalid. !> \retval rocsparse_status_invalid_pointer \p spildlt0_descr, \p A, \p P, or \p !> p_buffer_size_in_bytes pointer is invalid. interface rocsparse_spildlt0_buffer_size function rocsparse_spildlt0_buffer_size_(handle,spildlt0_descr,A,P,spildlt0_stage, & p_buffer_size_in_bytes,p_error) & bind(c, name="rocsparse_spildlt0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spildlt0_buffer_size_ type(c_ptr),value :: handle type(c_ptr),value :: spildlt0_descr type(c_ptr),value :: A type(c_ptr),value :: P integer(kind(rocsparse_spildlt0_stage_analysis)),value :: spildlt0_stage type(c_ptr),value :: p_buffer_size_in_bytes type(c_ptr) :: p_error end function end interface !> \ingroup generic_module !> \brief Incomplete \f$LDL^H\f$ factorization with 0 fill-ins and no pivoting. !> !> \details !> \p rocsparse_spildlt0 computes the incomplete \f$LDL^H\f$ factorization with 0 fill-ins !> and no pivoting of a sparse \f$m \times m\f$ Hermitian (or symmetric for real types) !> matrix \f$A\f$, such that !> \f[ !> A \approx L D L^H !> \f] !> where \f$L\f$ is unit lower triangular and \f$D\f$ is a real diagonal matrix. !> !> The diagonal entries of \f$D\f$ are computed as: !> \f[ !> D_i = \mathrm{real}(A_{ii}) - \sum_{k \f] !> and the off-diagonal entries of \f$L\f$ as: !> \f[ !> L_{ij} = \frac{1}{D_j} \left( A_{ij} - \sum_{k \f] !> for each entry found in the lower triangular part of the matrix \f$A\f$. !> !> Performing the above operation requires two stages, the stage !> `rocsparse_spildlt0_stage_analysis` and the stage `rocsparse_spildlt0_stage_compute`. !> The stage `rocsparse_spildlt0_stage_analysis` is required to perform the stage !> `rocsparse_spildlt0_stage_compute` and only needs to be called once for a given sparse matrix !> \f$A\f$, while the stage `rocsparse_spildlt0_stage_compute` can be repeatedly used with !> different matrices \f$A\f$ that have the same sparsity pattern. !> !> The factorization overwrites the values array of \p P with \f$L + D - I\f$: the strict !> lower-triangular entries hold \f$L\f$ (its unit diagonal is implicit), and the diagonal !> entries hold the real diagonal \f$D\f$. !> !> \p rocsparse_spildlt0 supports the following !> data types for \p A : `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, and `rocsparse_datatype_f64_c`. !> !> \note The descriptor \p spildlt0_descr needs to be configured with \ref !> rocsparse_spildlt0_set_input. !> !> \note !> The sparse matrix format currently supported is `rocsparse_format_csr`. !> !> \note !> the `rocsparse_spildlt0_stage_compute` stage is non-blocking !> and executed asynchronously with respect to the host. It can return before the actual !> computation has finished. !> The `rocsparse_spildlt0_stage_analysis` stage is blocking with respect to the host. !> !> \note !> Only the `rocsparse_spildlt0_stage_compute` stage !> supports execution in a hipGraph context. The `rocsparse_spildlt0_stage_analysis` stage does !> not support hipGraph. !> !> \note !> This routine only supports uniform strided batched computation, that is, the same sparsity !> pattern but strided batched values of the matrices. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] spildlt0_descr - SpILDLT0 descriptor. !> @param[in] A - descriptor of the matrix to factorize. !> @param[out] P - descriptor of the factorization. In-place \p P = \p A is allowed. !> @param[in] spildlt0_stage - stage for the SpILDLT0 computation. !> @param[in] buffer_size_in_bytes - number of bytes of the buffer. !> @param[in] buffer - buffer allocated by the user. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_not_implemented the sparse format is invalid or the preconditioner !> \p P is not identical to the matrix to factorize \p A. !> \retval rocsparse_status_invalid_value the \p spildlt0_stage value is invalid. !> \retval rocsparse_status_invalid_pointer \p spildlt0_descr, \p A, \p P, or \p !> buffer_size_in_bytes pointer is invalid. !> !> \par Example interface rocsparse_spildlt0 function rocsparse_spildlt0_(handle,spildlt0_descr,A,P,spildlt0_stage,buffer_size_in_bytes, & buffer,p_error) & bind(c, name="rocsparse_spildlt0") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spildlt0_ type(c_ptr),value :: handle type(c_ptr),value :: spildlt0_descr type(c_ptr),value :: A type(c_ptr),value :: P integer(kind(rocsparse_spildlt0_stage_analysis)),value :: spildlt0_stage integer(c_size_t),value :: buffer_size_in_bytes type(c_ptr),value :: buffer type(c_ptr) :: p_error end function end interface !> \ingroup generic_module !> \brief Get buffer size for incomplete LU factorization with 0 fill-ins and no pivoting. !> \details !> \p rocsparse_spilu0_buffer_size returns the size of the non-persistent buffer !> that is required by \ref rocsparse_spilu0, and must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> \note !> Supported formats are `rocsparse_format_csr` and `rocsparse_format_bsr`. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] spilu0_descr - Spilu0 descriptor. !> @param[in] A - descriptor of the matrix to factorize. !> @param[in] P - descriptor of the factorization. !> @param[in] spilu0_stage - stage for the Spilu0 computation. !> @param[out] p_buffer_size_in_bytes - number of bytes of the buffer. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if the user is not interested in !> obtaining an error descriptor. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_not_implemented the sparse format is invalid or the preconditioner !> \p P is not identical to the matrix to factorize \p A. !> \retval rocsparse_status_invalid_value the \p spilu0_stage value is invalid. !> \retval rocsparse_status_invalid_pointer \p spilu0_descr, \p A, \p P, or \p !> p_buffer_size_in_bytes pointer is invalid. interface rocsparse_spilu0_buffer_size function rocsparse_spilu0_buffer_size_(handle,spilu0_descr,A,P,spilu0_stage, & p_buffer_size_in_bytes,p_error) & bind(c, name="rocsparse_spilu0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spilu0_buffer_size_ type(c_ptr),value :: handle type(c_ptr),value :: spilu0_descr type(c_ptr),value :: A type(c_ptr),value :: P integer(kind(rocsparse_spilu0_stage_analysis)),value :: spilu0_stage type(c_ptr),value :: p_buffer_size_in_bytes type(c_ptr) :: p_error end function end interface !> \ingroup generic_module !> \brief Incomplete LU factorization with 0 fill-ins and no pivoting. !> !> \details !> \p rocsparse_spilu0 computes the incomplete LU factorization with 0 fill-ins and no !> pivoting of a sparse \f$m \times m\f$ matrix \f$A\f$, such that !> \f[ !> A \approx LU !> \f] !> where the lower triangular matrix \f$L\f$ and the upper triangular matrix \f$U\f$ are !> computed using: !> \f[ !> \begin{array}{ll} !> L_{ij} = \frac{1}{U_{jj}}(A_{ij} - \sum_{k=0}^{j-1}L_{ik} \times U_{kj}), & \text{if i !> > j} \\% !> U_{ij} = (A_{ij} - \sum_{k=0}^{j-1}L_{ik} \times U_{kj}), & \text{if i <= j} !> \end{array} !> \f] !> for each entry found in the matrix \f$A\f$. !> !> Performing the above operation requires two stages, the stage !> `rocsparse_spilu0_stage_analysis` and the stage `rocsparse_spilu0_stage_compute`. !> The stage `rocsparse_spilu0_stage_analysis` is required to perform the stage !> `rocsparse_spilu0_stage_compute` and only needs to be called once for a given sparse matrix !> \f$A\f$, while the stage `rocsparse_spilu0_stage_compute` can be repeatedly used with !> different matrices \f$A\f$ that have the same sparsity pattern. !> !> \p rocsparse_spilu0 supports the following !> data types for \p A : `rocsparse_datatype_f32_r`, `rocsparse_datatype_f64_r`, !> `rocsparse_datatype_f32_c`, and `rocsparse_datatype_f64_c`. !> !> \note The descriptor \p spilu0_descr needs to be configured with \ref !> rocsparse_spilu0_set_input. !> \note The sparse matrix formats currently supported are `rocsparse_format_csr` and !> `rocsparse_format_bsr`. !> !> \note !> the `rocsparse_spilu0_stage_compute` stage is non-blocking !> and executed asynchronously with respect to the host. It can return before the actual !> computation has finished. !> The `rocsparse_spilu0_stage_analysis` stage is blocking with respect to the host. !> !> \note !> Only the `rocsparse_spilu0_stage_compute` stage !> supports execution in a hipGraph context. The `rocsparse_spilu0_stage_analysis` stage does !> not support hipGraph. !> !> \note !> This routine only supports uniform batched computation, that is, same sparsity pattern but !> batched values of the matrices. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] spilu0_descr - Spilu0 descriptor. !> @param[in] A - descriptor of the matrix to factorize. !> @param[out] P - descriptor of the factorization. !> @param[in] spilu0_stage - stage for the Spilu0 computation. !> @param[in] buffer_size_in_bytes - number of bytes of the buffer. !> @param[in] buffer - buffer allocated by the user. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_not_implemented the sparse format is invalid or the preconditioner !> \p P is not identical to the matrix to factorize \p A. !> \retval rocsparse_status_invalid_value the \p spilu0_stage value is invalid. !> \retval rocsparse_status_invalid_pointer \p spilu0_descr, \p A, \p P, or \p !> buffer_size_in_bytes pointer is invalid. !> !> \par Example interface rocsparse_spilu0 function rocsparse_spilu0_(handle,spilu0_descr,A,P,spilu0_stage,buffer_size_in_bytes,buffer, & p_error) & bind(c, name="rocsparse_spilu0") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spilu0_ type(c_ptr),value :: handle type(c_ptr),value :: spilu0_descr type(c_ptr),value :: A type(c_ptr),value :: P integer(kind(rocsparse_spilu0_stage_analysis)),value :: spilu0_stage integer(c_size_t),value :: buffer_size_in_bytes type(c_ptr),value :: buffer type(c_ptr) :: p_error end function end interface !> \ingroup generic_module !> \brief Sparse iterative triangular solve. !> !> \details !> \p rocsparse_spitsv solves, using the Jacobi iterative method, a sparse triangular linear !> system of a sparse !> \f$m \times m\f$ matrix, defined in CSR format, a dense solution vector !> \f$y\f$ and the right-hand side \f$x\f$ that is multiplied by \f$\alpha\f$, such that !> \f[ !> op(A) y = \alpha x, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == rocsparse_operation_none} \\% !> A^T, & \text{if trans == rocsparse_operation_transpose} \\% !> A^H, & \text{if trans == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> !> The Jacobi method applied to the sparse triangular linear system above gives !> \f[ !> y_{k+1} = y_{k} + D^{-1} ( \alpha x - (D + T) y_{k} ) !> \f] !> with \f$A = D + T\f$, \f$D\f$ the diagonal of \f$A\f$ and \f$T\f$ the strict triangular part !> of \f$A\f$. !> !> The above equation can be also written as !> \f[ !> y_{k+1} = y_{k} + D^{-1} r_k !> \f] !> where !> \f[ !> r_k = \alpha x - (D + T) y_k. !> \f] !> Starting with \f$y_0 = \f$ \p y, the method iterates while \f$ k \lt \f$ \p host_nmaxiter and !> until !> \f[ !> \Vert r_k \Vert_{\infty} ≤ \epsilon, !> \f] !> with \f$\epsilon\f$ = \p host_tol. !> !> \p rocsparse_spitsv requires three stages to complete. First, pass the !> `rocsparse_spitsv_stage_buffer_size` !> stage to determine the size of the required temporary storage buffer. Next, allocate this !> buffer and call !> \p rocsparse_spitsv again with the `rocsparse_spitsv_stage_preprocess` stage, which will !> preprocess data and store it !> in the temporary buffer. Finally, call \p rocsparse_spitsv with the !> `rocsparse_spitsv_stage_compute` stage to !> perform the actual computation. After all calls to \p rocsparse_spitsv are complete, the !> temporary buffer !> can be deallocated. !> !> \p rocsparse_spitsv supports `rocsparse_indextype_i32` and `rocsparse_indextype_i64` index !> precisions for storing the !> row pointer and column indices arrays of the sparse matrix. \p rocsparse_spitsv supports the !> following data types for !> \f$op(A)\f$, \f$x\f$, \f$y\f$, and compute types for \f$\alpha\f$: !> !> \par Uniform Precisions: !> !> !>
Uniform Precisions
A / X / Y / compute_type !>
rocsparse_datatype_f32_r !>
rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_c !>
!> !> \note !> This routine does not support execution in a hipGraph context. !> !> \note !> This routine does not support batched computation. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[inout] host_nmaxiter - maximum number of iteration on input and number of iteration on !> output. If the output number of iterations is strictly less than the input maximum number of !> iterations, then the algorithm converged. !> @param[in] host_tol - if the pointer is null, then the loop will execute \p nmaxiter[0] !> iterations. The precision is float for f32-based calculations (including the complex case) !> and double for f64-based calculations (including the complex case). !> @param[out] host_history - Optional array to record the norm of the residual before each !> iteration. The precision is float for f32-based calculations (including the complex case) and !> double for f64-based calculations (including the complex case). !> @param[in] trans - matrix operation type. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] mat - matrix descriptor. !> @param[in] x - vector descriptor. !> @param[inout] y - vector descriptor. !> @param[in] compute_type - floating point precision for the SpITSV computation. !> @param[in] alg - SpITSV algorithm for the SpITSV computation. !> @param[in] stage - SpITSV stage for the SpITSV computation. !> @param[out] buffer_size - number of bytes of the temporary storage buffer. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. When a nullptr is !> passed, !> the required allocation size (in bytes) is written to \p buffer_size and !> function returns without performing the SpITSV operation. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p alpha, \p mat, \p x, \p y, \p descr, or !> \p buffer_size pointer is invalid. !> \retval rocsparse_status_not_implemented \p trans, \p compute_type, \p stage, or \p alg is !> currently not supported. !> !> \par Example interface rocsparse_spitsv function rocsparse_spitsv_(handle,host_nmaxiter,host_tol,host_history,trans,alpha,mat,x,y, & compute_type,alg,stage,buffer_size,temp_buffer) & bind(c, name="rocsparse_spitsv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spitsv_ type(c_ptr),value :: handle type(c_ptr),value :: host_nmaxiter type(c_ptr),value :: host_tol type(c_ptr),value :: host_history integer(kind(rocsparse_operation_none)),value :: trans type(c_ptr),value :: alpha type(c_ptr),value :: mat type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_datatype_f16_r)),value :: compute_type integer(kind(rocsparse_spitsv_alg_default)),value :: alg integer(kind(rocsparse_spitsv_stage_buffer_size)),value :: stage integer(c_size_t) :: buffer_size type(c_ptr),value :: temp_buffer end function end interface !> \ingroup generic_module !> \brief Sparse matrix dense matrix multiplication. !> !> \details !> \p rocsparse_spmm multiplies the scalar \f$\alpha\f$ with a sparse \f$m \times k\f$ matrix !> \f$op(A)\f$, !> defined in CSR, CSC, COO, BSR, or Blocked ELL storage format, and the dense \f$k \times n\f$ !> matrix \f$op(B)\f$ !> and adds the result to the dense \f$m \times n\f$ matrix \f$C\f$ that is multiplied by the !> scalar !> \f$\beta\f$, such that !> \f[ !> C := \alpha \cdot op(A) \cdot op(B) + \beta \cdot C, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans_A == rocsparse_operation_none} \\% !> A^T, & \text{if trans_A == rocsparse_operation_transpose} \\% !> A^H, & \text{if trans_A == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if trans_B == rocsparse_operation_none} \\% !> B^T, & \text{if trans_B == rocsparse_operation_transpose} \\% !> B^H, & \text{if trans_B == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> Both \f$B\f$ and \f$C\f$ can be in row or column order. !> !> \p rocsparse_spmm requires three stages to complete. First, pass the !> `rocsparse_spmm_stage_buffer_size` !> stage to determine the size of the required temporary storage buffer. Next, allocate this !> buffer and call !> \p rocsparse_spmm again with the `rocsparse_spmm_stage_preprocess` stage, which will perform !> analysis on the sparse !> matrix \f$op(A)\f$. Finally, call \p rocsparse_spmm with the `rocsparse_spmm_stage_compute` !> stage to perform !> the actual computation. The buffer size, buffer allocation, and preprocess stages only need !> to be called once for a given !> sparse matrix \f$op(A)\f$, while the computation stage can be repeatedly used with different !> \f$B\f$ and \f$C\f$ matrices. !> After all calls to \p rocsparse_spmm are complete, the temporary buffer can be deallocated. !> !> As noted above, both \f$B\f$ and \f$C\f$ can be in row or column order (this includes mixing !> the order so that \f$B\f$ is in !> row order and \f$C\f$ in column order and vice versa). For best performance, use row order !> for both \f$B\f$ and \f$C\f$ as !> this provides the best memory access. !> !> \p rocsparse_spmm supports multiple different algorithms. These algorithms have different !> trade-offs depending on the sparsity !> pattern of the matrix, whether or not the results need to be deterministic, and how many !> times the sparse-matrix product will !> be performed. !> !> !> !> !> !> !> !>
CSR Algorithms
CSR Algorithms Deterministic Preprocessing Notes !>
rocsparse_spmm_alg_csr Yes No Default algorithm.
rocsparse_spmm_alg_csr_row_split Yes No Assigns a fixed !> number of threads per row, regardless of the number of non-zeros in each row. This can !> perform well when each row in the matrix has roughly the same number of non-zeros.
rocsparse_spmm_alg_csr_nnz_split No Yes Distributes work !> by having each thread block work on a fixed number of non-zeros, regardless of the number of !> rows that might be involved. This can perform well when the matrix has some rows with few !> non-zeros and some rows with many non-zeros.
rocsparse_spmm_alg_csr_merge_path No Yes Attempts to !> combine the approaches of row-split and non-zero split by having each block work on a fixed !> amount of work, which can be either non-zeros or rows.
!> !> !> !> !> !> !>
COO Algorithms
COO Algorithms Deterministic Preprocessing Notes !>
rocsparse_spmm_alg_coo_segmented Yes No Generally not as !> fast as the atomic algorithm but is deterministic.
rocsparse_spmm_alg_coo_atomic No No Generally the fastest !> COO algorithm. This is the default algorithm.
rocsparse_spmm_alg_coo_segmented_atomic No No
!> !> !> !> !>
Blocked-ELL Algorithms
Blocked ELL Algorithms Deterministic Preprocessing Notes !>
rocsparse_spmm_alg_bell Yes No
!> !> !> !> !>
BSR Algorithms
BSR Algorithms Deterministic Preprocessing Notes !>
rocsparse_spmm_alg_bsr Yes No
!> !> It is also possible to pass `rocsparse_spmm_alg_default`, which will automatically select !> from the algorithms listed above !> based on the sparse matrix format. In the case of CSR or CSC matrices, this will set the !> algorithm to be `rocsparse_spmm_alg_csr`. In !> the case of blocked ELL matrices, this will set the algorithm to be !> `rocsparse_spmm_alg_bell`. In the case of BSR matrices, this !> will set the algorithm to be `rocsparse_spmm_alg_bsr`, and for COO matrices, it will set the !> algorithm to be !> `rocsparse_spmm_alg_coo_atomic`. !> !> When A is transposed, \p rocsparse_spmm will revert to using `rocsparse_spmm_alg_csr` !> for CSR and CSC formats and `rocsparse_spmm_alg_coo_atomic` for COO format, regardless of !> algorithm selected. !> !> \p rocsparse_spmm supports multiple combinations of data types and compute types. The tables !> below indicate the currently !> supported different data types that can be used for for the sparse matrix \f$op(A)\f$ and the !> dense matrices \f$op(B)\f$ and !> \f$C\f$ and the compute type for \f$\alpha\f$ and \f$\beta\f$. The advantage of using !> different data types is to save on !> memory bandwidth and storage when a user application allows, while performing the actual !> computation in a higher precision. !> !> \par Uniform Precisions: !> !> !>
Uniform Precisions
A / B / C / compute_type !>
rocsparse_datatype_f32_r !>
rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_c !>
!> !> \par Mixed precisions: !> !> !>
Mixed Precisions
A / B C compute_type !>
rocsparse_datatype_i8_r rocsparse_datatype_i32_r rocsparse_datatype_i32_r !>
rocsparse_datatype_i8_r rocsparse_datatype_f32_r rocsparse_datatype_f32_r !>
rocsparse_datatype_f16_r rocsparse_datatype_f32_r rocsparse_datatype_f32_r !>
rocsparse_datatype_f16_r rocsparse_datatype_f16_r rocsparse_datatype_f32_r !>
rocsparse_datatype_bf16_r rocsparse_datatype_f32_r rocsparse_datatype_f32_r !>
rocsparse_datatype_bf16_r rocsparse_datatype_bf16_r rocsparse_datatype_f32_r !>
!> !> \p rocsparse_spmm supports `rocsparse_indextype_i32` and `rocsparse_indextype_i64` index !> precisions !> for storing the row pointer and column indices arrays of the sparse matrices. !> !> \p rocsparse_spmm also supports batched computation for CSR and COO matrices. There are three !> supported batch modes: !> \f[ !> C_i = A \times B_i \\% !> C_i = A_i \times B \\% !> C_i = A_i \times B_i !> \f] !> !> The batch mode is determined by the batch count and stride passed for each matrix. For !> example, !> to use the first batch mode (\f$C_i = A \times B_i\f$) with 100 batches for non-transposed !> \f$A\f$, !> \f$B\f$, and \f$C\f$, pass: !> \f[ !> batch\_count\_A=1 \\% !> batch\_count\_B=100 \\% !> batch\_count\_C=100 \\% !> offsets\_batch\_stride\_A=0 \\% !> columns\_values\_batch\_stride\_A=0 \\% !> batch\_stride\_B=k*n \\% !> batch\_stride\_C=m*n !> \f] !> To use the second batch mode (\f$C_i = A_i \times B\f$), pass: !> \f[ !> batch\_count\_A=100 \\% !> batch\_count\_B=1 \\% !> batch\_count\_C=100 \\% !> offsets\_batch\_stride\_A=m+1 \\% !> columns\_values\_batch\_stride\_A=nnz \\% !> batch\_stride\_B=0 \\% !> batch\_stride\_C=m*n !> \f] !> And to use the third batch mode (\f$C_i = A_i \times B_i\f$), pass: !> \f[ !> batch\_count\_A=100 \\% !> batch\_count\_B=100 \\% !> batch\_count\_C=100 \\% !> offsets\_batch\_stride\_A=m+1 \\% !> columns\_values\_batch\_stride_A=nnz \\% !> batch\_stride_B=k*n \\% !> batch\_stride_C=m*n !> \f] !> See the examples below. !> !> \note !> None of the algorithms above are deterministic when \f$A\f$ is transposed or conjugate !> transposed. !> !> \note !> All algorithms perform best when using row ordering for the dense \f$B\f$ and \f$C\f$ !> matrices. !> !> \note !> The sparse matrix formats currently supported are: `rocsparse_format_coo`, !> `rocsparse_format_csr`, !> `rocsparse_format_csc`, `rocsparse_format_bsr`, and `rocsparse_format_bell`. !> !> \note !> Mixed precisions are only supported for BSR, CSR, CSC, and COO matrix formats. !> !> \note !> Only the `rocsparse_spmm_stage_buffer_size` stage and the `rocsparse_spmm_stage_compute` !> stage are non-blocking !> and executed asynchronously with respect to the host. They can return before the actual !> computation has finished. !> The `rocsparse_spmm_stage_preprocess` stage is blocking with respect to the host. !> !> \note !> Currently, only \p trans_A == `rocsparse_operation_none` is supported for the COO and blocked !> ELL formats. !> !> \note !> Only the `rocsparse_spmm_stage_buffer_size` stage and the `rocsparse_spmm_stage_compute` !> stage !> support execution in a hipGraph context. The `rocsparse_spmm_stage_preprocess` stage does not !> support hipGraph. !> !> \note !> Currently, only CSR, CSC, COO, BSR, and blocked ELL sparse formats are supported. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans_A - matrix operation type. !> @param[in] trans_B - matrix operation type. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] mat_A - matrix descriptor. !> @param[in] mat_B - matrix descriptor. !> @param[in] beta - scalar \f$\beta\f$. !> @param[in] mat_C - matrix descriptor. !> @param[in] compute_type - floating point precision for the SpMM computation. !> @param[in] alg - SpMM algorithm for the SpMM computation. !> @param[in] stage - SpMM stage for the SpMM computation. !> @param[out] buffer_size - number of bytes of the temporary storage buffer. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. When the !> `rocsparse_spmm_stage_buffer_size` stage is passed in, the required !> allocation size (in bytes) is written to \p buffer_size and function !> returns without performing the SpMM operation. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p alpha, \p mat_A, \p mat_B, \p mat_C, \p beta, or !> \p buffer_size pointer is invalid. !> \retval rocsparse_status_not_implemented \p trans_A, \p trans_B, \p compute_type, or \p alg !> is !> currently not supported. !> \par Example !> This example performs sparse matrix-dense matrix multiplication, \f$C := \alpha \cdot A \cdot !> B + \beta \cdot C\f$ !> !> !> \par Example !> An example of the first batch mode (\f$C_i = A \times B_i\f$) is provided below. interface rocsparse_spmm function rocsparse_spmm_(handle,trans_A,trans_B,alpha,mat_A,mat_B,beta,mat_C,compute_type,alg, & stage,buffer_size,temp_buffer) & bind(c, name="rocsparse_spmm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spmm_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B type(c_ptr),value :: alpha type(c_ptr),value :: mat_A type(c_ptr),value :: mat_B type(c_ptr),value :: beta type(c_ptr),value :: mat_C integer(kind(rocsparse_datatype_f16_r)),value :: compute_type integer(kind(rocsparse_spmm_alg_default)),value :: alg integer(kind(rocsparse_spmm_stage_buffer_size)),value :: stage integer(c_size_t) :: buffer_size type(c_ptr),value :: temp_buffer end function end interface !> \ingroup generic_module !> \brief Sparse matrix vector multiplication. !> !> \details !> \p rocsparse_spmv multiplies the scalar \f$\alpha\f$ with a sparse \f$m \times n\f$ matrix !> \f$op(A)\f$, defined in CSR, !> CSC, COO, COO (AoS), BSR, or ELL format, with the dense vector \f$x\f$ and adds the result to !> the dense vector \f$y\f$ !> that is multiplied by the scalar \f$\beta\f$, such that !> \f[ !> y := \alpha \cdot op(A) \cdot x + \beta \cdot y, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == rocsparse_operation_none} \\% !> A^T, & \text{if trans == rocsparse_operation_transpose} \\% !> A^H, & \text{if trans == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> !> Performing the above operation involves multiple steps. First, call \p rocsparse_spmv with !> the stage parameter set to !> `rocsparse_spmv_stage_buffer_size` to determine the size of the required temporary storage !> buffer. Then allocate this !> buffer and call \p rocsparse_spmv with the stage parameter set to !> `rocsparse_spmv_stage_preprocess`. Depending on the algorithm !> and sparse matrix format, this will perform analysis on the sparsity pattern of \f$op(A)\f$. !> Finally, complete the operation !> by calling \p rocsparse_spmv with the stage parmeter set to `rocsparse_spmv_stage_compute`. !> The buffer size, buffer allocation, and !> preprocess stages only need to be called once for a given sparse matrix \f$op(A)\f$, while !> the computation stage can be repeatedly used !> with different \f$x\f$ and \f$y\f$ vectors. After all calls to \p rocsparse_spmv are !> complete, the temporary buffer can be deallocated. !> !> \p rocsparse_spmv supports multiple different algorithms. These algorithms have different !> trade-offs depending on the sparsity !> pattern of the matrix, whether or not the results need to be deterministic, and how many !> times the sparse-vector product will !> be performed. !> !> !> !> !> !> !> !> !>
CSR/CSC Algorithms
Algorithm Deterministic Preprocessing Notes !>
rocsparse_spmv_alg_csr_rowsplit Yes No Is best suited for !> matrices with all rows having a similar number of non-zeros. Can outperform adaptive and LRB !> algorithms in certain sparsity patterns. Will perform very poorly if some rows have few !> non-zeros and some rows have many non-zeros.
rocsparse_spmv_alg_csr_stream Yes No [Deprecated] The old !> name for rocsparse_spmv_alg_csr_rowsplit.
rocsparse_spmv_alg_csr_adaptive No Yes Generally the !> fastest algorithm across all matrix sparsity patterns. This includes matrices that have some !> rows with many non-zeros and some rows with few non-zeros. Requires lengthy preprocessing !> that needs to be amortized over many subsequent sparse vector products.
rocsparse_spmv_alg_csr_lrb No Yes Like the adaptive !> algorithm, it generally performs well across all matrix sparsity patterns. Generally not as !> fast as the adaptive algorithm, however, it uses a much faster pre-processing step. Good for !> when only a small number of sparse vector products will be performed.
rocsparse_spmv_alg_csr_nnzsplit No Yes Like the adaptive !> algorithm, it generally performs well across all matrix sparsity patterns. Generally not as !> fast as the adaptive algorithm but faster than the LRB algorithm. It uses a much faster !> preprocessing step than LRB. Good when the number of sparse vector products that will be !> performed is less than one hundred. If more products need to be computed, the adaptive !> algorithm is probably faster.
!> !> !> !> !> !>
COO Algorithms
COO Algorithms Deterministic Preprocessing Notes !>
rocsparse_spmv_alg_coo Yes Yes Generally not as fast as !> the atomic algorithm but is deterministic.
rocsparse_spmv_alg_coo_atomic No No Generally the fastest !> COO algorithm.
!> !> !> !> !>
ELL Algorithms
ELL Algorithms Deterministic Preprocessing Notes !>
rocsparse_spmv_alg_ell Yes No
!> !> !> !> !>
BSR Algorithms
BSR Algorithm Deterministic Preprocessing Notes !>
rocsparse_spmv_alg_bsr Yes No
!> !> \p rocsparse_spmv supports multiple combinations of data types and compute types. The tables !> below indicate the currently !> supported different data types that can be used for the sparse matrix \f$op(A)\f$, the dense !> vectors \f$x\f$ and !> \f$y\f$, and the compute type for \f$\alpha\f$ and \f$\beta\f$. The advantage of using !> different data types is to save on !> memory bandwidth and storage when a user application allows, while performing the actual !> computation in a higher precision. !> !> \par Uniform Precisions: !> !> !>
Uniform Precisions
A / X / Y / compute_type !>
rocsparse_datatype_f32_r !>
rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_c !>
!> !> \par Mixed Precisions: !> !> !>
Mixed Precisions
A / X Y compute_type !>
rocsparse_datatype_i8_r rocsparse_datatype_i32_r rocsparse_datatype_i32_r !>
rocsparse_datatype_i8_r rocsparse_datatype_f32_r rocsparse_datatype_f32_r !>
rocsparse_datatype_f16_r rocsparse_datatype_f32_r rocsparse_datatype_f32_r !>
rocsparse_datatype_f16_r rocsparse_datatype_f16_r rocsparse_datatype_f32_r !>
rocsparse_datatype_bf16_r rocsparse_datatype_f32_r rocsparse_datatype_f32_r !>
rocsparse_datatype_bf16_r rocsparse_datatype_bf16_r rocsparse_datatype_f32_r !>
!> !> \par Mixed-regular Real Precisions !> !> !>
Mixed-regular Real Precisions
A X / Y / compute_type !>
rocsparse_datatype_f32_r rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c rocsparse_datatype_f64_c !>
!> !> \par Mixed-regular Complex Precisions !> !> !>
Mixed-regular Complex Precisions
A X / Y / compute_type !>
rocsparse_datatype_f32_r rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_r rocsparse_datatype_f64_c !>
!> !> \p rocsparse_spmv supports `rocsparse_indextype_i32` and `rocsparse_indextype_i64` index !> precisions !> for storing the row pointer and column indices arrays of the sparse matrices. !> !> \note !> None of the algorithms above are deterministic when \f$A\f$ is transposed. !> !> \note !> The sparse matrix formats currently supported are: `rocsparse_format_bsr`, !> `rocsparse_format_coo`, !> `rocsparse_format_coo_aos`, `rocsparse_format_csr`, `rocsparse_format_csc`, and !> `rocsparse_format_ell`. !> !> \note !> Only the `rocsparse_spmv_stage_buffer_size` stage and the `rocsparse_spmv_stage_compute` !> stage are non-blocking !> and executed asynchronously with respect to the host. They can return before the actual !> computation has finished. !> The `rocsparse_spmv_stage_preprocess` stage is blocking with respect to the host. !> !> \note !> Only the `rocsparse_spmv_stage_buffer_size` stage and the `rocsparse_spmv_stage_compute` !> stage !> support execution in a hipGraph context. The `rocsparse_spmv_stage_preprocess` stage does not !> support hipGraph. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans - matrix operation type. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] mat - matrix descriptor. !> @param[in] x - vector descriptor. !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] y - vector descriptor. !> @param[in] compute_type - floating point precision for the SpMV computation. !> @param[in] alg - SpMV algorithm for the SpMV computation. !> @param[in] stage - SpMV stage for the SpMV computation. !> @param[out] buffer_size - number of bytes of the temporary storage buffer. buffer_size is set !> when !> \p temp_buffer is nullptr. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. When the !> `rocsparse_spmv_stage_buffer_size` stage is passed, !> the required allocation size (in bytes) is written to \p buffer_size and !> function returns without performing the SpMV operation. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context \p handle was not initialized. !> \retval rocsparse_status_invalid_pointer \p alpha, \p mat, \p x, \p beta, \p y, or !> \p buffer_size pointer is invalid. !> \retval rocsparse_status_invalid_value the value of \p trans, \p compute_type, \p alg, or \p !> stage is incorrect. !> \retval rocsparse_status_not_implemented \p compute_type or \p alg is !> currently not supported. !> !> \par Example interface rocsparse_spmv function rocsparse_spmv_(handle,trans,alpha,mat,x,beta,y,compute_type,alg,stage,buffer_size, & temp_buffer) & bind(c, name="rocsparse_spmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spmv_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans type(c_ptr),value :: alpha type(c_ptr),value :: mat type(c_ptr),value :: x type(c_ptr),value :: beta type(c_ptr),value :: y integer(kind(rocsparse_datatype_f16_r)),value :: compute_type integer(kind(rocsparse_spmv_alg_default)),value :: alg integer(kind(rocsparse_spmv_stage_buffer_size)),value :: stage integer(c_size_t) :: buffer_size type(c_ptr),value :: temp_buffer end function end interface !> \ingroup generic_module !> \brief Sparse triangular system solve with multiple right-hand sides. !> !> \details !> \p rocsparse_spsm solves a triangular linear system of equations defined by a sparse \f$m !> \times m\f$ square matrix \f$op(A)\f$, !> given in CSR or COO storage format, such that !> \f[ !> op(A) \cdot C = \alpha \cdot op(B), !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == rocsparse_operation_none} \\% !> A^T, & \text{if trans == rocsparse_operation_transpose} !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if trans_B == rocsparse_operation_none} \\% !> B^T, & \text{if trans_B == rocsparse_operation_transpose} !> \end{array} !> \right. !> \f] !> and where \f$C\f$ is the dense solution matrix and \f$B\f$ is the dense right-hand side !> matrix. Both \f$B\f$ !> and \f$C\f$ can be in row or column order. !> !> Performing the above operation requires three stages. First, \p rocsparse_spsm must be called !> with the stage !> `rocsparse_spsm_stage_buffer_size`, which will determine the size of the required temporary !> storage buffer. !> Then allocate this buffer and call \p rocsparse_spsm with the stage !> `rocsparse_spsm_stage_preprocess`, !> which will perform analysis on the sparse matrix \f$op(A)\f$. Finally, complete the !> computation by calling !> \p rocsparse_spsm with the stage `rocsparse_spsm_stage_compute`. The buffer size, buffer !> allocation, and preprocess !> stages only need to be called once for a given sparse triangular matrix \f$op(A)\f$, while !> the computation stage can be !> repeatedly used with different \f$B\f$ and \f$C\f$ matrices. !> !> As noted above, both \f$B\f$ and \f$C\f$ can be in row or column order (this includes mixing !> the order so that \f$B\f$ is in !> row order and \f$C\f$ in column order and vice versa). Internally, however, rocSPARSE kernels !> solve the system assuming the !> matrices \f$B\f$ and \f$C\f$ are in row order, as this provides the best memory access. This !> means that if the matrix !> \f$C\f$ is not in row order and/or the matrix \f$B\f$ is not row order (or \f$B^{T}\f$ is not !> column order as this is !> equivalent to being in row order), then internally, memory copies and/or transposing of data !> might be performed to get them !> into the correct order (possibly using extra buffer size). After the computation is !> completed, additional memory copies and/or !> transposing of data might be performed to get them back into the user arrays. For the best !> performance and smallest required !> temporary storage buffers, use row order for the matrix \f$C\f$ and row order for the matrix !> \f$B\f$ (or column order if !> \f$B\f$ is being transposed). !> !> \p rocsparse_spsm supports `rocsparse_indextype_i32` and `rocsparse_indextype_i64` index !> precisions for storing the !> row pointer and column indices arrays of the sparse matrices. \p rocsparse_spsm supports the !> following data types for !> \f$op(A)\f$, \f$op(B)\f$, \f$C\f$, and compute types for \f$\alpha\f$: !> !> \par Uniform Precisions: !> !> !>
Uniform Precisions
A / B / C / compute_type !>
rocsparse_datatype_f32_r !>
rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_c !>
!> !> \note !> The sparse matrix formats currently supported are: `rocsparse_format_coo`, !> `rocsparse_format_csr`, and `rocsparse_format_csc`. !> !> \note !> Only the `rocsparse_spsm_stage_buffer_size` stage and the `rocsparse_spsm_stage_compute` !> stage are non-blocking !> and executed asynchronously with respect to the host. They can return before the actual !> computation has finished. !> The `rocsparse_spsm_stage_preprocess` stage is blocking with respect to the host. !> !> \note !> Currently, only \p trans_A == `rocsparse_operation_none` and \p trans_A == !> `rocsparse_operation_transpose` is supported. !> Currently, only \p trans_B == `rocsparse_operation_none` and \p trans_B == !> `rocsparse_operation_transpose` is supported. !> !> \note !> Only the `rocsparse_spsm_stage_buffer_size` stage and the `rocsparse_spsm_stage_compute` !> stage !> support execution in a hipGraph context. The `rocsparse_spsm_stage_preprocess` stage does not !> support hipGraph. !> !> \note !> This routine does not support batched computation. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans_A - matrix operation type for the sparse matrix \f$op(A)\f$. !> @param[in] trans_B - matrix operation type for the dense matrix \f$op(B)\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] matA - sparse matrix descriptor. !> @param[in] matB - dense matrix descriptor. !> @param[inout] matC - dense matrix descriptor. !> @param[in] compute_type - floating point precision for the SpSM computation. !> @param[in] alg - SpSM algorithm for the SpSM computation. !> @param[in] stage - SpSM stage for the SpSM computation. !> @param[out] buffer_size - number of bytes of the temporary storage buffer. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. When the !> `rocsparse_spsm_stage_buffer_size` stage is passed in, !> the required allocation size (in bytes) is written to \p buffer_size, and the !> function returns without performing the SpSM operation. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p alpha, \p matA, \p matB, \p matC, \p descr, or !> \p buffer_size pointer is invalid. !> \retval rocsparse_status_not_implemented \p trans_A, \p trans_B, \p compute_type, \p stage, !> or \p alg is !> currently not supported. !> !> \par Example interface rocsparse_spsm function rocsparse_spsm_(handle,trans_A,trans_B,alpha,matA,matB,matC,compute_type,alg,stage, & buffer_size,temp_buffer) & bind(c, name="rocsparse_spsm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spsm_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B type(c_ptr),value :: alpha type(c_ptr),value :: matA type(c_ptr),value :: matB type(c_ptr),value :: matC integer(kind(rocsparse_datatype_f16_r)),value :: compute_type integer(kind(rocsparse_spsm_alg_default)),value :: alg integer(kind(rocsparse_spsm_stage_buffer_size)),value :: stage integer(c_size_t) :: buffer_size type(c_ptr),value :: temp_buffer end function end interface !> \ingroup generic_module !> \brief Sparse triangular system solve. !> !> \details !> \p rocsparse_spsv solves a triangular linear system of equations defined by a sparse \f$m !> \times m\f$ square matrix \f$op(A)\f$, !> given in CSR or COO storage format, such that !> \f[ !> op(A) \cdot y = \alpha \cdot x, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == rocsparse_operation_none} \\% !> A^T, & \text{if trans == rocsparse_operation_transpose} !> \end{array} !> \right. !> \f] !> and where \f$y\f$ is the dense solution vector and \f$x\f$ is the dense right-hand side !> vector. !> !> Performing the above operation requires three stages. First, \p rocsparse_spsv must be called !> with the stage !> `rocsparse_spsv_stage_buffer_size`, which will determine the size of the required temporary !> storage buffer. !> The user then allocates this buffer and calls \p rocsparse_spsv with the stage !> `rocsparse_spsv_stage_preprocess`, !> which will perform analysis on the sparse matrix \f$op(A)\f$. Finally, complete the !> computation by calling !> \p rocsparse_spsv with the stage `rocsparse_spsv_stage_compute`. The buffer size, buffer !> allocation, and preprocess !> stages only need to be called once for a given sparse matrix \f$op(A)\f$, while the !> computation stage can be repeatedly !> used with different \f$x\f$ and \f$y\f$ vectors. !> !> \p rocsparse_spsv supports `rocsparse_indextype_i32` and `rocsparse_indextype_i64` index !> types for !> storing the row pointer and column indices arrays of the sparse matrices. \p rocsparse_spsv !> supports the following !> data types for \f$op(A)\f$, \f$x\f$, \f$y\f$ and compute types for \f$\alpha\f$: !> !> \par Uniform Precisions: !> !> !>
Uniform Precisions
A / X / Y / compute_type !>
rocsparse_datatype_f32_r !>
rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_c !>
!> !> \note !> The sparse matrix formats currently supported are: `rocsparse_format_coo`, !> `rocsparse_format_csr`, and `rocsparse_format_csc`. !> !> \note !> Only the `rocsparse_spsv_stage_buffer_size` stage and the `rocsparse_spsv_stage_compute` !> stage are non-blocking !> and executed asynchronously with respect to the host. They can return before the actual !> computation has finished. !> The `rocsparse_spsv_stage_preprocess` stage is blocking with respect to the host. !> !> \note !> Currently, only \p trans == `rocsparse_operation_none` and \p trans == !> `rocsparse_operation_transpose` is supported. !> !> \note !> Only the `rocsparse_spsv_stage_buffer_size` stage and the `rocsparse_spsv_stage_compute` !> stage !> support execution in a hipGraph context. The `rocsparse_spsv_stage_preprocess` stage does not !> support hipGraph. !> !> \note !> This routine does not support batched computation. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans - matrix operation type. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] mat - matrix descriptor. !> @param[in] x - vector descriptor. !> @param[inout] y - vector descriptor. !> @param[in] compute_type - floating point precision for the SpSV computation. !> @param[in] alg - SpSV algorithm for the SpSV computation. !> @param[in] stage - SpSV stage for the SpSV computation. !> @param[out] buffer_size - number of bytes of the temporary storage buffer. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. When the !> `rocsparse_spsv_stage_buffer_size` stage is passed, !> the required allocation size (in bytes) is written to \p buffer_size and the !> function returns without performing the SpSV operation. !> This buffer is non-persistent, and no data is stored in it. Therefore, this !> memory !> can be freed or reused for other tasks between the analysis phase and the !> compute phase. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p alpha, \p mat, \p x, \p y, or !> \p buffer_size pointer is invalid. !> \retval rocsparse_status_not_implemented \p trans, \p compute_type, \p stage, or \p alg is !> currently not supported. !> !> \par Example interface rocsparse_spsv function rocsparse_spsv_(handle,trans,alpha,mat,x,y,compute_type,alg,stage,buffer_size, & temp_buffer) & bind(c, name="rocsparse_spsv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spsv_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans type(c_ptr),value :: alpha type(c_ptr),value :: mat type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_datatype_f16_r)),value :: compute_type integer(kind(rocsparse_spsv_alg_default)),value :: alg integer(kind(rocsparse_spsv_stage_buffer_size)),value :: stage integer(c_size_t) :: buffer_size type(c_ptr),value :: temp_buffer end function end interface !> \ingroup generic_module !> \details !> \p rocsparse_sptrsm_buffer_size returns the size of the required buffer to execute the given !> stage of the SpTrSM operation. !> This routine is used in conjunction with `rocsparse_sptrsm` (). See `rocsparse_sptrsm` for a !> full description and example. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> \note !> This routine does not support batched execution. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] sptrsm_descr - SpTrSM descriptor. !> @param[in] A - sparse matrix descriptor. !> @param[in] X - dense matrix descriptor. !> @param[in] Y - dense matrix descriptor. !> @param[in] sptrsm_stage - stage for the SpTrSM computation. !> @param[out] buffer_size_in_bytes - number of bytes of the buffer. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value the \p sptrsm_stage value is invalid. !> \retval rocsparse_status_invalid_pointer \p A, \p X, \p Y, \p sptrsm_descr, or \p !> buffer_size_in_bytes pointer is invalid. interface rocsparse_sptrsm_buffer_size function rocsparse_sptrsm_buffer_size_(handle,sptrsm_descr,A,X,Y,sptrsm_stage, & buffer_size_in_bytes,p_error) & bind(c, name="rocsparse_sptrsm_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sptrsm_buffer_size_ type(c_ptr),value :: handle type(c_ptr),value :: sptrsm_descr type(c_ptr),value :: A type(c_ptr),value :: X type(c_ptr),value :: Y integer(kind(rocsparse_sptrsm_stage_analysis)),value :: sptrsm_stage integer(c_size_t) :: buffer_size_in_bytes type(c_ptr) :: p_error end function end interface !> \ingroup generic_module !> \brief Sparse triangular system solve with multiple right-hand sides. !> !> \details !> \p rocsparse_sptrsm solves a triangular linear system of equations defined by a sparse \f$m !> \times m\f$ square matrix \f$op(A)\f$, !> given in CSR or COO storage format, such that !> \f[ !> op(A) \cdot Y = \alpha \cdot op(X), !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == rocsparse_operation_none} \\% !> A^T, & \text{if trans == rocsparse_operation_transpose} !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(X) = \left\{ !> \begin{array}{ll} !> X, & \text{if trans_B == rocsparse_operation_none} \\% !> X^T, & \text{if trans_B == rocsparse_operation_transpose} !> \end{array} !> \right. !> \f] !> and where \f$Y\f$ is the dense solution matrix and \f$X\f$ is the dense right-hand side !> matrix. Both \f$X\f$ !> and \f$Y\f$ can be in row or column order. !> !> Performing the above operation requires two stages, the stage !> `rocsparse_sptrsm_stage_analysis` and the stage `rocsparse_sptrsm_stage_compute`. !> The stage `rocsparse_sptrsm_stage_analysis` is required to perform the stage !> `rocsparse_sptrsm_stage_compute` and only needs to be called once for a given sparse matrix !> \f$op(A)\f$, while the stage `rocsparse_sptrsm_stage_compute` can be repeatedly used with !> different \f$X\f$ and \f$Y\f$ matrices. !> !> As noted above, both \f$X\f$ and \f$Y\f$ can be in row or column order (this includes mixing !> the order so that \f$X\f$ is in !> row order and \f$Y\f$ in column order and vice versa). Internally, however, rocSPARSE kernels !> solve the system assuming the !> matrices \f$X\f$ and \f$Y\f$ are in row order, as this provides the best memory access. This !> means that if the matrix !> \f$Y\f$ is not in row order and/or the matrix \f$X\f$ is not in row order (or \f$X^{T}\f$ is !> not in column order as this is !> equivalent to being in row order), then internally, memory copies and/or transposing of data !> might be performed to get them !> into the correct order (possibly using extra buffer size). After the computation is !> completed, additional memory copies and/or !> transposing of data might be performed to get them back into the user arrays. For the best !> performance and smallest required !> temporary storage buffers, use row order for the matrix \f$Y\f$ and row order for the matrix !> \f$X\f$ (or column order if !> \f$X\f$ is being transposed). !> !> \p rocsparse_sptrsm supports `rocsparse_indextype_i32` and `rocsparse_indextype_i64` index !> precisions for storing the !> row pointer and column indices arrays of the sparse matrices. \p rocsparse_sptrsm supports !> the following data types for !> \f$op(A)\f$, \f$op(X)\f$, \f$Y\f$, and compute types for \f$\alpha\f$: !> !> \par Uniform Precisions: !> !> !>
Uniform Precisions
A / X / Y / compute_type !>
rocsparse_datatype_f32_r !>
rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_c !>
!> !> \note !> The sparse matrix formats currently supported are: `rocsparse_format_coo`, !> `rocsparse_format_csr`, and `rocsparse_format_csc`. !> !> \note !> Only the `rocsparse_sptrsm_stage_compute` stage is non-blocking !> and executed asynchronously with respect to the host. It can return before the actual !> computation has finished. !> The `rocsparse_sptrsm_stage_analysis` stage is blocking with respect to the host. !> !> \note !> Currently, only \p trans_A == `rocsparse_operation_none` and \p trans_A == !> `rocsparse_operation_transpose` are supported. !> Currently, only \p trans_X == `rocsparse_operation_none` and \p trans_X == !> `rocsparse_operation_transpose` are supported. !> !> \note !> Only the stage `rocsparse_sptrsm_stage_compute` !> supports execution in a hipGraph context. The `rocsparse_sptrsm_stage_analysis` stage does !> not support hipGraph. !> !> \note !> This routine does not support batched execution. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] sptrsm_descr - SpTrSM routine descriptor. !> @param[in] A - sparse matrix descriptor. !> @param[in] X - dense matrix descriptor. !> @param[inout] Y - dense matrix descriptor. !> @param[in] sptrsm_stage - SpTrSM stage for the SpTrSM computation. !> @param[out] buffer_size_in_bytes - number of bytes of the temporary storage buffer. !> @param[in] buffer - temporary storage buffer allocated by the user. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p A, X, \p Y, \p sptrsm_descr, or !> \p buffer_size pointer is invalid. !> \retval rocsparse_status_not_implemented the configuration of the descriptor \p sptrsm_descr !> is currently not supported. !> \par Example interface rocsparse_sptrsm function rocsparse_sptrsm_(handle,sptrsm_descr,A,X,Y,sptrsm_stage,buffer_size_in_bytes,buffer, & p_error) & bind(c, name="rocsparse_sptrsm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sptrsm_ type(c_ptr),value :: handle type(c_ptr),value :: sptrsm_descr type(c_ptr),value :: A type(c_ptr),value :: X type(c_ptr),value :: Y integer(kind(rocsparse_sptrsm_stage_analysis)),value :: sptrsm_stage integer(c_size_t),value :: buffer_size_in_bytes type(c_ptr),value :: buffer type(c_ptr) :: p_error end function end interface !> \ingroup generic_module !> \details !> \p rocsparse_sptrsv_buffer_size returns the size of the required buffer to execute the given !> stage of the SpTrSV operation. !> This routine is used in conjunction with `rocsparse_sptrsv` (). See `rocsparse_sptrsv` for a !> full description and example. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> \note !> This routine does not support batched computation. !> !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] sptrsv_descr - SpTrSV descriptor. !> @param[in] spmat_descr - sparse matrix descriptor. !> @param[in] x - dense vector descriptor. !> @param[in] y - dense vector descriptor. !> @param[in] sptrsv_stage - stage for the SpTrSV computation. !> @param[out] buffer_size_in_bytes - number of bytes of the buffer. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value the \p sptrsv_stage value is invalid. !> \retval rocsparse_status_invalid_pointer \p sptrsv_descr, \p spmat_descr, \p x, \p y, or \p !> buffer_size_in_bytes pointer is invalid. interface rocsparse_sptrsv_buffer_size function rocsparse_sptrsv_buffer_size_(handle,sptrsv_descr,spmat_descr,x,y,sptrsv_stage, & buffer_size_in_bytes,p_error) & bind(c, name="rocsparse_sptrsv_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sptrsv_buffer_size_ type(c_ptr),value :: handle type(c_ptr),value :: sptrsv_descr type(c_ptr),value :: spmat_descr type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_sptrsv_stage_analysis)),value :: sptrsv_stage integer(c_size_t) :: buffer_size_in_bytes type(c_ptr) :: p_error end function end interface !> \ingroup generic_module !> \brief Sparse triangular solve. !> !> \details !> \p rocsparse_sptrsv solves a triangular linear system of equations defined by a sparse \f$m !> \times m\f$ square matrix \f$op(A)\f$, !> such that !> \f[ !> op(A) \cdot y = \alpha \cdot x, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if op == rocsparse_operation_none} \\% !> A^T, & \text{if op == rocsparse_operation_transpose} \\% !> A^H, & \text{if op == rocsparse_operation_conjugate_transpose} \\% !> \end{array} !> \right. !> \f] !> and where \f$y\f$ is the dense solution vector and \f$x\f$ is the dense right-hand side !> vector. !> !> Performing the above operation requires two stages, the stage !> `rocsparse_sptrsv_stage_analysis` and the stage `rocsparse_sptrsv_stage_compute`. !> The stage `rocsparse_sptrsv_stage_analysis` is required to perform the stage !> `rocsparse_sptrsv_stage_compute` and only need to be called once for a given sparse matrix !> \f$op(A)\f$, while the stage `rocsparse_sptrsv_stage_compute` can be repeatedly used with !> different \f$x\f$ and \f$y\f$ vectors. !> !> \p rocsparse_sptrsv supports the following !> data types for \f$op(A)\f$, \f$x\f$, \f$y\f$, and scalar \f$\alpha\f$: !> !> \par Uniform Precisions: !> !> !>
Uniform Precisions
A / X / Y / scalar !>
rocsparse_datatype_f32_r !>
rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_c !>
!> !> \note The descriptor \p rocsparse_sptrsv_descr needs to be configured with \ref !> rocsparse_sptrsv_set_input. !> \note !> The sparse matrix formats currently supported are: `rocsparse_format_coo`, !> `rocsparse_format_csr`, and `rocsparse_format_csc`. !> !> \note !> the `rocsparse_sptrsv_stage_compute` stage is non-blocking !> and executed asynchronously with respect to the host. It can return before the actual !> computation has finished. !> The `rocsparse_sptrsv_stage_analysis` stage is blocking with respect to the host. !> !> \note !> Currently, only \p trans == `rocsparse_operation_none` and \p trans == !> `rocsparse_operation_transpose` are supported. !> Only the `rocsparse_sptrsv_stage_compute` stage !> supports execution in a hipGraph context. The `rocsparse_sptrsv_stage_analysis` stage does !> not support hipGraph. !> !> \note !> This routine does not support batched computation. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] sptrsv_descr - descriptor of the routine. !> @param[in] A - matrix descriptor. !> @param[in] x - vector descriptor. !> @param[inout] y - vector descriptor. !> @param[in] sptrsv_stage - stage for the SpTRSV computation. !> @param[in] buffer_size_in_bytes - number of bytes of the buffer. !> @param[in] buffer - buffer allocated by the user. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if the user is not interested in !> obtaining an error descriptor. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p sptrsv_descr, \p A, \p x, or \p y is invalid, or !> \p buffer is null and \p buffer_size_in_bytes is non-zero, or \p buffer is not null and \p !> buffer_size_in_bytes is zero. !> \retval rocsparse_status_invalid_value \p sptrsv_stage is invalid. !> !> \par Example interface rocsparse_sptrsv function rocsparse_sptrsv_(handle,sptrsv_descr,A,x,y,sptrsv_stage,buffer_size_in_bytes,buffer, & p_error) & bind(c, name="rocsparse_sptrsv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sptrsv_ type(c_ptr),value :: handle type(c_ptr),value :: sptrsv_descr type(c_ptr),value :: A type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_sptrsv_stage_analysis)),value :: sptrsv_stage integer(c_size_t),value :: buffer_size_in_bytes type(c_ptr),value :: buffer type(c_ptr) :: p_error end function end interface !> \ingroup generic_module !> \brief Sparse vector inner dot product. !> !> \details !> \p rocsparse_spvv computes the inner dot product of the sparse vector \f$x\f$ with the !> dense vector \f$y\f$, such that !> \f[ !> \text{result} := op(x) \cdot y, !> \f] !> with !> \f[ !> op(x) = \left\{ !> \begin{array}{ll} !> x, & \text{if trans == rocsparse_operation_none} \\% !> \bar{x}, & \text{if trans == rocsparse_operation_conjugate_transpose} \\% !> \end{array} !> \right. !> \f] !> !> \code{.c} !> result = 0; !> for(i = 0; i < nnz; ++i) !> { !> result += x_val[i] * y[x_ind[i]]; !> } !> \endcode !> !> Performing the above operation involves two steps. First, call \p rocsparse_spvv with \p !> temp_buffer set to \p nullptr, !> which will return the required temporary buffer size in the parameter \p buffer_size. Then !> allocate this buffer. Finally, !> complete the computation by calling \p rocsparse_spvv a second time with the newly allocated !> buffer. After the !> computation is complete, deallocate the buffer. !> !> \p rocsparse_spvv supports the following uniform and mixed-precision data types for the !> sparse and dense vectors \f$x\f$ and !> \f$y\f$ and compute types for the scalar \p result. !> !> \par Uniform Precisions: !> !> !>
Uniform Precisions
X / Y / compute_type !>
rocsparse_datatype_f32_r !>
rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_c !>
!> !> \par Mixed Precisions: !> !> !>
Mixed Precisions
X / Y compute_type / result !>
rocsparse_datatype_i8_r rocsparse_datatype_i32_r !>
rocsparse_datatype_i8_r rocsparse_datatype_f32_r !>
rocsparse_datatype_f16_r rocsparse_datatype_f32_r !>
rocsparse_datatype_bf16_r rocsparse_datatype_f32_r !>
!> !> \note !> This function writes the required allocation size (in bytes) to \p buffer_size and !> returns without performing the SpVV operation when a nullptr is passed for !> \p temp_buffer. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> \note !> This routine does not support batched computation. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans - sparse vector operation type. !> @param[in] x - sparse vector descriptor. !> @param[in] y - dense vector descriptor. !> @param[out] myResult - pointer to the result, which can be in host or device memory. !> @param[in] compute_type - floating point precision for the SpVV computation. !> @param[out] buffer_size - number of bytes of the temporary storage buffer. buffer_size is set !> when !> \p temp_buffer is nullptr. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. When a nullptr is !> passed, !> the required allocation size (in bytes) is written to \p buffer_size and the !> function returns without performing the SpVV operation. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p x, \p y, \p result, or \p buffer_size !> pointer is invalid. !> \retval rocsparse_status_not_implemented \p compute_type is currently not !> supported. !> !> \par Example interface rocsparse_spvv function rocsparse_spvv_(handle,trans,x,y,myResult,compute_type,buffer_size,temp_buffer) & bind(c, name="rocsparse_spvv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spvv_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans type(c_ptr),value :: x type(c_ptr),value :: y type(c_ptr),value :: myResult integer(kind(rocsparse_datatype_f16_r)),value :: compute_type integer(c_size_t) :: buffer_size type(c_ptr),value :: temp_buffer end function end interface !> \ingroup generic_module !> \details !> \p rocsparse_v2_spmv_buffer_size returns the size of the required buffer to execute the given !> stage of the Version 2 SpMV operation. !> This routine is used in conjunction with `rocsparse_v2_spmv` (). See `rocsparse_v2_spmv` for !> a full description and example. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] descr - SpMV descriptor. !> @param[in] mat - sparse matrix descriptor. !> @param[in] x - dense vector descriptor. !> @param[in] y - dense vector descriptor. !> @param[in] stage - Version 2 SpMV stage for the SpMV computation. !> @param[out] buffer_size_in_bytes - number of bytes of the buffer. !> @param[out] error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value the \p stage value is invalid. !> \retval rocsparse_status_invalid_pointer \p mat, \p x, \p y, \p descr, or \p !> buffer_size_in_bytes pointer is invalid. interface rocsparse_v2_spmv_buffer_size function rocsparse_v2_spmv_buffer_size_(handle,descr,mat,x,y,stage,buffer_size_in_bytes,error) & bind(c, name="rocsparse_v2_spmv_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_v2_spmv_buffer_size_ type(c_ptr),value :: handle type(c_ptr),value :: descr type(c_ptr),value :: mat type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_v2_spmv_stage_analysis)),value :: stage integer(c_size_t) :: buffer_size_in_bytes type(c_ptr) :: error end function end interface !> \ingroup generic_module !> \brief Sparse matrix vector multiplication. !> !> \details !> \p rocsparse_v2_spmv multiplies the scalar \f$\alpha\f$ with a sparse \f$m \times n\f$ matrix !> \f$op(A)\f$ with the dense vector \f$x\f$ and adds the result to the dense vector \f$y\f$ !> that is multiplied by the scalar \f$\beta\f$, such that !> \f[ !> y := \alpha \cdot op(A) \cdot x + \beta \cdot y, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == rocsparse_operation_none} \\% !> A^T, & \text{if trans == rocsparse_operation_transpose} \\% !> A^H, & \text{if trans == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> !> \note The sparse matrix format `rocsparse_format_bell` is not supported. !> !> Performing the above operation involves two stages. The first stage is !> `rocsparse_v2_spmv_stage_analysis`. This will perform an analysis !> of the symbolic information of \f$op(A)\f$. The second stage is !> `rocsparse_v2_spmv_stage_compute`, which corresponds to the actual calculation. !> The size of the buffer required for each stage is determined by calling the routine \ref !> rocsparse_v2_spmv_buffer_size. !> The stage `rocsparse_v2_spmv_stage_analysis` only needs to be called once for a given sparse !> matrix \f$op(A)\f$, while the computation stage can be repeatedly used !> with different \f$x\f$ and \f$y\f$ vectors. !> !> \note The stage `rocsparse_v2_spmv_stage_analysis` is mandatory. An error will be returned if !> that stage was not executed before the stage `rocsparse_v2_spmv_stage_compute`. !> !> \p rocsparse_v2_spmv supports multiple algorithms. These algorithms have different trade-offs !> depending on the sparsity pattern of the matrix, !> whether or not the results need to be deterministic, and how many times the sparse-vector !> product will be performed. !> !> !> !> !> !> !> !> !>
CSR/CSC Algorithms
Algorithm Deterministic Notes !>
rocsparse_spmv_alg_csr_rowsplit Yes This is best suited for !> matrices with all rows having a similar number of non-zeros. Can outperform adaptive and LRB !> algorithms in certain sparsity patterns. Will perform very poorly if some rows have few !> non-zeros and some rows have many non-zeros.
rocsparse_spmv_alg_csr_stream Yes [Deprecated] The old name for !> rocsparse_spmv_alg_csr_rowsplit.
rocsparse_spmv_alg_csr_adaptive No Generally the fastest algorithm !> across all matrix sparsity patterns. This includes matrices that have some rows with many !> non-zeros and some rows with few non-zeros. Requires lengthy preprocessing that needs to be !> amortized over many subsequent sparse vector products.
rocsparse_spmv_alg_csr_lrb No Like the adaptive algorithm, this !> generally performs well across all matrix sparsity patterns. Generally not as fast as the !> adaptive algorithm. However, it uses a much faster preprocessing step. Good for when only a !> small number of sparse vector products will be performed.
rocsparse_spmv_alg_csr_nnzsplit No Like the adaptive algorithm, !> this generally performs well across all matrix sparsity patterns. Generally not as fast as !> the adaptive algorithm but faster than the LRB algorithm. It uses a much faster preprocessing !> step than LRB. It's good when the number of sparse vector products that will be performed is !> less than one hundred. If more products need to be computed, the adaptive algorithm is !> probably faster.
!> !> !> !> !> !>
COO Algorithms
COO Algorithms Deterministic Notes !>
rocsparse_spmv_alg_coo Yes Generally not as fast as the atomic !> algorithm but is deterministic.
rocsparse_spmv_alg_coo_atomic No Generally the fastest COO !> algorithm.
!> !> !> !> !>
ELL Algorithms
ELL Algorithms Deterministic Notes !>
rocsparse_spmv_alg_ell Yes
!> !> !> !> !>
Sliced ELL Algorithms
Sliced ELL Algorithms Deterministic Notes !>
rocsparse_spmv_alg_sell Yes
!> !> !> !> !>
BSR Algorithms
BSR Algorithm Deterministic Notes !>
rocsparse_spmv_alg_bsr Yes
!> !> \p rocsparse_v2_spmv supports multiple combinations of data types and compute types. The !> tables below indicate the currently !> supported different data types that can be used for the sparse matrix \f$op(A)\f$, the dense !> vectors \f$x\f$ and !> \f$y\f$, and the compute type for \f$\alpha\f$ and \f$\beta\f$. The advantage of using !> different data types is to save on !> memory bandwidth and storage when a user application allows, while performing the actual !> computation in a higher precision. !> !> \par Uniform Precisions: !> !> !>
Uniform Precisions
A / X / Y / compute_type !>
rocsparse_datatype_f32_r !>
rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_c !>
!> !> \par Mixed Precisions: !> !> !>
Mixed Precisions
A / X Y compute_type !>
rocsparse_datatype_i8_r rocsparse_datatype_i32_r rocsparse_datatype_i32_r !>
rocsparse_datatype_i8_r rocsparse_datatype_f32_r rocsparse_datatype_f32_r !>
rocsparse_datatype_f16_r rocsparse_datatype_f32_r rocsparse_datatype_f32_r !>
rocsparse_datatype_f16_r rocsparse_datatype_f16_r rocsparse_datatype_f32_r !>
rocsparse_datatype_bf16_r rocsparse_datatype_f32_r rocsparse_datatype_f32_r !>
rocsparse_datatype_bf16_r rocsparse_datatype_bf16_r rocsparse_datatype_f32_r !>
!> !> \par Mixed-regular Real Precisions !> !> !>
Mixed-regular Real Precisions
A X / Y / compute_type !>
rocsparse_datatype_f32_r rocsparse_datatype_f64_r !>
rocsparse_datatype_f32_c rocsparse_datatype_f64_c !>
!> !> \par Mixed-regular Complex Precisions !> !> !>
Mixed-regular Complex Precisions
A X / Y / compute_type !>
rocsparse_datatype_f32_r rocsparse_datatype_f32_c !>
rocsparse_datatype_f64_r rocsparse_datatype_f64_c !>
!> !> \p rocsparse_v2_spmv supports `rocsparse_indextype_i32` and `rocsparse_indextype_i64` index !> precisions !> for storing the row pointer and column indices arrays of the sparse matrices. !> !> \note !> None of the algorithms above are deterministic when \f$A\f$ is transposed. !> !> \note !> All the sparse matrix formats are supported except `rocsparse_format_bell`. !> !> \note !> The `rocsparse_v2_spmv_stage_compute` stage is non-blocking !> and executed asynchronously with respect to the host. It can return before the actual !> computation has finished. !> The stage `rocsparse_v2_spmv_stage_analysis` is blocking with respect to the host. !> !> \note !> Only the stage `rocsparse_v2_spmv_stage_compute` !> supports execution in a hipGraph context. The `rocsparse_v2_spmv_stage_analysis` stage does !> not support hipGraph. !> !> \note !> This routine does not support batched computation. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] descr - SpMV descriptor. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] mat - matrix descriptor. !> @param[in] x - vector descriptor. !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] y - vector descriptor. !> @param[in] stage - SpMV stage of the SpMV algorithm. !> @param[in] buffer_size_in_bytes - size in bytes of the buffer, which must be greater or equal !> to the buffer size obtained from \ref rocsparse_v2_spmv_buffer_size. !> @param[in] buffer - temporary buffer allocated by the user. !> @param[out] error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context \p handle was not initialized. !> \retval rocsparse_status_invalid_pointer \p alpha, \p mat, \p x, \p beta, \p y, or !> \p buffer pointer is invalid. !> \retval rocsparse_status_invalid_value the value of \p stage is invalid. !> \retval rocsparse_status_not_implemented if \p alg is not supported or if the mixed precision !> configuration is not supported. !> !> \par Example interface rocsparse_v2_spmv function rocsparse_v2_spmv_(handle,descr,alpha,mat,x,beta,y,stage,buffer_size_in_bytes,buffer, & error) & bind(c, name="rocsparse_v2_spmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_v2_spmv_ type(c_ptr),value :: handle type(c_ptr),value :: descr type(c_ptr),value :: alpha type(c_ptr),value :: mat type(c_ptr),value :: x type(c_ptr),value :: beta type(c_ptr),value :: y integer(kind(rocsparse_v2_spmv_stage_analysis)),value :: stage integer(c_size_t),value :: buffer_size_in_bytes type(c_ptr),value :: buffer type(c_ptr) :: error end function end interface !> \ingroup generic_module !> \brief Set extra scalar and vector parameters for SpMV. !> !> \details !> \p rocsparse_spmv_set_extra sets a gamma dnvec vector and z vectors that are !> appended to the SpMV computation. The computation will be: !> \f$y = \alpha * op(A) * x + \beta * y + \sum_{i=1}^{n} \gamma_i z_i\f$ !> where \f$n\f$ is the number of extra terms set by \p num_extras. !> !> This feature can be used to implement residual calculations of the form !> \f$r = b - A * x\f$ within the SpMV call by setting \f$\gamma = 1\f$ and \f$z = b\f$. !> !> \par Data type Requirements !> The following data type requirements must be satisfied: !> - The \p gamma_vec data type must match the scalar data type set using !> \ref rocsparse_spmv_set_input with \p rocsparse_spmv_input_scalar_datatype. !> - All \p z_vecs must have the same data type as the compute data type set using !> \ref rocsparse_spmv_set_input with \p rocsparse_spmv_input_compute_datatype. !> - The size of \p gamma_vec must equal \p num_extras. !> - All \p z_vecs must have the same size (vector length). !> - Both scalar and compute data types must be set on the descriptor before calling this !> function. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[inout] descr - SpMV descriptor. !> @param[in] num_extras - number of extra terms (gamma/z pairs). !> @param[in] gamma_vec - dense vector descriptor containing gamma scalars. Must have a data !> type matching !> the scalar datatype and a size equal to \p num_extras. !> @param[in] z_vecs - array of dense vector descriptors for z vectors. All vectors must have a !> data type matching the compute data type and have the same size. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p descr, \p gamma_vec, or \p z_vecs is invalid. !> \retval rocsparse_status_invalid_value invalid parameters, including data type mismatches !> or missing scalar/compute data type configuration. !> \retval rocsparse_status_invalid_size size mismatches between \p gamma_vec and \p num_extras, !> or between \p z_vecs elements. !> !> \par Example interface rocsparse_spmv_set_extra function rocsparse_spmv_set_extra_(handle,descr,num_extras,gamma_vec,z_vecs,p_error) & bind(c, name="rocsparse_spmv_set_extra") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spmv_set_extra_ type(c_ptr),value :: handle type(c_ptr),value :: descr integer(c_int64_t),value :: num_extras type(c_ptr),value :: gamma_vec type(c_ptr) :: z_vecs type(c_ptr) :: p_error end function end interface !> \ingroup generic_module !> \brief Clear extra parameters for SpMV. !> !> \details !> \p rocsparse_spmv_clear_extra clears the extra parameters set by !> \ref rocsparse_spmv_set_extra. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[inout] descr - SpMV descriptor. !> @param[out] p_error - error descriptor created if the returned status is not !> `rocsparse_status_success`. A null pointer can be passed if an error descriptor is not !> required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p descr is invalid. interface rocsparse_spmv_clear_extra function rocsparse_spmv_clear_extra_(handle,descr,p_error) & bind(c, name="rocsparse_spmv_clear_extra") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_spmv_clear_extra_ type(c_ptr),value :: handle type(c_ptr),value :: descr type(c_ptr) :: p_error end function end interface !> \ingroup level1_module !> \brief Scale a sparse vector and add it to a dense vector. !> !> \details !> \p rocsparse_axpyi multiplies the sparse vector \f$x\f$ with scalar \f$\alpha\f$ and !> adds the result to the dense vector \f$y\f$, such that !> !> \f[ !> y := y + \alpha \cdot x !> \f] !> !> \code{.c} !> for(i = 0; i < nnz; ++i) !> { !> y[x_ind[i]] = y[x_ind[i]] + alpha * x_val[i]; !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] nnz - number of non-zero entries of vector \f$x\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] x_val - array of \p nnz elements containing the values of \f$x\f$. !> @param[in] x_ind - array of \p nnz elements containing the indices of the non-zero !> values of \f$x\f$. !> @param[inout] y - array of values in dense format. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p idx_base is invalid. !> \retval rocsparse_status_invalid_size \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p alpha, \p x_val, \p x_ind, or \p y pointer !> is invalid. !> !> \par Example interface rocsparse_saxpyi function rocsparse_saxpyi_(handle,nnz,alpha,x_val,x_ind,y,idx_base) & bind(c, name="rocsparse_saxpyi") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_saxpyi_ type(c_ptr),value :: handle integer(c_int),value :: nnz real(c_float) :: alpha type(c_ptr),value :: x_val type(c_ptr),value :: x_ind type(c_ptr),value :: y integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_saxpyi_assumed_rank #else module procedure & rocsparse_saxpyi_rank_0,& rocsparse_saxpyi_rank_1 #endif #endif end interface interface rocsparse_daxpyi function rocsparse_daxpyi_(handle,nnz,alpha,x_val,x_ind,y,idx_base) & bind(c, name="rocsparse_daxpyi") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_daxpyi_ type(c_ptr),value :: handle integer(c_int),value :: nnz real(c_double) :: alpha type(c_ptr),value :: x_val type(c_ptr),value :: x_ind type(c_ptr),value :: y integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_daxpyi_assumed_rank #else module procedure & rocsparse_daxpyi_rank_0,& rocsparse_daxpyi_rank_1 #endif #endif end interface interface rocsparse_caxpyi function rocsparse_caxpyi_(handle,nnz,alpha,x_val,x_ind,y,idx_base) & bind(c, name="rocsparse_caxpyi") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_caxpyi_ type(c_ptr),value :: handle integer(c_int),value :: nnz complex(c_float_complex) :: alpha type(c_ptr),value :: x_val type(c_ptr),value :: x_ind type(c_ptr),value :: y integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_caxpyi_assumed_rank #else module procedure & rocsparse_caxpyi_rank_0,& rocsparse_caxpyi_rank_1 #endif #endif end interface interface rocsparse_zaxpyi function rocsparse_zaxpyi_(handle,nnz,alpha,x_val,x_ind,y,idx_base) & bind(c, name="rocsparse_zaxpyi") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zaxpyi_ type(c_ptr),value :: handle integer(c_int),value :: nnz complex(c_double_complex) :: alpha type(c_ptr),value :: x_val type(c_ptr),value :: x_ind type(c_ptr),value :: y integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zaxpyi_assumed_rank #else module procedure & rocsparse_zaxpyi_rank_0,& rocsparse_zaxpyi_rank_1 #endif #endif end interface !> \ingroup level1_module !> \brief Compute the dot product of a complex conjugate sparse vector with a dense !> vector. !> !> \details !> \p rocsparse_dotci computes the dot product of the complex conjugate sparse vector !> \f$x\f$ with the dense vector \f$y\f$, such that !> \f[ !> \text{result} := \bar{x}^H y !> \f] !> !> \code{.c} !> result = 0 !> for(i = 0; i < nnz; ++i) !> { !> result += conj(x_val[i]) * y[x_ind[i]]; !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] nnz - number of non-zero entries of vector \f$x\f$. !> @param[in] x_val - array of \p nnz values. !> @param[in] x_ind - array of \p nnz elements containing the indices of the non-zero !> values of \f$x\f$. !> @param[in] y - array of values in dense format. !> @param[out] myResult - pointer to the result, which can be in host or device memory. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p idx_base is invalid. !> \retval rocsparse_status_invalid_size \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p x_val, \p x_ind, \p y, or \p result !> pointer is invalid. !> \retval rocsparse_status_memory_error the buffer for the dot product reduction !> could not be allocated. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_cdotci function rocsparse_cdotci_(handle,nnz,x_val,x_ind,y,myResult,idx_base) & bind(c, name="rocsparse_cdotci") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdotci_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: x_val type(c_ptr),value :: x_ind type(c_ptr),value :: y type(c_ptr),value :: myResult integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cdotci_assumed_rank #else module procedure & rocsparse_cdotci_rank_0,& rocsparse_cdotci_rank_1 #endif #endif end interface interface rocsparse_zdotci function rocsparse_zdotci_(handle,nnz,x_val,x_ind,y,myResult,idx_base) & bind(c, name="rocsparse_zdotci") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdotci_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: x_val type(c_ptr),value :: x_ind type(c_ptr),value :: y type(c_ptr),value :: myResult integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zdotci_assumed_rank #else module procedure & rocsparse_zdotci_rank_0,& rocsparse_zdotci_rank_1 #endif #endif end interface !> \ingroup level1_module !> \brief Compute the dot product of a sparse vector with a dense vector. !> !> \details !> \p rocsparse_doti computes the dot product of the sparse vector \f$x\f$ with the !> dense vector \f$y\f$, such that !> \f[ !> \text{result} := y^T x !> \f] !> !> \code{.c} !> result = 0 !> for(i = 0; i < nnz; ++i) !> { !> result += x_val[i] * y[x_ind[i]]; !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] nnz - number of non-zero entries of vector \f$x\f$. !> @param[in] x_val - array of \p nnz values. !> @param[in] x_ind - array of \p nnz elements containing the indices of the non-zero !> values of \f$x\f$. !> @param[in] y - array of values in dense format. !> @param[out] myResult - pointer to the result, which can be in host or device memory. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p idx_base is invalid. !> \retval rocsparse_status_invalid_size \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p x_val, \p x_ind, \p y, or \p result !> pointer is invalid. !> \retval rocsparse_status_memory_error the buffer for the dot product reduction !> could not be allocated. !> \retval rocsparse_status_internal_error an internal error occurred. !> !> \par Example interface rocsparse_sdoti function rocsparse_sdoti_(handle,nnz,x_val,x_ind,y,myResult,idx_base) & bind(c, name="rocsparse_sdoti") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sdoti_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: x_val type(c_ptr),value :: x_ind type(c_ptr),value :: y type(c_ptr),value :: myResult integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sdoti_assumed_rank #else module procedure & rocsparse_sdoti_rank_0,& rocsparse_sdoti_rank_1 #endif #endif end interface interface rocsparse_ddoti function rocsparse_ddoti_(handle,nnz,x_val,x_ind,y,myResult,idx_base) & bind(c, name="rocsparse_ddoti") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ddoti_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: x_val type(c_ptr),value :: x_ind type(c_ptr),value :: y type(c_ptr),value :: myResult integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ddoti_assumed_rank #else module procedure & rocsparse_ddoti_rank_0,& rocsparse_ddoti_rank_1 #endif #endif end interface interface rocsparse_cdoti function rocsparse_cdoti_(handle,nnz,x_val,x_ind,y,myResult,idx_base) & bind(c, name="rocsparse_cdoti") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdoti_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: x_val type(c_ptr),value :: x_ind type(c_ptr),value :: y type(c_ptr),value :: myResult integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cdoti_assumed_rank #else module procedure & rocsparse_cdoti_rank_0,& rocsparse_cdoti_rank_1 #endif #endif end interface interface rocsparse_zdoti function rocsparse_zdoti_(handle,nnz,x_val,x_ind,y,myResult,idx_base) & bind(c, name="rocsparse_zdoti") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdoti_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: x_val type(c_ptr),value :: x_ind type(c_ptr),value :: y type(c_ptr),value :: myResult integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zdoti_assumed_rank #else module procedure & rocsparse_zdoti_rank_0,& rocsparse_zdoti_rank_1 #endif #endif end interface !> \ingroup level1_module !> \brief Gather elements from a dense vector and store them in a sparse vector. !> !> \details !> \p rocsparse_gthr gathers the elements that are listed in \p x_ind from the dense !> vector \f$y\f$ and stores them in the sparse vector \f$x\f$. !> !> \code{.c} !> for(i = 0; i < nnz; ++i) !> { !> x_val[i] = y[x_ind[i]]; !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] nnz - number of non-zero entries of \f$x\f$. !> @param[in] y - array of values in dense format. !> @param[out] x_val - array of \p nnz elements containing the values of \f$x\f$. !> @param[in] x_ind - array of \p nnz elements containing the indices of the non-zero !> values of \f$x\f$. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p idx_base is invalid. !> \retval rocsparse_status_invalid_size \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p y, \p x_val, or \p x_ind pointer is !> invalid. !> !> \par Example interface rocsparse_sgthr function rocsparse_sgthr_(handle,nnz,y,x_val,x_ind,idx_base) bind(c, name="rocsparse_sgthr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgthr_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: y type(c_ptr),value :: x_val type(c_ptr),value :: x_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sgthr_assumed_rank #else module procedure & rocsparse_sgthr_rank_0,& rocsparse_sgthr_rank_1 #endif #endif end interface interface rocsparse_dgthr function rocsparse_dgthr_(handle,nnz,y,x_val,x_ind,idx_base) bind(c, name="rocsparse_dgthr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgthr_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: y type(c_ptr),value :: x_val type(c_ptr),value :: x_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dgthr_assumed_rank #else module procedure & rocsparse_dgthr_rank_0,& rocsparse_dgthr_rank_1 #endif #endif end interface interface rocsparse_cgthr function rocsparse_cgthr_(handle,nnz,y,x_val,x_ind,idx_base) bind(c, name="rocsparse_cgthr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgthr_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: y type(c_ptr),value :: x_val type(c_ptr),value :: x_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cgthr_assumed_rank #else module procedure & rocsparse_cgthr_rank_0,& rocsparse_cgthr_rank_1 #endif #endif end interface interface rocsparse_zgthr function rocsparse_zgthr_(handle,nnz,y,x_val,x_ind,idx_base) bind(c, name="rocsparse_zgthr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgthr_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: y type(c_ptr),value :: x_val type(c_ptr),value :: x_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zgthr_assumed_rank #else module procedure & rocsparse_zgthr_rank_0,& rocsparse_zgthr_rank_1 #endif #endif end interface !> \ingroup level1_module !> \brief Gather and zero out elements from a dense vector and store them in a sparse !> vector. !> !> \details !> \p rocsparse_gthrz gathers the elements that are listed in \p x_ind from the dense !> vector \f$y\f$ and stores them in the sparse vector \f$x\f$. The gathered elements !> in \f$y\f$ are replaced by zero. !> !> \code{.c} !> for(i = 0; i < nnz; ++i) !> { !> x_val[i] = y[x_ind[i]]; !> y[x_ind[i]] = 0; !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] nnz - number of non-zero entries of \f$x\f$. !> @param[inout] y - array of values in dense format. !> @param[out] x_val - array of \p nnz elements containing the non-zero values of \f$x\f$. !> @param[in] x_ind - array of \p nnz elements containing the indices of the non-zero !> values of \f$x\f$. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p idx_base is invalid. !> \retval rocsparse_status_invalid_size \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p y, \p x_val, or \p x_ind pointer is !> invalid. interface rocsparse_sgthrz function rocsparse_sgthrz_(handle,nnz,y,x_val,x_ind,idx_base) bind(c, name="rocsparse_sgthrz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgthrz_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: y type(c_ptr),value :: x_val type(c_ptr),value :: x_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sgthrz_assumed_rank #else module procedure & rocsparse_sgthrz_rank_0,& rocsparse_sgthrz_rank_1 #endif #endif end interface interface rocsparse_dgthrz function rocsparse_dgthrz_(handle,nnz,y,x_val,x_ind,idx_base) bind(c, name="rocsparse_dgthrz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgthrz_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: y type(c_ptr),value :: x_val type(c_ptr),value :: x_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dgthrz_assumed_rank #else module procedure & rocsparse_dgthrz_rank_0,& rocsparse_dgthrz_rank_1 #endif #endif end interface interface rocsparse_cgthrz function rocsparse_cgthrz_(handle,nnz,y,x_val,x_ind,idx_base) bind(c, name="rocsparse_cgthrz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgthrz_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: y type(c_ptr),value :: x_val type(c_ptr),value :: x_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cgthrz_assumed_rank #else module procedure & rocsparse_cgthrz_rank_0,& rocsparse_cgthrz_rank_1 #endif #endif end interface interface rocsparse_zgthrz function rocsparse_zgthrz_(handle,nnz,y,x_val,x_ind,idx_base) bind(c, name="rocsparse_zgthrz") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgthrz_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: y type(c_ptr),value :: x_val type(c_ptr),value :: x_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zgthrz_assumed_rank #else module procedure & rocsparse_zgthrz_rank_0,& rocsparse_zgthrz_rank_1 #endif #endif end interface !> \ingroup level1_module !> \brief Apply Givens rotation to a dense and a sparse vector. !> !> \details !> \p rocsparse_roti applies the Givens rotation matrix \f$G\f$ to the sparse vector !> \f$x\f$ and the dense vector \f$y\f$, where !> \f[ !> G = \begin{pmatrix} c & s \\ -s & c \end{pmatrix} !> \f] !> !> \code{.c} !> for(i = 0; i < nnz; ++i) !> { !> x_tmp = x_val[i]; !> y_tmp = y[x_ind[i]]; !> !> x_val[i] = c * x_tmp + s * y_tmp; !> y[x_ind[i]] = c * y_tmp - s * x_tmp; !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] nnz - number of non-zero entries of \f$x\f$. !> @param[inout] x_val - array of \p nnz elements containing the non-zero values of \f$x\f$. !> @param[in] x_ind - array of \p nnz elements containing the indices of the non-zero !> values of \f$x\f$. !> @param[inout] y - array of values in dense format. !> @param[in] c - pointer to the cosine element of \f$G\f$, can be on the host or device. !> @param[in] s - pointer to the sine element of \f$G\f$, can be on the host or device. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p idx_base is invalid. !> \retval rocsparse_status_invalid_size \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p c, \p s, \p x_val, \p x_ind, or \p y !> pointer is invalid. !> !> \par Example interface rocsparse_sroti function rocsparse_sroti_(handle,nnz,x_val,x_ind,y,c,s,idx_base) bind(c, name="rocsparse_sroti") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sroti_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: x_val type(c_ptr),value :: x_ind type(c_ptr),value :: y real(c_float) :: c real(c_float) :: s integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sroti_assumed_rank #else module procedure & rocsparse_sroti_rank_0,& rocsparse_sroti_rank_1 #endif #endif end interface interface rocsparse_droti function rocsparse_droti_(handle,nnz,x_val,x_ind,y,c,s,idx_base) bind(c, name="rocsparse_droti") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_droti_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: x_val type(c_ptr),value :: x_ind type(c_ptr),value :: y real(c_double) :: c real(c_double) :: s integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_droti_assumed_rank #else module procedure & rocsparse_droti_rank_0,& rocsparse_droti_rank_1 #endif #endif end interface !> \ingroup level1_module !> \brief Scatter elements from a dense vector across a sparse vector. !> !> \details !> \p rocsparse_sctr scatters the elements that are listed in \p x_ind from the sparse !> vector \f$x\f$ into the dense vector \f$y\f$. Indices of \f$y\f$ that are not listed !> in \p x_ind remain unchanged. !> !> \code{.c} !> for(i = 0; i < nnz; ++i) !> { !> y[x_ind[i]] = x_val[i]; !> } !> \endcode !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] nnz - number of non-zero entries of \f$x\f$. !> @param[in] x_val - array of \p nnz elements containing the non-zero values of \f$x\f$. !> @param[in] x_ind - array of \p nnz elements containing the indices of the non-zero !> values of x. !> @param[inout] y - array of values in dense format. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p idx_base is invalid. !> \retval rocsparse_status_invalid_size \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p x_val, \p x_ind, or \p y pointer is !> invalid. !> !> \par Example interface rocsparse_ssctr function rocsparse_ssctr_(handle,nnz,x_val,x_ind,y,idx_base) bind(c, name="rocsparse_ssctr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ssctr_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: x_val type(c_ptr),value :: x_ind type(c_ptr),value :: y integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ssctr_assumed_rank #else module procedure & rocsparse_ssctr_rank_0,& rocsparse_ssctr_rank_1 #endif #endif end interface interface rocsparse_dsctr function rocsparse_dsctr_(handle,nnz,x_val,x_ind,y,idx_base) bind(c, name="rocsparse_dsctr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dsctr_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: x_val type(c_ptr),value :: x_ind type(c_ptr),value :: y integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dsctr_assumed_rank #else module procedure & rocsparse_dsctr_rank_0,& rocsparse_dsctr_rank_1 #endif #endif end interface interface rocsparse_csctr function rocsparse_csctr_(handle,nnz,x_val,x_ind,y,idx_base) bind(c, name="rocsparse_csctr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csctr_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: x_val type(c_ptr),value :: x_ind type(c_ptr),value :: y integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_csctr_assumed_rank #else module procedure & rocsparse_csctr_rank_0,& rocsparse_csctr_rank_1 #endif #endif end interface interface rocsparse_zsctr function rocsparse_zsctr_(handle,nnz,x_val,x_ind,y,idx_base) bind(c, name="rocsparse_zsctr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zsctr_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: x_val type(c_ptr),value :: x_ind type(c_ptr),value :: y integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zsctr_assumed_rank #else module procedure & rocsparse_zsctr_rank_0,& rocsparse_zsctr_rank_1 #endif #endif end interface interface rocsparse_isctr function rocsparse_isctr_(handle,nnz,x_val,x_ind,y,idx_base) bind(c, name="rocsparse_isctr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_isctr_ type(c_ptr),value :: handle integer(c_int),value :: nnz type(c_ptr),value :: x_val type(c_ptr),value :: x_ind type(c_ptr),value :: y integer(kind(rocsparse_index_base_zero)),value :: idx_base end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_isctr_assumed_rank #else module procedure & rocsparse_isctr_rank_0,& rocsparse_isctr_rank_1 #endif #endif end interface !> \ingroup level2_module !> \details !> \p rocsparse_bsrmv_analysis performs the analysis step for \ref rocsparse_sbsrmv !> "rocsparse_Xbsrmv()". !> It is expected that this function will be executed only once for a given sparsity pattern and !> particular operation !> type. The gathered analysis meta data is stored in the `rocsparse_mat_info` object and can be !> cleared by !> `rocsparse_bsrmv_clear`(). !> !> If the matrix sparsity pattern changes, the gathered information will become invalid. To !> perform another !> sparse matrix multiplication with a matrix having a different sparsity pattern, either !> destroy !> the old \p info object and create a new one or clear the existing \p info object using !> `rocsparse_bsrmv_clear`(). In both cases, the analysis will need to be called again. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - matrix storage of BSR blocks. !> @param[in] trans - matrix operation type. !> @param[in] mb - number of block rows of the sparse BSR matrix. !> @param[in] nb - number of block columns of the sparse BSR matrix. !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix. !> @param[in] descr - descriptor of the sparse BSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] bsr_val - array of \p nnzb blocks of the sparse BSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of !> the sparse BSR matrix. !> @param[in] bsr_col_ind - array of \p nnzb elements containing the block column indices of the !> sparse !> BSR matrix. !> @param[in] block_dim - block dimension of the sparse BSR matrix. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nb, or \p nnzb is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p bsr_val, \p bsr_row_ptr, !> \p bsr_col_ind, or \p info pointer is invalid. !> \retval rocsparse_status_memory_error the buffer for the gathered information !> could not be allocated. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> \p trans != `rocsparse_operation_none` or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_sbsrmv_analysis function rocsparse_sbsrmv_analysis_(handle,dir,trans,mb,nb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo) & bind(c, name="rocsparse_sbsrmv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrmv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo end function end interface interface rocsparse_dbsrmv_analysis function rocsparse_dbsrmv_analysis_(handle,dir,trans,mb,nb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo) & bind(c, name="rocsparse_dbsrmv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrmv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo end function end interface interface rocsparse_cbsrmv_analysis function rocsparse_cbsrmv_analysis_(handle,dir,trans,mb,nb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo) & bind(c, name="rocsparse_cbsrmv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrmv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo end function end interface interface rocsparse_zbsrmv_analysis function rocsparse_zbsrmv_analysis_(handle,dir,trans,mb,nb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo) & bind(c, name="rocsparse_zbsrmv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrmv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo end function end interface !> \ingroup level2_module !> \brief Sparse matrix vector multiplication using the BSR storage format. !> !> \details !> \p rocsparse_bsrmv multiplies the scalar \f$\alpha\f$ with a sparse !> \f$m \times n\f$ matrix, defined in BSR storage format, and the dense vector \f$x\f$ and adds !> the !> result to the dense vector \f$y\f$ that is multiplied by the scalar \f$\beta\f$, such that !> \f[ !> y := \alpha \cdot op(A) \cdot x + \beta \cdot y, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == rocsparse_operation_none} !> \end{array} !> \right. !> \f] !> and where \f$m = mb \times block\_dim\f$ and \f$n= nb \times block\_dim\f$. !> !> The operation above can be done with or without analysis. Running with analysis might result !> in better performance !> when computing the matrix vector product but will also incur a performance cost attributed to !> the additional analysis step. !> For this reason, running with analysis makes sense when a user plans on computing the matrix !> vector product many times and !> therefore can amortize the analysis cost. !> !> To run the operation above without analysis, call the \p rocsparse_bsrmv routine while !> passing !> \p NULL for the \p info parameter. !> !> Running the operation with analysis involves two steps. First, create a `rocsparse_mat_info` !> object !> by calling \ref rocsparse_create_mat_info and then pass this to \ref !> rocsparse_sbsrmv_analysis "rocsparse_Xbsrmv_analysis()", !> which will perform analysis on the sparsity pattern of the matrix \f$op(A)\f$. Then complete !> the operation by !> calling \p rocsparse_bsrmv. The creation of the \p info object and the call to the analysis !> routine only need to be performed !> once for a given sparsity pattern, while the computation can be performed repeatedly as long !> as the sparsity pattern has !> not changed. After all calls to \p rocsparse_bsrmv have been made, the \p info object can be !> destroyed with a call to !> `rocsparse_destroy_mat_info`. !> !> When running with analysis, users might want to perform multiple sparse matrix !> multiplications, with each sparse matrix having a different sparsity pattern. Instead of !> creating and destroying multiple !> `rocsparse_mat_info` objects for each unique sparsity pattern, the user can instead create !> the \p info object once and !> then call `rocsparse_bsrmv_clear`, followed by re-running the analysis in between each sparse !> matrix multiplication. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p trans == `rocsparse_operation_none` is supported. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - matrix storage of BSR blocks. !> @param[in] trans - matrix operation type. !> @param[in] mb - number of block rows of the sparse BSR matrix. !> @param[in] nb - number of block columns of the sparse BSR matrix. !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr - descriptor of the sparse BSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] bsr_val - array of \p nnzb blocks of the sparse BSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of !> the sparse BSR matrix. !> @param[in] bsr_col_ind - array of \p nnzb elements containing the block column indices of the !> sparse !> BSR matrix. !> @param[in] block_dim - block dimension of the sparse BSR matrix. !> @param[in] x - array of \p nb*block_dim elements (\f$op(A) = A\f$) or \p mb*block_dim !> elements (\f$op(A) = A^T\f$ or \f$op(A) = A^H\f$). !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] y - array of \p mb*block_dim elements (\f$op(A) = A\f$) or \p nb*block_dim !> elements (\f$op(A) = A^T\f$ or \f$op(A) = A^H\f$). !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nb, \p nnzb, or \p block_dim is !> invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p alpha, \p bsr_val, !> \p bsr_row_ind, \p bsr_col_ind, \p x, \p beta, or \p y pointer is invalid. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> \retval rocsparse_status_not_implemented !> \p trans != `rocsparse_operation_none` or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> This example performs a sparse matrix vector multiplication in BSR format. interface rocsparse_sbsrmv function rocsparse_sbsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,x,beta,y) & bind(c, name="rocsparse_sbsrmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrmv_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb real(c_float) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo type(c_ptr),value :: x real(c_float) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sbsrmv_assumed_rank #else module procedure & rocsparse_sbsrmv_rank_0,& rocsparse_sbsrmv_rank_1 #endif #endif end interface interface rocsparse_dbsrmv function rocsparse_dbsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,x,beta,y) & bind(c, name="rocsparse_dbsrmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrmv_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb real(c_double) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo type(c_ptr),value :: x real(c_double) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dbsrmv_assumed_rank #else module procedure & rocsparse_dbsrmv_rank_0,& rocsparse_dbsrmv_rank_1 #endif #endif end interface interface rocsparse_cbsrmv function rocsparse_cbsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,x,beta,y) & bind(c, name="rocsparse_cbsrmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrmv_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb complex(c_float_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo type(c_ptr),value :: x complex(c_float_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cbsrmv_assumed_rank #else module procedure & rocsparse_cbsrmv_rank_0,& rocsparse_cbsrmv_rank_1 #endif #endif end interface interface rocsparse_zbsrmv function rocsparse_zbsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,x,beta,y) & bind(c, name="rocsparse_zbsrmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrmv_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb complex(c_double_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo type(c_ptr),value :: x complex(c_double_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zbsrmv_assumed_rank #else module procedure & rocsparse_zbsrmv_rank_0,& rocsparse_zbsrmv_rank_1 #endif #endif end interface !> \ingroup level2_module !> \details !> \p rocsparse_bsrmv_clear deallocates all memory that was allocated by !> \ref rocsparse_sbsrmv_analysis "rocsparse_Xbsrmv_analysis()". This is especially useful !> if memory is an issue and the analysis data is not required anymore for further computation, !> for example, when switching to another sparse matrix format. !> !> Calling \p rocsparse_bsrmv_clear is optional. All allocated resources will be !> cleared when the opaque `rocsparse_mat_info` object is destroyed using !> `rocsparse_destroy_mat_info`(). !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[inout] myInfo - structure that holds the information collected during analysis step. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info pointer is invalid. !> \retval rocsparse_status_memory_error the buffer for the gathered information !> could not be deallocated. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_bsrmv_clear function rocsparse_bsrmv_clear_(handle,myInfo) bind(c, name="rocsparse_bsrmv_clear") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_bsrmv_clear_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo end function end interface !> \ingroup level2_module !> \details !> \p rocsparse_bsrsv_zero_pivot returns `rocsparse_status_zero_pivot` if either a !> structural or numerical zero has been found during \ref rocsparse_sbsrsv_solve !> "rocsparse_sbsrsv_solve()" !> computation. The first zero pivot \f$j\f$ at \f$A_{j,j}\f$ is stored in \p position, !> using the same index base as the BSR matrix. !> !> \p position can be in host or device memory. If no zero pivot has been found, !> \p position is set to -1 and `rocsparse_status_success` is returned instead. !> !> \note \p rocsparse_bsrsv_zero_pivot is a blocking function. It might negatively influence !> performance. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[inout] position - pointer to zero pivot \f$j\f$, which can be in host or device !> memory. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info or \p position pointer is !> invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_zero_pivot zero pivot has been found. interface rocsparse_bsrsv_zero_pivot function rocsparse_bsrsv_zero_pivot_(handle,myInfo,position) & bind(c, name="rocsparse_bsrsv_zero_pivot") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_bsrsv_zero_pivot_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int) :: position end function end interface !> \ingroup level2_module !> \details !> \p rocsparse_bsrsv_buffer_size returns the size of the temporary storage buffer that !> is required by \ref rocsparse_sbsrsv_analysis "rocsparse_Xbsrsv_analysis()" and !> \ref rocsparse_sbsrsv_solve "rocsparse_Xbsrsv_solve()". The temporary storage buffer !> must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - matrix storage of BSR blocks. !> @param[in] trans - matrix operation type. !> @param[in] mb - number of block rows of the sparse BSR matrix. !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix. !> @param[in] descr - descriptor of the sparse BSR matrix. !> @param[in] bsr_val - array of \p nnzb blocks of the sparse BSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of !> the sparse BSR matrix. !> @param[in] bsr_col_ind - array of \p nnz containing the block column indices of the sparse !> BSR matrix. !> @param[in] block_dim - block dimension of the sparse BSR matrix. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> rocsparse_sbsrsv_analysis(), rocsparse_dbsrsv_analysis(), !> rocsparse_cbsrsv_analysis(), rocsparse_zbsrsv_analysis(), !> rocsparse_sbsrsv_solve(), rocsparse_dbsrsv_solve(), !> rocsparse_cbsrsv_solve(), and rocsparse_zbsrsv_solve(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nnzb, or \p block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p bsr_val, \p bsr_row_ptr, !> \p bsr_col_ind, \p info, or \p buffer_size pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> \p trans == `rocsparse_operation_conjugate_transpose` or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_sbsrsv_buffer_size function rocsparse_sbsrsv_buffer_size_(handle,dir,trans,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) & bind(c, name="rocsparse_sbsrsv_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsv_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sbsrsv_buffer_size_assumed_rank #else module procedure & rocsparse_sbsrsv_buffer_size_rank_0,& rocsparse_sbsrsv_buffer_size_rank_1 #endif #endif end interface interface rocsparse_dbsrsv_buffer_size function rocsparse_dbsrsv_buffer_size_(handle,dir,trans,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) & bind(c, name="rocsparse_dbsrsv_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsv_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dbsrsv_buffer_size_assumed_rank #else module procedure & rocsparse_dbsrsv_buffer_size_rank_0,& rocsparse_dbsrsv_buffer_size_rank_1 #endif #endif end interface interface rocsparse_cbsrsv_buffer_size function rocsparse_cbsrsv_buffer_size_(handle,dir,trans,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) & bind(c, name="rocsparse_cbsrsv_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsv_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cbsrsv_buffer_size_assumed_rank #else module procedure & rocsparse_cbsrsv_buffer_size_rank_0,& rocsparse_cbsrsv_buffer_size_rank_1 #endif #endif end interface interface rocsparse_zbsrsv_buffer_size function rocsparse_zbsrsv_buffer_size_(handle,dir,trans,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) & bind(c, name="rocsparse_zbsrsv_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsv_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zbsrsv_buffer_size_assumed_rank #else module procedure & rocsparse_zbsrsv_buffer_size_rank_0,& rocsparse_zbsrsv_buffer_size_rank_1 #endif #endif end interface !> \ingroup level2_module !> \details !> \p rocsparse_bsrsv_analysis performs the analysis step for \ref rocsparse_sbsrsv_solve !> "rocsparse_sbsrsv_solve()". !> It is expected that this function will be executed only once for a given matrix and !> particular operation type. !> The analysis meta data can be cleared by `rocsparse_bsrsv_clear`(). !> !> \p rocsparse_bsrsv_analysis can share its meta data with \ref rocsparse_sbsrsm_analysis !> "rocsparse_Xbsrsm_analysis()", !> \ref rocsparse_sbsrilu0_analysis "rocsparse_Xbsrilu0_analysis()", and !> \ref rocsparse_sbsric0_analysis "rocsparse_Xbsric0_analysis()". Selecting !> `rocsparse_analysis_policy_reuse` policy !> can greatly improve computation performance of metadata. However, the user needs to ensure !> that the sparsity !> pattern remains unchanged. Otherwise, `rocsparse_analysis_policy_force` has to be used. !> !> \note !> If the matrix sparsity pattern changes, the gathered information will become invalid. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - matrix storage of BSR blocks. !> @param[in] trans - matrix operation type. !> @param[in] mb - number of block rows of the sparse BSR matrix. !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix. !> @param[in] descr - descriptor of the sparse BSR matrix. !> @param[in] bsr_val - array of \p nnzb blocks of the sparse BSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of !> the sparse BSR matrix. !> @param[in] bsr_col_ind - array of \p nnz containing the block column indices of the sparse !> BSR matrix. !> @param[in] block_dim - block dimension of the sparse BSR matrix. !> @param[out] myInfo - structure that holds the information collected during !> the analysis step. !> @param[in] analysis - `rocsparse_analysis_policy_reuse` or !> `rocsparse_analysis_policy_force`. !> @param[in] solve - `rocsparse_solve_policy_auto`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nnzb, or \p block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p bsr_row_ptr, !> \p bsr_col_ind, \p info, or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> \p trans == `rocsparse_operation_conjugate_transpose` or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_sbsrsv_analysis function rocsparse_sbsrsv_analysis_(handle,dir,trans,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_sbsrsv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sbsrsv_analysis_assumed_rank #else module procedure & rocsparse_sbsrsv_analysis_rank_0,& rocsparse_sbsrsv_analysis_rank_1 #endif #endif end interface interface rocsparse_dbsrsv_analysis function rocsparse_dbsrsv_analysis_(handle,dir,trans,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_dbsrsv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dbsrsv_analysis_assumed_rank #else module procedure & rocsparse_dbsrsv_analysis_rank_0,& rocsparse_dbsrsv_analysis_rank_1 #endif #endif end interface interface rocsparse_cbsrsv_analysis function rocsparse_cbsrsv_analysis_(handle,dir,trans,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_cbsrsv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cbsrsv_analysis_assumed_rank #else module procedure & rocsparse_cbsrsv_analysis_rank_0,& rocsparse_cbsrsv_analysis_rank_1 #endif #endif end interface interface rocsparse_zbsrsv_analysis function rocsparse_zbsrsv_analysis_(handle,dir,trans,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_zbsrsv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zbsrsv_analysis_assumed_rank #else module procedure & rocsparse_zbsrsv_analysis_rank_0,& rocsparse_zbsrsv_analysis_rank_1 #endif #endif end interface !> \ingroup level2_module !> \details !> \p rocsparse_bsrsv_clear deallocates all memory that was allocated by !> \ref rocsparse_sbsrsv_analysis "rocsparse_sbsrsv_analysis()". This is especially useful !> if memory is an issue and the analysis data is not required for further computation, for !> example, !> when switching to another sparse matrix format. Calling \p rocsparse_bsrsv_clear is optional. !> All allocated resources will be cleared when the opaque `rocsparse_mat_info` struct is !> destroyed using `rocsparse_destroy_mat_info`(). !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[inout] myInfo - structure that holds the information collected during the analysis !> step. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info pointer is invalid. !> \retval rocsparse_status_memory_error the buffer holding the meta data could not !> be deallocated. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_bsrsv_clear function rocsparse_bsrsv_clear_(handle,myInfo) bind(c, name="rocsparse_bsrsv_clear") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_bsrsv_clear_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo end function end interface !> \ingroup level2_module !> \brief Sparse triangular solve using the BSR storage format. !> !> \details !> \p rocsparse_bsrsv_solve solves a sparse triangular linear system of a sparse !> \f$m \times m\f$ matrix, defined in BSR storage format, a dense solution vector !> \f$y\f$, and the right-hand side \f$x\f$ that is multiplied by \f$\alpha\f$, such that !> \f[ !> op(A) \cdot y = \alpha \cdot x, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == rocsparse_operation_none} \\% !> A^T, & \text{if trans == rocsparse_operation_transpose} !> \end{array} !> \right. !> \f] !> !> Performing the above operation requires three steps. First, call !> \ref rocsparse_sbsrsv_buffer_size "rocsparse_Xbsrsv_buffer_size()", which will determine the !> size of the required !> temporary storage buffer. Then allocate this buffer and call !> \ref rocsparse_sbsrsv_analysis "rocsparse_Xbsrsv_analysis()", which will perform analysis on !> the sparse matrix !> \f$op(A)\f$. Finally, complete the computation by calling \p rocsparse_bsrsv_solve. The !> buffer size, !> buffer allocation, and analysis only need to be called once for a given sparse matrix !> \f$op(A)\f$, while the !> computation stage can be repeatedly used with different \f$x\f$ and \f$y\f$ vectors. After !> all calls to !> \p rocsparse_bsrsv_solve are complete, the temporary buffer can be deallocated. !> !> Solving a triangular system involves inverting the diagonal blocks. This means that if the !> sparse matrix is !> missing the diagonal block (referred to as a structural zero) or the diagonal block is not !> invertible (referred !> to as a numerical zero), then a solution is not possible. \p rocsparse_bsrsv_solve tracks the !> location of the first !> zero pivot (either numerical or structural zero). The zero pivot status can be checked by !> calling `rocsparse_bsrsv_zero_pivot` (). !> If `rocsparse_bsrsv_zero_pivot` () returns `rocsparse_status_success`, then no zero pivot was !> found and therefore !> the matrix does not have a structural or numerical zero. !> !> The user can specify that the sparse matrix should be interpreted as having identity blocks !> on the diagonal by setting the diagonal !> type on the descriptor \p descr to `rocsparse_diag_type_unit` using !> `rocsparse_set_mat_diag_type`. If !> `rocsparse_diag_type` == `rocsparse_diag_type_unit`, no zero pivot will be reported, even if !> the diagonal block \f$A_{j,j}\f$ !> for some \f$j\f$ is not invertible. !> !> The sparse CSR matrix passed to \p rocsparse_bsrsv_solve does not actually have to be a !> triangular matrix. Instead, the !> triangular upper or lower part of the sparse matrix is solved based on `rocsparse_fill_mode` !> set on the descriptor !> \p descr. If the fill mode is set to `rocsparse_fill_mode_lower`, then the lower triangular !> matrix is solved. If the !> fill mode is set to `rocsparse_fill_mode_upper`, then the upper triangular matrix is solved. !> !> \note !> The sparse BSR matrix has to be sorted. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p trans == `rocsparse_operation_none` and !> \p trans == `rocsparse_operation_transpose` are supported. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - matrix storage of BSR blocks. !> @param[in] trans - matrix operation type. !> @param[in] mb - number of block rows of the sparse BSR matrix. !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr - descriptor of the sparse BSR matrix. !> @param[in] bsr_val - array of \p nnzb blocks of the sparse BSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of !> the sparse BSR matrix. !> @param[in] bsr_col_ind - array of \p nnz containing the block column indices of the sparse !> BSR matrix. !> @param[in] block_dim - block dimension of the sparse BSR matrix. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] x - array of \p m elements, holding the right-hand side. !> @param[out] y - array of \p m elements, holding the solution. !> @param[in] policy - `rocsparse_solve_policy_auto`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nnzb, or \p block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p alpha, \p bsr_val, !> \p bsr_row_ptr, \p bsr_col_ind, \p x, or \p y pointer is invalid. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> \p trans == `rocsparse_operation_conjugate_transpose` or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> Consider the lower triangular \f$m \times m\f$ matrix \f$L\f$, stored in BSR !> storage format with unit diagonal. The following example solves \f$L \cdot y = x\f$. interface rocsparse_sbsrsv_solve function rocsparse_sbsrsv_solve_(handle,dir,trans,mb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,x,y,policy,temp_buffer) & bind(c, name="rocsparse_sbsrsv_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsv_solve_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nnzb real(c_float) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sbsrsv_solve_assumed_rank #else module procedure & rocsparse_sbsrsv_solve_rank_0,& rocsparse_sbsrsv_solve_rank_1 #endif #endif end interface interface rocsparse_dbsrsv_solve function rocsparse_dbsrsv_solve_(handle,dir,trans,mb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,x,y,policy,temp_buffer) & bind(c, name="rocsparse_dbsrsv_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsv_solve_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nnzb real(c_double) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dbsrsv_solve_assumed_rank #else module procedure & rocsparse_dbsrsv_solve_rank_0,& rocsparse_dbsrsv_solve_rank_1 #endif #endif end interface interface rocsparse_cbsrsv_solve function rocsparse_cbsrsv_solve_(handle,dir,trans,mb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,x,y,policy,temp_buffer) & bind(c, name="rocsparse_cbsrsv_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsv_solve_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nnzb complex(c_float_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cbsrsv_solve_assumed_rank #else module procedure & rocsparse_cbsrsv_solve_rank_0,& rocsparse_cbsrsv_solve_rank_1 #endif #endif end interface interface rocsparse_zbsrsv_solve function rocsparse_zbsrsv_solve_(handle,dir,trans,mb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,x,y,policy,temp_buffer) & bind(c, name="rocsparse_zbsrsv_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsv_solve_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nnzb complex(c_double_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zbsrsv_solve_assumed_rank #else module procedure & rocsparse_zbsrsv_solve_rank_0,& rocsparse_zbsrsv_solve_rank_1 #endif #endif end interface !> \ingroup level2_module !> \brief Sparse matrix vector multiplication with mask operation using the BSR storage format. !> !> \details !> \p rocsparse_bsrxmv multiplies the scalar \f$\alpha\f$ with a sparse !> \f$m \times n\f$ modified matrix, defined in BSR storage format, and the dense vector \f$x\f$ !> and adds the result to the dense vector \f$y\f$ that is multiplied by the scalar \f$\beta\f$, !> such that !> \f[ !> y := \left( \alpha \cdot op(A) \cdot x + \beta \cdot y \right)\left( \text{mask} \right), !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == rocsparse_operation_none} !> \end{array} !> \right. !> \f] !> and where \f$m = mb \times block\_dim\f$ and \f$n = nb \times block\_dim\f$. !> !> The \f$\text{mask}\f$ is defined as an array of block row indices. !> The input sparse matrix is defined with a modified BSR storage format where the beginning and !> the end of each row !> is defined with two arrays, \p bsr_row_ptr and \p bsr_end_ptr (both of size \p mb), rather !> the usual \p bsr_row_ptr of size \p mb+1. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p trans == `rocsparse_operation_none` is supported. !> Currently, \p block_dim==1 is not supported. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - matrix storage of BSR blocks. !> @param[in] trans - matrix operation type. !> @param[in] size_of_mask - number of updated block rows of the array \p y. !> @param[in] mb - number of block rows of the sparse BSR matrix. !> @param[in] nb - number of block columns of the sparse BSR matrix. !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr - descriptor of the sparse BSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] bsr_val - array of \p nnzb blocks of the sparse BSR matrix. !> !> @param[in] bsr_mask_ptr - array of \p size_of_mask elements that give the indices of the !> updated block rows. !> !> @param[in] bsr_row_ptr - array of \p mb elements that point to the start of every block row !> of !> the sparse BSR matrix. !> @param[in] bsr_end_ptr - array of \p mb elements that point to the end of every block row of !> the sparse BSR matrix. !> @param[in] bsr_col_ind - array of \p nnzb elements containing the block column indices of the !> sparse !> BSR matrix. !> @param[in] block_dim - block dimension of the sparse BSR matrix. !> @param[in] x - array of \p nb*block_dim elements (\f$op(A) = A\f$) or \p mb*block_dim !> elements (\f$op(A) = A^T\f$ or \f$op(A) = A^H\f$). !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] y - array of \p mb*block_dim elements (\f$op(A) = A\f$) or \p nb*block_dim !> elements (\f$op(A) = A^T\f$ or \f$op(A) = A^H\f$). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nb, \p nnzb, \p block_dim, or \p size_of_mask !> is !> invalid. !> \retval rocsparse_status_invalid_value \p size_of_mask is greater than \p mb. !> \retval rocsparse_status_invalid_pointer \p descr, \p alpha, \p bsr_val, !> \p bsr_row_ind, \p bsr_col_ind, \p x, \p beta, or \p y pointer is invalid. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> \retval rocsparse_status_not_implemented !> \p block_dim==1, \p trans != `rocsparse_operation_none` or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_sbsrxmv function rocsparse_sbsrxmv_(handle,dir,trans,size_of_mask,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_mask_ptr,bsr_row_ptr,bsr_end_ptr,bsr_col_ind,block_dim,x,beta,y) & bind(c, name="rocsparse_sbsrxmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrxmv_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: size_of_mask integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb real(c_float) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_mask_ptr type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_end_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: x real(c_float) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sbsrxmv_assumed_rank #else module procedure & rocsparse_sbsrxmv_rank_0,& rocsparse_sbsrxmv_rank_1 #endif #endif end interface interface rocsparse_dbsrxmv function rocsparse_dbsrxmv_(handle,dir,trans,size_of_mask,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_mask_ptr,bsr_row_ptr,bsr_end_ptr,bsr_col_ind,block_dim,x,beta,y) & bind(c, name="rocsparse_dbsrxmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrxmv_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: size_of_mask integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb real(c_double) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_mask_ptr type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_end_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: x real(c_double) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dbsrxmv_assumed_rank #else module procedure & rocsparse_dbsrxmv_rank_0,& rocsparse_dbsrxmv_rank_1 #endif #endif end interface interface rocsparse_cbsrxmv function rocsparse_cbsrxmv_(handle,dir,trans,size_of_mask,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_mask_ptr,bsr_row_ptr,bsr_end_ptr,bsr_col_ind,block_dim,x,beta,y) & bind(c, name="rocsparse_cbsrxmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrxmv_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: size_of_mask integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb complex(c_float_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_mask_ptr type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_end_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: x complex(c_float_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cbsrxmv_assumed_rank #else module procedure & rocsparse_cbsrxmv_rank_0,& rocsparse_cbsrxmv_rank_1 #endif #endif end interface interface rocsparse_zbsrxmv function rocsparse_zbsrxmv_(handle,dir,trans,size_of_mask,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_mask_ptr,bsr_row_ptr,bsr_end_ptr,bsr_col_ind,block_dim,x,beta,y) & bind(c, name="rocsparse_zbsrxmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrxmv_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: size_of_mask integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb complex(c_double_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_mask_ptr type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_end_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: x complex(c_double_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zbsrxmv_assumed_rank #else module procedure & rocsparse_zbsrxmv_rank_0,& rocsparse_zbsrxmv_rank_1 #endif #endif end interface !> \ingroup level2_module !> \brief Sparse matrix vector multiplication using the COO storage format. !> !> \details !> \p rocsparse_coomv multiplies the scalar \f$\alpha\f$ with a sparse \f$m \times n\f$ !> matrix, defined in COO storage format, and the dense vector \f$x\f$ and adds the !> result to the dense vector \f$y\f$ that is multiplied by the scalar \f$\beta\f$, !> such that !> \f[ !> y := \alpha \cdot op(A) \cdot x + \beta \cdot y, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == rocsparse_operation_none} \\% !> A^T, & \text{if trans == rocsparse_operation_transpose} \\% !> A^H, & \text{if trans == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> !> The COO matrix has to be sorted by row indices. This can be achieved by using !> `rocsparse_coosort_by_row()`. !> !> \code{.c} !> for(i = 0; i < m; ++i) !> { !> y[i] = beta * y[i]; !> } !> !> for(i = 0; i < nnz; ++i) !> { !> y[coo_row_ind[i]] += alpha * coo_val[i] * x[coo_col_ind[i]]; !> } !> \endcode !> !> \note !> This function does not produce deterministic results when A is transposed. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans - matrix operation type. !> @param[in] m - number of rows of the sparse COO matrix. !> @param[in] n - number of columns of the sparse COO matrix. !> @param[in] nnz - number of non-zero entries of the sparse COO matrix. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr - descriptor of the sparse COO matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] coo_val - array of \p nnz elements of the sparse COO matrix. !> @param[in] coo_row_ind - array of \p nnz elements containing the row indices of the sparse !> COO !> matrix. !> @param[in] coo_col_ind - array of \p nnz elements containing the column indices of the sparse !> COO matrix. !> @param[in] x - array of \p n elements (\f$op(A) = A\f$) or \p m elements !> (\f$op(A) = A^T\f$ or \f$op(A) = A^H\f$). !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] y - array of \p m elements (\f$op(A) = A\f$) or \p n elements !> (\f$op(A) = A^T\f$ or \f$op(A) = A^H\f$). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p alpha, \p coo_val, !> \p coo_row_ind, \p coo_col_ind, \p x, \p beta, or \p y pointer is invalid. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> This example performs a sparse matrix vector multiplication in COO format. interface rocsparse_scoomv function rocsparse_scoomv_(handle,trans,m,n,nnz,alpha,descr,coo_val,coo_row_ind,coo_col_ind,x, & beta,y) & bind(c, name="rocsparse_scoomv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scoomv_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz real(c_float) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind type(c_ptr),value :: x real(c_float) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scoomv_assumed_rank #else module procedure & rocsparse_scoomv_rank_0,& rocsparse_scoomv_rank_1 #endif #endif end interface interface rocsparse_dcoomv function rocsparse_dcoomv_(handle,trans,m,n,nnz,alpha,descr,coo_val,coo_row_ind,coo_col_ind,x, & beta,y) & bind(c, name="rocsparse_dcoomv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcoomv_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz real(c_double) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind type(c_ptr),value :: x real(c_double) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcoomv_assumed_rank #else module procedure & rocsparse_dcoomv_rank_0,& rocsparse_dcoomv_rank_1 #endif #endif end interface interface rocsparse_ccoomv function rocsparse_ccoomv_(handle,trans,m,n,nnz,alpha,descr,coo_val,coo_row_ind,coo_col_ind,x, & beta,y) & bind(c, name="rocsparse_ccoomv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccoomv_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz complex(c_float_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind type(c_ptr),value :: x complex(c_float_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccoomv_assumed_rank #else module procedure & rocsparse_ccoomv_rank_0,& rocsparse_ccoomv_rank_1 #endif #endif end interface interface rocsparse_zcoomv function rocsparse_zcoomv_(handle,trans,m,n,nnz,alpha,descr,coo_val,coo_row_ind,coo_col_ind,x, & beta,y) & bind(c, name="rocsparse_zcoomv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcoomv_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz complex(c_double_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind type(c_ptr),value :: x complex(c_double_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcoomv_assumed_rank #else module procedure & rocsparse_zcoomv_rank_0,& rocsparse_zcoomv_rank_1 #endif #endif end interface !> \ingroup level2_module !> \details !> \p rocsparse_csritsv_zero_pivot returns `rocsparse_status_zero_pivot` if either a !> structural or numerical zero has been found during !> \ref rocsparse_scsritsv_solve "rocsparse_Xcsritsv_solve()" and/or !> \ref rocsparse_scsritsv_analysis "rocsparse_Xcsritsv_analysis()" execution. The first zero !> pivot \f$j\f$ at !> \f$A_{j,j}\f$ is stored in \p position, using the same index base as the CSR matrix. !> !> \p position can be in host or device memory. If no zero pivot has been found, !> \p position is set to -1 and `rocsparse_status_success` is returned instead. !> !> \note \p rocsparse_csritsv_zero_pivot is a blocking function. It might negatively influence !> performance. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] descr - descriptor of the sparse CSR matrix. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[inout] position - pointer to zero pivot \f$j\f$, which can be in host or device !> memory. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info or \p position pointer is !> invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_zero_pivot zero pivot has been found. interface rocsparse_csritsv_zero_pivot function rocsparse_csritsv_zero_pivot_(handle,descr,myInfo,position) & bind(c, name="rocsparse_csritsv_zero_pivot") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csritsv_zero_pivot_ type(c_ptr),value :: handle type(c_ptr),value :: descr type(c_ptr),value :: myInfo type(c_ptr),value :: position end function end interface !> \ingroup level2_module !> \details !> \p rocsparse_csritsv_buffer_size returns the size of the temporary storage buffer that !> is required by \ref rocsparse_scsritsv_analysis "rocsparse_Xcsritsv_analysis()" and !> \ref rocsparse_scsritsv_solve "rocsparse_Xcsritsv_solve()". The temporary storage buffer !> must be allocated by the user. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans - matrix operation type. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descr - descriptor of the sparse CSR matrix. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> \ref rocsparse_scsritsv_analysis "rocsparse_Xcsritsv_analysis()" and !> \ref rocsparse_scsritsv_solve "rocsparse_Xcsritsv_solve()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p csr_val, \p csr_row_ptr, !> \p csr_col_ind, \p info, or \p buffer_size pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general` and !> `rocsparse_matrix_type` != `rocsparse_matrix_type_triangular`. interface rocsparse_scsritsv_buffer_size function rocsparse_scsritsv_buffer_size_(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) & bind(c, name="rocsparse_scsritsv_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsritsv_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function end interface interface rocsparse_dcsritsv_buffer_size function rocsparse_dcsritsv_buffer_size_(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) & bind(c, name="rocsparse_dcsritsv_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsritsv_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function end interface interface rocsparse_ccsritsv_buffer_size function rocsparse_ccsritsv_buffer_size_(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) & bind(c, name="rocsparse_ccsritsv_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsritsv_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function end interface interface rocsparse_zcsritsv_buffer_size function rocsparse_zcsritsv_buffer_size_(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) & bind(c, name="rocsparse_zcsritsv_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsritsv_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function end interface !> \ingroup level2_module !> \details !> \p rocsparse_csritsv_analysis performs the analysis step for \ref rocsparse_scsritsv_solve !> "rocsparse_Xcsritsv_solve()". !> It is expected that this function will be executed only once for a given matrix and !> particular operation type. The !> analysis meta data can be cleared by `rocsparse_csritsv_clear`(). !> !> Selecting !> `rocsparse_analysis_policy_reuse` policy can greatly improve the computation !> performance of metadata. However, the user needs to ensure that the sparsity !> pattern remains unchanged. If this cannot be assured, !> `rocsparse_analysis_policy_force` has to be used. !> !> \note !> If the matrix sparsity pattern changes, the gathered information will become invalid. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans - matrix operation type. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descr - descriptor of the sparse CSR matrix. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[out] myInfo - structure that holds the information collected during !> the analysis step. !> @param[in] analysis - `rocsparse_analysis_policy_reuse` or !> `rocsparse_analysis_policy_force`. !> @param[in] solve - `rocsparse_solve_policy_auto`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p csr_row_ptr, !> \p csr_col_ind, \p info, or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general` and !> `rocsparse_matrix_type` != `rocsparse_matrix_type_triangular`. interface rocsparse_scsritsv_analysis function rocsparse_scsritsv_analysis_(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_scsritsv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsritsv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_dcsritsv_analysis function rocsparse_dcsritsv_analysis_(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_dcsritsv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsritsv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_ccsritsv_analysis function rocsparse_ccsritsv_analysis_(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_ccsritsv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsritsv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_zcsritsv_analysis function rocsparse_zcsritsv_analysis_(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_zcsritsv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsritsv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function end interface !> \ingroup level2_module !> \details !> \p rocsparse_csritsv_clear deallocates all memory that was allocated by !> \ref rocsparse_scsritsv_analysis "rocsparse_Xcsritsv_analysis()". This is !> especially useful if memory is an issue and the analysis data is not !> required for further computation, for example, when switching to another sparse !> matrix format. Calling \p rocsparse_csritsv_clear is optional. All allocated !> resources will be cleared when the opaque `rocsparse_mat_info` struct is !> destroyed using `rocsparse_destroy_mat_info`(). !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] descr - descriptor of the sparse CSR matrix. !> @param[inout] myInfo - structure that holds the information collected during the analysis !> step. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info pointer is invalid. !> \retval rocsparse_status_memory_error the buffer holding the meta data could not !> be deallocated. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_csritsv_clear function rocsparse_csritsv_clear_(handle,descr,myInfo) bind(c, name="rocsparse_csritsv_clear") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csritsv_clear_ type(c_ptr),value :: handle type(c_ptr),value :: descr type(c_ptr),value :: myInfo end function end interface !> \ingroup level2_module !> \brief Sparse iterative triangular solve using the CSR storage format. !> !> \details !> \p rocsparse_csritsv_solve solves iteratively, with the use of the Jacobi method, a sparse !> triangular linear system of a sparse !> \f$m \times m\f$ matrix, defined in CSR storage format, a dense solution vector !> \f$y\f$, and the right-hand side \f$x\f$ that is multiplied by \f$\alpha\f$, such that !> \f[ !> op(A) y = \alpha x, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == rocsparse_operation_none} \\% !> A^T, & \text{if trans == rocsparse_operation_transpose} \\% !> A^H, & \text{if trans == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> !> The Jacobi method applied to the sparse triangular linear system above gives !> \f[ !> y_{k+1} = y_{k} + D^{-1} ( \alpha x - (D + T) y_{k} ) !> \f] !> with \f$A = D + T\f$, \f$D\f$ the diagonal of \f$A\f$ and \f$T\f$ the strict triangular part !> of \f$A\f$. !> !> The above equation can be also written as !> \f[ !> y_{k+1} = y_{k} + D^{-1} r_k !> \f] !> where !> \f[ !> r_k = \alpha x - (D + T) y_k. !> \f] !> Starting with \f$y_0 = \f$ \p y, the method iterates if \f$ 0 ≤ k \lt \f$ \p host_nmaxiter !> and if !> \f[ !> \Vert r_k \Vert_{\infty} \gt \epsilon, !> \f] !> with \f$\epsilon\f$ = \p host_tol. !> !> \p rocsparse_csritsv_solve requires a user allocated temporary buffer. Its size is !> returned by \ref rocsparse_scsritsv_buffer_size "rocsparse_Xcsritsv_buffer_size()". !> In addition, analysis metadata is required. It can be obtained by !> \ref rocsparse_scsritsv_analysis "rocsparse_Xcsritsv_analysis()". \p rocsparse_csritsv_solve !> reports the first zero pivot (either numerical or structural zero). !> The zero pivot status can be checked by calling `rocsparse_csritsv_zero_pivot`(). If !> `rocsparse_diag_type` == `rocsparse_diag_type_unit`, no zero pivot will be !> reported, even if \f$A_{j,j} = 0\f$ for some \f$j\f$. !> !> \note !> The sparse CSR matrix has to be sorted. This can be achieved by calling !> `rocsparse_csrsort()`. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[inout] host_nmaxiter - maximum number of iterations on input and number of iterations !> on output. If the output number of iterations is strictly less than the input maximum number !> of iterations, then the algorithm converged. !> @param[in] host_tol - if the pointer is null then loop will execute \p nmaxiter[0] !> iterations. !> @param[out] host_history - optional array to record the norm of the residual before each !> iteration. !> @param[in] trans - matrix operation type. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr - descriptor of the sparse CSR matrix. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start !> of every row of the sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] x - array of \p m elements, holding the right-hand side. !> @param[inout] y - array of \p m elements, holding the solution. !> @param[in] policy - `rocsparse_solve_policy_auto`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p alpha, \p csr_val, !> \p csr_row_ptr, \p csr_col_ind, \p x, or \p y pointer is invalid. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general` and !> `rocsparse_matrix_type` != `rocsparse_matrix_type_triangular`. !> !> \par Example !> Consider the lower triangular \f$m \times m\f$ matrix \f$L\f$, stored in CSR !> storage format with unit diagonal. The following example solves \f$L \cdot y = x\f$. !> \code{.c} !> // Create rocSPARSE handle !> rocsparse_handle handle; !> rocsparse_create_handle(&handle); !> !> // Create matrix descriptor !> rocsparse_mat_descr descr; !> rocsparse_create_mat_descr(&descr); !> rocsparse_set_mat_fill_mode(descr, rocsparse_fill_mode_lower); !> rocsparse_set_mat_diag_type(descr, rocsparse_diag_type_unit); !> !> // Create matrix info structure !> rocsparse_mat_info info; !> rocsparse_create_mat_info(&info); !> !> // Obtain required buffer size !> size_t buffer_size; !> rocsparse_dcsritsv_buffer_size(handle, !> rocsparse_operation_none, !> m, !> nnz, !> descr, !> csr_val, !> csr_row_ptr, !> csr_col_ind, !> info, !> &buffer_size); !> !> // Allocate temporary buffer !> void* temp_buffer; !> hipMalloc(&temp_buffer, buffer_size); !> !> // Perform analysis step !> rocsparse_dcsritsv_analysis(handle, !> rocsparse_operation_none, !> m, !> nnz, !> descr, !> csr_val, !> csr_row_ptr, !> csr_col_ind, !> info, !> rocsparse_analysis_policy_reuse, !> rocsparse_solve_policy_auto, !> temp_buffer); !> !> // Solve Ly = x !> rocsparse_int nmaxiter = 200; !> rocsparse_int host_maxiter = nmaxiter; !> double host_tol = 1.0e-4; !> double host_history[200]; !> !> // Initialization of y !> hipMemset(y, 0, sizeof(double) * m); !> !> rocsparse_dcsritsv_solve(handle, !> &host_maxiter, !> &host_tol, !> host_history, !> rocsparse_operation_none, !> m, !> nnz, !> &alpha, !> descr, !> csr_val, !> csr_row_ptr, !> csr_col_ind, !> info, !> x, !> y, !> rocsparse_solve_policy_auto, !> temp_buffer); !> !> if (host_maxiter < nmaxiter) !> { !> printf("convergence"); !> } !> else !> { !> printf("no convergence"); !> } !> for (int i=0;i<=host_maxiter;++i) !> { !> printf("iter = %d, nrm inf residual=%e", i, host_history[i]); !> } !> !> // No zero pivot should be found, with L having unit diagonal !> !> // Clean up !> hipFree(temp_buffer); !> rocsparse_destroy_mat_info(info); !> rocsparse_destroy_mat_descr(descr); !> rocsparse_destroy_handle(handle); !> \endcode interface rocsparse_scsritsv_solve function rocsparse_scsritsv_solve_(handle,host_nmaxiter,host_tol,host_history,trans,m,nnz, & alpha,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,x,y,policy,temp_buffer) & bind(c, name="rocsparse_scsritsv_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsritsv_solve_ type(c_ptr),value :: handle type(c_ptr),value :: host_nmaxiter type(c_ptr),value :: host_tol type(c_ptr),value :: host_history integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz real(c_float) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_dcsritsv_solve function rocsparse_dcsritsv_solve_(handle,host_nmaxiter,host_tol,host_history,trans,m,nnz, & alpha,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,x,y,policy,temp_buffer) & bind(c, name="rocsparse_dcsritsv_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsritsv_solve_ type(c_ptr),value :: handle type(c_ptr),value :: host_nmaxiter type(c_ptr),value :: host_tol type(c_ptr),value :: host_history integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz real(c_double) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_ccsritsv_solve function rocsparse_ccsritsv_solve_(handle,host_nmaxiter,host_tol,host_history,trans,m,nnz, & alpha,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,x,y,policy,temp_buffer) & bind(c, name="rocsparse_ccsritsv_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsritsv_solve_ type(c_ptr),value :: handle type(c_ptr),value :: host_nmaxiter type(c_ptr),value :: host_tol type(c_ptr),value :: host_history integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz complex(c_float_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_zcsritsv_solve function rocsparse_zcsritsv_solve_(handle,host_nmaxiter,host_tol,host_history,trans,m,nnz, & alpha,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,x,y,policy,temp_buffer) & bind(c, name="rocsparse_zcsritsv_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsritsv_solve_ type(c_ptr),value :: handle type(c_ptr),value :: host_nmaxiter type(c_ptr),value :: host_tol type(c_ptr),value :: host_history integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz complex(c_double_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function end interface !> \ingroup level2_module !> \brief Sparse iterative triangular solve using the CSR storage format. !> !> \details !> \p rocsparse_csritsv_solve_ex solves iteratively, with the use of the Jacobi method, a sparse !> triangular linear system of a sparse !> \f$m \times m\f$ matrix, defined in CSR storage format, a dense solution vector !> \f$y\f$, and the right-hand side \f$x\f$ that is multiplied by \f$\alpha\f$, such that !> \f[ !> op(A) y = \alpha x, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == rocsparse_operation_none} \\% !> A^T, & \text{if trans == rocsparse_operation_transpose} \\% !> A^H, & \text{if trans == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> !> The Jacobi method applied to the sparse triangular linear system above gives !> \f[ !> y_{k+1} = y_{k} + D^{-1} ( \alpha x - (D + T) y_{k} ) !> \f] !> with \f$A = D + T\f$, \f$D\f$ the diagonal of \f$A\f$ and \f$T\f$ the strict triangular part !> of \f$A\f$. !> !> The above equation can be also written as !> \f[ !> y_{k+1} = y_{k} + D^{-1} r_k !> \f] !> where !> \f[ !> r_k = \alpha x - (D + T) y_k. !> \f] !> Starting with \f$y_0 = \f$ \p y, the method iterates if \f$ 0 ≤ k \lt \f$ \p host_nmaxiter !> and if !> \f[ !> \Vert r_k \Vert_{\infty} \gt \epsilon, !> \f] !> with \f$\epsilon\f$ = \p host_tol. !> !> The parameter \p host_nfreeiter is used to control the frequence of the stopping criteria !> evaluation, potentially improving the performance of the algorithm with less norm !> calculation. Between each iteration of index \f$ k \f$, \p host_nfreeiter are performed !> without stopping criteria evaluation. Therefore, if the convergence is obtained at index \f$ !> k \f$, that means \f$ (k + 1) \f$ \p host_nfreeiter \f$ + k \f$ iterations have been !> performed. !> !> \p rocsparse_csritsv_solve_ex requires a user allocated temporary buffer. Its size is !> returned by \ref rocsparse_scsritsv_buffer_size "rocsparse_Xcsritsv_buffer_size()". !> Furthermore, analysis meta data is required. It can be obtained by !> \ref rocsparse_scsritsv_analysis "rocsparse_Xcsritsv_analysis()". \p !> rocsparse_csritsv_solve_ex !> reports the first zero pivot (either numerical or structural zero). The zero pivot status !> can be checked by calling `rocsparse_csritsv_zero_pivot()`. If !> `rocsparse_diag_type` == `rocsparse_diag_type_unit`, no zero pivot will be !> reported, even if \f$A_{j,j} = 0\f$ for some \f$j\f$. !> !> \note !> The sparse CSR matrix has to be sorted. This can be achieved by calling !> `rocsparse_csrsort()`. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[inout] host_nmaxiter - maximum number of iterations on input and number of iterations !> on output. If the output number of iterations is strictly less than the input maximum number !> of iterations, then the algorithm converged. !> @param[in] host_nfreeiter - number of free iterations, that is, the number of iterations !> performed without stopping criteria evaluation between two iterations with stopping criteria !> evaluation. !> @param[in] host_tol - if the pointer is null, then loop will execute \p nmaxiter[0] !> iterations. !> @param[out] host_history - optional array to record the norm of the residual before each !> iteration. !> @param[in] trans - matrix operation type. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr - descriptor of the sparse CSR matrix. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start !> of every row of the sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] x - array of \p m elements, holding the right-hand side. !> @param[inout] y - array of \p m elements, holding the solution. !> @param[in] policy - `rocsparse_solve_policy_auto`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p alpha, \p csr_val, !> \p csr_row_ptr, \p csr_col_ind, \p x, or \p y pointer is invalid. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general` and !> `rocsparse_matrix_type` != `rocsparse_matrix_type_triangular`. !> !> \par Example !> Consider the lower triangular \f$m \times m\f$ matrix \f$L\f$, stored in CSR !> storage format with unit diagonal. The following example solves \f$L \cdot y = x\f$. !> \code{.c} !> // Create rocSPARSE handle !> rocsparse_handle handle; !> rocsparse_create_handle(&handle); !> !> // Create matrix descriptor !> rocsparse_mat_descr descr; !> rocsparse_create_mat_descr(&descr); !> rocsparse_set_mat_fill_mode(descr, rocsparse_fill_mode_lower); !> rocsparse_set_mat_diag_type(descr, rocsparse_diag_type_unit); !> !> // Create matrix info structure !> rocsparse_mat_info info; !> rocsparse_create_mat_info(&info); !> !> // Obtain required buffer size !> size_t buffer_size; !> rocsparse_dcsritsv_buffer_size(handle, !> rocsparse_operation_none, !> m, !> nnz, !> descr, !> csr_val, !> csr_row_ptr, !> csr_col_ind, !> info, !> &buffer_size); !> !> // Allocate temporary buffer !> void* temp_buffer; !> hipMalloc(&temp_buffer, buffer_size); !> !> // Perform analysis step !> rocsparse_dcsritsv_analysis(handle, !> rocsparse_operation_none, !> m, !> nnz, !> descr, !> csr_val, !> csr_row_ptr, !> csr_col_ind, !> info, !> rocsparse_analysis_policy_reuse, !> rocsparse_solve_policy_auto, !> temp_buffer); !> !> // Solve Ly = x !> rocsparse_int nmaxiter = 200; !> rocsparse_int host_maxiter = nmaxiter; !> !> rocsparse_int host_nfreeiter = 20; !> double host_tol = 1.0e-4; !> double host_history[200]; !> !> // Initialization of y !> hipMemset(y, 0, sizeof(double) * m); !> !> rocsparse_dcsritsv_solve_ex(handle, !> &host_maxiter, !> host_nfreeiter, !> &host_tol, !> host_history, !> rocsparse_operation_none, !> m, !> nnz, !> &alpha, !> descr, !> csr_val, !> csr_row_ptr, !> csr_col_ind, !> info, !> x, !> y, !> rocsparse_solve_policy_auto, !> temp_buffer); !> !> if (host_maxiter < nmaxiter) !> { !> printf("convergence"); !> } !> else !> { !> printf("no convergence"); !> } !> for (int i=0;i<=host_maxiter;++i) !> { !> printf("iter = %d, nrm inf residual=%e", i, host_history[i]); !> } !> // No zero pivot should be found, with L having unit diagonal !> !> // Clean up !> hipFree(temp_buffer); !> rocsparse_destroy_mat_info(info); !> rocsparse_destroy_mat_descr(descr); !> rocsparse_destroy_handle(handle); !> \endcode interface rocsparse_scsritsv_solve_ex function rocsparse_scsritsv_solve_ex_(handle,host_nmaxiter,host_nfreeiter,host_tol, & host_history,trans,m,nnz,alpha,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,x,y,policy, & temp_buffer) & bind(c, name="rocsparse_scsritsv_solve_ex") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsritsv_solve_ex_ type(c_ptr),value :: handle type(c_ptr),value :: host_nmaxiter integer(c_int),value :: host_nfreeiter type(c_ptr),value :: host_tol type(c_ptr),value :: host_history integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz real(c_float) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_dcsritsv_solve_ex function rocsparse_dcsritsv_solve_ex_(handle,host_nmaxiter,host_nfreeiter,host_tol, & host_history,trans,m,nnz,alpha,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,x,y,policy, & temp_buffer) & bind(c, name="rocsparse_dcsritsv_solve_ex") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsritsv_solve_ex_ type(c_ptr),value :: handle type(c_ptr),value :: host_nmaxiter integer(c_int),value :: host_nfreeiter type(c_ptr),value :: host_tol type(c_ptr),value :: host_history integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz real(c_double) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_ccsritsv_solve_ex function rocsparse_ccsritsv_solve_ex_(handle,host_nmaxiter,host_nfreeiter,host_tol, & host_history,trans,m,nnz,alpha,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,x,y,policy, & temp_buffer) & bind(c, name="rocsparse_ccsritsv_solve_ex") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsritsv_solve_ex_ type(c_ptr),value :: handle type(c_ptr),value :: host_nmaxiter integer(c_int),value :: host_nfreeiter type(c_ptr),value :: host_tol type(c_ptr),value :: host_history integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz complex(c_float_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_zcsritsv_solve_ex function rocsparse_zcsritsv_solve_ex_(handle,host_nmaxiter,host_nfreeiter,host_tol, & host_history,trans,m,nnz,alpha,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,x,y,policy, & temp_buffer) & bind(c, name="rocsparse_zcsritsv_solve_ex") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsritsv_solve_ex_ type(c_ptr),value :: handle type(c_ptr),value :: host_nmaxiter integer(c_int),value :: host_nfreeiter type(c_ptr),value :: host_tol type(c_ptr),value :: host_history integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz complex(c_double_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function end interface !> \ingroup level2_module !> \details !> \p rocsparse_csrmv_analysis performs the analysis step for \ref rocsparse_scsrmv !> "rocsparse_Xcsrmv()". !> It is expected that this function will be executed only once for a given sparsity pattern and !> particular operation !> type. The gathered analysis metadata is stored in the `rocsparse_mat_info` object and can be !> cleared by !> `rocsparse_csrmv_clear`(). !> !> If the matrix sparsity pattern changes, the gathered information will become invalid. To !> perform another !> sparse matrix multiplication with a matrix having a different sparsity pattern, either !> destroy !> the old \p info object and create a new one or clear the existing info object using !> `rocsparse_csrmv_clear`(). In both cases, the analysis will need to be called again. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans - matrix operation type. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descr - descriptor of the sparse CSR matrix. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p csr_val, \p csr_row_ptr, !> \p csr_col_ind, or \p info pointer is invalid. !> \retval rocsparse_status_memory_error the buffer for the gathered information !> could not be allocated. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented if `rocsparse_matrix_type` is not one of !> `rocsparse_matrix_type_general`, `rocsparse_matrix_type_symmetric`, or !> `rocsparse_matrix_type_triangular`. interface rocsparse_scsrmv_analysis function rocsparse_scsrmv_analysis_(handle,trans,m,n,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo) & bind(c, name="rocsparse_scsrmv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrmv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsrmv_analysis_assumed_rank #else module procedure & rocsparse_scsrmv_analysis_rank_0,& rocsparse_scsrmv_analysis_rank_1 #endif #endif end interface interface rocsparse_dcsrmv_analysis function rocsparse_dcsrmv_analysis_(handle,trans,m,n,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo) & bind(c, name="rocsparse_dcsrmv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrmv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsrmv_analysis_assumed_rank #else module procedure & rocsparse_dcsrmv_analysis_rank_0,& rocsparse_dcsrmv_analysis_rank_1 #endif #endif end interface interface rocsparse_ccsrmv_analysis function rocsparse_ccsrmv_analysis_(handle,trans,m,n,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo) & bind(c, name="rocsparse_ccsrmv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrmv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsrmv_analysis_assumed_rank #else module procedure & rocsparse_ccsrmv_analysis_rank_0,& rocsparse_ccsrmv_analysis_rank_1 #endif #endif end interface interface rocsparse_zcsrmv_analysis function rocsparse_zcsrmv_analysis_(handle,trans,m,n,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo) & bind(c, name="rocsparse_zcsrmv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrmv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsrmv_analysis_assumed_rank #else module procedure & rocsparse_zcsrmv_analysis_rank_0,& rocsparse_zcsrmv_analysis_rank_1 #endif #endif end interface !> \ingroup level2_module !> \details !> \p rocsparse_csrmv_clear deallocates all memory that was allocated by !> \ref rocsparse_scsrmv_analysis "rocsparse_Xcsrmv_analysis()". This is especially useful !> if memory is an issue and the analysis data is not required for further !> computation, for example, when switching to another sparse matrix format. !> !> \note !> Calling \p rocsparse_csrmv_clear is optional. All allocated resources will be !> cleared, when the opaque `rocsparse_mat_info` object is destroyed using !> `rocsparse_destroy_mat_info`(). !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[inout] myInfo - structure that holds the information collected during the analysis !> step. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info pointer is invalid. !> \retval rocsparse_status_memory_error the buffer for the gathered information !> could not be deallocated. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_csrmv_clear function rocsparse_csrmv_clear_(handle,myInfo) bind(c, name="rocsparse_csrmv_clear") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrmv_clear_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo end function end interface !> \ingroup level2_module !> \brief Sparse matrix vector multiplication using the CSR storage format. !> !> \details !> \p rocsparse_csrmv multiplies the scalar \f$\alpha\f$ with a sparse \f$m \times n\f$ !> matrix, defined in CSR storage format, and the dense vector \f$x\f$ and adds the !> result to the dense vector \f$y\f$ that is multiplied by the scalar \f$\beta\f$, !> such that !> \f[ !> y := \alpha \cdot op(A) \cdot x + \beta \cdot y, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == rocsparse_operation_none} \\% !> A^T, & \text{if trans == rocsparse_operation_transpose} \\% !> A^H, & \text{if trans == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> !> The \p info parameter is optional and contains information collected by !> \ref rocsparse_scsrmv_analysis "rocsparse_Xcsrmv_analysis()". If present, the !> information will be used to speed up the \p csrmv computation. If !> \p info == \p NULL, a general \p csrmv routine will be used instead. Running with !> analysis might result in better performance when computing the matrix vector product !> but will also incur a performance cost attributed to the additional analysis step. !> For this reason, running with analysis makes sense when computing !> the matrix vector product many times, therefore amortizing the analysis cost. !> !> \code{.c} !> for(i = 0; i < m; ++i) !> { !> y[i] = beta * y[i]; !> !> for(j = csr_row_ptr[i]; j < csr_row_ptr[i + 1]; ++j) !> { !> y[i] = y[i] + alpha * csr_val[j] * x[csr_col_ind[j]]; !> } !> } !> \endcode !> !> To run the above operation without analysis, call the \p rocsparse_csrmv routine while !> passing !> \p NULL for the \p info parameter. !> !> With analysis, completing the sparse matrix vector multiplication involves two steps. First, !> create a `rocsparse_mat_info` object by calling \ref rocsparse_create_mat_info and then pass !> this to !> \ref rocsparse_scsrmv_analysis "rocsparse_Xcsrmv_analysis()", which will perform analysis on !> the sparsity pattern of the !> matrix \f$op(A)\f$. Then complete the operation by calling \p rocsparse_csrmv. The creation !> of the \p info object !> and the call to the analysis routine only need to be performed once for a given sparsity !> pattern, while the computation !> can be performed repeatedly as long as the sparsity pattern has not changed. After all calls !> to \p rocsparse_csrmv have !> been made, the \p info object can be destroyed with a call to `rocsparse_destroy_mat_info`. !> !> When running with analysis, a user might want to perform multiple sparse matrix !> multiplications, with each sparse matrix having a different sparsity pattern. Instead of !> creating and destroying multiple !> `rocsparse_mat_info` objects for each unique sparsity pattern, they can instead create the \p !> info object once and !> then call `rocsparse_csrmv_clear` and rerun the analysis in between each sparse matrix !> multiplication. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans - matrix operation type. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr - descriptor of the sparse CSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start !> of every row of the sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[in] myInfo - information collected by \ref rocsparse_scsrmv_analysis !> "rocsparse_Xcsrmv_analysis()", !> which can be \p NULL if no information is available. !> @param[in] x - array of \p n elements (\f$op(A) == A\f$) or \p m elements !> (\f$op(A) == A^T\f$ or \f$op(A) == A^H\f$). !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] y - array of \p m elements (\f$op(A) == A\f$) or \p n elements !> (\f$op(A) == A^T\f$ or \f$op(A) == A^H\f$). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p alpha, \p csr_val, !> \p csr_row_ptr, \p csr_col_ind, \p x, \p beta, or \p y pointer is !> invalid. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> This example performs a sparse matrix vector multiplication in CSR format !> using additional meta data to improve performance. interface rocsparse_scsrmv function rocsparse_scsrmv_(handle,trans,m,n,nnz,alpha,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,x,beta,y) & bind(c, name="rocsparse_scsrmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrmv_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz real(c_float) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo type(c_ptr),value :: x real(c_float) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsrmv_assumed_rank #else module procedure & rocsparse_scsrmv_rank_0,& rocsparse_scsrmv_rank_1 #endif #endif end interface interface rocsparse_dcsrmv function rocsparse_dcsrmv_(handle,trans,m,n,nnz,alpha,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,x,beta,y) & bind(c, name="rocsparse_dcsrmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrmv_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz real(c_double) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo type(c_ptr),value :: x real(c_double) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsrmv_assumed_rank #else module procedure & rocsparse_dcsrmv_rank_0,& rocsparse_dcsrmv_rank_1 #endif #endif end interface interface rocsparse_ccsrmv function rocsparse_ccsrmv_(handle,trans,m,n,nnz,alpha,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,x,beta,y) & bind(c, name="rocsparse_ccsrmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrmv_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz complex(c_float_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo type(c_ptr),value :: x complex(c_float_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsrmv_assumed_rank #else module procedure & rocsparse_ccsrmv_rank_0,& rocsparse_ccsrmv_rank_1 #endif #endif end interface interface rocsparse_zcsrmv function rocsparse_zcsrmv_(handle,trans,m,n,nnz,alpha,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,x,beta,y) & bind(c, name="rocsparse_zcsrmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrmv_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz complex(c_double_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo type(c_ptr),value :: x complex(c_double_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsrmv_assumed_rank #else module procedure & rocsparse_zcsrmv_rank_0,& rocsparse_zcsrmv_rank_1 #endif #endif end interface !> \ingroup level2_module !> \details !> \p rocsparse_csrsv_zero_pivot returns `rocsparse_status_zero_pivot` if either a !> structural or numerical zero has been found during \ref rocsparse_scsrsv_solve !> "rocsparse_Xcsrsv_solve()" !> computation. The first zero pivot \f$j\f$ at \f$A_{j,j}\f$ is stored in \p position, !> using the same index base as the CSR matrix. !> !> \p position can be in host or device memory. If no zero pivot has been found, !> \p position is set to -1 and `rocsparse_status_success` is returned instead. !> !> \note \p rocsparse_csrsv_zero_pivot is a blocking function. It might negatively influence !> performance. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] descr - descriptor of the sparse CSR matrix. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[inout] position - pointer to zero pivot \f$j\f$, can be in host or device memory. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info or \p position pointer is !> invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_zero_pivot zero pivot has been found. interface rocsparse_csrsv_zero_pivot function rocsparse_csrsv_zero_pivot_(handle,descr,myInfo,position) & bind(c, name="rocsparse_csrsv_zero_pivot") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrsv_zero_pivot_ type(c_ptr),value :: handle type(c_ptr),value :: descr type(c_ptr),value :: myInfo integer(c_int) :: position end function end interface !> \ingroup level2_module !> \details !> \p rocsparse_csrsv_buffer_size returns the size of the temporary storage buffer that !> is required by \ref rocsparse_scsrsv_analysis "rocsparse_Xcsrsv_analysis()" and !> \ref rocsparse_scsrsv_solve "rocsparse_Xcsrsv_solve()". The temporary storage buffer !> must be allocated by the user. The size of the temporary storage buffer is identical !> to the size returned by \ref rocsparse_scsrilu0_buffer_size !> "rocsparse_Xcsrilu0_buffer_size()" !> if the matrix sparsity pattern is identical. The user-allocated buffer can therefore be !> shared !> between subsequent calls to those functions. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans - matrix operation type. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descr - descriptor of the sparse CSR matrix. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> \ref rocsparse_scsrsv_analysis "rocsparse_Xcsrsv_analysis()" and !> \ref rocsparse_scsrsv_solve "rocsparse_Xcsrsv_solve()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p csr_val, \p csr_row_ptr, !> \p csr_col_ind, \p info, or \p buffer_size pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> \p trans == `rocsparse_operation_conjugate_transpose` or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_scsrsv_buffer_size function rocsparse_scsrsv_buffer_size_(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) & bind(c, name="rocsparse_scsrsv_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsv_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsrsv_buffer_size_assumed_rank #else module procedure & rocsparse_scsrsv_buffer_size_rank_0,& rocsparse_scsrsv_buffer_size_rank_1 #endif #endif end interface interface rocsparse_dcsrsv_buffer_size function rocsparse_dcsrsv_buffer_size_(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) & bind(c, name="rocsparse_dcsrsv_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsv_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsrsv_buffer_size_assumed_rank #else module procedure & rocsparse_dcsrsv_buffer_size_rank_0,& rocsparse_dcsrsv_buffer_size_rank_1 #endif #endif end interface interface rocsparse_ccsrsv_buffer_size function rocsparse_ccsrsv_buffer_size_(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) & bind(c, name="rocsparse_ccsrsv_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsv_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsrsv_buffer_size_assumed_rank #else module procedure & rocsparse_ccsrsv_buffer_size_rank_0,& rocsparse_ccsrsv_buffer_size_rank_1 #endif #endif end interface interface rocsparse_zcsrsv_buffer_size function rocsparse_zcsrsv_buffer_size_(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) & bind(c, name="rocsparse_zcsrsv_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsv_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsrsv_buffer_size_assumed_rank #else module procedure & rocsparse_zcsrsv_buffer_size_rank_0,& rocsparse_zcsrsv_buffer_size_rank_1 #endif #endif end interface !> \ingroup level2_module !> \details !> \p rocsparse_csrsv_analysis performs the analysis step for !> \ref rocsparse_scsrsv_solve "rocsparse_Xcsrsv_solve()". It is expected that this !> function will be executed only once for a given matrix and particular operation !> type. The analysis metadata can be cleared by `rocsparse_csrsv_clear`(). !> !> If the matrix sparsity pattern changes, the gathered information will become invalid. To !> perform another !> sparse triangular solve with a matrix having a different sparsity pattern, either destroy !> the old \p info object and create a new one or clear the existing \p info object using !> `rocsparse_csrsv_clear`(). In both cases, the analysis will need to be called again. !> !> \p rocsparse_csrsv_analysis can share its meta data with !> \ref rocsparse_scsrsm_analysis "rocsparse_Xcsrsm_analysis()", !> \ref rocsparse_scsrilu0_analysis "rocsparse_Xcsrilu0_analysis()", and !> \ref rocsparse_scsric0_analysis "rocsparse_Xcsric0_analysis()". Selecting !> `rocsparse_analysis_policy_reuse` policy can greatly improve the computation !> performance of the metadata. However, the user needs to ensure that the sparsity !> pattern remains unchanged. If this cannot be assured, !> `rocsparse_analysis_policy_force` must be used. !> !> \note !> If the matrix sparsity pattern changes, the gathered information will become invalid. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans - matrix operation type. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descr - descriptor of the sparse CSR matrix. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[out] myInfo - structure that holds the information collected during !> the analysis step. !> @param[in] analysis - `rocsparse_analysis_policy_reuse` or !> `rocsparse_analysis_policy_force`. !> @param[in] solve - `rocsparse_solve_policy_auto`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p csr_row_ptr, !> \p csr_col_ind, \p info, or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> \p trans == `rocsparse_operation_conjugate_transpose` or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_scsrsv_analysis function rocsparse_scsrsv_analysis_(handle,trans,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_scsrsv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsrsv_analysis_assumed_rank #else module procedure & rocsparse_scsrsv_analysis_rank_0,& rocsparse_scsrsv_analysis_rank_1 #endif #endif end interface interface rocsparse_dcsrsv_analysis function rocsparse_dcsrsv_analysis_(handle,trans,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_dcsrsv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsrsv_analysis_assumed_rank #else module procedure & rocsparse_dcsrsv_analysis_rank_0,& rocsparse_dcsrsv_analysis_rank_1 #endif #endif end interface interface rocsparse_ccsrsv_analysis function rocsparse_ccsrsv_analysis_(handle,trans,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_ccsrsv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsrsv_analysis_assumed_rank #else module procedure & rocsparse_ccsrsv_analysis_rank_0,& rocsparse_ccsrsv_analysis_rank_1 #endif #endif end interface interface rocsparse_zcsrsv_analysis function rocsparse_zcsrsv_analysis_(handle,trans,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_zcsrsv_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsv_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsrsv_analysis_assumed_rank #else module procedure & rocsparse_zcsrsv_analysis_rank_0,& rocsparse_zcsrsv_analysis_rank_1 #endif #endif end interface !> \ingroup level2_module !> \details !> \p rocsparse_csrsv_clear deallocates all memory that was allocated by !> \ref rocsparse_scsrsv_analysis "rocsparse_Xcsrsv_analysis()". This is especially useful !> if memory is an issue and the analysis data is not required for further computation, for !> example, !> when switching to another sparse matrix format. !> !> Calling \p rocsparse_csrsv_clear is optional. All allocated resources will be cleared when !> the !> opaque `rocsparse_mat_info` struct is destroyed using `rocsparse_destroy_mat_info`(). !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] descr - descriptor of the sparse CSR matrix. !> @param[inout] myInfo - structure that holds the information collected during the analysis !> step. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info pointer is invalid. !> \retval rocsparse_status_memory_error the buffer holding the meta data could not !> be deallocated. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_csrsv_clear function rocsparse_csrsv_clear_(handle,descr,myInfo) bind(c, name="rocsparse_csrsv_clear") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrsv_clear_ type(c_ptr),value :: handle type(c_ptr),value :: descr type(c_ptr),value :: myInfo end function end interface !> \ingroup level2_module !> \brief Sparse triangular solve using CSR storage format. !> !> \details !> \p rocsparse_csrsv_solve solves a sparse triangular linear system of a sparse !> \f$m \times m\f$ matrix, defined in CSR storage format, a dense solution vector !> \f$y\f$ and the right-hand side \f$x\f$ that is multiplied by \f$\alpha\f$, such that !> \f[ !> op(A) \cdot y = \alpha \cdot x, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == rocsparse_operation_none} \\% !> A^T, & \text{if trans == rocsparse_operation_transpose} \\% !> A^H, & \text{if trans == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> !> Performing the above operation requires three steps. First, call !> \ref rocsparse_scsrsv_buffer_size "rocsparse_Xcsrsv_buffer_size()", which determines the size !> of the required !> temporary storage buffer. Then allocate this buffer and call !> \ref rocsparse_scsrsv_analysis "rocsparse_Xcsrsv_analysis()", which will perform analysis on !> the sparse matrix !> \f$op(A)\f$. Finally, complete the computation by calling \p rocsparse_csrsv_solve. The !> buffer size, !> buffer allocation, and analysis only need to be called once for a given sparse matrix !> \f$op(A)\f$, while the !> computation stage can be repeatedly used with different \f$x\f$ and \f$y\f$ vectors. After !> all calls to !> \p rocsparse_csrsv_solve are complete, the temporary buffer can be deallocated. !> !> Solving a triangular system involves division by the diagonal elements. This means that if !> the sparse matrix is !> missing the diagonal entry (referred to as a structural zero) or the diagonal entry is zero !> (referred to as a numerical zero), !> then a division by zero would occur. \p rocsparse_csrsv_solve tracks the location of the !> first zero pivot (either numerical !> or structural zero). The zero pivot status can be checked by calling !> `rocsparse_csrsv_zero_pivot` (). If !> `rocsparse_csrsv_zero_pivot` () returns `rocsparse_status_success`, then no zero pivot was !> found and therefore !> the matrix does not have a structural or numerical zero. !> !> The user can specify that the sparse matrix should be interpreted as having ones on the !> diagonal by setting the diagonal type !> on the descriptor \p descr to `rocsparse_diag_type_unit` using `rocsparse_set_mat_diag_type`. !> If !> `rocsparse_diag_type` == `rocsparse_diag_type_unit`, no zero pivot will be reported, even if !> \f$A_{j,j} = 0\f$ for !> some \f$j\f$. !> !> The sparse CSR matrix passed to \p rocsparse_csrsv_solve does not actually have to be a !> triangular matrix. Instead the !> triangular upper or lower part of the sparse matrix is solved based on `rocsparse_fill_mode` !> set on the descriptor !> \p descr. If the fill mode is set to `rocsparse_fill_mode_lower`, then the lower triangular !> matrix is solved. If the !> fill mode is set to `rocsparse_fill_mode_upper`, then the upper triangular matrix is solved. !> !> \note !> The sparse CSR matrix has to be sorted. This can be achieved by calling !> `rocsparse_csrsort()`. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p trans == `rocsparse_operation_none` and !> \p trans == `rocsparse_operation_transpose` is supported. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans - matrix operation type. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr - descriptor of the sparse CSR matrix. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start !> of every row of the sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] x - array of \p m elements, holding the right-hand side. !> @param[out] y - array of \p m elements, holding the solution. !> @param[in] policy - `rocsparse_solve_policy_auto`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p alpha, \p csr_val, !> \p csr_row_ptr, \p csr_col_ind, \p x, or \p y pointer is invalid. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> \p trans == `rocsparse_operation_conjugate_transpose` or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> Consider the lower triangular \f$m \times m\f$ matrix \f$L\f$, stored in CSR !> storage format with unit diagonal. The following example solves \f$L \cdot y = x\f$. interface rocsparse_scsrsv_solve function rocsparse_scsrsv_solve_(handle,trans,m,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,y,policy,temp_buffer) & bind(c, name="rocsparse_scsrsv_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsv_solve_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz real(c_float) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsrsv_solve_assumed_rank #else module procedure & rocsparse_scsrsv_solve_rank_0,& rocsparse_scsrsv_solve_rank_1 #endif #endif end interface interface rocsparse_dcsrsv_solve function rocsparse_dcsrsv_solve_(handle,trans,m,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,y,policy,temp_buffer) & bind(c, name="rocsparse_dcsrsv_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsv_solve_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz real(c_double) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsrsv_solve_assumed_rank #else module procedure & rocsparse_dcsrsv_solve_rank_0,& rocsparse_dcsrsv_solve_rank_1 #endif #endif end interface interface rocsparse_ccsrsv_solve function rocsparse_ccsrsv_solve_(handle,trans,m,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,y,policy,temp_buffer) & bind(c, name="rocsparse_ccsrsv_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsv_solve_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz complex(c_float_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsrsv_solve_assumed_rank #else module procedure & rocsparse_ccsrsv_solve_rank_0,& rocsparse_ccsrsv_solve_rank_1 #endif #endif end interface interface rocsparse_zcsrsv_solve function rocsparse_zcsrsv_solve_(handle,trans,m,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,y,policy,temp_buffer) & bind(c, name="rocsparse_zcsrsv_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsv_solve_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: nnz complex(c_double_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo type(c_ptr),value :: x type(c_ptr),value :: y integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsrsv_solve_assumed_rank #else module procedure & rocsparse_zcsrsv_solve_rank_0,& rocsparse_zcsrsv_solve_rank_1 #endif #endif end interface !> \ingroup level2_module !> \brief Sparse matrix vector multiplication using the ELL storage format. !> !> \details !> \p rocsparse_ellmv multiplies the scalar \f$\alpha\f$ with a sparse \f$m \times n\f$ !> matrix, defined in ELL storage format, and the dense vector \f$x\f$ and adds the !> result to the dense vector \f$y\f$ that is multiplied by the scalar \f$\beta\f$, !> such that !> \f[ !> y := \alpha \cdot op(A) \cdot x + \beta \cdot y, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == rocsparse_operation_none} \\% !> A^T, & \text{if trans == rocsparse_operation_transpose} \\% !> A^H, & \text{if trans == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> !> \code{.c} !> for(i = 0; i < m; ++i) !> { !> y[i] = beta * y[i]; !> !> for(p = 0; p < ell_width; ++p) !> { !> idx = p * m + i; !> !> if((ell_col_ind[idx] >= 0) && (ell_col_ind[idx] < n)) !> { !> y[i] = y[i] + alpha * ell_val[idx] * x[ell_col_ind[idx]]; !> } !> } !> } !> \endcode !> !> \note !> This function does not produce deterministic results when A is transposed. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans - matrix operation type. !> @param[in] m - number of rows of the sparse ELL matrix. !> @param[in] n - number of columns of the sparse ELL matrix. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr - descriptor of the sparse ELL matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] ell_val - array that contains the elements of the sparse ELL matrix. Padded !> elements should be zero. !> @param[in] ell_col_ind - array that contains the column indices of the sparse ELL matrix. !> Padded column indices should be -1. !> @param[in] ell_width - number of non-zero elements per row of the sparse ELL matrix. !> @param[in] x - array of \p n elements (\f$op(A) == A\f$) or \p m elements !> (\f$op(A) == A^T\f$ or \f$op(A) == A^H\f$). !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] y - array of \p m elements (\f$op(A) == A\f$) or \p n elements !> (\f$op(A) == A^T\f$ or \f$op(A) == A^H\f$). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p ell_width is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p alpha, \p ell_val, !> \p ell_col_ind, \p x, \p beta, or \p y pointer is invalid. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> This example performs a sparse matrix vector multiplication in ELL format. It also shows how !> to convert !> from CSR to ELL format. interface rocsparse_sellmv function rocsparse_sellmv_(handle,trans,m,n,alpha,descr,ell_val,ell_col_ind,ell_width,x,beta, & y) & bind(c, name="rocsparse_sellmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sellmv_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind integer(c_int),value :: ell_width type(c_ptr),value :: x real(c_float) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sellmv_assumed_rank #else module procedure & rocsparse_sellmv_rank_0,& rocsparse_sellmv_rank_1 #endif #endif end interface interface rocsparse_dellmv function rocsparse_dellmv_(handle,trans,m,n,alpha,descr,ell_val,ell_col_ind,ell_width,x,beta, & y) & bind(c, name="rocsparse_dellmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dellmv_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind integer(c_int),value :: ell_width type(c_ptr),value :: x real(c_double) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dellmv_assumed_rank #else module procedure & rocsparse_dellmv_rank_0,& rocsparse_dellmv_rank_1 #endif #endif end interface interface rocsparse_cellmv function rocsparse_cellmv_(handle,trans,m,n,alpha,descr,ell_val,ell_col_ind,ell_width,x,beta, & y) & bind(c, name="rocsparse_cellmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cellmv_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind integer(c_int),value :: ell_width type(c_ptr),value :: x complex(c_float_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cellmv_assumed_rank #else module procedure & rocsparse_cellmv_rank_0,& rocsparse_cellmv_rank_1 #endif #endif end interface interface rocsparse_zellmv function rocsparse_zellmv_(handle,trans,m,n,alpha,descr,ell_val,ell_col_ind,ell_width,x,beta, & y) & bind(c, name="rocsparse_zellmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zellmv_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind integer(c_int),value :: ell_width type(c_ptr),value :: x complex(c_double_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zellmv_assumed_rank #else module procedure & rocsparse_zellmv_rank_0,& rocsparse_zellmv_rank_1 #endif #endif end interface !> \ingroup level2_module !> \brief Sparse matrix vector multiplication using the GEBSR storage format. !> !> \details !> \p rocsparse_gebsrmv multiplies the scalar \f$\alpha\f$ with a sparse !> \f$m \times n\f$ matrix, defined in GEBSR storage format, and the dense vector !> \f$x\f$ and adds the result to the dense vector \f$y\f$ that is multiplied by !> the scalar \f$\beta\f$, such that !> \f[ !> y := \alpha \cdot op(A) \cdot x + \beta \cdot y, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == rocsparse_operation_none} !> \end{array} !> \right. !> \f] !> and where \f$m = mb \times row\_block\_dim\f$ and \f$n = nb \times col\_block\_dim\f$. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p trans == `rocsparse_operation_none` is supported. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - matrix storage of GEBSR blocks. !> @param[in] trans - matrix operation type. !> @param[in] mb - number of block rows of the sparse GEBSR matrix. !> @param[in] nb - number of block columns of the sparse GEBSR matrix. !> @param[in] nnzb - number of non-zero blocks of the sparse GEBSR matrix. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr - descriptor of the sparse GEBSR matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] bsr_val - array of \p nnzb blocks of the sparse GEBSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of !> the sparse GEBSR matrix. !> @param[in] bsr_col_ind - array of \p nnz containing the block column indices of the sparse !> GEBSR matrix. !> @param[in] row_block_dim - row block dimension of the sparse GEBSR matrix. !> @param[in] col_block_dim - column block dimension of the sparse GEBSR matrix. !> @param[in] x - array of \p nb*col_block_dim elements (\f$op(A) = A\f$) or \p mb*row_block_dim !> elements (\f$op(A) = A^T\f$ or \f$op(A) = A^H\f$). !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] y - array of \p mb*row_block_dim elements (\f$op(A) = A\f$) or \p !> nb*col_block_dim !> elements (\f$op(A) = A^T\f$ or \f$op(A) = A^H\f$). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nb, \p nnzb, \p row_block_dim, !> or \p col_block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p alpha, \p bsr_val, !> \p bsr_row_ind, \p bsr_col_ind, \p x, \p beta, or \p y pointer is invalid. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> \retval rocsparse_status_not_implemented !> \p trans != `rocsparse_operation_none` or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> This example performs a sparse matrix vector multiplication in GEBSR format. interface rocsparse_sgebsrmv function rocsparse_sgebsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,x,beta,y) & bind(c, name="rocsparse_sgebsrmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsrmv_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb real(c_float) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: x real(c_float) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sgebsrmv_assumed_rank #else module procedure & rocsparse_sgebsrmv_rank_0,& rocsparse_sgebsrmv_rank_1 #endif #endif end interface interface rocsparse_dgebsrmv function rocsparse_dgebsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,x,beta,y) & bind(c, name="rocsparse_dgebsrmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsrmv_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb real(c_double) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: x real(c_double) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dgebsrmv_assumed_rank #else module procedure & rocsparse_dgebsrmv_rank_0,& rocsparse_dgebsrmv_rank_1 #endif #endif end interface interface rocsparse_cgebsrmv function rocsparse_cgebsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,x,beta,y) & bind(c, name="rocsparse_cgebsrmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsrmv_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb complex(c_float_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: x complex(c_float_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cgebsrmv_assumed_rank #else module procedure & rocsparse_cgebsrmv_rank_0,& rocsparse_cgebsrmv_rank_1 #endif #endif end interface interface rocsparse_zgebsrmv function rocsparse_zgebsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,x,beta,y) & bind(c, name="rocsparse_zgebsrmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsrmv_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb complex(c_double_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: x complex(c_double_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zgebsrmv_assumed_rank #else module procedure & rocsparse_zgebsrmv_rank_0,& rocsparse_zgebsrmv_rank_1 #endif #endif end interface !> \ingroup level2_module !> \details !> \p rocsparse_gemvi_buffer_size returns the size of the temporary storage buffer !> required by \ref rocsparse_sgemvi "rocsparse_Xgemvi()". The temporary storage !> buffer must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans - matrix operation type. !> @param[in] m - number of rows of the dense matrix. !> @param[in] n - number of columns of the dense matrix. !> @param[in] nnz - number of non-zero entries in the sparse vector. !> @param[out] buffer_size - temporary storage buffer size. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p buffer_size pointer is invalid. !> \retval rocsparse_status_not_implemented !> \p trans != `rocsparse_operation_none` or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_sgemvi_buffer_size function rocsparse_sgemvi_buffer_size_(handle,trans,m,n,nnz,buffer_size) & bind(c, name="rocsparse_sgemvi_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgemvi_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz integer(c_size_t) :: buffer_size end function end interface interface rocsparse_dgemvi_buffer_size function rocsparse_dgemvi_buffer_size_(handle,trans,m,n,nnz,buffer_size) & bind(c, name="rocsparse_dgemvi_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgemvi_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz integer(c_size_t) :: buffer_size end function end interface interface rocsparse_cgemvi_buffer_size function rocsparse_cgemvi_buffer_size_(handle,trans,m,n,nnz,buffer_size) & bind(c, name="rocsparse_cgemvi_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgemvi_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz integer(c_size_t) :: buffer_size end function end interface interface rocsparse_zgemvi_buffer_size function rocsparse_zgemvi_buffer_size_(handle,trans,m,n,nnz,buffer_size) & bind(c, name="rocsparse_zgemvi_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgemvi_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz integer(c_size_t) :: buffer_size end function end interface !> \ingroup level2_module !> \brief Dense matrix sparse vector multiplication. !> !> \details !> \p rocsparse_gemvi multiplies the scalar \f$\alpha\f$ with a dense \f$m \times n\f$ !> matrix \f$A\f$ and the sparse vector \f$x\f$ and adds the result to the dense vector !> \f$y\f$ that is multiplied by the scalar \f$\beta\f$, such that !> \f[ !> y := \alpha \cdot op(A) \cdot x + \beta \cdot y, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == rocsparse_operation_none} !> \end{array} !> \right. !> \f] !> !> Performing the above operation involves two steps. First, call !> \ref rocsparse_sgemvi_buffer_size "rocsparse_Xgemvi_buffer_size()" to determine the size of !> the temporary storage buffer. Next, allocate this temporary buffer and pass it to !> \p rocsparse_gemvi to complete the computation. After all calls to \p rocsparse_gemvi are !> complete, the !> temporary storage buffer can be freed. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p trans == `rocsparse_operation_none` is supported. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans - matrix operation type. !> @param[in] m - number of rows of the dense matrix. !> @param[in] n - number of columns of the dense matrix. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] A - pointer to the dense matrix. !> @param[in] lda - leading dimension of the dense matrix. !> @param[in] nnz - number of non-zero entries in the sparse vector. !> @param[in] x_val - array of \p nnz elements containing the values of the sparse vector. !> @param[in] x_ind - array of \p nnz elements containing the indices of the sparse vector. !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] y - array of \p m elements (\f$op(A) == A\f$) or \p n elements !> (\f$op(A) == A^T\f$ or \f$op(A) == A^H\f$). !> @param[in] idx_base - rocsparse_index_base_zero or rocsparse_index_base_one. !> @param[in] temp_buffer - temporary storage buffer. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, \p lda, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p alpha, \p A, \p x_val, \p x_ind, !> \p beta, \p y, or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_not_implemented !> \p trans != `rocsparse_operation_none` or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example interface rocsparse_sgemvi function rocsparse_sgemvi_(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y,idx_base, & temp_buffer) & bind(c, name="rocsparse_sgemvi") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgemvi_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: nnz type(c_ptr),value :: x_val type(c_ptr),value :: x_ind real(c_float) :: beta type(c_ptr),value :: y integer(kind(rocsparse_index_base_zero)),value :: idx_base type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sgemvi_assumed_rank #else module procedure & rocsparse_sgemvi_rank_0,& rocsparse_sgemvi_rank_1,& rocsparse_sgemvi_full_rank #endif #endif end interface interface rocsparse_dgemvi function rocsparse_dgemvi_(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y,idx_base, & temp_buffer) & bind(c, name="rocsparse_dgemvi") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgemvi_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: nnz type(c_ptr),value :: x_val type(c_ptr),value :: x_ind real(c_double) :: beta type(c_ptr),value :: y integer(kind(rocsparse_index_base_zero)),value :: idx_base type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dgemvi_assumed_rank #else module procedure & rocsparse_dgemvi_rank_0,& rocsparse_dgemvi_rank_1,& rocsparse_dgemvi_full_rank #endif #endif end interface interface rocsparse_cgemvi function rocsparse_cgemvi_(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y,idx_base, & temp_buffer) & bind(c, name="rocsparse_cgemvi") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgemvi_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: nnz type(c_ptr),value :: x_val type(c_ptr),value :: x_ind complex(c_float_complex) :: beta type(c_ptr),value :: y integer(kind(rocsparse_index_base_zero)),value :: idx_base type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cgemvi_assumed_rank #else module procedure & rocsparse_cgemvi_rank_0,& rocsparse_cgemvi_rank_1,& rocsparse_cgemvi_full_rank #endif #endif end interface interface rocsparse_zgemvi function rocsparse_zgemvi_(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y,idx_base, & temp_buffer) & bind(c, name="rocsparse_zgemvi") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgemvi_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans integer(c_int),value :: m integer(c_int),value :: n complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda integer(c_int),value :: nnz type(c_ptr),value :: x_val type(c_ptr),value :: x_ind complex(c_double_complex) :: beta type(c_ptr),value :: y integer(kind(rocsparse_index_base_zero)),value :: idx_base type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zgemvi_assumed_rank #else module procedure & rocsparse_zgemvi_rank_0,& rocsparse_zgemvi_rank_1,& rocsparse_zgemvi_full_rank #endif #endif end interface !> \ingroup level2_module !> \brief Sparse matrix vector multiplication using the HYB storage format. !> !> \details !> \p rocsparse_hybmv multiplies the scalar \f$\alpha\f$ with a sparse \f$m \times n\f$ !> matrix, defined in HYB storage format, and the dense vector \f$x\f$ and adds the !> result to the dense vector \f$y\f$ that is multiplied by the scalar \f$\beta\f$, !> such that !> \f[ !> y := \alpha \cdot op(A) \cdot x + \beta \cdot y, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans == rocsparse_operation_none} !> \end{array} !> \right. !> \f] !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans - matrix operation type. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr - descriptor of the sparse HYB matrix. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] hyb - matrix in HYB storage format. !> @param[in] x - array of \p n elements (\f$op(A) == A\f$) or \p m elements !> (\f$op(A) == A^T\f$ or \f$op(A) == A^H\f$). !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] y - array of \p m elements (\f$op(A) == A\f$) or \p n elements !> (\f$op(A) == A^T\f$ or \f$op(A) == A^H\f$). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p hyb structure was not initialized with !> valid matrix sizes. !> \retval rocsparse_status_invalid_pointer \p descr, \p alpha, \p hyb, \p x, !> \p beta, or \p y pointer is invalid. !> \retval rocsparse_status_invalid_value \p hyb structure was not initialized !> with a valid partitioning type. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> \retval rocsparse_status_memory_error the buffer could not be allocated. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> \p trans != `rocsparse_operation_none` or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> This example performs a sparse matrix vector multiplication in HYB format and !> demonstrates a conversion from the CSR to HYB format. interface rocsparse_shybmv function rocsparse_shybmv_(handle,trans,alpha,descr,hyb,x,beta,y) & bind(c, name="rocsparse_shybmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_shybmv_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans real(c_float) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: hyb type(c_ptr),value :: x real(c_float) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_shybmv_assumed_rank #else module procedure & rocsparse_shybmv_rank_0,& rocsparse_shybmv_rank_1 #endif #endif end interface interface rocsparse_dhybmv function rocsparse_dhybmv_(handle,trans,alpha,descr,hyb,x,beta,y) & bind(c, name="rocsparse_dhybmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dhybmv_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans real(c_double) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: hyb type(c_ptr),value :: x real(c_double) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dhybmv_assumed_rank #else module procedure & rocsparse_dhybmv_rank_0,& rocsparse_dhybmv_rank_1 #endif #endif end interface interface rocsparse_chybmv function rocsparse_chybmv_(handle,trans,alpha,descr,hyb,x,beta,y) & bind(c, name="rocsparse_chybmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_chybmv_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans complex(c_float_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: hyb type(c_ptr),value :: x complex(c_float_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_chybmv_assumed_rank #else module procedure & rocsparse_chybmv_rank_0,& rocsparse_chybmv_rank_1 #endif #endif end interface interface rocsparse_zhybmv function rocsparse_zhybmv_(handle,trans,alpha,descr,hyb,x,beta,y) & bind(c, name="rocsparse_zhybmv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zhybmv_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans complex(c_double_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: hyb type(c_ptr),value :: x complex(c_double_complex) :: beta type(c_ptr),value :: y end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zhybmv_assumed_rank #else module procedure & rocsparse_zhybmv_rank_0,& rocsparse_zhybmv_rank_1 #endif #endif end interface !> \ingroup level3_module !> \brief Sparse matrix dense matrix multiplication using the BSR storage format. !> !> \details !> \p rocsparse_bsrmm multiplies the scalar \f$\alpha\f$ with a sparse \f$m \times k\f$ !> matrix \f$A\f$, defined in BSR storage format, and the column-oriented dense \f$k \times n\f$ !> matrix \f$B\f$ and adds the result to the column-oriented dense \f$m \times n\f$ matrix !> \f$C\f$ that !> is multiplied by the scalar \f$\beta\f$, such that !> \f[ !> C := \alpha \cdot op(A) \cdot op(B) + \beta \cdot C, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans_A == rocsparse_operation_none} \\% !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if trans_B == rocsparse_operation_none} \\% !> B^T, & \text{if trans_B == rocsparse_operation_transpose} \\% !> \end{array} !> \right. !> \f] !> and where \f$k = block\_dim \times kb\f$ and \f$m = block\_dim \times mb\f$. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p trans_A == `rocsparse_operation_none` is supported. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - the storage format of the blocks. Can be `rocsparse_direction_row` or !> `rocsparse_direction_column`. !> @param[in] trans_A - matrix \f$A\f$ operation type. Currently, only !> `rocsparse_operation_none` is supported. !> @param[in] trans_B - matrix \f$B\f$ operation type. Currently, only !> `rocsparse_operation_none` and rocsparse_operation_transpose !> are supported. !> @param[in] mb - number of block rows of the sparse BSR matrix \f$A\f$. !> @param[in] n - number of columns of the column-oriented dense matrix \f$op(B)\f$ and \f$C\f$. !> @param[in] kb - number of block columns of the sparse BSR matrix \f$A\f$. !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix \f$A\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr - descriptor of the sparse BSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] bsr_val - array of \p nnzb*block_dim*block_dim elements of the sparse BSR matrix !> \f$A\f$. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse BSR matrix \f$A\f$. !> @param[in] bsr_col_ind - array of \p nnzb elements containing the block column indices of the !> sparse !> BSR matrix \f$A\f$. !> @param[in] block_dim - size of the blocks in the sparse BSR matrix. !> @param[in] B - column-oriented dense matrix of dimension \f$ldb \times n\f$ (\f$op(B) == !> B\f$), !> \f$ldb \times k\f$ otherwise. !> @param[in] ldb - leading dimension of \f$B\f$, must be at least \f$\max{(1, k)}\f$ (\f$ op(B) !> == B\f$) where \f$k = block\_dim \times kb\f$, !> \f$\max{(1, n)}\f$ otherwise. !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] C - column-oriented dense matrix of dimension \f$ldc \times n\f$. !> @param[in] ldc - leading dimension of \f$C\f$, must be at least \f$\max{(1, m)}\f$ (\f$ op(A) !> == A\f$) where \f$m = block\_dim \times mb\f$, !> \f$\max{(1, k)}\f$ where \f$k = block\_dim \times kb\f$ otherwise. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p n, \p kb, \p nnzb, \p ldb, or \p ldc !> is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p alpha, \p bsr_val, !> \p bsr_row_ptr, \p bsr_col_ind, \p B, \p beta, or \p C pointer is invalid. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> \retval rocsparse_status_not_implemented !> \p trans_A != `rocsparse_operation_none`, !> \p trans_B == `rocsparse_operation_conjugate_transpose`, or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> This example multiplies a BSR matrix with a column-oriented dense matrix. interface rocsparse_sbsrmm function rocsparse_sbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) & bind(c, name="rocsparse_sbsrmm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrmm_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: mb integer(c_int),value :: n integer(c_int),value :: kb integer(c_int),value :: nnzb real(c_float) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sbsrmm_assumed_rank #else module procedure & rocsparse_sbsrmm_rank_0,& rocsparse_sbsrmm_rank_1,& rocsparse_sbsrmm_full_rank #endif #endif end interface interface rocsparse_dbsrmm function rocsparse_dbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) & bind(c, name="rocsparse_dbsrmm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrmm_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: mb integer(c_int),value :: n integer(c_int),value :: kb integer(c_int),value :: nnzb real(c_double) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dbsrmm_assumed_rank #else module procedure & rocsparse_dbsrmm_rank_0,& rocsparse_dbsrmm_rank_1,& rocsparse_dbsrmm_full_rank #endif #endif end interface interface rocsparse_cbsrmm function rocsparse_cbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) & bind(c, name="rocsparse_cbsrmm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrmm_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: mb integer(c_int),value :: n integer(c_int),value :: kb integer(c_int),value :: nnzb complex(c_float_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cbsrmm_assumed_rank #else module procedure & rocsparse_cbsrmm_rank_0,& rocsparse_cbsrmm_rank_1,& rocsparse_cbsrmm_full_rank #endif #endif end interface interface rocsparse_zbsrmm function rocsparse_zbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) & bind(c, name="rocsparse_zbsrmm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrmm_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: mb integer(c_int),value :: n integer(c_int),value :: kb integer(c_int),value :: nnzb complex(c_double_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zbsrmm_assumed_rank #else module procedure & rocsparse_zbsrmm_rank_0,& rocsparse_zbsrmm_rank_1,& rocsparse_zbsrmm_full_rank #endif #endif end interface !> \ingroup level3_module !> \details !> \p rocsparse_bsrsm_zero_pivot returns `rocsparse_status_zero_pivot` if either a !> structural or numerical zero has been found during !> \ref rocsparse_sbsrsm_solve "rocsparse_Xbsrsm_solve()" computation. The first zero !> pivot \f$j\f$ at \f$A_{j,j}\f$ is stored in \p position, using the same index base as !> the BSR matrix. !> !> \p position can be in the host or device memory. If no zero pivot has been found, !> \p position is set to -1 and `rocsparse_status_success` is returned instead. !> !> \note \p rocsparse_bsrsm_zero_pivot is a blocking function. It might negatively influence !> performance. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[inout] position - pointer to zero pivot \f$j\f$, which can be in host or device !> memory. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info or \p position pointer is !> invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_zero_pivot zero pivot has been found. interface rocsparse_bsrsm_zero_pivot function rocsparse_bsrsm_zero_pivot_(handle,myInfo,position) & bind(c, name="rocsparse_bsrsm_zero_pivot") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_bsrsm_zero_pivot_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int) :: position end function end interface !> \ingroup level3_module !> \details !> \p rocsparse_bsrsm_buffer_size returns the size of the temporary storage buffer that !> is required by \ref rocsparse_sbsrsm_analysis "rocsparse_Xbsrsm_analysis()" and !> \ref rocsparse_sbsrsm_solve "rocsparse_Xbsrsm_solve()". The temporary storage buffer !> must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - matrix storage of BSR blocks. !> @param[in] trans_A - matrix A operation type. !> @param[in] trans_X - matrix X operation type. !> @param[in] mb - number of block rows of the sparse BSR matrix A. !> @param[in] nrhs - number of columns of the column-oriented dense matrix op(X). !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix A. !> @param[in] descr - descriptor of the sparse BSR matrix A. !> @param[in] bsr_val - array of \p nnzb blocks of the sparse BSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of !> the sparse BSR matrix. !> @param[in] bsr_col_ind - array of \p nnzb containing the block column indices of the sparse !> BSR matrix. !> @param[in] block_dim - block dimension of the sparse BSR matrix. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> \ref rocsparse_sbsrsm_analysis "rocsparse_Xbsrsm_analysis()" and !> \ref rocsparse_sbsrsm_solve "rocsparse_Xbsrsm_solve()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nrhs, \p nnzb, or \p block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p bsr_val, !> \p bsr_row_ptr, \p bsr_col_ind, \p info, or \p buffer_size pointer !> is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> \p trans_A == `rocsparse_operation_conjugate_transpose`, !> \p trans_X == `rocsparse_operation_conjugate_transpose`, or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_sbsrsm_buffer_size function rocsparse_sbsrsm_buffer_size_(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) & bind(c, name="rocsparse_sbsrsm_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsm_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_X integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sbsrsm_buffer_size_assumed_rank #else module procedure & rocsparse_sbsrsm_buffer_size_rank_0,& rocsparse_sbsrsm_buffer_size_rank_1 #endif #endif end interface interface rocsparse_dbsrsm_buffer_size function rocsparse_dbsrsm_buffer_size_(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) & bind(c, name="rocsparse_dbsrsm_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsm_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_X integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dbsrsm_buffer_size_assumed_rank #else module procedure & rocsparse_dbsrsm_buffer_size_rank_0,& rocsparse_dbsrsm_buffer_size_rank_1 #endif #endif end interface interface rocsparse_cbsrsm_buffer_size function rocsparse_cbsrsm_buffer_size_(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) & bind(c, name="rocsparse_cbsrsm_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsm_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_X integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cbsrsm_buffer_size_assumed_rank #else module procedure & rocsparse_cbsrsm_buffer_size_rank_0,& rocsparse_cbsrsm_buffer_size_rank_1 #endif #endif end interface interface rocsparse_zbsrsm_buffer_size function rocsparse_zbsrsm_buffer_size_(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) & bind(c, name="rocsparse_zbsrsm_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsm_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_X integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zbsrsm_buffer_size_assumed_rank #else module procedure & rocsparse_zbsrsm_buffer_size_rank_0,& rocsparse_zbsrsm_buffer_size_rank_1 #endif #endif end interface !> \ingroup level3_module !> \details !> \p rocsparse_bsrsm_analysis performs the analysis step for !> \ref rocsparse_sbsrsm_solve "rocsparse_Xbsrsm_solve()". It is expected that this function !> will be executed only once for a given matrix and particular operation type. The analysis !> meta data can be cleared by `rocsparse_bsrsm_clear`(). !> !> \p rocsparse_bsrsm_analysis can share its meta data with !> \ref rocsparse_sbsrilu0_analysis "rocsparse_Xbsrilu0_analysis()", !> \ref rocsparse_sbsric0_analysis "rocsparse_Xbsric0_analysis()", and !> \ref rocsparse_sbsrsv_analysis "rocsparse_Xbsrsv_analysis()". Selecting !> `rocsparse_analysis_policy_reuse` policy can greatly improve the computation !> performance of the metadata. However, the user needs to ensure that the sparsity !> pattern remains unchanged. If this cannot be assured, !> `rocsparse_analysis_policy_force` has to be used. !> !> \note !> If the matrix sparsity pattern changes, the gathered information will become invalid. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - matrix storage of BSR blocks. !> @param[in] trans_A - matrix A operation type. !> @param[in] trans_X - matrix X operation type. !> @param[in] mb - number of block rows of the sparse BSR matrix A. !> @param[in] nrhs - number of columns of the column-oriented dense matrix op(X). !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix A. !> @param[in] descr - descriptor of the sparse BSR matrix A. !> @param[in] bsr_val - array of \p nnzb blocks of the sparse BSR matrix A. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of !> the sparse BSR matrix A. !> @param[in] bsr_col_ind - array of \p nnzb containing the block column indices of the sparse !> BSR matrix A. !> @param[in] block_dim - block dimension of the sparse BSR matrix A. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[in] analysis - `rocsparse_analysis_policy_reuse` or !> `rocsparse_analysis_policy_force`. !> @param[in] solve - `rocsparse_solve_policy_auto`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nrhs, \p nnzb, or \p block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p bsr_val, \p bsr_row_ptr, !> \p bsr_col_ind, \p info, or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> \p trans_A == `rocsparse_operation_conjugate_transpose`, !> \p trans_X == `rocsparse_operation_conjugate_transpose`, or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_sbsrsm_analysis function rocsparse_sbsrsm_analysis_(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_sbsrsm_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsm_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_X integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sbsrsm_analysis_assumed_rank #else module procedure & rocsparse_sbsrsm_analysis_rank_0,& rocsparse_sbsrsm_analysis_rank_1 #endif #endif end interface interface rocsparse_dbsrsm_analysis function rocsparse_dbsrsm_analysis_(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_dbsrsm_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsm_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_X integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dbsrsm_analysis_assumed_rank #else module procedure & rocsparse_dbsrsm_analysis_rank_0,& rocsparse_dbsrsm_analysis_rank_1 #endif #endif end interface interface rocsparse_cbsrsm_analysis function rocsparse_cbsrsm_analysis_(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_cbsrsm_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsm_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_X integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cbsrsm_analysis_assumed_rank #else module procedure & rocsparse_cbsrsm_analysis_rank_0,& rocsparse_cbsrsm_analysis_rank_1 #endif #endif end interface interface rocsparse_zbsrsm_analysis function rocsparse_zbsrsm_analysis_(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_zbsrsm_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsm_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_X integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zbsrsm_analysis_assumed_rank #else module procedure & rocsparse_zbsrsm_analysis_rank_0,& rocsparse_zbsrsm_analysis_rank_1 #endif #endif end interface !> \ingroup level3_module !> \details !> \p rocsparse_bsrsm_clear deallocates all memory that was allocated by !> \ref rocsparse_sbsrsm_analysis "rocsparse_Xbsrsm_analysis()". This is especially useful !> if memory is an issue and the analysis data is not required for further computation, for !> example, !> when switching to another sparse matrix format. Calling \p rocsparse_bsrsm_clear is optional. !> All allocated resources will be cleared when the opaque `rocsparse_mat_info` struct !> is destroyed using `rocsparse_destroy_mat_info`(). !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[inout] myInfo - structure that holds the information collected during the analysis !> step. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info pointer is invalid. !> \retval rocsparse_status_memory_error the buffer holding the metadata could not !> be deallocated. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_bsrsm_clear function rocsparse_bsrsm_clear_(handle,myInfo) bind(c, name="rocsparse_bsrsm_clear") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_bsrsm_clear_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo end function end interface !> \ingroup level3_module !> \brief Sparse triangular system solve using the BSR storage format. !> !> \details !> \p rocsparse_bsrsm_solve solves a sparse triangular linear system of a sparse !> \f$m \times m\f$ matrix, defined in BSR storage format, a column-oriented dense solution !> matrix !> \f$X\f$, and the column-oriented dense right-hand side matrix \f$B\f$ that is multiplied by !> \f$\alpha\f$, !> such that !> \f[ !> op(A) \cdot op(X) = \alpha \cdot op(B), !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans_A == rocsparse_operation_none} \\% !> A^T, & \text{if trans_A == rocsparse_operation_transpose} \\% !> A^H, & \text{if trans_A == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> , !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if trans_X == rocsparse_operation_none} \\% !> B^T, & \text{if trans_X == rocsparse_operation_transpose} \\% !> B^H, & \text{if trans_X == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(X) = \left\{ !> \begin{array}{ll} !> X, & \text{if trans_X == rocsparse_operation_none} \\% !> X^T, & \text{if trans_X == rocsparse_operation_transpose} \\% !> X^H, & \text{if trans_X == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> and where \f$m = block\_dim \times mb\f$. !> !> Note that, as indicated above, the operation type of both \f$op(B)\f$ and \f$op(X)\f$ is !> specified by the !> \p trans_X parameter and that the operation type of B and X must match. For example, if !> \f$op(B)=B\f$, then !> \f$op(X)=X\f$. Likewise, if \f$op(B)=B^T\f$, then \f$op(X)=X^T\f$. !> !> Given that the sparse matrix A is a square matrix, its size is \f$m \times m\f$ regardless of !> whether A is transposed or not. The size of the column-oriented dense matrices B and X have !> a size that depends on the value of \p trans_X : !> !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> ldb \times nrhs, \text{ } ldb ≥ m, & \text{if trans_X == rocsparse_operation_none} !> \\% !> ldb \times m, \text{ } ldb ≥ nrhs, & \text{if trans_X == !> rocsparse_operation_transpose} \\% !> ldb \times m, \text{ } ldb ≥ nrhs, & \text{if trans_X == !> rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(X) = \left\{ !> \begin{array}{ll} !> ldb \times nrhs, \text{ } ldb ≥ m, & \text{if trans_X == rocsparse_operation_none} !> \\% !> ldb \times m, \text{ } ldb ≥ nrhs, & \text{if trans_X == !> rocsparse_operation_transpose} \\% !> ldb \times m, \text{ } ldb ≥ nrhs, & \text{if trans_X == !> rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> !> \p rocsparse_bsrsm_solve requires a user-allocated temporary buffer. Its size is returned by !> \ref rocsparse_sbsrsm_buffer_size "rocsparse_Xbsrsm_buffer_size()". The size of the required !> buffer is larger !> when \p trans_A equals `rocsparse_operation_transpose` or !> `rocsparse_operation_conjugate_transpose` and !> when \p trans_X is `rocsparse_operation_none`. The subsequent solve will also be faster when !> \f$A\f$ is !> non-transposed and \f$B\f$ is transposed (or conjugate transposed). For example, instead of !> solving: !> !> \f[ !> \left[ !> \begin{array}{c | c} !> \begin{array}{c c} !> a_{00} & a_{01} \\% !> a_{10} & a_{11} !> \end{array} & !> \begin{array}{c c} !> 0 & 0 \\% !> 0 & 0 !> \end{array} \\% !> \hline !> \begin{array}{c c} !> a_{20} & a_{21} \\% !> a_{30} & a_{31} !> \end{array} & !> \begin{array}{c c} !> a_{22} & a_{23} \\% !> a_{32} & a_{33} !> \end{array} \\% !> \end{array} !> \right] !> \cdot !> \begin{bmatrix} !> x_{00} & x_{01} \\% !> x_{10} & x_{11} \\% !> x_{20} & x_{21} \\% !> x_{30} & x_{31} \\% !> \end{bmatrix} !> = !> \begin{bmatrix} !> b_{00} & b_{01} \\% !> b_{10} & b_{11} \\% !> b_{20} & b_{21} \\% !> b_{30} & b_{31} \\% !> \end{bmatrix} !> \f] !> !> Consider solving: !> !> \f[ !> \left[ !> \begin{array}{c | c} !> \begin{array}{c c} !> a_{00} & a_{01} \\% !> a_{10} & a_{11} !> \end{array} & !> \begin{array}{c c} !> 0 & 0 \\% !> 0 & 0 !> \end{array} \\% !> \hline !> \begin{array}{c c} !> a_{20} & a_{21} \\% !> a_{30} & a_{31} !> \end{array} & !> \begin{array}{c c} !> a_{22} & a_{23} \\% !> a_{32} & a_{33} !> \end{array} \\% !> \end{array} !> \right] !> \cdot !> \begin{bmatrix} !> x_{00} & x_{10} & x_{20} & x_{30} \\% !> x_{01} & x_{11} & x_{21} & x_{31} !> \end{bmatrix}^{T} !> = !> \begin{bmatrix} !> b_{00} & b_{10} & b_{20} & b_{30} \\% !> b_{01} & b_{11} & b_{21} & b_{31} !> \end{bmatrix}^{T} !> \f] !> !> After the temporary storage buffer has been allocated, analysis metadata is required. It can !> be obtained !> by \ref rocsparse_sbsrsm_analysis "rocsparse_Xbsrsm_analysis()". !> !> Solving a triangular system involves inverting the diagonal blocks. This means that if the !> sparse matrix is !> missing the diagonal block (referred to as a structural zero) or the diagonal block is not !> invertible (referred !> to as a numerical zero) then a solution is not possible. \p rocsparse_bsrsm_solve tracks the !> location of the first !> zero pivot (either numerical or structural zero). The zero pivot status can be checked by !> calling `rocsparse_bsrsm_zero_pivot` (). !> If `rocsparse_bsrsm_zero_pivot` () returns `rocsparse_status_success`, then no zero pivot was !> found and therefore !> the matrix does not have a structural or numerical zero. !> !> The user can specify that the sparse matrix should be interpreted as having identity blocks !> on the diagonal by setting the diagonal !> type on the descriptor \p descr to `rocsparse_diag_type_unit` using !> `rocsparse_set_mat_diag_type`. If !> `rocsparse_diag_type` == `rocsparse_diag_type_unit`, no zero pivot will be reported, even if !> the diagonal block \f$A_{j,j}\f$ !> for some \f$j\f$ is not invertible. !> !> The sparse CSR matrix passed to \p rocsparse_bsrsm_solve does not actually have to be a !> triangular matrix. Instead, the !> triangular upper or lower part of the sparse matrix is solved based on `rocsparse_fill_mode` !> set on the descriptor !> \p descr. If the fill mode is set to `rocsparse_fill_mode_lower`, then the lower triangular !> matrix is solved. If the !> fill mode is set to `rocsparse_fill_mode_upper`, then the upper triangular matrix is solved. !> !> \note !> The sparse BSR matrix has to be sorted. !> !> \note !> Operation type of B and X must match, , if \f$op(B)=B\f$ then \f$op(X)=X\f$. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p trans_A != `rocsparse_operation_conjugate_transpose` and !> \p trans_X != `rocsparse_operation_conjugate_transpose` is supported. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - matrix storage of BSR blocks. !> @param[in] trans_A - matrix A operation type. !> @param[in] trans_X - matrix X operation type. !> @param[in] mb - number of block rows of the sparse BSR matrix A. !> @param[in] nrhs - number of columns of the column-oriented dense matrix op(X). !> @param[in] nnzb - number of non-zero blocks of the sparse BSR matrix A. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr - descriptor of the sparse BSR matrix A. !> @param[in] bsr_val - array of \p nnzb blocks of the sparse BSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of !> the sparse BSR matrix. !> @param[in] bsr_col_ind - array of \p nnzb containing the block column indices of the sparse !> BSR matrix. !> @param[in] block_dim - block dimension of the sparse BSR matrix. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] B - column-oriented dense matrix B with leading dimension \p ldb. !> @param[in] ldb - leading dimension of rhs matrix B. !> @param[out] X - column-oriented dense solution matrix X with leading dimension \p ldx. !> @param[in] ldx - leading dimension of solution matrix X. !> @param[in] policy - `rocsparse_solve_policy_auto`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nrhs, \p nnzb, or \p block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p alpha, \p descr, \p bsr_val, !> \p bsr_row_ptr, \p bsr_col_ind, \p B, \p X \p info, or \p temp_buffer pointer !> is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> \p trans_A == `rocsparse_operation_conjugate_transpose`, !> \p trans_X == `rocsparse_operation_conjugate_transpose`, or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> Consider the lower triangular \f$m \times m\f$ matrix \f$L\f$, stored in BSR !> storage format with non-unit diagonal. The following example solves \f$L \cdot X = B\f$. interface rocsparse_sbsrsm_solve function rocsparse_sbsrsm_solve_(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) & bind(c, name="rocsparse_sbsrsm_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsm_solve_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_X integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb real(c_float) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sbsrsm_solve_assumed_rank #else module procedure & rocsparse_sbsrsm_solve_rank_0,& rocsparse_sbsrsm_solve_rank_1,& rocsparse_sbsrsm_solve_full_rank #endif #endif end interface interface rocsparse_dbsrsm_solve function rocsparse_dbsrsm_solve_(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) & bind(c, name="rocsparse_dbsrsm_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsm_solve_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_X integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb real(c_double) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dbsrsm_solve_assumed_rank #else module procedure & rocsparse_dbsrsm_solve_rank_0,& rocsparse_dbsrsm_solve_rank_1,& rocsparse_dbsrsm_solve_full_rank #endif #endif end interface interface rocsparse_cbsrsm_solve function rocsparse_cbsrsm_solve_(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) & bind(c, name="rocsparse_cbsrsm_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsm_solve_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_X integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb complex(c_float_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cbsrsm_solve_assumed_rank #else module procedure & rocsparse_cbsrsm_solve_rank_0,& rocsparse_cbsrsm_solve_rank_1,& rocsparse_cbsrsm_solve_full_rank #endif #endif end interface interface rocsparse_zbsrsm_solve function rocsparse_zbsrsm_solve_(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) & bind(c, name="rocsparse_zbsrsm_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsm_solve_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_X integer(c_int),value :: mb integer(c_int),value :: nrhs integer(c_int),value :: nnzb complex(c_double_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: X integer(c_int),value :: ldx integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zbsrsm_solve_assumed_rank #else module procedure & rocsparse_zbsrsm_solve_rank_0,& rocsparse_zbsrsm_solve_rank_1,& rocsparse_zbsrsm_solve_full_rank #endif #endif end interface !> \ingroup level3_module !> \brief Sparse matrix dense matrix multiplication using the CSR storage format. !> !> \details !> \p rocsparse_csrmm multiplies the scalar \f$\alpha\f$ with a sparse \f$m \times k\f$ !> matrix \f$A\f$, defined in CSR storage format, and the column-oriented dense \f$k \times n\f$ !> matrix \f$B\f$ and adds the result to the column-oriented dense \f$m \times n\f$ matrix !> \f$C\f$ that !> is multiplied by the scalar \f$\beta\f$, such that !> \f[ !> C := \alpha \cdot op(A) \cdot op(B) + \beta \cdot C, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans_A == rocsparse_operation_none} \\% !> A^T, & \text{if trans_A == rocsparse_operation_transpose} \\% !> A^H, & \text{if trans_A == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if trans_B == rocsparse_operation_none} \\% !> B^T, & \text{if trans_B == rocsparse_operation_transpose} \\% !> B^H, & \text{if trans_B == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> !> \code{.c} !> for(i = 0; i < ldc; ++i) !> { !> for(j = 0; j < n; ++j) !> { !> C[i][j] = beta * C[i][j]; !> !> for(k = csr_row_ptr[i]; k < csr_row_ptr[i + 1]; ++k) !> { !> C[i][j] += alpha * csr_val[k] * B[csr_col_ind[k]][j]; !> } !> } !> } !> \endcode !> !> \note !> This function does not produce deterministic results when A is transposed. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans_A - matrix \f$A\f$ operation type. !> @param[in] trans_B - matrix \f$B\f$ operation type. !> @param[in] m - number of rows of the sparse CSR matrix \f$A\f$. !> @param[in] n - number of columns of the column-oriented dense matrix \f$op(B)\f$ and \f$C\f$. !> @param[in] k - number of columns of the sparse CSR matrix \f$A\f$. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix \f$A\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr - descriptor of the sparse CSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix \f$A\f$. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix \f$A\f$. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix \f$A\f$. !> @param[in] B - column-oriented dense matrix of dimension \f$ldb \times n\f$ (\f$op(B) == !> B\f$), !> \f$ldb \times k\f$ otherwise. !> @param[in] ldb - leading dimension of \f$B\f$, must be at least \f$\max{(1, k)}\f$ !> (\f$op(B) == B\f$), \f$\max{(1, n)}\f$ otherwise. !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] C - column-oriented dense matrix of dimension \f$ldc \times n\f$. !> @param[in] ldc - leading dimension of \f$C\f$, must be at least \f$\max{(1, m)}\f$ !> (\f$op(A) == A\f$), \f$\max{(1, k)}\f$ otherwise. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, \p k, \p nnz, \p ldb, or \p ldc !> is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p alpha, \p csr_val, !> \p csr_row_ptr, \p csr_col_ind, \p B, \p beta, or \p C pointer is invalid. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> This example multiplies a CSR matrix with a column-oriented dense matrix. interface rocsparse_scsrmm function rocsparse_scsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,B,ldb,beta,C,ldc) & bind(c, name="rocsparse_scsrmm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrmm_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz real(c_float) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsrmm_assumed_rank #else module procedure & rocsparse_scsrmm_rank_0,& rocsparse_scsrmm_rank_1,& rocsparse_scsrmm_full_rank #endif #endif end interface interface rocsparse_dcsrmm function rocsparse_dcsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,B,ldb,beta,C,ldc) & bind(c, name="rocsparse_dcsrmm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrmm_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz real(c_double) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsrmm_assumed_rank #else module procedure & rocsparse_dcsrmm_rank_0,& rocsparse_dcsrmm_rank_1,& rocsparse_dcsrmm_full_rank #endif #endif end interface interface rocsparse_ccsrmm function rocsparse_ccsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,B,ldb,beta,C,ldc) & bind(c, name="rocsparse_ccsrmm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrmm_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz complex(c_float_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsrmm_assumed_rank #else module procedure & rocsparse_ccsrmm_rank_0,& rocsparse_ccsrmm_rank_1,& rocsparse_ccsrmm_full_rank #endif #endif end interface interface rocsparse_zcsrmm function rocsparse_zcsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,B,ldb,beta,C,ldc) & bind(c, name="rocsparse_zcsrmm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrmm_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz complex(c_double_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsrmm_assumed_rank #else module procedure & rocsparse_zcsrmm_rank_0,& rocsparse_zcsrmm_rank_1,& rocsparse_zcsrmm_full_rank #endif #endif end interface !> \ingroup level3_module !> \details !> \p rocsparse_csrsm_zero_pivot returns `rocsparse_status_zero_pivot` if either a !> structural or numerical zero has been found during !> \ref rocsparse_scsrsm_solve "rocsparse_Xcsrsm_solve()" computation. The first zero !> pivot \f$j\f$ at \f$A_{j,j}\f$ is stored in \p position, using the same index base as !> the CSR matrix. !> !> \p position can be in host or device memory. If no zero pivot has been found, !> \p position is set to -1 and `rocsparse_status_success` is returned instead. !> !> \note \p rocsparse_csrsm_zero_pivot is a blocking function. It might negatively influence !> performance. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[inout] position - pointer to zero pivot \f$j\f$, which can be in host or device !> memory. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info or \p position pointer is !> invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_zero_pivot zero pivot has been found. interface rocsparse_csrsm_zero_pivot function rocsparse_csrsm_zero_pivot_(handle,myInfo,position) & bind(c, name="rocsparse_csrsm_zero_pivot") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrsm_zero_pivot_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int) :: position end function end interface !> \ingroup level3_module !> \details !> \p rocsparse_csrsm_buffer_size returns the size of the temporary storage buffer that !> is required by \ref rocsparse_scsrsm_analysis "rocsparse_Xcsrsm_analysis()" and !> \ref rocsparse_scsrsm_solve "rocsparse_Xcsrsm_solve()". The temporary storage buffer !> must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans_A - matrix A operation type. !> @param[in] trans_B - matrix B operation type. !> @param[in] m - number of rows of the sparse CSR matrix A. !> @param[in] nrhs - number of columns of the column-oriented dense matrix op(B). !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix A. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr - descriptor of the sparse CSR matrix A. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix A. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix A. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix A. !> @param[in] B - column-oriented dense matrix of dimension \p m \f$\times\f$ \p nrhs elements !> of the rhs matrix B. !> @param[in] ldb - leading dimension of rhs matrix B. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] policy - `rocsparse_solve_policy_auto`. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> rocsparse_scsrsm_analysis(), rocsparse_dcsrsm_analysis(), !> rocsparse_ccsrsm_analysis(), rocsparse_zcsrsm_analysis(), !> rocsparse_scsrsm_solve(), rocsparse_dcsrsm_solve(), !> rocsparse_ccsrsm_solve(), and rocsparse_zcsrsm_solve(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p nrhs, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p alpha, \p descr, \p csr_val, !> \p csr_row_ptr, \p csr_col_ind, \p B, \p info, or \p buffer_size pointer !> is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> \p trans_A == `rocsparse_operation_conjugate_transpose`, !> \p trans_B == `rocsparse_operation_conjugate_transpose`, or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_scsrsm_buffer_size function rocsparse_scsrsm_buffer_size_(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) & bind(c, name="rocsparse_scsrsm_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsm_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz real(c_float) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsrsm_buffer_size_assumed_rank #else module procedure & rocsparse_scsrsm_buffer_size_rank_0,& rocsparse_scsrsm_buffer_size_rank_1,& rocsparse_scsrsm_buffer_size_full_rank #endif #endif end interface interface rocsparse_dcsrsm_buffer_size function rocsparse_dcsrsm_buffer_size_(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) & bind(c, name="rocsparse_dcsrsm_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsm_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz real(c_double) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsrsm_buffer_size_assumed_rank #else module procedure & rocsparse_dcsrsm_buffer_size_rank_0,& rocsparse_dcsrsm_buffer_size_rank_1,& rocsparse_dcsrsm_buffer_size_full_rank #endif #endif end interface interface rocsparse_ccsrsm_buffer_size function rocsparse_ccsrsm_buffer_size_(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) & bind(c, name="rocsparse_ccsrsm_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsm_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz complex(c_float_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsrsm_buffer_size_assumed_rank #else module procedure & rocsparse_ccsrsm_buffer_size_rank_0,& rocsparse_ccsrsm_buffer_size_rank_1,& rocsparse_ccsrsm_buffer_size_full_rank #endif #endif end interface interface rocsparse_zcsrsm_buffer_size function rocsparse_zcsrsm_buffer_size_(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) & bind(c, name="rocsparse_zcsrsm_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsm_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz complex(c_double_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsrsm_buffer_size_assumed_rank #else module procedure & rocsparse_zcsrsm_buffer_size_rank_0,& rocsparse_zcsrsm_buffer_size_rank_1,& rocsparse_zcsrsm_buffer_size_full_rank #endif #endif end interface !> \ingroup level3_module !> \details !> \p rocsparse_csrsm_analysis performs the analysis step for !> \ref rocsparse_scsrsm_solve "rocsparse_Xcsrsm_solve()". It is expected that this !> function will be executed only once for a given matrix and particular operation !> type. The analysis metadata can be cleared by `rocsparse_csrsm_clear`(). !> !> \p rocsparse_csrsm_analysis can share its meta data with !> \ref rocsparse_scsrilu0_analysis "rocsparse_Xcsrilu0_analysis()", !> \ref rocsparse_scsric0_analysis "rocsparse_Xcsric0_analysis()", and !> \ref rocsparse_scsrsv_analysis "rocsparse_Xcsrsv_analysis()". Selecting !> `rocsparse_analysis_policy_reuse` policy can greatly improve computation !> performance of the metadata. However, the user needs to ensure that the sparsity !> pattern remains unchanged. If this cannot be assured, !> `rocsparse_analysis_policy_force` has to be used. !> !> \note !> If the matrix sparsity pattern changes, the gathered information will become invalid. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans_A - matrix A operation type. !> @param[in] trans_B - matrix B operation type. !> @param[in] m - number of rows of the sparse CSR matrix A. !> @param[in] nrhs - number of columns of the column-oriented dense matrix op(B). !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix A. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr - descriptor of the sparse CSR matrix A. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix A. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix A. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix A. !> @param[in] B - column-oriented dense matrix of dimension \p m \f$\times\f$ \p nrhs elements !> of the rhs matrix B. !> @param[in] ldb - leading dimension of rhs matrix B. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[in] analysis - `rocsparse_analysis_policy_reuse` or !> `rocsparse_analysis_policy_force`. !> @param[in] solve - `rocsparse_solve_policy_auto`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p nrhs, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p alpha, \p descr, \p csr_val, !> \p csr_row_ptr, \p csr_col_ind, \p B, \p info, or \p temp_buffer pointer !> is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> \p trans_A == `rocsparse_operation_conjugate_transpose`, !> \p trans_B == `rocsparse_operation_conjugate_transpose`, or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_scsrsm_analysis function rocsparse_scsrsm_analysis_(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_scsrsm_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsm_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz real(c_float) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsrsm_analysis_assumed_rank #else module procedure & rocsparse_scsrsm_analysis_rank_0,& rocsparse_scsrsm_analysis_rank_1,& rocsparse_scsrsm_analysis_full_rank #endif #endif end interface interface rocsparse_dcsrsm_analysis function rocsparse_dcsrsm_analysis_(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_dcsrsm_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsm_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz real(c_double) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsrsm_analysis_assumed_rank #else module procedure & rocsparse_dcsrsm_analysis_rank_0,& rocsparse_dcsrsm_analysis_rank_1,& rocsparse_dcsrsm_analysis_full_rank #endif #endif end interface interface rocsparse_ccsrsm_analysis function rocsparse_ccsrsm_analysis_(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_ccsrsm_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsm_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz complex(c_float_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsrsm_analysis_assumed_rank #else module procedure & rocsparse_ccsrsm_analysis_rank_0,& rocsparse_ccsrsm_analysis_rank_1,& rocsparse_ccsrsm_analysis_full_rank #endif #endif end interface interface rocsparse_zcsrsm_analysis function rocsparse_zcsrsm_analysis_(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_zcsrsm_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsm_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz complex(c_double_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsrsm_analysis_assumed_rank #else module procedure & rocsparse_zcsrsm_analysis_rank_0,& rocsparse_zcsrsm_analysis_rank_1,& rocsparse_zcsrsm_analysis_full_rank #endif #endif end interface !> \ingroup level3_module !> \details !> \p rocsparse_csrsm_clear deallocates all memory that was allocated by !> \ref rocsparse_scsrsm_analysis "rocsparse_Xcsrsm_analysis()". This is especially !> useful if memory is an issue and the analysis data is not required for further !> computation, for example, when switching to another sparse matrix format. Calling !> \p rocsparse_csrsm_clear is optional. All allocated resources will be cleared !> when the opaque `rocsparse_mat_info` struct is destroyed using !> `rocsparse_destroy_mat_info`(). !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[inout] myInfo - structure that holds the information collected during the analysis !> step. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info pointer is invalid. !> \retval rocsparse_status_memory_error the buffer holding the metadata could not !> be deallocated. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_csrsm_clear function rocsparse_csrsm_clear_(handle,myInfo) bind(c, name="rocsparse_csrsm_clear") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrsm_clear_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo end function end interface !> \ingroup level3_module !> \brief Sparse triangular system solve using the CSR storage format. !> !> \details !> \p rocsparse_csrsm_solve solves a sparse triangular linear system of a sparse !> \f$m \times m\f$ matrix, defined in CSR storage format, a column-oriented dense solution !> matrix !> \f$X\f$ and the column-oriented dense right-hand side matrix \f$B\f$ that is multiplied by !> \f$\alpha\f$, such that !> \f[ !> op(A) \cdot op(X) = \alpha \cdot op(B), !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans_A == rocsparse_operation_none} \\% !> A^T, & \text{if trans_A == rocsparse_operation_transpose} \\% !> A^H, & \text{if trans_A == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> , !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if trans_B == rocsparse_operation_none} \\% !> B^T, & \text{if trans_B == rocsparse_operation_transpose} \\% !> B^H, & \text{if trans_B == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(X) = \left\{ !> \begin{array}{ll} !> X, & \text{if trans_B == rocsparse_operation_none} \\% !> X^T, & \text{if trans_B == rocsparse_operation_transpose} \\% !> X^H, & \text{if trans_B == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> !> The solution is performed inplace, meaning that the matrix B is overwritten with the solution !> X after calling \p rocsparse_csrsm_solve. Given that the sparse matrix A is a square matrix, !> its !> size is \f$m \times m\f$, regardless of whether A is transposed or not. The size of the !> column-oriented dense !> matrices B and X depends on the value of \p trans_B: !> !> \f[ !> op(B)/op(X) = \left\{ !> \begin{array}{ll} !> ldb \times nrhs, \text{ } ldb ≥ m, & \text{if trans_B == rocsparse_operation_none} !> \\% !> ldb \times m, \text{ } ldb ≥ nrhs, & \text{if trans_B == !> rocsparse_operation_transpose} \\% !> ldb \times m, \text{ } ldb ≥ nrhs, & \text{if trans_B == !> rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> !> \p rocsparse_csrsm_solve requires a user-allocated temporary buffer. Its size is returned by !> \ref rocsparse_scsrsm_buffer_size "rocsparse_Xcsrsm_buffer_size()". The size of the required !> buffer is !> larger when \p trans_A equals `rocsparse_operation_transpose` or !> `rocsparse_operation_conjugate_transpose` !> and when \p trans_B is `rocsparse_operation_none`. The subsequent solve will also be faster !> when \f$A\f$ !> is non-transposed and \f$B\f$ is transposed (or conjugate transposed). For example, instead !> of solving: !> !> \f[ !> \begin{bmatrix} !> a_{00} & 0 & 0 \\% !> a_{10} & a_{11} & 0 \\% !> a_{20} & a_{21} & a_{22} \\% !> \end{bmatrix} !> \cdot !> \begin{bmatrix} !> x_{00} & x_{01} \\% !> x_{10} & x_{11} \\% !> x_{20} & x_{21} \\% !> \end{bmatrix} !> = !> \begin{bmatrix} !> b_{00} & b_{01} \\% !> b_{10} & b_{11} \\% !> b_{20} & b_{21} \\% !> \end{bmatrix} !> \f] !> !> Consider solving: !> !> \f[ !> \begin{bmatrix} !> a_{00} & 0 & 0 \\% !> a_{10} & a_{11} & 0 \\% !> a_{20} & a_{21} & a_{22} !> \end{bmatrix} !> \cdot !> \begin{bmatrix} !> x_{00} & x_{10} & x_{20} \\% !> x_{01} & x_{11} & x_{21} !> \end{bmatrix}^{T} !> = !> \begin{bmatrix} !> b_{00} & b_{10} & b_{20} \\% !> b_{01} & b_{11} & b_{21} !> \end{bmatrix}^{T} !> \f] !> !> After the temporary storage buffer has been allocated, analysis of the metadata is required. !> It can be obtained by \ref rocsparse_scsrsm_analysis "rocsparse_Xcsrsm_analysis()". !> !> Solving a triangular system involves division by the diagonal elements. This means that if !> the sparse matrix is !> missing the diagonal entry (referred to as a structural zero) or the diagonal entry is zero !> (referred to as a numerical zero), !> then a division by zero would occur. \p rocsparse_csrsm_solve tracks the location of the !> first zero pivot (either numerical !> or structural zero). The zero pivot status can be checked by calling !> `rocsparse_csrsm_zero_pivot` (). If !> `rocsparse_csrsm_zero_pivot` () returns `rocsparse_status_success`, then no zero pivot was !> found and therefore !> the matrix does not have a structural or numerical zero. !> !> The user can specify that the sparse matrix should be interpreted as having ones on the !> diagonal by setting the diagonal type !> on the descriptor \p descr to `rocsparse_diag_type_unit` using `rocsparse_set_mat_diag_type`. !> If !> `rocsparse_diag_type` == `rocsparse_diag_type_unit`, no zero pivot will be reported, even if !> \f$A_{j,j} = 0\f$ for !> some \f$j\f$. !> !> The sparse CSR matrix passed to \p rocsparse_csrsm_solve does not actually have to be a !> triangular matrix. Instead, the !> triangular upper or lower part of the sparse matrix is solved based on the !> `rocsparse_fill_mode` setting on the descriptor !> \p descr. If the fill mode is set to `rocsparse_fill_mode_lower`, then the lower triangular !> matrix is solved. If the !> fill mode is set to `rocsparse_fill_mode_upper`, then the upper triangular matrix is solved. !> !> \note !> The sparse CSR matrix has to be sorted. This can be achieved by calling !> `rocsparse_csrsort()`. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p trans_A != `rocsparse_operation_conjugate_transpose` and !> \p trans_B != `rocsparse_operation_conjugate_transpose` is supported. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans_A - matrix A operation type. !> @param[in] trans_B - matrix B operation type. !> @param[in] m - number of rows of the sparse CSR matrix A. !> @param[in] nrhs - number of columns of the column-oriented dense matrix op(B). !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix A. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr - descriptor of the sparse CSR matrix A. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix A. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix A. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix A. !> @param[inout] B - column-oriented dense matrix of dimension \p m \f$\times\f$ \p nrhs !> elements of the rhs matrix B. !> @param[in] ldb - leading dimension of rhs matrix B. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] policy - `rocsparse_solve_policy_auto`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p nrhs, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p alpha, \p descr, \p csr_val, !> \p csr_row_ptr, \p csr_col_ind, \p B, \p info, or \p temp_buffer pointer !> is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> \p trans_A == `rocsparse_operation_conjugate_transpose`, !> \p trans_B == `rocsparse_operation_conjugate_transpose`, or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> Consider the lower triangular \f$m \times m\f$ matrix \f$L\f$, stored in CSR !> storage format with unit diagonal. The following example solves \f$L \cdot X = B\f$. interface rocsparse_scsrsm_solve function rocsparse_scsrsm_solve_(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) & bind(c, name="rocsparse_scsrsm_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsm_solve_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz real(c_float) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsrsm_solve_assumed_rank #else module procedure & rocsparse_scsrsm_solve_rank_0,& rocsparse_scsrsm_solve_rank_1,& rocsparse_scsrsm_solve_full_rank #endif #endif end interface interface rocsparse_dcsrsm_solve function rocsparse_dcsrsm_solve_(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) & bind(c, name="rocsparse_dcsrsm_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsm_solve_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz real(c_double) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsrsm_solve_assumed_rank #else module procedure & rocsparse_dcsrsm_solve_rank_0,& rocsparse_dcsrsm_solve_rank_1,& rocsparse_dcsrsm_solve_full_rank #endif #endif end interface interface rocsparse_ccsrsm_solve function rocsparse_ccsrsm_solve_(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) & bind(c, name="rocsparse_ccsrsm_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsm_solve_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz complex(c_float_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsrsm_solve_assumed_rank #else module procedure & rocsparse_ccsrsm_solve_rank_0,& rocsparse_ccsrsm_solve_rank_1,& rocsparse_ccsrsm_solve_full_rank #endif #endif end interface interface rocsparse_zcsrsm_solve function rocsparse_zcsrsm_solve_(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) & bind(c, name="rocsparse_zcsrsm_solve") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsm_solve_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: nrhs integer(c_int),value :: nnz complex(c_double_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsrsm_solve_assumed_rank #else module procedure & rocsparse_zcsrsm_solve_rank_0,& rocsparse_zcsrsm_solve_rank_1,& rocsparse_zcsrsm_solve_full_rank #endif #endif end interface !> \ingroup level3_module !> \brief Sparse matrix dense matrix multiplication using the general BSR storage format !> !> \details !> \p rocsparse_gebsrmm multiplies the scalar \f$\alpha\f$ with a sparse \f$m \times k\f$ !> matrix \f$A\f$, defined in general BSR storage format, and the column-oriented dense \f$k !> \times n\f$ !> matrix \f$B\f$ and adds the result to the column-oriented dense \f$m \times n\f$ matrix !> \f$C\f$ that !> is multiplied by the scalar \f$\beta\f$, such that !> \f[ !> C := \alpha \cdot op(A) \cdot op(B) + \beta \cdot C, !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans_A == rocsparse_operation_none} \\% !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if trans_B == rocsparse_operation_none} \\% !> B^T, & \text{if trans_B == rocsparse_operation_transpose} \\% !> \end{array} !> \right. !> \f] !> and where \f$k = col\_block\_dim \times kb\f$ and \f$m = row\_block\_dim \times mb\f$. !> !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> Currently, only \p trans_A == `rocsparse_operation_none` is supported. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - the storage format of the blocks. Can be `rocsparse_direction_row` or !> `rocsparse_direction_column`. !> @param[in] trans_A - matrix \f$A\f$ operation type. Currently, only !> `rocsparse_operation_none` is supported. !> @param[in] trans_B - matrix \f$B\f$ operation type. Currently, only !> `rocsparse_operation_none` and rocsparse_operation_transpose !> are supported. !> @param[in] mb - number of block rows of the sparse general BSR matrix \f$A\f$. !> @param[in] n - number of columns of the column-oriented dense matrix \f$op(B)\f$ and \f$C\f$. !> @param[in] kb - number of block columns of the sparse general BSR matrix \f$A\f$. !> @param[in] nnzb - number of non-zero blocks of the sparse general BSR matrix \f$A\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] descr - descriptor of the sparse general BSR matrix \f$A\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] bsr_val - array of \p nnzb*row_block_dim*col_block_dim elements of the sparse !> general BSR matrix \f$A\f$. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse general BSR matrix \f$A\f$. !> @param[in] bsr_col_ind - array of \p nnzb elements containing the block column indices of the !> sparse !> general BSR matrix \f$A\f$. !> @param[in] row_block_dim - row size of the blocks in the sparse general BSR matrix. !> @param[in] col_block_dim - column size of the blocks in the sparse general BSR matrix. !> @param[in] B - column-oriented dense matrix of dimension \f$ldb \times n\f$ (\f$op(B) == !> B\f$), !> \f$ldb \times k\f$ otherwise. !> @param[in] ldb - leading dimension of \f$B\f$, which must be at least \f$\max{(1, k)}\f$ (\f$ !> op(B) == B\f$) where \f$k = col\_block\_dim \times kb\f$, !> \f$\max{(1, n)}\f$ otherwise. !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] C - column-oriented dense matrix of dimension \f$ldc \times n\f$. !> @param[in] ldc - leading dimension of \f$C\f$, which must be at least \f$\max{(1, m)}\f$ (\f$ !> op(A) == A\f$) where \f$m = row\_block\_dim \times mb\f$, !> \f$\max{(1, k)}\f$ where \f$k = col\_block\_dim \times kb\f$ otherwise. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p n, \p kb, \p nnzb, \p ldb, \p ldc, \p !> row_block_dim, !> or \p col_block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p alpha, \p bsr_val, !> \p bsr_row_ptr, \p bsr_col_ind, \p B, \p beta, or \p C pointer is invalid. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> \retval rocsparse_status_not_implemented !> \p trans_A != `rocsparse_operation_none`, !> \p trans_B == `rocsparse_operation_conjugate_transpose`, or !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> This example multiplies a general BSR matrix with a column-oriented dense matrix. interface rocsparse_sgebsrmm function rocsparse_sgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) & bind(c, name="rocsparse_sgebsrmm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsrmm_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: mb integer(c_int),value :: n integer(c_int),value :: kb integer(c_int),value :: nnzb real(c_float) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: B integer(c_int),value :: ldb real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sgebsrmm_assumed_rank #else module procedure & rocsparse_sgebsrmm_rank_0,& rocsparse_sgebsrmm_rank_1,& rocsparse_sgebsrmm_full_rank #endif #endif end interface interface rocsparse_dgebsrmm function rocsparse_dgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) & bind(c, name="rocsparse_dgebsrmm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsrmm_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: mb integer(c_int),value :: n integer(c_int),value :: kb integer(c_int),value :: nnzb real(c_double) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: B integer(c_int),value :: ldb real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dgebsrmm_assumed_rank #else module procedure & rocsparse_dgebsrmm_rank_0,& rocsparse_dgebsrmm_rank_1,& rocsparse_dgebsrmm_full_rank #endif #endif end interface interface rocsparse_cgebsrmm function rocsparse_cgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) & bind(c, name="rocsparse_cgebsrmm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsrmm_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: mb integer(c_int),value :: n integer(c_int),value :: kb integer(c_int),value :: nnzb complex(c_float_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cgebsrmm_assumed_rank #else module procedure & rocsparse_cgebsrmm_rank_0,& rocsparse_cgebsrmm_rank_1,& rocsparse_cgebsrmm_full_rank #endif #endif end interface interface rocsparse_zgebsrmm function rocsparse_zgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) & bind(c, name="rocsparse_zgebsrmm") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsrmm_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: mb integer(c_int),value :: n integer(c_int),value :: kb integer(c_int),value :: nnzb complex(c_double_complex) :: alpha type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: B integer(c_int),value :: ldb complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zgebsrmm_assumed_rank #else module procedure & rocsparse_zgebsrmm_rank_0,& rocsparse_zgebsrmm_rank_1,& rocsparse_zgebsrmm_full_rank #endif #endif end interface !> \ingroup level3_module !> \brief Dense matrix sparse matrix multiplication using the CSR storage format. !> !> \details !> \p rocsparse_gemmi multiplies the scalar \f$\alpha\f$ with a column-oriented dense \f$m !> \times k\f$ !> matrix \f$op(A)\f$ and the sparse \f$k \times n\f$ matrix \f$op(B)\f$, defined in CSR !> storage format, and adds the result to the column-oriented dense \f$m \times n\f$ matrix !> \f$C\f$ that !> is multiplied by the scalar \f$\beta\f$, such that !> \f[ !> C := \alpha \cdot op(A) \cdot op(B) + \beta \cdot C !> \f] !> with !> \f[ !> op(A) = \left\{ !> \begin{array}{ll} !> A, & \text{if trans_A == rocsparse_operation_none} \\% !> A^T, & \text{if trans_A == rocsparse_operation_transpose} \\% !> A^H, & \text{if trans_A == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> and !> \f[ !> op(B) = \left\{ !> \begin{array}{ll} !> B, & \text{if trans_B == rocsparse_operation_none} \\% !> B^T, & \text{if trans_B == rocsparse_operation_transpose} \\% !> B^H, & \text{if trans_B == rocsparse_operation_conjugate_transpose} !> \end{array} !> \right. !> \f] !> !> \note !> Currently, only \p trans_A == `rocsparse_operation_none` is supported. !> !> \note !> Currently, only \p trans_B == `rocsparse_operation_transpose` is supported. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] trans_A - matrix \f$A\f$ operation type. !> @param[in] trans_B - matrix \f$B\f$ operation type. !> @param[in] m - number of rows of the column-oriented dense matrix \f$A\f$. !> @param[in] n - number of columns of the sparse CSR matrix \f$op(B)\f$ and \f$C\f$. !> @param[in] k - number of columns of the column-oriented dense matrix \f$A\f$. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix \f$B\f$. !> @param[in] alpha - scalar \f$\alpha\f$. !> @param[in] A - array of dimension \f$lda \times k\f$ (\f$op(A) == A\f$) or !> \f$lda \times m\f$ (\f$op(A) == A^T\f$ or \f$op(A) == A^H\f$). !> @param[in] lda - leading dimension of \f$A\f$, must be at least \f$m\f$ !> (\f$op(A) == A\f$) or \f$k\f$ (\f$op(A) == A^T\f$ or !> \f$op(A) == A^H\f$). !> @param[in] descr - descriptor of the sparse CSR matrix \f$B\f$. Currently, only !> `rocsparse_matrix_type_general` is supported. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix \f$B\f$. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix \f$B\f$. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR !> matrix \f$B\f$. !> @param[in] beta - scalar \f$\beta\f$. !> @param[inout] C - column-oriented dense matrix of dimension \f$ldc \times n\f$ that holds the !> values of \f$C\f$. !> @param[in] ldc - leading dimension of \f$C\f$, must be at least \f$m\f$. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, \p k, \p nnz, \p lda, or \p ldc !> is invalid. !> \retval rocsparse_status_invalid_pointer \p alpha, \p A, \p csr_val, !> \p csr_row_ptr, \p csr_col_ind, \p beta, or \p C pointer is invalid. !> !> \par Example !> This example multiplies a column-oriented dense matrix with a CSC matrix. interface rocsparse_sgemmi function rocsparse_sgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr,csr_val, & csr_row_ptr,csr_col_ind,beta,C,ldc) & bind(c, name="rocsparse_sgemmi") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgemmi_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz real(c_float) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind real(c_float) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sgemmi_assumed_rank #else module procedure & rocsparse_sgemmi_rank_0,& rocsparse_sgemmi_rank_1,& rocsparse_sgemmi_full_rank #endif #endif end interface interface rocsparse_dgemmi function rocsparse_dgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr,csr_val, & csr_row_ptr,csr_col_ind,beta,C,ldc) & bind(c, name="rocsparse_dgemmi") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgemmi_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz real(c_double) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind real(c_double) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dgemmi_assumed_rank #else module procedure & rocsparse_dgemmi_rank_0,& rocsparse_dgemmi_rank_1,& rocsparse_dgemmi_full_rank #endif #endif end interface interface rocsparse_cgemmi function rocsparse_cgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr,csr_val, & csr_row_ptr,csr_col_ind,beta,C,ldc) & bind(c, name="rocsparse_cgemmi") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgemmi_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz complex(c_float_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind complex(c_float_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cgemmi_assumed_rank #else module procedure & rocsparse_cgemmi_rank_0,& rocsparse_cgemmi_rank_1,& rocsparse_cgemmi_full_rank #endif #endif end interface interface rocsparse_zgemmi function rocsparse_zgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr,csr_val, & csr_row_ptr,csr_col_ind,beta,C,ldc) & bind(c, name="rocsparse_zgemmi") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgemmi_ type(c_ptr),value :: handle integer(kind(rocsparse_operation_none)),value :: trans_A integer(kind(rocsparse_operation_none)),value :: trans_B integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: k integer(c_int),value :: nnz complex(c_double_complex) :: alpha type(c_ptr),value :: A integer(c_int),value :: lda type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind complex(c_double_complex) :: beta type(c_ptr),value :: C integer(c_int),value :: ldc end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zgemmi_assumed_rank #else module procedure & rocsparse_zgemmi_rank_0,& rocsparse_zgemmi_rank_1,& rocsparse_zgemmi_full_rank #endif #endif end interface !> \ingroup precond_module !> \details !> \p rocsparse_bsric0_zero_pivot returns `rocsparse_status_zero_pivot` if either a !> structural or numerical zero has been found during \ref rocsparse_sbsric0 !> "rocsparse_Xbsric0()" !> computation. The first zero pivot \f$j\f$ at \f$A_{j,j}\f$ is stored in \p position, using !> the same !> index base as the BSR matrix. !> !> \p position can be in host or device memory. If no zero pivot has been found, !> \p position is set to -1 and `rocsparse_status_success` is returned instead. !> !> \note !> If a zero pivot is found, \p position=j means that either the diagonal block \p A(j,j) !> is missing (structural zero) or the diagonal block \p A(j,j) is not positive definite !> (numerical zero). !> !> \note \p rocsparse_bsric0_zero_pivot is a blocking function. It might influence negatively !> performance. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[inout] position - pointer to zero pivot \f$j\f$, which can be in host or device !> memory. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info or \p position pointer is !> invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_zero_pivot zero pivot has been found. interface rocsparse_bsric0_zero_pivot function rocsparse_bsric0_zero_pivot_(handle,myInfo,position) & bind(c, name="rocsparse_bsric0_zero_pivot") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_bsric0_zero_pivot_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int) :: position end function end interface !> \ingroup precond_module !> \details !> \p rocsparse_bsric0_buffer_size returns the size of the temporary storage buffer !> that is required by \ref rocsparse_sbsric0_analysis "rocsparse_Xbsric0_analysis()" and !> \ref rocsparse_sbsric0 "rocsparse_Xbsric0()". The temporary storage buffer must be !> allocated by the user. The size of the temporary storage buffer is identical to the size !> returned by \ref rocsparse_sbsrsv_buffer_size "rocsparse_Xbsrsv_buffer_size()" and !> \ref rocsparse_sbsrilu0_buffer_size "rocsparse_Xbsrilu0_buffer_size()" if the matrix sparsity !> pattern is identical. The user-allocated buffer can therefore be shared between subsequent !> calls !> to those functions. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - direction that specifies whether to count non-zero elements by !> `rocsparse_direction_row` or by !> `rocsparse_direction_column`. !> @param[in] mb - number of block rows in the sparse BSR matrix. !> @param[in] nnzb - number of non-zero block entries of the sparse BSR matrix. !> @param[in] descr - descriptor of the sparse BSR matrix. !> @param[in] bsr_val - array of length \p nnzb*block_dim*block_dim containing the values of the !> sparse BSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse BSR matrix. !> @param[in] bsr_col_ind - array of \p nnzb elements containing the block column indices of the !> sparse BSR matrix. !> @param[in] block_dim - the block dimension of the BSR matrix. Between 1 and m, where \p !> m=mb*block_dim. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> \ref rocsparse_sbsric0_analysis "rocsparse_Xbsric0_analysis()" and !> \ref rocsparse_sbsric0 "rocsparse_Xbsric0()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nnzb, or \p block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p bsr_val, \p bsr_row_ptr, !> \p bsr_col_ind, \p info, or \p buffer_size pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_sbsric0_buffer_size function rocsparse_sbsric0_buffer_size_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) & bind(c, name="rocsparse_sbsric0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsric0_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sbsric0_buffer_size_assumed_rank #else module procedure & rocsparse_sbsric0_buffer_size_rank_0,& rocsparse_sbsric0_buffer_size_rank_1 #endif #endif end interface interface rocsparse_dbsric0_buffer_size function rocsparse_dbsric0_buffer_size_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) & bind(c, name="rocsparse_dbsric0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsric0_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dbsric0_buffer_size_assumed_rank #else module procedure & rocsparse_dbsric0_buffer_size_rank_0,& rocsparse_dbsric0_buffer_size_rank_1 #endif #endif end interface interface rocsparse_cbsric0_buffer_size function rocsparse_cbsric0_buffer_size_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) & bind(c, name="rocsparse_cbsric0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsric0_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cbsric0_buffer_size_assumed_rank #else module procedure & rocsparse_cbsric0_buffer_size_rank_0,& rocsparse_cbsric0_buffer_size_rank_1 #endif #endif end interface interface rocsparse_zbsric0_buffer_size function rocsparse_zbsric0_buffer_size_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) & bind(c, name="rocsparse_zbsric0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsric0_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zbsric0_buffer_size_assumed_rank #else module procedure & rocsparse_zbsric0_buffer_size_rank_0,& rocsparse_zbsric0_buffer_size_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p rocsparse_bsric0_analysis performs the analysis step for !> \ref rocsparse_sbsric0 "rocsparse_Xbsric0()". It is expected that this function will !> be executed only once for a given matrix and particular operation type. The analysis !> metadata can be cleared by `rocsparse_bsric0_clear`(). !> !> \p rocsparse_bsric0_analysis can share its meta data with !> \ref rocsparse_sbsrilu0_analysis "rocsparse_Xbsrilu0_analysis()", !> \ref rocsparse_sbsrsv_analysis "rocsparse_Xbsrsv_analysis()", and !> \ref rocsparse_sbsrsm_analysis "rocsparse_Xbsrsm_analysis()". Selecting !> `rocsparse_analysis_policy_reuse` policy can greatly improve the computation !> performance of metadata. However, the user needs to ensure that the sparsity !> pattern remains unchanged. If this cannot be assured, !> `rocsparse_analysis_policy_force` must be used. !> !> \note !> If the matrix sparsity pattern changes, the gathered information will become invalid. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - direction that specified whether to count non-zero elements by !> `rocsparse_direction_row` or by !> `rocsparse_direction_column`. !> @param[in] mb - number of block rows in the sparse BSR matrix. !> @param[in] nnzb - number of non-zero block entries of the sparse BSR matrix. !> @param[in] descr - descriptor of the sparse BSR matrix. !> @param[in] bsr_val - array of length \p nnzb*block_dim*block_dim containing the values of the !> sparse BSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse BSR matrix. !> @param[in] bsr_col_ind - array of \p nnzb elements containing the block column indices of the !> sparse BSR matrix. !> @param[in] block_dim - the block dimension of the BSR matrix. Between 1 and m, where \p !> m=mb*block_dim. !> @param[out] myInfo - structure that holds the information collected during !> the analysis step. !> @param[in] analysis - `rocsparse_analysis_policy_reuse` or !> `rocsparse_analysis_policy_force`. !> @param[in] solve - `rocsparse_solve_policy_auto`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nnzb, or \p block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p bsr_val, \p bsr_row_ptr, !> \p bsr_col_ind, \p info, or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_sbsric0_analysis function rocsparse_sbsric0_analysis_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_sbsric0_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsric0_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sbsric0_analysis_assumed_rank #else module procedure & rocsparse_sbsric0_analysis_rank_0,& rocsparse_sbsric0_analysis_rank_1 #endif #endif end interface interface rocsparse_dbsric0_analysis function rocsparse_dbsric0_analysis_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_dbsric0_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsric0_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dbsric0_analysis_assumed_rank #else module procedure & rocsparse_dbsric0_analysis_rank_0,& rocsparse_dbsric0_analysis_rank_1 #endif #endif end interface interface rocsparse_cbsric0_analysis function rocsparse_cbsric0_analysis_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_cbsric0_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsric0_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cbsric0_analysis_assumed_rank #else module procedure & rocsparse_cbsric0_analysis_rank_0,& rocsparse_cbsric0_analysis_rank_1 #endif #endif end interface interface rocsparse_zbsric0_analysis function rocsparse_zbsric0_analysis_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_zbsric0_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsric0_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zbsric0_analysis_assumed_rank #else module procedure & rocsparse_zbsric0_analysis_rank_0,& rocsparse_zbsric0_analysis_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p rocsparse_bsric0_clear deallocates all memory that was allocated by !> \ref rocsparse_sbsric0_analysis "rocsparse_Xbsric0_analysis()". This is especially useful !> if memory is an issue and the analysis data is not required for further computation. !> !> \note !> Calling \p rocsparse_bsric0_clear is optional. All allocated resources will be !> cleared when the opaque `rocsparse_mat_info` struct is destroyed using !> `rocsparse_destroy_mat_info`(). !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[inout] myInfo - structure that holds the information collected during the analysis !> step. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info pointer is invalid. !> \retval rocsparse_status_memory_error the buffer holding the meta data could not !> be deallocated. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_bsric0_clear function rocsparse_bsric0_clear_(handle,myInfo) bind(c, name="rocsparse_bsric0_clear") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_bsric0_clear_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo end function end interface !> \ingroup precond_module !> \brief Incomplete Cholesky factorization with 0 fill-ins and no pivoting using the BSR !> storage format. !> !> \details !> \p rocsparse_bsric0 computes the incomplete Cholesky factorization with 0 fill-ins !> and no pivoting of a sparse \f$mb \times mb\f$ BSR matrix \f$A\f$, such that !> \f[ !> A \approx LL^T !> \f] !> !> Computing the above incomplete Cholesky factorization requires three steps to complete. !> First, !> determine the size of the required temporary storage buffer by calling \ref !> rocsparse_sbsric0_buffer_size, !> \ref rocsparse_dbsric0_buffer_size, \ref rocsparse_cbsric0_buffer_size, or \ref !> rocsparse_zbsric0_buffer_size. After !> this buffer size has been determined, allocate the buffer and pass it to \ref !> rocsparse_sbsric0_analysis, !> \ref rocsparse_dbsric0_analysis, \ref rocsparse_cbsric0_analysis, or \ref !> rocsparse_zbsric0_analysis. This will !> perform analysis on the sparsity pattern of the matrix. Finally, call \p rocsparse_sbsric0, !> \p rocsparse_dbsric0, \p rocsparse_cbsric0, or \p rocsparse_zbsric0 to perform the actual !> factorization. The calculation !> of the buffer size and the analysis of the sparse matrix only need to be performed once for a !> given sparsity pattern, !> while the factorization can be repeatedly applied to multiple matrices having the same !> sparsity pattern. After all calls !> to \ref rocsparse_sbsric0 "rocsparse_Xbsric0()" are complete, the temporary buffer can be !> deallocated. !> !> \p rocsparse_bsric0 reports the first zero pivot (either numerical or structural zero). !> The zero pivot status can be obtained by calling `rocsparse_bsric0_zero_pivot`(). !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - direction that specified whether to count non-zero elements by !> `rocsparse_direction_row` or by !> `rocsparse_direction_column`. !> @param[in] mb - number of block rows in the sparse BSR matrix. !> @param[in] nnzb - number of non-zero block entries of the sparse BSR matrix. !> @param[in] descr - descriptor of the sparse BSR matrix. !> @param[inout] bsr_val - array of length \p nnzb*block_dim*block_dim containing the values of !> the sparse BSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse BSR matrix. !> @param[in] bsr_col_ind - array of \p nnzb elements containing the block column indices of the !> sparse BSR matrix. !> @param[in] block_dim - the block dimension of the BSR matrix. Between 1 and m, where \p !> m=mb*block_dim. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] policy - `rocsparse_solve_policy_auto`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nnzb, or \p block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p bsr_val, \p bsr_row_ptr, !> or \p bsr_col_ind pointer is invalid. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> Consider the sparse \f$m \times m\f$ matrix \f$A\f$, stored in BSR !> storage format. The following example computes the incomplete Cholesky factorization !> \f$M \approx LL^T\f$ and solves the preconditioned system \f$My = x\f$. interface rocsparse_sbsric0 function rocsparse_sbsric0_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) & bind(c, name="rocsparse_sbsric0") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsric0_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sbsric0_assumed_rank #else module procedure & rocsparse_sbsric0_rank_0,& rocsparse_sbsric0_rank_1 #endif #endif end interface interface rocsparse_dbsric0 function rocsparse_dbsric0_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) & bind(c, name="rocsparse_dbsric0") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsric0_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dbsric0_assumed_rank #else module procedure & rocsparse_dbsric0_rank_0,& rocsparse_dbsric0_rank_1 #endif #endif end interface interface rocsparse_cbsric0 function rocsparse_cbsric0_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) & bind(c, name="rocsparse_cbsric0") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsric0_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cbsric0_assumed_rank #else module procedure & rocsparse_cbsric0_rank_0,& rocsparse_cbsric0_rank_1 #endif #endif end interface interface rocsparse_zbsric0 function rocsparse_zbsric0_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) & bind(c, name="rocsparse_zbsric0") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsric0_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zbsric0_assumed_rank #else module procedure & rocsparse_zbsric0_rank_0,& rocsparse_zbsric0_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p rocsparse_bsrilu0_zero_pivot returns `rocsparse_status_zero_pivot` if either a !> structural or numerical zero has been found during \ref rocsparse_sbsrilu0 !> "rocsparse_Xbsrilu0()" !> computation. The first zero pivot \f$j\f$ at \f$A_{j,j}\f$ is stored in \p position, using !> the same !> index base as the BSR matrix. !> !> \p position can be in host or device memory. If no zero pivot has been found, !> \p position is set to -1 and `rocsparse_status_success` is returned instead. !> !> \note !> If a zero pivot is found, \p position \f$=j\f$ means that either the diagonal block !> \f$A_{j,j}\f$ is missing (structural zero) or the diagonal block \f$A_{j,j}\f$ is not !> invertible (numerical zero). !> !> \note \p rocsparse_bsrilu0_zero_pivot is a blocking function. It might negatively influence !> performance. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[inout] position - pointer to zero pivot \f$j\f$, which can be in host or device !> memory. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info or \p position pointer is !> invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_zero_pivot zero pivot has been found. interface rocsparse_bsrilu0_zero_pivot function rocsparse_bsrilu0_zero_pivot_(handle,myInfo,position) & bind(c, name="rocsparse_bsrilu0_zero_pivot") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_bsrilu0_zero_pivot_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int) :: position end function end interface !> \ingroup precond_module !> \details !> \p rocsparse_bsrilu0_numeric_boost enables the user to replace a numerical value in !> an incomplete LU factorization. \p tol is used to determine whether a numerical value !> is replaced by \p boost_val, such that \f$A_{j,j} = \text{boost_val}\f$ if !> \f$\text{tol} ≥ \left|A_{j,j}\right|\f$. !> !> \note The boost value is enabled by setting \p enable_boost to 1 or disabled by !> setting \p enable_boost to 0. !> !> \note \p tol and \p boost_val can be in host or device memory. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] enable_boost - enable/disable numeric boost. !> @param[in] boost_tol - tolerance to determine whether a numerical value is replaced or not. !> @param[in] boost_val - boost value to replace a numerical value. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info, \p tol, or \p boost_val pointer !> is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_sbsrilu0_numeric_boost function rocsparse_sbsrilu0_numeric_boost_(handle,myInfo,enable_boost,boost_tol,boost_val) & bind(c, name="rocsparse_sbsrilu0_numeric_boost") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrilu0_numeric_boost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_float) :: boost_tol real(c_float) :: boost_val end function end interface interface rocsparse_dbsrilu0_numeric_boost function rocsparse_dbsrilu0_numeric_boost_(handle,myInfo,enable_boost,boost_tol,boost_val) & bind(c, name="rocsparse_dbsrilu0_numeric_boost") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrilu0_numeric_boost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_double) :: boost_tol real(c_double) :: boost_val end function end interface interface rocsparse_cbsrilu0_numeric_boost function rocsparse_cbsrilu0_numeric_boost_(handle,myInfo,enable_boost,boost_tol,boost_val) & bind(c, name="rocsparse_cbsrilu0_numeric_boost") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrilu0_numeric_boost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_float) :: boost_tol complex(c_float_complex) :: boost_val end function end interface interface rocsparse_zbsrilu0_numeric_boost function rocsparse_zbsrilu0_numeric_boost_(handle,myInfo,enable_boost,boost_tol,boost_val) & bind(c, name="rocsparse_zbsrilu0_numeric_boost") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrilu0_numeric_boost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_double) :: boost_tol complex(c_double_complex) :: boost_val end function end interface interface rocsparse_dsbsrilu0_numeric_boost function rocsparse_dsbsrilu0_numeric_boost_(handle,myInfo,enable_boost,boost_tol,boost_val) & bind(c, name="rocsparse_dsbsrilu0_numeric_boost") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dsbsrilu0_numeric_boost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_double) :: boost_tol real(c_float) :: boost_val end function end interface interface rocsparse_dcbsrilu0_numeric_boost function rocsparse_dcbsrilu0_numeric_boost_(handle,myInfo,enable_boost,boost_tol,boost_val) & bind(c, name="rocsparse_dcbsrilu0_numeric_boost") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcbsrilu0_numeric_boost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_double) :: boost_tol complex(c_float_complex) :: boost_val end function end interface !> \ingroup precond_module !> \details !> \p rocsparse_bsrilu0_buffer_size returns the size of the temporary storage buffer !> that is required by \ref rocsparse_sbsrilu0_analysis "rocsparse_Xbsrilu0_analysis()" and !> \ref rocsparse_sbsrilu0 "rocsparse_Xbsrilu0()". The temporary storage buffer must be !> allocated !> by the user. The size of the temporary storage buffer is identical to the size returned by !> \ref rocsparse_sbsrsv_buffer_size "rocsparse_Xbsrsv_buffer_size()" and !> \ref rocsparse_sbsric0_buffer_size "rocsparse_Xbsric0_buffer_size()" if the matrix sparsity !> pattern is identical. The user-allocated buffer can therefore be shared between subsequent !> calls !> to those functions. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - direction that specifies whether to count non-zero elements by !> `rocsparse_direction_row` or by !> `rocsparse_direction_column`. !> @param[in] mb - number of block rows in the sparse BSR matrix. !> @param[in] nnzb - number of non-zero block entries of the sparse BSR matrix. !> @param[in] descr - descriptor of the sparse BSR matrix. !> @param[in] bsr_val - array of length \p nnzb*block_dim*block_dim containing the values of the !> sparse BSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse BSR matrix. !> @param[in] bsr_col_ind - array of \p nnzb elements containing the block column indices of the !> sparse BSR matrix. !> @param[in] block_dim - the block dimension of the BSR matrix. Between 1 and m, where \p !> m=mb*block_dim. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> \ref rocsparse_sbsrilu0_analysis "rocsparse_Xbsrilu0_analysis()" and !> \ref rocsparse_sbsrilu0 "rocsparse_Xbsrilu0()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nnzb, or \p block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p bsr_val, \p bsr_row_ptr, !> \p bsr_col_ind, \p info, or \p buffer_size pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_sbsrilu0_buffer_size function rocsparse_sbsrilu0_buffer_size_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) & bind(c, name="rocsparse_sbsrilu0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrilu0_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sbsrilu0_buffer_size_assumed_rank #else module procedure & rocsparse_sbsrilu0_buffer_size_rank_0,& rocsparse_sbsrilu0_buffer_size_rank_1 #endif #endif end interface interface rocsparse_dbsrilu0_buffer_size function rocsparse_dbsrilu0_buffer_size_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) & bind(c, name="rocsparse_dbsrilu0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrilu0_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dbsrilu0_buffer_size_assumed_rank #else module procedure & rocsparse_dbsrilu0_buffer_size_rank_0,& rocsparse_dbsrilu0_buffer_size_rank_1 #endif #endif end interface interface rocsparse_cbsrilu0_buffer_size function rocsparse_cbsrilu0_buffer_size_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) & bind(c, name="rocsparse_cbsrilu0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrilu0_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cbsrilu0_buffer_size_assumed_rank #else module procedure & rocsparse_cbsrilu0_buffer_size_rank_0,& rocsparse_cbsrilu0_buffer_size_rank_1 #endif #endif end interface interface rocsparse_zbsrilu0_buffer_size function rocsparse_zbsrilu0_buffer_size_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) & bind(c, name="rocsparse_zbsrilu0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrilu0_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zbsrilu0_buffer_size_assumed_rank #else module procedure & rocsparse_zbsrilu0_buffer_size_rank_0,& rocsparse_zbsrilu0_buffer_size_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p rocsparse_bsrilu0_analysis performs the analysis step for !> \ref rocsparse_sbsrilu0 "rocsparse_Xbsrilu0()". It is expected that this function will !> be executed only once for a given matrix. The analysis metadata can be cleared by !> `rocsparse_bsrilu0_clear`(). !> !> \p rocsparse_bsrilu0_analysis can share its metadata with !> \ref rocsparse_sbsric0_analysis "rocsparse_Xbsric0_analysis()", !> \ref rocsparse_sbsrsv_analysis "rocsparse_Xbsrsv_analysis()", and !> \ref rocsparse_sbsrsm_analysis "rocsparse_Xbsrsm_analysis()". Selecting !> `rocsparse_analysis_policy_reuse` policy can greatly improve the computation !> performance of metadata. However, the user needs to ensure that the sparsity !> pattern remains unchanged. If this cannot be assured, !> `rocsparse_analysis_policy_force` must be used. !> !> \note !> If the matrix sparsity pattern changes, the gathered information will become invalid. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - direction that specified whether to count non-zero elements by !> `rocsparse_direction_row` or by `rocsparse_direction_column`. !> @param[in] mb - number of block rows in the sparse BSR matrix. !> @param[in] nnzb - number of non-zero block entries of the sparse BSR matrix. !> @param[in] descr - descriptor of the sparse BSR matrix. !> @param[in] bsr_val - array of length \p nnzb*block_dim*block_dim containing the values of the !> sparse BSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse BSR matrix. !> @param[in] bsr_col_ind - array of \p nnzb elements containing the block column indices of the !> sparse BSR matrix. !> @param[in] block_dim - the block dimension of the BSR matrix. Between 1 and m, where \p !> m=mb*block_dim. !> @param[out] myInfo - structure that holds the information collected during !> the analysis step. !> @param[in] analysis - `rocsparse_analysis_policy_reuse` or !> `rocsparse_analysis_policy_force`. !> @param[in] solve - `rocsparse_solve_policy_auto`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nnzb, or \p block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p bsr_val, \p bsr_row_ptr, !> \p bsr_col_ind, \p info, or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_sbsrilu0_analysis function rocsparse_sbsrilu0_analysis_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_sbsrilu0_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrilu0_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sbsrilu0_analysis_assumed_rank #else module procedure & rocsparse_sbsrilu0_analysis_rank_0,& rocsparse_sbsrilu0_analysis_rank_1 #endif #endif end interface interface rocsparse_dbsrilu0_analysis function rocsparse_dbsrilu0_analysis_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_dbsrilu0_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrilu0_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dbsrilu0_analysis_assumed_rank #else module procedure & rocsparse_dbsrilu0_analysis_rank_0,& rocsparse_dbsrilu0_analysis_rank_1 #endif #endif end interface interface rocsparse_cbsrilu0_analysis function rocsparse_cbsrilu0_analysis_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_cbsrilu0_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrilu0_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cbsrilu0_analysis_assumed_rank #else module procedure & rocsparse_cbsrilu0_analysis_rank_0,& rocsparse_cbsrilu0_analysis_rank_1 #endif #endif end interface interface rocsparse_zbsrilu0_analysis function rocsparse_zbsrilu0_analysis_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_zbsrilu0_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrilu0_analysis_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zbsrilu0_analysis_assumed_rank #else module procedure & rocsparse_zbsrilu0_analysis_rank_0,& rocsparse_zbsrilu0_analysis_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p rocsparse_bsrilu0_clear deallocates all memory that was allocated by !> \ref rocsparse_sbsrilu0_analysis "rocsparse_Xbsrilu0_analysis()". This is especially useful !> if memory is an issue and the analysis data is not required for further computation. !> !> \note !> Calling \p rocsparse_bsrilu0_clear is optional. All allocated resources will be !> cleared when the opaque `rocsparse_mat_info` struct is destroyed using !> `rocsparse_destroy_mat_info`(). !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[inout] myInfo - structure that holds the information collected during the analysis !> step. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info pointer is invalid. !> \retval rocsparse_status_memory_error the buffer holding the metadata could not !> be deallocated. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_bsrilu0_clear function rocsparse_bsrilu0_clear_(handle,myInfo) bind(c, name="rocsparse_bsrilu0_clear") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_bsrilu0_clear_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo end function end interface !> \ingroup precond_module !> \brief Incomplete LU factorization with 0 fill-ins and no pivoting using the BSR storage !> format !> !> \details !> \p rocsparse_bsrilu0 computes the incomplete LU factorization with 0 fill-ins and no !> pivoting of a sparse \f$mb \times mb\f$ BSR matrix \f$A\f$, such that !> \f[ !> A \approx LU !> \f] !> !> Computing the above incomplete LU factorization requires three steps to complete. First, !> determine the size of the required temporary storage buffer by calling !> \ref rocsparse_sbsrilu0_buffer_size "rocsparse_Xbsrilu0_buffer_size()". After this buffer !> size !> has been determined, allocate the buffer and pass it to !> \ref rocsparse_sbsrilu0_analysis "rocsparse_Xbsrilu0_analysis()". This will perform analysis !> on !> the sparsity pattern of the matrix. Finally, call \p rocsparse_sbsrilu0, \p !> rocsparse_dbsrilu0, !> \p rocsparse_cbsrilu0, or \p rocsparse_zbsrilu0 to perform the actual factorization. The !> calculation of !> the buffer size and the analysis of the sparse matrix only need to be performed once for a !> given sparsity !> pattern, while the factorization can be repeatedly applied to multiple matrices having the !> same sparsity !> pattern. After all calls to \ref rocsparse_sbsrilu0 "rocsparse_Xbsrilu0()" are complete, the !> temporary !> buffer can be deallocated. !> !> \p rocsparse_bsrilu0 reports the first zero pivot (either numerical or structural zero). !> The zero pivot status can be obtained by calling `rocsparse_bsrilu0_zero_pivot`(). !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - direction that specified whether to count non-zero elements by !> `rocsparse_direction_row` or by `rocsparse_direction_column`. !> @param[in] mb - number of block rows in the sparse BSR matrix. !> @param[in] nnzb - number of non-zero block entries of the sparse BSR matrix. !> @param[in] descr - descriptor of the sparse BSR matrix. !> @param[inout] bsr_val - array of length \p nnzb*block_dim*block_dim containing the values of !> the sparse BSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every block row !> of the !> sparse BSR matrix. !> @param[in] bsr_col_ind - array of \p nnzb elements containing the block column indices of the !> sparse BSR matrix. !> @param[in] block_dim - the block dimension of the BSR matrix. Between 1 and m, where \p !> m=mb*block_dim. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] policy - `rocsparse_solve_policy_auto`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p mb, \p nnzb, or \p block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p bsr_val, \p bsr_row_ptr, !> or \p bsr_col_ind pointer is invalid. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> Consider the sparse \f$m \times m\f$ matrix \f$A\f$, stored in the BSR !> storage format. The following example computes the incomplete LU factorization !> \f$M \approx LU\f$ and solves the preconditioned system \f$My = x\f$. interface rocsparse_sbsrilu0 function rocsparse_sbsrilu0_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) & bind(c, name="rocsparse_sbsrilu0") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrilu0_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sbsrilu0_assumed_rank #else module procedure & rocsparse_sbsrilu0_rank_0,& rocsparse_sbsrilu0_rank_1 #endif #endif end interface interface rocsparse_dbsrilu0 function rocsparse_dbsrilu0_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) & bind(c, name="rocsparse_dbsrilu0") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrilu0_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dbsrilu0_assumed_rank #else module procedure & rocsparse_dbsrilu0_rank_0,& rocsparse_dbsrilu0_rank_1 #endif #endif end interface interface rocsparse_cbsrilu0 function rocsparse_cbsrilu0_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) & bind(c, name="rocsparse_cbsrilu0") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrilu0_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cbsrilu0_assumed_rank #else module procedure & rocsparse_cbsrilu0_rank_0,& rocsparse_cbsrilu0_rank_1 #endif #endif end interface interface rocsparse_zbsrilu0 function rocsparse_zbsrilu0_(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) & bind(c, name="rocsparse_zbsrilu0") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrilu0_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nnzb type(c_ptr),value :: descr type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(c_int),value :: block_dim type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zbsrilu0_assumed_rank #else module procedure & rocsparse_zbsrilu0_rank_0,& rocsparse_zbsrilu0_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p rocsparse_csric_zero_pivot returns `rocsparse_status_zero_pivot` if either a !> structural or numerical zero has been found during \ref rocsparse_scsric0 !> "rocsparse_Xcsric0()" !> computation. The first zero pivot \f$j\f$ at \f$A_{j,j}\f$ is stored in \p position, using !> the same index base as the CSR matrix. !> !> \p position can be in host or device memory. If no zero pivot has been found, !> \p position is set to -1 and `rocsparse_status_success` is returned instead. !> !> \note \p rocsparse_csric0_zero_pivot is a blocking function. It might negatively influence !> performance. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[inout] position - pointer to zero pivot \f$j\f$, which can be in host or device !> memory. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info or \p position pointer is !> invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_zero_pivot zero pivot has been found. interface rocsparse_csric0_zero_pivot function rocsparse_csric0_zero_pivot_(handle,myInfo,position) & bind(c, name="rocsparse_csric0_zero_pivot") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csric0_zero_pivot_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int) :: position end function end interface !> \ingroup precond_module !> \details !> rocsparse_csric0_singular_pivot() returns the position of a !> numerical singular pivot (where \f$|L_{j,j}| ≤ \text{tolerance}\f$) !> that has been found during \ref rocsparse_scsric0 "rocsparse_Xcsric0()" computation. !> The first singular pivot \f$j\f$ at \f$L_{j,j}\f$ is stored in \p position, using the !> same index base as the CSR matrix. !> !> \p position can be in host or device memory. If no singular pivot has been found, !> \p position is set to -1. !> !> \note rocsparse_csric0_singular_pivot() is a blocking function. It might negatively influence !> performance. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[inout] position - pointer to singular pivot \f$k\f$, which can be in host or device !> memory. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info or \p position pointer is !> invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_csric0_singular_pivot function rocsparse_csric0_singular_pivot_(handle,myInfo,position) & bind(c, name="rocsparse_csric0_singular_pivot") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csric0_singular_pivot_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo type(c_ptr),value :: position end function end interface !> \ingroup precond_module !> \details !> rocsparse_csric0_set_tolerance() sets the numerical tolerance for detecting a !> numerical singular pivot (where \f$|L_{j,j}| ≤ \text{tolerance}\f$) !> that might be found during \ref rocsparse_scsric0 "rocsparse_Xcsric0()" computation. !> !> !> \note rocsparse_csric0_set_tolerance() is a blocking function. It might negatively influence !> performance. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] tolerance - tolerance for detecting singular pivot (\f$|L_{j,j}| ≤ !> \text{tolerance}\f$). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer if \p info tolerance pointer is !> invalid interface rocsparse_csric0_set_tolerance function rocsparse_csric0_set_tolerance_(handle,myInfo,tolerance) & bind(c, name="rocsparse_csric0_set_tolerance") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csric0_set_tolerance_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo real(c_double),value :: tolerance end function end interface !> \ingroup precond_module !> \details !> rocsparse_csric0_get_tolerance() returns the numerical tolerance for detecting a !> numerical singular pivot (where \f$|L_{j,j}| ≤ \text{tolerance}\f$) !> that might be found during \ref rocsparse_scsric0 "rocsparse_Xcsric0()" computation. !> !> !> \note rocsparse_csric0_get_tolerance() is a blocking function. It might negatively influence !> performance. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[out] tolerance - obtain tolerance for detecting singular pivot (\f$|L_{j,j}| ≤ !> \text{tolerance}\f$). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer if \p info or \p tolerance pointer is !> invalid interface rocsparse_csric0_get_tolerance function rocsparse_csric0_get_tolerance_(handle,myInfo,tolerance) & bind(c, name="rocsparse_csric0_get_tolerance") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csric0_get_tolerance_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo real(c_double) :: tolerance end function end interface !> \ingroup precond_module !> \details !> \p rocsparse_csric0_buffer_size returns the size of the temporary storage buffer !> that is required by \ref rocsparse_scsric0_analysis "rocsparse_Xcsric0_analysis()". !> The temporary storage buffer must be allocated by the user. The size of the temporary !> storage buffer is identical to the size returned by !> \ref rocsparse_scsrsv_buffer_size "rocsparse_Xcsrsv_buffer_size()" and !> \ref rocsparse_scsrilu0_buffer_size "rocsparse_Xcsrilu0_buffer_size()" if the matrix !> sparsity pattern is identical. The user-allocated buffer can therefore be shared between !> subsequent calls to those functions. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descr - descriptor of the sparse CSR matrix. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> \ref rocsparse_scsric0_analysis "rocsparse_Xcsric0_analysis()" and !> \ref rocsparse_scsric0 "rocsparse_Xcsric0()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p csr_val, \p csr_row_ptr, !> \p csr_col_ind, \p info, or \p buffer_size pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_scsric0_buffer_size function rocsparse_scsric0_buffer_size_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,buffer_size) & bind(c, name="rocsparse_scsric0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsric0_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsric0_buffer_size_assumed_rank #else module procedure & rocsparse_scsric0_buffer_size_rank_0,& rocsparse_scsric0_buffer_size_rank_1 #endif #endif end interface interface rocsparse_dcsric0_buffer_size function rocsparse_dcsric0_buffer_size_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,buffer_size) & bind(c, name="rocsparse_dcsric0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsric0_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsric0_buffer_size_assumed_rank #else module procedure & rocsparse_dcsric0_buffer_size_rank_0,& rocsparse_dcsric0_buffer_size_rank_1 #endif #endif end interface interface rocsparse_ccsric0_buffer_size function rocsparse_ccsric0_buffer_size_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,buffer_size) & bind(c, name="rocsparse_ccsric0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsric0_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsric0_buffer_size_assumed_rank #else module procedure & rocsparse_ccsric0_buffer_size_rank_0,& rocsparse_ccsric0_buffer_size_rank_1 #endif #endif end interface interface rocsparse_zcsric0_buffer_size function rocsparse_zcsric0_buffer_size_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,buffer_size) & bind(c, name="rocsparse_zcsric0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsric0_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsric0_buffer_size_assumed_rank #else module procedure & rocsparse_zcsric0_buffer_size_rank_0,& rocsparse_zcsric0_buffer_size_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p rocsparse_csric0_analysis performs the analysis step for !> \ref rocsparse_scsric0 "rocsparse_Xcsric0()". It is expected that this function will be !> executed only once for a given matrix and particular operation type. The analysis metadata !> can be cleared by `rocsparse_csric0_clear`(). !> !> \p rocsparse_csric0_analysis can share its metadata with !> \ref rocsparse_scsrilu0_analysis "rocsparse_Xcsrilu0_analysis()", !> \ref rocsparse_scsrsv_analysis "rocsparse_Xcsrsv_analysis()", and !> \ref rocsparse_scsrsm_analysis "rocsparse_Xcsrsm_analysis()". Selecting !> `rocsparse_analysis_policy_reuse` policy can greatly improve the computation !> performance of metadata. However, the user needs to ensure that the sparsity !> pattern remains unchanged. If this cannot be assured, !> `rocsparse_analysis_policy_force` has to be used. !> !> \note !> If the matrix sparsity pattern changes, the gathered information will become invalid. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descr - descriptor of the sparse CSR matrix. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[out] myInfo - structure that holds the information collected during !> the analysis step. !> @param[in] analysis - `rocsparse_analysis_policy_reuse` or !> `rocsparse_analysis_policy_force`. !> @param[in] solve - `rocsparse_solve_policy_auto`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p csr_val, \p csr_row_ptr, !> \p csr_col_ind, \p info, or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_scsric0_analysis function rocsparse_scsric0_analysis_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_scsric0_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsric0_analysis_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsric0_analysis_assumed_rank #else module procedure & rocsparse_scsric0_analysis_rank_0,& rocsparse_scsric0_analysis_rank_1 #endif #endif end interface interface rocsparse_dcsric0_analysis function rocsparse_dcsric0_analysis_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_dcsric0_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsric0_analysis_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsric0_analysis_assumed_rank #else module procedure & rocsparse_dcsric0_analysis_rank_0,& rocsparse_dcsric0_analysis_rank_1 #endif #endif end interface interface rocsparse_ccsric0_analysis function rocsparse_ccsric0_analysis_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_ccsric0_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsric0_analysis_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsric0_analysis_assumed_rank #else module procedure & rocsparse_ccsric0_analysis_rank_0,& rocsparse_ccsric0_analysis_rank_1 #endif #endif end interface interface rocsparse_zcsric0_analysis function rocsparse_zcsric0_analysis_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_zcsric0_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsric0_analysis_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsric0_analysis_assumed_rank #else module procedure & rocsparse_zcsric0_analysis_rank_0,& rocsparse_zcsric0_analysis_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p rocsparse_csric0_clear deallocates all memory that was allocated by !> \ref rocsparse_scsric0_analysis "rocsparse_Xcsric0_analysis()". This is especially !> useful if memory is an issue and the analysis data is not required for further !> computation. !> !> \note !> Calling \p rocsparse_csric0_clear is optional. All allocated resources will be !> cleared when the opaque `rocsparse_mat_info` struct is destroyed using !> `rocsparse_destroy_mat_info`(). !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[inout] myInfo - structure that holds the information collected during the analysis !> step. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info pointer is invalid. !> \retval rocsparse_status_memory_error the buffer holding the metadata could not !> be deallocated. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_csric0_clear function rocsparse_csric0_clear_(handle,myInfo) bind(c, name="rocsparse_csric0_clear") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csric0_clear_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo end function end interface !> \ingroup precond_module !> \brief Incomplete Cholesky factorization with 0 fill-ins and no pivoting using the CSR !> storage format. !> !> \details !> \p rocsparse_csric0 computes the incomplete Cholesky factorization with 0 fill-ins !> and no pivoting of a sparse \f$m \times m\f$ CSR matrix \f$A\f$, such that !> \f[ !> A \approx LL^T !> \f] !> where the lower triangular matrix \f$L\f$ is computed using: !> \f[ !> L_{ij} = \left\{ !> \begin{array}{ll} !> \sqrt{A_{jj} - \sum_{k=0}^{j-1}(L_{jk})^{2}}, & \text{if i == j} \\% !> \frac{1}{L_{jj}}(A_{ij} - \sum_{k=0}^{j-1}L_{ik} \times L_{jk}), & \text{if i > j} !> \end{array} !> \right. !> \f] !> for each entry found in the CSR matrix \f$A\f$. !> !> Computing the above incomplete Cholesky factorization requires three steps to complete. !> First, !> determine the size of the required temporary storage buffer by calling !> \ref rocsparse_scsric0_buffer_size "rocsparse_Xcsric0_buffer_size()". After this buffer size !> has been determined, !> allocate the buffer and pass it to \ref rocsparse_scsric0_analysis !> "rocsparse_Xcsric0_analysis()". !> This will perform analysis on the sparsity pattern of the matrix. Finally, call \p !> rocsparse_scsric0, !> \p rocsparse_dcsric0, \p rocsparse_ccsric0, or \p rocsparse_zcsric0 to perform the actual !> factorization. The calculation !> of the buffer size and the analysis of the sparse matrix only need to be performed once for a !> given sparsity pattern, !> while the factorization can be repeatedly applied to multiple matrices having the same !> sparsity pattern. After all calls !> to \ref rocsparse_scsric0 "rocsparse_Xcsric0()" are complete, the temporary buffer can be !> deallocated. !> !> When computing the Cholesky factorization, it is possible that \f$L_{jj} == 0\f$, which would !> result in a division by zero. !> This could occur from either \f$A_{jj}\f$ not existing in the sparse CSR matrix (referred to !> as a structural zero) or because !> \f$A_{jj} - \sum_{k=0}^{j-1}(L_{jk})^{2} == 0\f$ (referred to as a numerical zero). For !> example, running the Cholesky !> factorization on the following matrix: !> \f[ !> \begin{bmatrix} !> 2 & 1 & 0 \\% !> 1 & 2 & 1 \\% !> 0 & 1 & 2 !> \end{bmatrix} !> \f] !> results in a successful Cholesky factorization, however running with the matrix: !> \f[ !> \begin{bmatrix} !> 2 & 1 & 0 \\% !> 1 & 1/2 & 1 \\% !> 0 & 1 & 2 !> \end{bmatrix} !> \f] !> results in a numerical zero because: !> \f[ !> \begin{array}{ll} !> L_{00} &= \sqrt{2} \\% !> L_{10} &= \frac{1}{\sqrt{2}} \\% !> L_{11} &= \sqrt{\frac{1}{2} - (\frac{1}{\sqrt{2}})^2} !> &= 0 !> \end{array} !> \f] !> The user can detect the presence of a structural zero by calling !> `rocsparse_csric0_zero_pivot` () after !> \ref rocsparse_scsric0_analysis "rocsparse_Xcsric0_analysis()" and/or the presence of a !> structural or !> numerical zero by calling `rocsparse_csric0_zero_pivot` () after \ref rocsparse_scsric0 !> "rocsparse_Xcsric0()": !> \code{.c} !> rocsparse_dcsric0(handle, !> m, !> nnz, !> descr_M, !> csr_val, !> csr_row_ptr, !> csr_col_ind, !> info, !> rocsparse_solve_policy_auto, !> temp_buffer); !> !> // Check for zero pivot !> if(rocsparse_status_zero_pivot == rocsparse_csric0_zero_pivot(handle, !> info, !> &position)) !> { !> printf("L has structural and/or numerical zero at L(%d,%d)", position, position); !> } !> \endcode !> In both cases, `rocsparse_csric0_zero_pivot` () will report the first zero pivot (either !> numerical or structural) !> found. See the full example below. The user can also set the diagonal type to be \f$1\f$ !> using `rocsparse_set_mat_diag_type` (), !> which will interpret the matrix \f$A\f$ as having ones on its diagonal (even if no non-zero !> exists in the sparsity pattern). !> !> \p rocsparse_csric0 computes the Cholesky factorization inplace, meaning that the values !> array \p csr_val of the \f$A\f$ !> matrix is overwritten with the \f$L\f$ matrix stored in the lower triangular part of \f$A\f$: !> !> \f[ !> \begin{align} !> \begin{bmatrix} !> a_{00} & a_{01} & a_{02} \\% !> a_{10} & a_{11} & a_{12} \\% !> a_{20} & a_{21} & a_{22} !> \end{bmatrix} !> \rightarrow !> \begin{bmatrix} !> l_{00} & a_{01} & a_{02} \\% !> l_{10} & l_{11} & a_{12} \\% !> l_{20} & l_{21} & l_{22} !> \end{bmatrix} !> \end{align} !> \f] !> The row pointer array \p csr_row_ptr and the column indices array \p csr_col_ind remain the !> same for \f$A\f$ and the output, as !> the incomplete factorization does not generate new non-zeros in the output which do not !> already exist in \f$A\f$. !> !> The performance of computing the Cholesky factorization with rocSPARSE greatly depends on the !> sparsity pattern !> of the matrix \f$A\f$, as this is what determines the amount of parallelism available. !> !> \note !> The sparse CSR matrix has to be sorted. This can be achieved by calling !> `rocsparse_csrsort()`. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descr - descriptor of the sparse CSR matrix. !> @param[inout] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start !> of every row of the sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] policy - `rocsparse_solve_policy_auto`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p csr_val, \p csr_row_ptr, !> or \p csr_col_ind pointer is invalid. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> Consider the sparse \f$m \times m\f$ matrix \f$A\f$, stored in the CSR !> storage format. The following example computes the incomplete Cholesky factorization !> \f$M \approx LL^T\f$ and solves the preconditioned system \f$My = x\f$. interface rocsparse_scsric0 function rocsparse_scsric0_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,policy, & temp_buffer) & bind(c, name="rocsparse_scsric0") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsric0_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsric0_assumed_rank #else module procedure & rocsparse_scsric0_rank_0,& rocsparse_scsric0_rank_1 #endif #endif end interface interface rocsparse_dcsric0 function rocsparse_dcsric0_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,policy, & temp_buffer) & bind(c, name="rocsparse_dcsric0") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsric0_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsric0_assumed_rank #else module procedure & rocsparse_dcsric0_rank_0,& rocsparse_dcsric0_rank_1 #endif #endif end interface interface rocsparse_ccsric0 function rocsparse_ccsric0_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,policy, & temp_buffer) & bind(c, name="rocsparse_ccsric0") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsric0_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsric0_assumed_rank #else module procedure & rocsparse_ccsric0_rank_0,& rocsparse_ccsric0_rank_1 #endif #endif end interface interface rocsparse_zcsric0 function rocsparse_zcsric0_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,policy, & temp_buffer) & bind(c, name="rocsparse_zcsric0") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsric0_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsric0_assumed_rank #else module procedure & rocsparse_zcsric0_rank_0,& rocsparse_zcsric0_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p rocsparse_csrilu0_zero_pivot returns `rocsparse_status_zero_pivot` if either a !> structural or numerical zero has been found during \ref rocsparse_scsrilu0 !> "rocsparse_Xcsrilu0()" !> computation. The first zero pivot \f$j\f$ at \f$A_{j,j}\f$ is stored in \p position, using !> the same index !> base as the CSR matrix. !> !> \p position can be in host or device memory. If no zero pivot has been found, !> \p position is set to -1 and `rocsparse_status_success` is returned instead. !> !> \note \p rocsparse_csrilu0_zero_pivot is a blocking function. It might negatively influence !> performance. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[inout] position - pointer to zero pivot \f$j\f$, which can be in host or device !> memory. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info or \p position pointer is !> invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_zero_pivot zero pivot has been found. interface rocsparse_csrilu0_zero_pivot function rocsparse_csrilu0_zero_pivot_(handle,myInfo,position) & bind(c, name="rocsparse_csrilu0_zero_pivot") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrilu0_zero_pivot_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int) :: position end function end interface !> \ingroup precond_module !> \details !> rocsparse_csrilu0_set_tolerance() sets the numerical tolerance for detecting a !> near numerical zero entry during \ref rocsparse_scsrilu0 "rocsparse_Xcsrilu0()" !> computation. The first singular pivot \f$j\f$ at \f$|A_{j,j}| ≤ \text{tolerance}\f$. !> !> !> \note rocsparse_csrilu0_set_tolerance() is a blocking function. It might negatively influence !> performance. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] tolerance - tolerance value to determine singular pivot \f$|A_{j,j}| ≤ !> \text{tolerance}\f$, !> where variable tolerance is in host memory. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_csrilu0_set_tolerance function rocsparse_csrilu0_set_tolerance_(handle,myInfo,tolerance) & bind(c, name="rocsparse_csrilu0_set_tolerance") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrilu0_set_tolerance_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo real(c_double),value :: tolerance end function end interface !> \ingroup precond_module !> \details !> rocsparse_csrilu0_get_tolerance() returns the numerical tolerance for detecting !> a near numerical zero entry during \ref rocsparse_scsrilu0 "rocsparse_Xcsrilu0()" !> computation. The first singular pivot \f$j\f$ at \f$|A_{j,j}| ≤ \text{tolerance}\f$. !> !> \note rocsparse_csrilu0_get_tolerance() is a blocking function. It might negatively influence !> performance. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[out] tolerance - obtain tolerance value to determine the singular pivot \f$|A_{j,j}| !> ≤ \text{tolerance}\f$, !> where variable tolerance is in host memory. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info or tolerance pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_csrilu0_get_tolerance function rocsparse_csrilu0_get_tolerance_(handle,myInfo,tolerance) & bind(c, name="rocsparse_csrilu0_get_tolerance") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrilu0_get_tolerance_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo real(c_double) :: tolerance end function end interface !> \ingroup precond_module !> \details !> rocsparse_csrilu0_singular_pivot() returns the position of a !> near numerical zero entry that has been found during \ref rocsparse_scsrilu0 !> "rocsparse_Xcsrilu0()" !> computation. The first singular pivot \f$j\f$ at \f$|A_{j,j}| ≤ \text{tolerance}\f$ is !> stored !> in \p position, using the same index base as the CSR matrix. !> !> \p position can be in host or device memory. If no singular pivot has been found, !> \p position is set to -1. !> !> \note rocsparse_csrilu0_singular_pivot() is a blocking function. It might influence !> performance negatively. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[inout] position - pointer to singular pivot \f$j\f$, which can be in host or device !> memory. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info or \p position pointer is !> invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_csrilu0_singular_pivot function rocsparse_csrilu0_singular_pivot_(handle,myInfo,position) & bind(c, name="rocsparse_csrilu0_singular_pivot") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrilu0_singular_pivot_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo type(c_ptr),value :: position end function end interface !> \ingroup precond_module !> \details !> \p rocsparse_csrilu0_numeric_boost enables the user to replace a numerical value in !> an incomplete LU factorization. \p tol is used to determine whether a numerical value !> is replaced by \p boost_val, such that \f$A_{j,j} = \text{boost_val}\f$ if !> \f$\text{tol} ≥ \left|A_{j,j}\right|\f$. !> !> \note The boost value is enabled by setting \p enable_boost to 1 or disabled by !> setting \p enable_boost to 0. !> !> \note \p tol and \p boost_val can be in host or device memory. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] enable_boost - enable/disable numeric boost. !> @param[in] boost_tol - tolerance to determine whether a numerical value is replaced or not. !> @param[in] boost_val - boost value to replace a numerical value. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info, \p tol, or \p boost_val pointer !> is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_scsrilu0_numeric_boost function rocsparse_scsrilu0_numeric_boost_(handle,myInfo,enable_boost,boost_tol,boost_val) & bind(c, name="rocsparse_scsrilu0_numeric_boost") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrilu0_numeric_boost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_float) :: boost_tol real(c_float) :: boost_val end function end interface interface rocsparse_dcsrilu0_numeric_boost function rocsparse_dcsrilu0_numeric_boost_(handle,myInfo,enable_boost,boost_tol,boost_val) & bind(c, name="rocsparse_dcsrilu0_numeric_boost") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrilu0_numeric_boost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_double) :: boost_tol real(c_double) :: boost_val end function end interface interface rocsparse_ccsrilu0_numeric_boost function rocsparse_ccsrilu0_numeric_boost_(handle,myInfo,enable_boost,boost_tol,boost_val) & bind(c, name="rocsparse_ccsrilu0_numeric_boost") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrilu0_numeric_boost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_float) :: boost_tol complex(c_float_complex) :: boost_val end function end interface interface rocsparse_zcsrilu0_numeric_boost function rocsparse_zcsrilu0_numeric_boost_(handle,myInfo,enable_boost,boost_tol,boost_val) & bind(c, name="rocsparse_zcsrilu0_numeric_boost") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrilu0_numeric_boost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_double) :: boost_tol complex(c_double_complex) :: boost_val end function end interface interface rocsparse_dscsrilu0_numeric_boost function rocsparse_dscsrilu0_numeric_boost_(handle,myInfo,enable_boost,boost_tol,boost_val) & bind(c, name="rocsparse_dscsrilu0_numeric_boost") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dscsrilu0_numeric_boost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_double) :: boost_tol real(c_float) :: boost_val end function end interface interface rocsparse_dccsrilu0_numeric_boost function rocsparse_dccsrilu0_numeric_boost_(handle,myInfo,enable_boost,boost_tol,boost_val) & bind(c, name="rocsparse_dccsrilu0_numeric_boost") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dccsrilu0_numeric_boost_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo integer(c_int),value :: enable_boost real(c_double) :: boost_tol complex(c_float_complex) :: boost_val end function end interface !> \ingroup precond_module !> \details !> \p rocsparse_csrilu0_buffer_size returns the size of the temporary storage buffer !> that is required by \ref rocsparse_scsrilu0_analysis "rocsparse_Xcsrilu0_analysis()" and !> \ref rocsparse_scsrilu0 "rocsparse_Xcsrilu0()". The temporary storage buffer must be !> allocated !> by the user. The size of the temporary storage buffer is identical to the size returned by !> \ref rocsparse_scsrsv_buffer_size "rocsparse_Xcsrsv_buffer_size()" if the matrix sparsity !> pattern !> is identical. The user-allocated buffer can therefore be shared between subsequent calls to !> those functions. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descr - descriptor of the sparse CSR matrix. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[out] myInfo - structure that holds the information collected during the analysis step. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> \ref rocsparse_scsrilu0_analysis "rocsparse_Xcsrilu0_analysis()" and !> \ref rocsparse_scsrilu0 "rocsparse_Xcsrilu0()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p csr_val, \p csr_row_ptr, !> \p csr_col_ind, \p info, or \p buffer_size pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_scsrilu0_buffer_size function rocsparse_scsrilu0_buffer_size_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,buffer_size) & bind(c, name="rocsparse_scsrilu0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrilu0_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsrilu0_buffer_size_assumed_rank #else module procedure & rocsparse_scsrilu0_buffer_size_rank_0,& rocsparse_scsrilu0_buffer_size_rank_1 #endif #endif end interface interface rocsparse_dcsrilu0_buffer_size function rocsparse_dcsrilu0_buffer_size_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,buffer_size) & bind(c, name="rocsparse_dcsrilu0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrilu0_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsrilu0_buffer_size_assumed_rank #else module procedure & rocsparse_dcsrilu0_buffer_size_rank_0,& rocsparse_dcsrilu0_buffer_size_rank_1 #endif #endif end interface interface rocsparse_ccsrilu0_buffer_size function rocsparse_ccsrilu0_buffer_size_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,buffer_size) & bind(c, name="rocsparse_ccsrilu0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrilu0_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsrilu0_buffer_size_assumed_rank #else module procedure & rocsparse_ccsrilu0_buffer_size_rank_0,& rocsparse_ccsrilu0_buffer_size_rank_1 #endif #endif end interface interface rocsparse_zcsrilu0_buffer_size function rocsparse_zcsrilu0_buffer_size_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,buffer_size) & bind(c, name="rocsparse_zcsrilu0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrilu0_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsrilu0_buffer_size_assumed_rank #else module procedure & rocsparse_zcsrilu0_buffer_size_rank_0,& rocsparse_zcsrilu0_buffer_size_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p rocsparse_csrilu0_analysis performs the analysis step for \ref rocsparse_scsrilu0 !> "rocsparse_Xcsrilu0()". !> It is expected that this function will be executed only once for a given matrix and !> particular !> operation type. The analysis metadata can be cleared by `rocsparse_csrilu0_clear`(). !> !> \p rocsparse_csrilu0_analysis can share its meta data with !> \ref rocsparse_scsric0_analysis "rocsparse_Xcsric0_analysis()", !> \ref rocsparse_scsrsv_analysis "rocsparse_Xcsrsv_analysis()", and !> \ref rocsparse_scsrsm_analysis "rocsparse_Xcsrsm_analysis()". Selecting !> `rocsparse_analysis_policy_reuse` policy can greatly improve the computation !> performance of metadata. However, the user needs to ensure that the sparsity !> pattern remains unchanged. If this cannot be assured, !> `rocsparse_analysis_policy_force` must be used. !> !> \note !> If the matrix sparsity pattern changes, the gathered information will become invalid. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descr - descriptor of the sparse CSR matrix. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[out] myInfo - structure that holds the information collected during !> the analysis step. !> @param[in] analysis - `rocsparse_analysis_policy_reuse` or !> `rocsparse_analysis_policy_force`. !> @param[in] solve - `rocsparse_solve_policy_auto`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p csr_val, \p csr_row_ptr, !> \p csr_col_ind, \p info, or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. interface rocsparse_scsrilu0_analysis function rocsparse_scsrilu0_analysis_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_scsrilu0_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrilu0_analysis_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsrilu0_analysis_assumed_rank #else module procedure & rocsparse_scsrilu0_analysis_rank_0,& rocsparse_scsrilu0_analysis_rank_1 #endif #endif end interface interface rocsparse_dcsrilu0_analysis function rocsparse_dcsrilu0_analysis_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_dcsrilu0_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrilu0_analysis_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsrilu0_analysis_assumed_rank #else module procedure & rocsparse_dcsrilu0_analysis_rank_0,& rocsparse_dcsrilu0_analysis_rank_1 #endif #endif end interface interface rocsparse_ccsrilu0_analysis function rocsparse_ccsrilu0_analysis_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_ccsrilu0_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrilu0_analysis_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsrilu0_analysis_assumed_rank #else module procedure & rocsparse_ccsrilu0_analysis_rank_0,& rocsparse_ccsrilu0_analysis_rank_1 #endif #endif end interface interface rocsparse_zcsrilu0_analysis function rocsparse_zcsrilu0_analysis_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) & bind(c, name="rocsparse_zcsrilu0_analysis") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrilu0_analysis_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_analysis_policy_reuse)),value :: analysis integer(kind(rocsparse_solve_policy_auto)),value :: solve type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsrilu0_analysis_assumed_rank #else module procedure & rocsparse_zcsrilu0_analysis_rank_0,& rocsparse_zcsrilu0_analysis_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p rocsparse_csrilu0_clear deallocates all memory that was allocated by !> \ref rocsparse_scsrilu0_analysis "rocsparse_Xcsrilu0_analysis()". This is especially !> useful if memory is an issue and the analysis data is not required for further !> computation. !> !> \note !> Calling \p rocsparse_csrilu0_clear is optional. All allocated resources will be !> cleared when the opaque `rocsparse_mat_info` struct is destroyed using !> `rocsparse_destroy_mat_info`(). !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[inout] myInfo - structure that holds the information collected during the analysis !> step. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p info pointer is invalid. !> \retval rocsparse_status_memory_error the buffer holding the metadata could not !> be deallocated. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_csrilu0_clear function rocsparse_csrilu0_clear_(handle,myInfo) bind(c, name="rocsparse_csrilu0_clear") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrilu0_clear_ type(c_ptr),value :: handle type(c_ptr),value :: myInfo end function end interface !> \ingroup precond_module !> \brief Incomplete LU factorization with 0 fill-ins and no pivoting using the CSR !> storage format. !> !> \details !> \p rocsparse_csrilu0 computes the incomplete LU factorization with 0 fill-ins and no !> pivoting of a sparse \f$m \times m\f$ CSR matrix \f$A\f$, such that !> \f[ !> A \approx LU !> \f] !> where the lower triangular matrix \f$L\f$ and the upper triangular matrix \f$U\f$ are !> computed using: !> \f[ !> \begin{array}{ll} !> L_{ij} = \frac{1}{U_{jj}}(A_{ij} - \sum_{k=0}^{j-1}L_{ik} \times U_{kj}), & \text{if i !> > j} \\% !> U_{ij} = (A_{ij} - \sum_{k=0}^{j-1}L_{ik} \times U_{kj}), & \text{if i <= j} !> \end{array} !> \f] !> for each entry found in the CSR matrix \f$A\f$. !> !> Computing the above incomplete \f$LU\f$ factorization requires three steps to complete. !> First, !> determine the size of the required temporary storage buffer by calling !> \ref rocsparse_scsrilu0_buffer_size "rocsparse_Xcsrilu0_buffer_size()". After this buffer !> size has been determined, !> allocate the buffer and pass it to \ref rocsparse_scsrilu0_analysis !> "rocsparse_Xcsrilu0_analysis()". !> This will perform analysis on the sparsity pattern of the matrix. Finally, call \p !> rocsparse_scsrilu0, !> \p rocsparse_dcsrilu0, \p rocsparse_ccsrilu0, or \p rocsparse_zcsrilu0 to perform the actual !> factorization. The calculation !> of the buffer size and the analysis of the sparse matrix only need to be performed once for a !> given sparsity pattern !> while the factorization can be repeatedly applied to multiple matrices having the same !> sparsity pattern. After all calls !> to \ref rocsparse_scsrilu0 "rocsparse_Xcsrilu0()" are complete, the temporary buffer can be !> deallocated. !> !> When computing the \f$LU\f$ factorization, it is possible that \f$U_{jj} == 0\f$, which would !> result in a division by zero. !> This could occur from either \f$A_{jj}\f$ not existing in the sparse CSR matrix (referred to !> as a structural zero) or because !> \f$A_{ij} - \sum_{k=0}^{j-1}L_{ik} \times U_{kj} == 0\f$ (referred to as a numerical zero). !> For example, running the !> \f$LU\f$ factorization on the following matrix: !> \f[ !> \begin{bmatrix} !> 2 & 1 & 0 \\% !> 1 & 2 & 1 \\% !> 0 & 1 & 2 !> \end{bmatrix} !> \f] !> results in a successful \f$LU\f$ factorization. However, running with the matrix: !> \f[ !> \begin{bmatrix} !> 2 & 1 & 0 \\% !> 1 & 1/2 & 1 \\% !> 0 & 1 & 2 !> \end{bmatrix} !> \f] !> results in a numerical zero because: !> \f[ !> \begin{array}{ll} !> U_{00} &= 2 \\% !> U_{01} &= 1 \\% !> L_{10} &= \frac{1}{2} \\% !> U_{11} &= \frac{1}{2} - \frac{1}{2} !> &= 0 !> \end{array} !> \f] !> The user can detect the presence of a structural zero by calling !> `rocsparse_csrilu0_zero_pivot` () after !> \ref rocsparse_scsrilu0_analysis "rocsparse_Xcsrilu0_analysis()" and/or the presence of a !> structural or !> numerical zero by calling `rocsparse_csrilu0_zero_pivot` () after \ref rocsparse_scsrilu0 !> "rocsparse_Xcsric0()". !> In both cases, `rocsparse_csrilu0_zero_pivot` () will report the first zero pivot (either !> numerical or structural) !> found. See the example below. The user can also set the diagonal type to be \f$1\f$ using !> `rocsparse_set_mat_diag_type` (), !> which will interpret the matrix \f$A\f$ as having ones on its diagonal (even if no non-zero !> exists in the sparsity pattern). !> !> \p rocsparse_csrilu0 computes the \f$LU\f$ factorization inplace, meaning that the values !> array \p csr_val of the \f$A\f$ !> matrix is overwritten with the \f$L\f$ matrix stored in the strictly lower triangular part of !> \f$A\f$ and the \f$U\f$ matrix !> stored in the upper part of \f$A\f$: !> !> \f[ !> \begin{align} !> \begin{bmatrix} !> a_{00} & a_{01} & a_{02} \\% !> a_{10} & a_{11} & a_{12} \\% !> a_{20} & a_{21} & a_{22} !> \end{bmatrix} !> \rightarrow !> \begin{bmatrix} !> u_{00} & u_{01} & u_{02} \\% !> l_{10} & u_{11} & u_{12} \\% !> l_{20} & l_{21} & u_{22} !> \end{bmatrix} !> \end{align} !> \f] !> The row pointer array \p csr_row_ptr and the column indices array \p csr_col_ind remain the !> same for \f$A\f$ and \f$LU\f$, as !> the incomplete factorization does not generate new non-zeros in \f$LU\f$ which do not already !> exist in \f$A\f$. !> !> The performance of computing \f$LU\f$ factorization with rocSPARSE greatly depends on the !> sparsity pattern !> the the matrix \f$A\f$, as this is what determines the amount of parallelism available. !> !> \note !> The sparse CSR matrix has to be sorted. This can be achieved by calling !> `rocsparse_csrsort()`. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] descr - descriptor of the sparse CSR matrix. !> @param[inout] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start !> of every row of the sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[in] myInfo - structure that holds the information collected during the analysis step. !> @param[in] policy - `rocsparse_solve_policy_auto`. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p csr_val, \p csr_row_ptr, !> or \p csr_col_ind pointer is invalid. !> \retval rocsparse_status_arch_mismatch the device is not supported. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_not_implemented !> `rocsparse_matrix_type` != `rocsparse_matrix_type_general`. !> !> \par Example !> Consider the sparse \f$m \times m\f$ matrix \f$A\f$, stored in CSR !> storage format. The following example computes the incomplete LU factorization !> \f$M \approx LU\f$ and solves the preconditioned system \f$My = x\f$. interface rocsparse_scsrilu0 function rocsparse_scsrilu0_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,policy, & temp_buffer) & bind(c, name="rocsparse_scsrilu0") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrilu0_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsrilu0_assumed_rank #else module procedure & rocsparse_scsrilu0_rank_0,& rocsparse_scsrilu0_rank_1 #endif #endif end interface interface rocsparse_dcsrilu0 function rocsparse_dcsrilu0_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,policy, & temp_buffer) & bind(c, name="rocsparse_dcsrilu0") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrilu0_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsrilu0_assumed_rank #else module procedure & rocsparse_dcsrilu0_rank_0,& rocsparse_dcsrilu0_rank_1 #endif #endif end interface interface rocsparse_ccsrilu0 function rocsparse_ccsrilu0_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,policy, & temp_buffer) & bind(c, name="rocsparse_ccsrilu0") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrilu0_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsrilu0_assumed_rank #else module procedure & rocsparse_ccsrilu0_rank_0,& rocsparse_ccsrilu0_rank_1 #endif #endif end interface interface rocsparse_zcsrilu0 function rocsparse_zcsrilu0_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,policy, & temp_buffer) & bind(c, name="rocsparse_zcsrilu0") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrilu0_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: myInfo integer(kind(rocsparse_solve_policy_auto)),value :: policy type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsrilu0_assumed_rank #else module procedure & rocsparse_zcsrilu0_rank_0,& rocsparse_zcsrilu0_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p rocsparse_csritilu0_buffer_size computes the size in bytes of the buffer that must be !> allocated by the user. !> This buffer is then used in \ref rocsparse_csritilu0_preprocess, \ref !> rocsparse_scsritilu0_compute "rocsparse_Xcsritilu0_compute()", !> \ref rocsparse_scsritilu0_compute_ex "rocsparse_Xcsritilu0_compute_ex()", and \ref !> rocsparse_scsritilu0_history "rocsparse_Xcsritilu0_history()". !> !> \note !> The sparse CSR matrix has to be sorted. This can be achieved by calling !> `rocsparse_csrsort()`. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] alg - algorithm to use, `rocsparse_itilu0_alg`. !> @param[in] option - combination of enumeration values from `rocsparse_itilu0_option`. !> @param[in] nmaxiter - maximum number of iterations. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start !> of every row of the sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] datatype - Type of numerical values, `rocsparse_datatype`. !> @param[out] buffer_size - size of the temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_value \p alg, \p base, or datatype is invalid. !> \retval rocsparse_status_invalid_pointer \p csr_row_ptr !> or \p csr_col_ind pointer is invalid. !> \retval rocsparse_status_zero_pivot if nnz is zero. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_csritilu0_buffer_size function rocsparse_csritilu0_buffer_size_(handle,alg,option,nmaxiter,m,nnz,csr_row_ptr, & csr_col_ind,idx_base,datatype,buffer_size) & bind(c, name="rocsparse_csritilu0_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csritilu0_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_itilu0_alg_default)),value :: alg integer(c_int),value :: option integer(c_int),value :: nmaxiter integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_datatype_f16_r)),value :: datatype integer(c_size_t) :: buffer_size end function end interface !> \ingroup precond_module !> \details !> \p rocsparse_csritilu0_preprocess computes the information required to run \ref !> rocsparse_scsritilu0_compute "rocsparse_Xcsritilu0_compute()" !> and \ref rocsparse_scsritilu0_compute_ex "rocsparse_Xcsritilu0_compute_ex()" and stores it in !> the buffer. !> !> \note !> The sparse CSR matrix has to be sorted. This can be achieved by calling !> `rocsparse_csrsort()`. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] alg - algorithm to use, `rocsparse_itilu0_alg`. !> @param[in] option - combination of enumeration values from `rocsparse_itilu0_option`. !> @param[in] nmaxiter - maximum number of iterations. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start !> of every row of the sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] datatype - type of numerical values, `rocsparse_datatype`. !> @param[in] buffer_size - size of the storage buffer allocated by the user. !> @param[in] buffer - storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p alg, \p base, or datatype is invalid. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p csr_row_ptr !> or \p csr_col_ind pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> \retval rocsparse_status_zero_pivot if a missing diagonal element is detected. interface rocsparse_csritilu0_preprocess function rocsparse_csritilu0_preprocess_(handle,alg,option,nmaxiter,m,nnz,csr_row_ptr, & csr_col_ind,idx_base,datatype,buffer_size,buffer) & bind(c, name="rocsparse_csritilu0_preprocess") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csritilu0_preprocess_ type(c_ptr),value :: handle integer(kind(rocsparse_itilu0_alg_default)),value :: alg integer(c_int),value :: option integer(c_int),value :: nmaxiter integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_datatype_f16_r)),value :: datatype integer(c_size_t),value :: buffer_size type(c_ptr),value :: buffer end function end interface !> \ingroup precond_module !> \brief Iterative Incomplete LU factorization with 0 fill-ins and no pivoting using the CSR !> storage format. !> !> \details !> \p rocsparse_csritilu0_compute computes iteratively the incomplete LU factorization with 0 !> fill-ins and no !> pivoting of a sparse \f$m \times m\f$ CSR matrix \f$A\f$, such that !> \f[ !> A \approx (L + Id)(D + U) !> \f] !> !> The following notation applies for the equations below: diag is the diagonal part, lower is !> the strict lower triangular part, and upper is the strict upper triangular part of a given !> matrix. !> Starting with \f$L_{0} = lower(\f$ \p ilu0 \f$)\f$ and \f$U_{0} = upper(\f$ \p ilu0 \f$)\f$, !> the method iterates with !> \f[ !> \begin{eqnarray} !> R_k &=& A - L_{k} U_{k},\\% !> D_{k+1} &=& diag(R_k),\\% !> L_{k+1} &=& lower(R_k) D_{k+1}^{-1},\\% !> U_{k+1} &=& upper(R_k), !> \end{eqnarray} !> \f] !> if \f$ 0 ≤ k \lt \f$ \p nmaxiter and if !> \f[ !> \Vert R_k \Vert_{\infty} \gt \epsilon \Vert A \Vert_{\infty}, !> \f] !> with \f$\epsilon\f$ = \p tol. Note that the calculation of \f$R_k\f$ is performed with no !> fill-in. !> !> Computing the above iterative incomplete LU factorization requires three steps to complete. !> First, !> determine the size of the required temporary storage buffer by calling \ref !> rocsparse_csritilu0_buffer_size. !> After this buffer size has been determined, allocate the buffer and pass it to !> \ref rocsparse_csritilu0_preprocess. This will perform analysis on the sparsity pattern of !> the matrix. Finally, !> call \p rocsparse_scsritilu0_compute, \p rocsparse_dcsritilu0_compute, \p !> rocsparse_ccsritilu0_compute, !> or \p rocsparse_zcsritilu0_compute to perform the actual factorization. The calculation !> of the buffer size and the analysis of the sparse matrix only need to be performed once for a !> given sparsity pattern !> while the factorization can be repeatedly applied to multiple matrices having the same !> sparsity pattern. After all calls !> to \ref rocsparse_scsritilu0_compute "rocsparse_Xcsritilu0_compute()" are complete, the !> temporary buffer can be deallocated. !> !> \p rocsparse_csritilu0 has a number of options that can be useful for examining the !> convergence history, easily printing debug !> information, and using the COO internal format. !> !> !> !> !> !> !> !> !>
Options
Option Notes !>
rocsparse_itilu0_option_verbose Print to stdout convergence data as the !> routine runs. Useful for debugging.
rocsparse_itilu0_option_stopping_criteria Enable stopping criteria.
rocsparse_itilu0_option_compute_nrm_correction Compute and store normalized !> correction. The stored data can then be queried later with \ref rocsparse_scsritilu0_history !> "rocsparse_Xcsritilu0_history".
rocsparse_itilu0_option_compute_nrm_residual Compute and store the !> normalized residual of the between the approximate solution and the exact solution per !> iteration. The stored data can then be queried later with \ref rocsparse_scsritilu0_history !> "rocsparse_Xcsritilu0_history".
rocsparse_itilu0_option_convergence_history Enable collecting convergence !> history data with \ref rocsparse_scsritilu0_history "rocsparse_Xcsritilu0_history".
rocsparse_itilu0_option_coo_format Use COO format internally.
!> !> \note !> The sparse CSR matrix has to be sorted. This can be achieved by calling !> `rocsparse_csrsort()`. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] alg - algorithm to use, `rocsparse_itilu0_alg` !> @param[in] option - combination of enumeration values from `rocsparse_itilu0_option`. !> @param[inout] nmaxiter - maximum number of iterations on input and number of iterations on !> output. If the output number of iterations is strictly less than the input maximum number of !> iterations, then the algorithm converged. !> @param[in] tol - tolerance to use for stopping criteria. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start !> of every row of the sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[inout] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[out] ilu0 - incomplete factorization. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] buffer_size - size of the storage buffer allocated by the user. !> @param[in] buffer - storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_value \p alg or \p base is invalid. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p csr_row_ptr !> or \p csr_col_ind pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> !> \par Example interface rocsparse_scsritilu0_compute function rocsparse_scsritilu0_compute_(handle,alg,option,nmaxiter,tol,m,nnz,csr_row_ptr, & csr_col_ind,csr_val,ilu0,idx_base,buffer_size,buffer) & bind(c, name="rocsparse_scsritilu0_compute") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsritilu0_compute_ type(c_ptr),value :: handle integer(kind(rocsparse_itilu0_alg_default)),value :: alg integer(c_int),value :: option type(c_ptr),value :: nmaxiter real(c_float),value :: tol integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: csr_val type(c_ptr),value :: ilu0 integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(c_size_t),value :: buffer_size type(c_ptr),value :: buffer end function end interface interface rocsparse_dcsritilu0_compute function rocsparse_dcsritilu0_compute_(handle,alg,option,nmaxiter,tol,m,nnz,csr_row_ptr, & csr_col_ind,csr_val,ilu0,idx_base,buffer_size,buffer) & bind(c, name="rocsparse_dcsritilu0_compute") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsritilu0_compute_ type(c_ptr),value :: handle integer(kind(rocsparse_itilu0_alg_default)),value :: alg integer(c_int),value :: option type(c_ptr),value :: nmaxiter real(c_double),value :: tol integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: csr_val type(c_ptr),value :: ilu0 integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(c_size_t),value :: buffer_size type(c_ptr),value :: buffer end function end interface interface rocsparse_ccsritilu0_compute function rocsparse_ccsritilu0_compute_(handle,alg,option,nmaxiter,tol,m,nnz,csr_row_ptr, & csr_col_ind,csr_val,ilu0,idx_base,buffer_size,buffer) & bind(c, name="rocsparse_ccsritilu0_compute") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsritilu0_compute_ type(c_ptr),value :: handle integer(kind(rocsparse_itilu0_alg_default)),value :: alg integer(c_int),value :: option type(c_ptr),value :: nmaxiter real(c_float),value :: tol integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: csr_val type(c_ptr),value :: ilu0 integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(c_size_t),value :: buffer_size type(c_ptr),value :: buffer end function end interface interface rocsparse_zcsritilu0_compute function rocsparse_zcsritilu0_compute_(handle,alg,option,nmaxiter,tol,m,nnz,csr_row_ptr, & csr_col_ind,csr_val,ilu0,idx_base,buffer_size,buffer) & bind(c, name="rocsparse_zcsritilu0_compute") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsritilu0_compute_ type(c_ptr),value :: handle integer(kind(rocsparse_itilu0_alg_default)),value :: alg integer(c_int),value :: option type(c_ptr),value :: nmaxiter real(c_double),value :: tol integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: csr_val type(c_ptr),value :: ilu0 integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(c_size_t),value :: buffer_size type(c_ptr),value :: buffer end function end interface !> \ingroup precond_module !> \brief Iterative incomplete LU factorization with 0 fill-ins and no pivoting using the CSR !> storage format. !> !> \details !> \p rocsparse_csritilu0_compute computes iteratively the incomplete LU factorization with 0 !> fill-ins and no !> pivoting of a sparse \f$m \times m\f$ CSR matrix \f$A\f$, such that !> \f[ !> A \approx (L + Id)(D + U) !> \f] !> !> !> The following notation applies for the equations below: diag is the diagonal part, lower is !> the strict lower triangular part, and upper is the strict upper triangular part of a given !> matrix. !> Starting with \f$L_{0} = lower(\f$ \p ilu0 \f$)\f$, \f$U_{0} = upper(\f$ \p ilu0 \f$)\f$, the !> method iterates with !> \f[ !> \begin{eqnarray} !> R_k &=& A - L_{k} U_{k},\\% !> D_{k+1} &=& diag(R_k),\\% !> L_{k+1} &=& lower(R_k) D_{k+1}^{-1},\\% !> U_{k+1} &=& upper(R_k), !> \end{eqnarray} !> \f] !> if \f$ 0 ≤ k \lt \f$ \p nmaxiter and if !> \f[ !> \Vert R_k \Vert_{\infty} \gt \epsilon \Vert A \Vert_{\infty}, !> \f] !> with \f$\epsilon\f$ = \p tol. Note that the calculation of \f$R_k\f$ is performed with no !> fill-in. !> !> The parameter \p nfreeiter is used to control the frequence of the stopping criteria !> evaluation, potentially improving the performance of the algorithm with less norm !> calculation. Between each iteration of index \f$ k \f$, \p nfreeiter are performed without !> stopping criteria evaluation. Therefore, if the convergence is obtained with \f$ k \f$, this !> means \f$ (k + 1)( \f$ \p nfreeiter \f$ ) + k \f$ iterations. !> !> \p rocsparse_csritilu0 requires a user-allocated temporary buffer. Its size is returned !> by rocsparse_csritilu0_buffer_size(). Furthermore, !> analysis metadata is required. It can be obtained by rocsparse_csritilu0_preprocess(). !> !> \note !> The sparse CSR matrix has to be sorted. This can be achieved by calling !> `rocsparse_csrsort()`. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] alg - algorithm to use, `rocsparse_itilu0_alg`. !> @param[in] option - combination of enumeration values from `rocsparse_itilu0_option`. !> @param[inout] nmaxiter - maximum number of iterations on input and number of iterations on !> output. If the output number of iterations is strictly less than the input maximum number of !> iterations, then the algorithm converged. !> @param[inout] nfreeiter - number of free iterations, that is, the number of iterations the !> algorithm will perform without stopping criteria evaluations. !> @param[in] tol - tolerance to use for stopping criteria. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start !> of every row of the sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[inout] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[out] ilu0 - incomplete factorization. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] buffer_size - size of the storage buffer allocated by the user. !> @param[in] buffer - storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_value \p alg or \p base is invalid. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p csr_row_ptr !> or \p csr_col_ind pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_scsritilu0_compute_ex function rocsparse_scsritilu0_compute_ex_(handle,alg,option,nmaxiter,nfreeiter,tol,m,nnz, & csr_row_ptr,csr_col_ind,csr_val,ilu0,idx_base,buffer_size,buffer) & bind(c, name="rocsparse_scsritilu0_compute_ex") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsritilu0_compute_ex_ type(c_ptr),value :: handle integer(kind(rocsparse_itilu0_alg_default)),value :: alg integer(c_int),value :: option type(c_ptr),value :: nmaxiter integer(c_int),value :: nfreeiter real(c_float),value :: tol integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: csr_val type(c_ptr),value :: ilu0 integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(c_size_t),value :: buffer_size type(c_ptr),value :: buffer end function end interface interface rocsparse_dcsritilu0_compute_ex function rocsparse_dcsritilu0_compute_ex_(handle,alg,option,nmaxiter,nfreeiter,tol,m,nnz, & csr_row_ptr,csr_col_ind,csr_val,ilu0,idx_base,buffer_size,buffer) & bind(c, name="rocsparse_dcsritilu0_compute_ex") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsritilu0_compute_ex_ type(c_ptr),value :: handle integer(kind(rocsparse_itilu0_alg_default)),value :: alg integer(c_int),value :: option type(c_ptr),value :: nmaxiter integer(c_int),value :: nfreeiter real(c_double),value :: tol integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: csr_val type(c_ptr),value :: ilu0 integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(c_size_t),value :: buffer_size type(c_ptr),value :: buffer end function end interface interface rocsparse_ccsritilu0_compute_ex function rocsparse_ccsritilu0_compute_ex_(handle,alg,option,nmaxiter,nfreeiter,tol,m,nnz, & csr_row_ptr,csr_col_ind,csr_val,ilu0,idx_base,buffer_size,buffer) & bind(c, name="rocsparse_ccsritilu0_compute_ex") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsritilu0_compute_ex_ type(c_ptr),value :: handle integer(kind(rocsparse_itilu0_alg_default)),value :: alg integer(c_int),value :: option type(c_ptr),value :: nmaxiter integer(c_int),value :: nfreeiter real(c_float),value :: tol integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: csr_val type(c_ptr),value :: ilu0 integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(c_size_t),value :: buffer_size type(c_ptr),value :: buffer end function end interface interface rocsparse_zcsritilu0_compute_ex function rocsparse_zcsritilu0_compute_ex_(handle,alg,option,nmaxiter,nfreeiter,tol,m,nnz, & csr_row_ptr,csr_col_ind,csr_val,ilu0,idx_base,buffer_size,buffer) & bind(c, name="rocsparse_zcsritilu0_compute_ex") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsritilu0_compute_ex_ type(c_ptr),value :: handle integer(kind(rocsparse_itilu0_alg_default)),value :: alg integer(c_int),value :: option type(c_ptr),value :: nmaxiter integer(c_int),value :: nfreeiter real(c_double),value :: tol integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind type(c_ptr),value :: csr_val type(c_ptr),value :: ilu0 integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(c_size_t),value :: buffer_size type(c_ptr),value :: buffer end function end interface !> \ingroup precond_module !> \details !> \p rocsparse_csritilu0_history fetches convergence history data if !> `rocsparse_itilu0_option_convergence_history` has been set when calling !> \ref rocsparse_scsritilu0_compute "rocsparse_Xcsritilu0_compute" or !> \ref rocsparse_scsritilu0_compute_ex "rocsparse_Xcsritilu0_compute_ex": !> !> \code{.c} !> int options = 0; !> options |= rocsparse_itilu0_option_stopping_criteria; !> options |= rocsparse_itilu0_option_compute_nrm_residual; !> options |= rocsparse_itilu0_option_convergence_history; !> rocsparse_scsritilu0_compute(handle, !> alg, !> options, !> &nmaxiter, !> tol, !> m, !> nnz, !> dcsr_row_ptr, !> dcsr_col_ind, !> dcsr_val, !> dilu0, !> idx_base, !> buffer_size, !> dbuffer); !> !> if((options & rocsparse_itilu0_option_convergence_history) > 0) !> { !> std::vector history(nmaxiter * 2); !> rocsparse_int history_niter = 0; !> rocsparse_scsritilu0_history(handle, alg, &history_niter, history.data(), buffer_size, !> dbuffer); !> !> const bool nrm_residual = (options & rocsparse_itilu0_option_compute_nrm_residual) > 0; !> for(rocsparse_int i = 0; i < history_niter; ++i) !> { !> std::cout << std::setw(12) << i; !> if(nrm_residual) !> { !> std::cout << std::setw(12) << history[history_niter + i]; !> } !> std::cout << std::endl; !> } !> } !> \endcode !> !> \note !> The sparse CSR matrix has to be sorted. This can be achieved by calling !> `rocsparse_csrsort()`. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] alg - algorithm to use, `rocsparse_itilu0_alg`. !> @param[out] niter - number of performed iterations. !> @param[out] myData - norms. !> @param[in] buffer_size - size of the buffer allocated by the user. !> @param[in] buffer - buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_pointer \p niter or \p data is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_scsritilu0_history function rocsparse_scsritilu0_history_(handle,alg,niter,myData,buffer_size,buffer) & bind(c, name="rocsparse_scsritilu0_history") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsritilu0_history_ type(c_ptr),value :: handle integer(kind(rocsparse_itilu0_alg_default)),value :: alg type(c_ptr),value :: niter type(c_ptr),value :: myData integer(c_size_t),value :: buffer_size type(c_ptr),value :: buffer end function end interface interface rocsparse_dcsritilu0_history function rocsparse_dcsritilu0_history_(handle,alg,niter,myData,buffer_size,buffer) & bind(c, name="rocsparse_dcsritilu0_history") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsritilu0_history_ type(c_ptr),value :: handle integer(kind(rocsparse_itilu0_alg_default)),value :: alg type(c_ptr),value :: niter type(c_ptr),value :: myData integer(c_size_t),value :: buffer_size type(c_ptr),value :: buffer end function end interface interface rocsparse_ccsritilu0_history function rocsparse_ccsritilu0_history_(handle,alg,niter,myData,buffer_size,buffer) & bind(c, name="rocsparse_ccsritilu0_history") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsritilu0_history_ type(c_ptr),value :: handle integer(kind(rocsparse_itilu0_alg_default)),value :: alg type(c_ptr),value :: niter type(c_ptr),value :: myData integer(c_size_t),value :: buffer_size type(c_ptr),value :: buffer end function end interface interface rocsparse_zcsritilu0_history function rocsparse_zcsritilu0_history_(handle,alg,niter,myData,buffer_size,buffer) & bind(c, name="rocsparse_zcsritilu0_history") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsritilu0_history_ type(c_ptr),value :: handle integer(kind(rocsparse_itilu0_alg_default)),value :: alg type(c_ptr),value :: niter type(c_ptr),value :: myData integer(c_size_t),value :: buffer_size type(c_ptr),value :: buffer end function end interface !> \ingroup precond_module !> \details !> \p rocsparse_gpsv_interleaved_batch_buffer_size calculates the required buffer size !> for \ref rocsparse_sgpsv_interleaved_batch "rocsparse_Xgpsv_interleaved_batch()". It is the !> user's !> responsibility to allocate this buffer. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] alg - algorithm to solve the linear system. !> @param[in] m - size of the pentadiagonal linear system. !> @param[in] ds - lower diagonal (distance 2) of pentadiagonal system. The first two entries !> must be zero. !> @param[in] dl - lower diagonal of pentadiagonal system. The first entry must be zero. !> @param[in] d - main diagonal of pentadiagonal system. !> @param[in] du - upper diagonal of pentadiagonal system. The last entry must be zero. !> @param[in] dw - upper diagonal (distance 2) of pentadiagonal system. The last two entries !> must be zero. !> @param[in] x - Dense array of right-hand-sides, with dimension \p batch_stride by \p m. !> @param[in] batch_count - The number of systems to solve. !> @param[in] batch_stride - The number of elements that separate consecutive elements in a !> system. !> Must satisfy \p batch_stride >= \p batch_count. !> @param[out] buffer_size - Number of bytes of the temporary storage buffer required. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p alg, \p batch_count, or !> \p batch_stride is invalid. !> \retval rocsparse_status_invalid_pointer \p ds, \p dl, \p d, \p du, \p dw, \p x, !> or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_sgpsv_interleaved_batch_buffer_size function rocsparse_sgpsv_interleaved_batch_buffer_size_(handle,alg,m,ds,dl,d,du,dw,x, & batch_count,batch_stride,buffer_size) & bind(c, name="rocsparse_sgpsv_interleaved_batch_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgpsv_interleaved_batch_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)),value :: alg integer(c_int),value :: m type(c_ptr),value :: ds type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: dw type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sgpsv_interleaved_batch_buffer_size_assumed_rank #else module procedure & rocsparse_sgpsv_interleaved_batch_buffer_size_rank_0,& rocsparse_sgpsv_interleaved_batch_buffer_size_rank_1 #endif #endif end interface interface rocsparse_dgpsv_interleaved_batch_buffer_size function rocsparse_dgpsv_interleaved_batch_buffer_size_(handle,alg,m,ds,dl,d,du,dw,x, & batch_count,batch_stride,buffer_size) & bind(c, name="rocsparse_dgpsv_interleaved_batch_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgpsv_interleaved_batch_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)),value :: alg integer(c_int),value :: m type(c_ptr),value :: ds type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: dw type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dgpsv_interleaved_batch_buffer_size_assumed_rank #else module procedure & rocsparse_dgpsv_interleaved_batch_buffer_size_rank_0,& rocsparse_dgpsv_interleaved_batch_buffer_size_rank_1 #endif #endif end interface interface rocsparse_cgpsv_interleaved_batch_buffer_size function rocsparse_cgpsv_interleaved_batch_buffer_size_(handle,alg,m,ds,dl,d,du,dw,x, & batch_count,batch_stride,buffer_size) & bind(c, name="rocsparse_cgpsv_interleaved_batch_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgpsv_interleaved_batch_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)),value :: alg integer(c_int),value :: m type(c_ptr),value :: ds type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: dw type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cgpsv_interleaved_batch_buffer_size_assumed_rank #else module procedure & rocsparse_cgpsv_interleaved_batch_buffer_size_rank_0,& rocsparse_cgpsv_interleaved_batch_buffer_size_rank_1 #endif #endif end interface interface rocsparse_zgpsv_interleaved_batch_buffer_size function rocsparse_zgpsv_interleaved_batch_buffer_size_(handle,alg,m,ds,dl,d,du,dw,x, & batch_count,batch_stride,buffer_size) & bind(c, name="rocsparse_zgpsv_interleaved_batch_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgpsv_interleaved_batch_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)),value :: alg integer(c_int),value :: m type(c_ptr),value :: ds type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: dw type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zgpsv_interleaved_batch_buffer_size_assumed_rank #else module procedure & rocsparse_zgpsv_interleaved_batch_buffer_size_rank_0,& rocsparse_zgpsv_interleaved_batch_buffer_size_rank_1 #endif #endif end interface !> \ingroup precond_module !> \brief Batched pentadiagonal solver. !> !> \details !> \p rocsparse_gpsv_interleaved_batch solves a batch of pentadiagonal linear systems !> \f[ !> P^{i}*x^{i} = x^{i} !> \f] !> where for each batch \f$i=0\ldots\f$ \p batch_count, \f$P^{i}\f$ is a sparse pentadiagonal !> matrix and !> \f$x^{i}\f$ is a dense right-hand side vector. All of the pentadiagonal matrices, !> \f$P^{i}\f$, are !> packed in an interleaved fashion into five vectors: \p ds for the lowest diagonals, \p dl for !> the lower !> diagonals, \p d for the main diagonals, \p du for the upper diagonals, and \p dw for the !> highest diagonals. !> See below for a description of what this interleaved memory pattern looks like. !> !> Solving the batched pentadiagonal system involves two steps. First, call !> \ref rocsparse_sgpsv_interleaved_batch_buffer_size !> "rocsparse_Xgpsv_interleaved_batch_buffer_size()" !> to determine the size of the required temporary storage buffer. After this is determined, !> allocate !> the buffer and pass it to \ref rocsparse_sgpsv_interleaved_batch !> "rocsparse_Xgpsv_interleaved_batch()" !> to perform the actual solve. The \f$x^{i}\f$ vectors, which initially stores the right-hand !> side values, are !> overwritten with the solution after the call to !> \ref rocsparse_sgpsv_interleaved_batch "rocsparse_Xgpsv_interleaved_batch()". !> !> Unlike the strided batch routines, which write each batch matrix one after the other in !> memory, the interleaved !> routines write the batch matrices such that each element from each matrix is written !> consecutively one after !> the other. For example, consider the following batch matrices: !> !> \f[ !> \begin{bmatrix} !> t^{0}_{00} & t^{0}_{01} & t^{0}_{02} \\% !> t^{0}_{10} & t^{0}_{11} & t^{0}_{12} \\% !> t^{0}_{20} & t^{0}_{21} & t^{0}_{22} !> \end{bmatrix} !> \begin{bmatrix} !> t^{1}_{00} & t^{1}_{01} & t^{1}_{02} \\% !> t^{1}_{10} & t^{1}_{11} & t^{1}_{12} \\% !> t^{1}_{20} & t^{1}_{21} & t^{1}_{22} !> \end{bmatrix} !> \begin{bmatrix} !> t^{2}_{00} & t^{2}_{01} & t^{2}_{02} \\% !> t^{2}_{10} & t^{2}_{11} & t^{2}_{12} \\% !> t^{2}_{20} & t^{2}_{21} & t^{2}_{22} !> \end{bmatrix} !> \f] !> !> In interleaved format, the highest, higher, lowest, lower, and diagonal arrays would look !> like: !> \f[ !> \begin{align} !> \text{lowest} &= \begin{bmatrix} 0 & 0 & 0 & 0 & 0 & 0 & t^{0}_{20} & t^{1}_{20} & !> t^{2}_{20} \end{bmatrix} \\% !> \text{lower} &= \begin{bmatrix} 0 & 0 & 0 & t^{0}_{10} & t^{1}_{10} & t^{1}_{10} & !> t^{0}_{21} & t^{1}_{21} & t^{2}_{21} \end{bmatrix} \\% !> \text{diagonal} &= \begin{bmatrix} t^{0}_{00} & t^{1}_{00} & t^{2}_{00} & t^{0}_{11} & !> t^{1}_{11} & t^{2}_{11} & t^{0}_{22} & t^{1}_{22} & t^{2}_{22} \end{bmatrix} \\% !> \text{higher} &= \begin{bmatrix} t^{0}_{01} & t^{1}_{01} & t^{2}_{01} & t^{0}_{12} & !> t^{1}_{12} & t^{2}_{12} & 0 & 0 & 0 \end{bmatrix} \\% !> \text{highest} &= \begin{bmatrix} t^{0}_{02} & t^{1}_{02} & t^{2}_{02} & 0 & 0 & 0 & 0 & 0 !> & 0 \end{bmatrix} \\% !> \end{align} !> \f] !> For the lowest array, the first \p 2*batch_count entries are zero, and for the lower array, !> the first \p batch_count entries are zero. !> For the upper array, the last \p batch_count entries are zero, and for the highest array, the !> last \p 2*batch_count entries are zero. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> The routine is numerically stable because it uses QR to solve the linear systems. !> !> \note !> m need to be at least 3 to be a valid pentadiagonal matrix. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] alg - algorithm to solve the linear system. !> @param[in] m - size of the pentadiagonal linear system. !> @param[inout] ds - lower diagonal (distance 2) of pentadiagonal system. The first two entries !> must be zero. !> @param[inout] dl - lower diagonal of pentadiagonal system. The first entry must be zero. !> @param[inout] d - main diagonal of pentadiagonal system. !> @param[inout] du - upper diagonal of pentadiagonal system. The last entry must be zero. !> @param[inout] dw - upper diagonal (distance 2) of pentadiagonal system. The last two entries !> must be zero. !> @param[inout] x - Dense array of right-hand-sides, with dimension \p batch_stride by \p m. !> @param[in] batch_count - The number of systems to solve. !> @param[in] batch_stride - The number of elements that separate consecutive elements in a !> system. !> Must satisfy \p batch_stride >= \p batch_count. !> @param[in] temp_buffer - Temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p alg, \p batch_count, or !> \p batch_stride is invalid. !> \retval rocsparse_status_invalid_pointer \p ds, \p dl, \p d, \p du, \p dw, \p x, !> or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> !> \par Example interface rocsparse_sgpsv_interleaved_batch function rocsparse_sgpsv_interleaved_batch_(handle,alg,m,ds,dl,d,du,dw,x,batch_count, & batch_stride,temp_buffer) & bind(c, name="rocsparse_sgpsv_interleaved_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgpsv_interleaved_batch_ type(c_ptr),value :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)),value :: alg integer(c_int),value :: m type(c_ptr),value :: ds type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: dw type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sgpsv_interleaved_batch_assumed_rank #else module procedure & rocsparse_sgpsv_interleaved_batch_rank_0,& rocsparse_sgpsv_interleaved_batch_rank_1 #endif #endif end interface interface rocsparse_dgpsv_interleaved_batch function rocsparse_dgpsv_interleaved_batch_(handle,alg,m,ds,dl,d,du,dw,x,batch_count, & batch_stride,temp_buffer) & bind(c, name="rocsparse_dgpsv_interleaved_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgpsv_interleaved_batch_ type(c_ptr),value :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)),value :: alg integer(c_int),value :: m type(c_ptr),value :: ds type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: dw type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dgpsv_interleaved_batch_assumed_rank #else module procedure & rocsparse_dgpsv_interleaved_batch_rank_0,& rocsparse_dgpsv_interleaved_batch_rank_1 #endif #endif end interface interface rocsparse_cgpsv_interleaved_batch function rocsparse_cgpsv_interleaved_batch_(handle,alg,m,ds,dl,d,du,dw,x,batch_count, & batch_stride,temp_buffer) & bind(c, name="rocsparse_cgpsv_interleaved_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgpsv_interleaved_batch_ type(c_ptr),value :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)),value :: alg integer(c_int),value :: m type(c_ptr),value :: ds type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: dw type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cgpsv_interleaved_batch_assumed_rank #else module procedure & rocsparse_cgpsv_interleaved_batch_rank_0,& rocsparse_cgpsv_interleaved_batch_rank_1 #endif #endif end interface interface rocsparse_zgpsv_interleaved_batch function rocsparse_zgpsv_interleaved_batch_(handle,alg,m,ds,dl,d,du,dw,x,batch_count, & batch_stride,temp_buffer) & bind(c, name="rocsparse_zgpsv_interleaved_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgpsv_interleaved_batch_ type(c_ptr),value :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)),value :: alg integer(c_int),value :: m type(c_ptr),value :: ds type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: dw type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zgpsv_interleaved_batch_assumed_rank #else module procedure & rocsparse_zgpsv_interleaved_batch_rank_0,& rocsparse_zgpsv_interleaved_batch_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p rocsparse_gtsv_buffer_size returns the size of the temporary storage buffer !> that is required by \ref rocsparse_sgtsv "rocsparse_Xgtsv()". The temporary !> storage buffer must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - size of the tri-diagonal linear system (must be >= 2). !> @param[in] n - number of columns in the dense matrix B. !> @param[in] dl - lower diagonal of tri-diagonal system. The first entry must be zero. !> @param[in] d - main diagonal of tri-diagonal system. !> @param[in] du - upper diagonal of tri-diagonal system. The last entry must be zero. !> @param[in] B - dense matrix of size ( \p ldb, \p n ). !> @param[in] ldb - leading dimension of B. Must satisfy \p ldb >= max(1, m). !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> rocsparse_sgtsv(), rocsparse_dgtsv(), rocsparse_cgtsv(), !> and rocsparse_zgtsv(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p ldb is invalid. !> \retval rocsparse_status_invalid_pointer \p dl, \p d, \p du, !> \p B, or \p buffer_size pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_sgtsv_buffer_size function rocsparse_sgtsv_buffer_size_(handle,m,n,dl,d,du,B,ldb,buffer_size) & bind(c, name="rocsparse_sgtsv_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sgtsv_buffer_size_assumed_rank #else module procedure & rocsparse_sgtsv_buffer_size_rank_0,& rocsparse_sgtsv_buffer_size_rank_1,& rocsparse_sgtsv_buffer_size_full_rank #endif #endif end interface interface rocsparse_dgtsv_buffer_size function rocsparse_dgtsv_buffer_size_(handle,m,n,dl,d,du,B,ldb,buffer_size) & bind(c, name="rocsparse_dgtsv_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dgtsv_buffer_size_assumed_rank #else module procedure & rocsparse_dgtsv_buffer_size_rank_0,& rocsparse_dgtsv_buffer_size_rank_1,& rocsparse_dgtsv_buffer_size_full_rank #endif #endif end interface interface rocsparse_cgtsv_buffer_size function rocsparse_cgtsv_buffer_size_(handle,m,n,dl,d,du,B,ldb,buffer_size) & bind(c, name="rocsparse_cgtsv_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cgtsv_buffer_size_assumed_rank #else module procedure & rocsparse_cgtsv_buffer_size_rank_0,& rocsparse_cgtsv_buffer_size_rank_1,& rocsparse_cgtsv_buffer_size_full_rank #endif #endif end interface interface rocsparse_zgtsv_buffer_size function rocsparse_zgtsv_buffer_size_(handle,m,n,dl,d,du,B,ldb,buffer_size) & bind(c, name="rocsparse_zgtsv_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zgtsv_buffer_size_assumed_rank #else module procedure & rocsparse_zgtsv_buffer_size_rank_0,& rocsparse_zgtsv_buffer_size_rank_1,& rocsparse_zgtsv_buffer_size_full_rank #endif #endif end interface !> \ingroup precond_module !> \brief Tridiagonal solver with pivoting !> !> \details !> \p rocsparse_gtsv solves a tridiagonal system for multiple right-hand sides using pivoting !> \f[ !> T*B = B !> \f] !> where \f$T\f$ is a sparse tridiagonal matrix and \f$B\f$ is a dense \f$ldb \times n\f$ matrix !> storing the !> right-hand side vectors in column order. The tridiagonal matrix \f$T\f$ is defined by three !> vectors: \p dl !> for the lower diagonal, \p d for the main diagonal, and \p du for the upper diagonal. !> !> Solving the tridiagonal system involves two steps. First, call !> \ref rocsparse_sgtsv_buffer_size "rocsparse_Xgtsv_buffer_size()" to determine the size of the !> required !> temporary storage buffer. After this is determined, allocate this buffer and pass it to !> \ref rocsparse_sgtsv "rocsparse_Xgtsv()" to perform the actual solve. The \f$B\f$ dense !> matrix, which initially !> stores the \p n right-hand side vectors, is overwritten with the \p n solution vectors after !> the call to !> \ref rocsparse_sgtsv "rocsparse_Xgtsv()". !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - size of the tri-diagonal linear system (must be >= 2). !> @param[in] n - number of columns in the dense matrix B. !> @param[in] dl - lower diagonal of tri-diagonal system. The first entry must be zero. !> @param[in] d - main diagonal of tri-diagonal system. !> @param[in] du - upper diagonal of tri-diagonal system. The last entry must be zero. !> @param[inout] B - dense matrix of size ( \p ldb, \p n ). !> @param[in] ldb - leading dimension of B. Must satisfy \p ldb >= max(1, m). !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p ldb is invalid. !> \retval rocsparse_status_invalid_pointer \p dl, \p d, !> \p du, \p B, or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> !> \par Example interface rocsparse_sgtsv function rocsparse_sgtsv_(handle,m,n,dl,d,du,B,ldb,temp_buffer) bind(c, name="rocsparse_sgtsv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sgtsv_assumed_rank #else module procedure & rocsparse_sgtsv_rank_0,& rocsparse_sgtsv_rank_1,& rocsparse_sgtsv_full_rank #endif #endif end interface interface rocsparse_dgtsv function rocsparse_dgtsv_(handle,m,n,dl,d,du,B,ldb,temp_buffer) bind(c, name="rocsparse_dgtsv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dgtsv_assumed_rank #else module procedure & rocsparse_dgtsv_rank_0,& rocsparse_dgtsv_rank_1,& rocsparse_dgtsv_full_rank #endif #endif end interface interface rocsparse_cgtsv function rocsparse_cgtsv_(handle,m,n,dl,d,du,B,ldb,temp_buffer) bind(c, name="rocsparse_cgtsv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cgtsv_assumed_rank #else module procedure & rocsparse_cgtsv_rank_0,& rocsparse_cgtsv_rank_1,& rocsparse_cgtsv_full_rank #endif #endif end interface interface rocsparse_zgtsv function rocsparse_zgtsv_(handle,m,n,dl,d,du,B,ldb,temp_buffer) bind(c, name="rocsparse_zgtsv") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zgtsv_assumed_rank #else module procedure & rocsparse_zgtsv_rank_0,& rocsparse_zgtsv_rank_1,& rocsparse_zgtsv_full_rank #endif #endif end interface !> \ingroup precond_module !> \details !> \p rocsparse_gtsv_no_pivot_buffer_size returns the size of the temporary storage buffer !> that is required by \ref rocsparse_sgtsv_no_pivot "rocsparse_Xgtsv_no_pivot()". The temporary !> storage buffer must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - size of the tri-diagonal linear system (must be >= 2). !> @param[in] n - number of columns in the dense matrix B. !> @param[in] dl - lower diagonal of tri-diagonal system. The first entry must be zero. !> @param[in] d - main diagonal of tri-diagonal system. !> @param[in] du - upper diagonal of tri-diagonal system. The last entry must be zero. !> @param[in] B - dense matrix of size ( \p ldb, \p n ). !> @param[in] ldb - leading dimension of B. Must satisfy \p ldb >= max(1, m). !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> rocsparse_sgtsv_no_pivot(), rocsparse_dgtsv_no_pivot(), !> rocsparse_cgtsv_no_pivot(), !> and rocsparse_zgtsv_no_pivot(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p ldb is invalid. !> \retval rocsparse_status_invalid_pointer \p dl, \p d, \p du, !> \p B, or \p buffer_size pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_sgtsv_no_pivot_buffer_size function rocsparse_sgtsv_no_pivot_buffer_size_(handle,m,n,dl,d,du,B,ldb,buffer_size) & bind(c, name="rocsparse_sgtsv_no_pivot_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_no_pivot_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sgtsv_no_pivot_buffer_size_assumed_rank #else module procedure & rocsparse_sgtsv_no_pivot_buffer_size_rank_0,& rocsparse_sgtsv_no_pivot_buffer_size_rank_1,& rocsparse_sgtsv_no_pivot_buffer_size_full_rank #endif #endif end interface interface rocsparse_dgtsv_no_pivot_buffer_size function rocsparse_dgtsv_no_pivot_buffer_size_(handle,m,n,dl,d,du,B,ldb,buffer_size) & bind(c, name="rocsparse_dgtsv_no_pivot_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_no_pivot_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dgtsv_no_pivot_buffer_size_assumed_rank #else module procedure & rocsparse_dgtsv_no_pivot_buffer_size_rank_0,& rocsparse_dgtsv_no_pivot_buffer_size_rank_1,& rocsparse_dgtsv_no_pivot_buffer_size_full_rank #endif #endif end interface interface rocsparse_cgtsv_no_pivot_buffer_size function rocsparse_cgtsv_no_pivot_buffer_size_(handle,m,n,dl,d,du,B,ldb,buffer_size) & bind(c, name="rocsparse_cgtsv_no_pivot_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_no_pivot_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cgtsv_no_pivot_buffer_size_assumed_rank #else module procedure & rocsparse_cgtsv_no_pivot_buffer_size_rank_0,& rocsparse_cgtsv_no_pivot_buffer_size_rank_1,& rocsparse_cgtsv_no_pivot_buffer_size_full_rank #endif #endif end interface interface rocsparse_zgtsv_no_pivot_buffer_size function rocsparse_zgtsv_no_pivot_buffer_size_(handle,m,n,dl,d,du,B,ldb,buffer_size) & bind(c, name="rocsparse_zgtsv_no_pivot_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_no_pivot_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zgtsv_no_pivot_buffer_size_assumed_rank #else module procedure & rocsparse_zgtsv_no_pivot_buffer_size_rank_0,& rocsparse_zgtsv_no_pivot_buffer_size_rank_1,& rocsparse_zgtsv_no_pivot_buffer_size_full_rank #endif #endif end interface !> \ingroup precond_module !> \brief Tridiagonal solver (no pivoting) !> !> \details !> \p rocsparse_gtsv_no_pivot solves a tridiagonal linear system for multiple right-hand sides !> without pivoting !> \f[ !> T*B = B !> \f] !> where \f$T\f$ is a sparse tridiagonal matrix and \f$B\f$ is a dense \f$ldb \times n\f$ matrix !> storing the !> right-hand side vectors in column order. The tridiagonal matrix \f$T\f$ is defined by three !> vectors: \p dl !> for the lower diagonal, \p d for the main diagonal, and \p du for the upper diagonal. !> !> Solving the tridiagonal system with multiple right-hand sides without pivoting involves two !> steps. First, !> call \ref rocsparse_sgtsv_no_pivot_buffer_size "rocsparse_Xgtsv_no_pivot_buffer_size()" !> to determine the size of the required temporary storage buffer. After this is determined, !> allocate the !> buffer and pass it to \ref rocsparse_sgtsv_no_pivot "rocsparse_Xgtsv_no_pivot()" to perform !> the actual !> solve. The \f$B\f$ dense matrix, which initially stores the \p n right-hand side vectors, is !> overwritten !> with the \p n solution vectors after the call to \ref rocsparse_sgtsv_no_pivot !> "rocsparse_Xgtsv_no_pivot()". !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - size of the tri-diagonal linear system (must be >= 2). !> @param[in] n - number of columns in the dense matrix B. !> @param[in] dl - lower diagonal of tri-diagonal system. The first entry must be zero. !> @param[in] d - main diagonal of tri-diagonal system. !> @param[in] du - upper diagonal of tri-diagonal system. The last entry must be zero. !> @param[inout] B - dense matrix of size ( \p ldb, \p n ). !> @param[in] ldb - leading dimension of B. Must satisfy \p ldb >= max(1, m). !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p ldb is invalid. !> \retval rocsparse_status_invalid_pointer \p dl, \p d, !> \p du, \p B, or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> !> \par Example interface rocsparse_sgtsv_no_pivot function rocsparse_sgtsv_no_pivot_(handle,m,n,dl,d,du,B,ldb,temp_buffer) & bind(c, name="rocsparse_sgtsv_no_pivot") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_no_pivot_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sgtsv_no_pivot_assumed_rank #else module procedure & rocsparse_sgtsv_no_pivot_rank_0,& rocsparse_sgtsv_no_pivot_rank_1,& rocsparse_sgtsv_no_pivot_full_rank #endif #endif end interface interface rocsparse_dgtsv_no_pivot function rocsparse_dgtsv_no_pivot_(handle,m,n,dl,d,du,B,ldb,temp_buffer) & bind(c, name="rocsparse_dgtsv_no_pivot") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_no_pivot_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dgtsv_no_pivot_assumed_rank #else module procedure & rocsparse_dgtsv_no_pivot_rank_0,& rocsparse_dgtsv_no_pivot_rank_1,& rocsparse_dgtsv_no_pivot_full_rank #endif #endif end interface interface rocsparse_cgtsv_no_pivot function rocsparse_cgtsv_no_pivot_(handle,m,n,dl,d,du,B,ldb,temp_buffer) & bind(c, name="rocsparse_cgtsv_no_pivot") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_no_pivot_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cgtsv_no_pivot_assumed_rank #else module procedure & rocsparse_cgtsv_no_pivot_rank_0,& rocsparse_cgtsv_no_pivot_rank_1,& rocsparse_cgtsv_no_pivot_full_rank #endif #endif end interface interface rocsparse_zgtsv_no_pivot function rocsparse_zgtsv_no_pivot_(handle,m,n,dl,d,du,B,ldb,temp_buffer) & bind(c, name="rocsparse_zgtsv_no_pivot") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_no_pivot_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: B integer(c_int),value :: ldb type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zgtsv_no_pivot_assumed_rank #else module procedure & rocsparse_zgtsv_no_pivot_rank_0,& rocsparse_zgtsv_no_pivot_rank_1,& rocsparse_zgtsv_no_pivot_full_rank #endif #endif end interface !> \ingroup precond_module !> \details !> \p rocsparse_gtsv_no_pivot_strided_batch_buffer_size returns the size of the temporary !> storage buffer !> that is required by \ref rocsparse_sgtsv_no_pivot_strided_batch !> "rocsparse_Xgtsv_no_pivot_strided_batch()". !> The temporary storage buffer must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - size of the tri-diagonal linear system. !> @param[in] dl - lower diagonal of tri-diagonal system, where the ith system lower diagonal !> starts at \p dl+batch_stride*i. !> @param[in] d - main diagonal of tri-diagonal system, where the ith system diagonal starts at !> \p d+batch_stride*i. !> @param[in] du - upper diagonal of tri-diagonal system, where the ith system upper diagonal !> starts at \p du+batch_stride*i. !> @param[inout] x - dense array of righthand-sides where the ith righthand-side starts at \p !> x+batch_stride*i. !> @param[in] batch_count - the number of systems to solve. !> @param[in] batch_stride - the number of elements that separate each system. Must satisfy \p !> batch_stride >= \p m. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> \ref rocsparse_sgtsv_no_pivot_strided_batch !> "rocsparse_Xgtsv_no_pivot_strided_batch()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p batch_count, or \p batch_stride is invalid. !> \retval rocsparse_status_invalid_pointer \p dl, \p d, \p du, !> \p x, or \p buffer_size pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_sgtsv_no_pivot_strided_batch_buffer_size function rocsparse_sgtsv_no_pivot_strided_batch_buffer_size_(handle,m,dl,d,du,x,batch_count, & batch_stride,buffer_size) & bind(c, name="rocsparse_sgtsv_no_pivot_strided_batch_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_no_pivot_strided_batch_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sgtsv_no_pivot_strided_batch_buffer_size_assumed_rank #else module procedure & rocsparse_sgtsv_no_pivot_strided_batch_buffer_size_rank_0,& rocsparse_sgtsv_no_pivot_strided_batch_buffer_size_rank_1 #endif #endif end interface interface rocsparse_dgtsv_no_pivot_strided_batch_buffer_size function rocsparse_dgtsv_no_pivot_strided_batch_buffer_size_(handle,m,dl,d,du,x,batch_count, & batch_stride,buffer_size) & bind(c, name="rocsparse_dgtsv_no_pivot_strided_batch_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_no_pivot_strided_batch_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dgtsv_no_pivot_strided_batch_buffer_size_assumed_rank #else module procedure & rocsparse_dgtsv_no_pivot_strided_batch_buffer_size_rank_0,& rocsparse_dgtsv_no_pivot_strided_batch_buffer_size_rank_1 #endif #endif end interface interface rocsparse_cgtsv_no_pivot_strided_batch_buffer_size function rocsparse_cgtsv_no_pivot_strided_batch_buffer_size_(handle,m,dl,d,du,x,batch_count, & batch_stride,buffer_size) & bind(c, name="rocsparse_cgtsv_no_pivot_strided_batch_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_no_pivot_strided_batch_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cgtsv_no_pivot_strided_batch_buffer_size_assumed_rank #else module procedure & rocsparse_cgtsv_no_pivot_strided_batch_buffer_size_rank_0,& rocsparse_cgtsv_no_pivot_strided_batch_buffer_size_rank_1 #endif #endif end interface interface rocsparse_zgtsv_no_pivot_strided_batch_buffer_size function rocsparse_zgtsv_no_pivot_strided_batch_buffer_size_(handle,m,dl,d,du,x,batch_count, & batch_stride,buffer_size) & bind(c, name="rocsparse_zgtsv_no_pivot_strided_batch_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_no_pivot_strided_batch_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride integer(c_size_t) :: buffer_size end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zgtsv_no_pivot_strided_batch_buffer_size_assumed_rank #else module procedure & rocsparse_zgtsv_no_pivot_strided_batch_buffer_size_rank_0,& rocsparse_zgtsv_no_pivot_strided_batch_buffer_size_rank_1 #endif #endif end interface !> \ingroup precond_module !> \brief Strided Batch tridiagonal solver (no pivoting) !> !> \details !> \p rocsparse_gtsv_no_pivot_strided_batch solves a batched tridiagonal linear system !> \f[ !> T^{i}*x^{i} = x^{i} !> \f] !> where for each batch \f$i=0\ldots\f$ \p batch_count, \f$T^{i}\f$ is a sparse tridiagonal !> matrix and !> \f$x^{i}\f$ is a dense right-hand side vector. All of the tridiagonal matrices, \f$T^{i}\f$, !> are !> packed one after the other into three vectors: \p dl for the lower diagonals, \p d for the !> main !> diagonals, and \p du for the upper diagonals. See below for a description of what this !> strided !> memory pattern looks like. !> !> Solving the batched tridiagonal system involves two steps. First, call !> \ref rocsparse_sgtsv_no_pivot_strided_batch_buffer_size !> "rocsparse_Xgtsv_no_pivot_strided_batch_buffer_size()" !> to determine the size of the required temporary storage buffer. After this is determined, !> allocate !> the buffer and pass it to \ref rocsparse_sgtsv_no_pivot_strided_batch !> "rocsparse_Xgtsv_no_pivot_strided_batch()" !> to perform the actual solve. The \f$x^{i}\f$ vectors, which initially stores the right-hand !> side values, are !> overwritten with the solution after the call to !> \ref rocsparse_sgtsv_no_pivot_strided_batch "rocsparse_Xgtsv_no_pivot_strided_batch()". !> !> The strided batch routines write each batch matrix one after the other in memory. For !> example, consider !> the following batch matrices: !> !> \f[ !> \begin{bmatrix} !> t^{0}_{00} & t^{0}_{01} & 0 \\% !> t^{0}_{10} & t^{0}_{11} & t^{0}_{12} \\% !> 0 & t^{0}_{21} & t^{0}_{22} !> \end{bmatrix} !> \begin{bmatrix} !> t^{1}_{00} & t^{1}_{01} & 0 \\% !> t^{1}_{10} & t^{1}_{11} & t^{1}_{12} \\% !> 0 & t^{1}_{21} & t^{1}_{22} !> \end{bmatrix} !> \begin{bmatrix} !> t^{2}_{00} & t^{2}_{01} & 0 \\% !> t^{2}_{10} & t^{2}_{11} & t^{2}_{12} \\% !> 0 & t^{2}_{21} & t^{2}_{22} !> \end{bmatrix} !> \f] !> !> In strided format, the upper, lower, and diagonal arrays would look like: !> \f[ !> \begin{align} !> \text{lower} &= \begin{bmatrix} 0 & t^{0}_{10} & t^{0}_{21} & 0 & t^{1}_{10} & t^{1}_{21} & !> 0 & t^{2}_{10} & t^{2}_{21} \end{bmatrix} \\% !> \text{diagonal} &= \begin{bmatrix} t^{0}_{00} & t^{0}_{11} & t^{0}_{22} & t^{1}_{00} & !> t^{1}_{11} & t^{1}_{22} & t^{2}_{00} & t^{2}_{11} & t^{2}_{22} \end{bmatrix} \\% !> \text{upper} &= \begin{bmatrix} t^{0}_{01} & t^{0}_{12} & 0 & t^{1}_{01} & t^{1}_{12} & 0 & !> t^{2}_{01} & t^{2}_{12} & 0 \end{bmatrix} \\% !> \end{align} !> \f] !> For the lower array, for each batch \p i, the \p i*batch_stride entries are zero, and for the !> upper array, the !> \p i*batch_stride+batch_stride-1 entries are zero. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - size of the tri-diagonal linear system (must be >= 2). !> @param[in] dl - lower diagonal of tri-diagonal system. The first entry must be zero. !> @param[in] d - main diagonal of tri-diagonal system. !> @param[in] du - upper diagonal of tri-diagonal system. The last entry must be zero. !> @param[inout] x - dense array of righthand-sides, where the ith right-hand side starts at \p !> x+batch_stride*i. !> @param[in] batch_count - the number of systems to solve. !> @param[in] batch_stride - the number of elements that separate each system. Must satisfy \p !> batch_stride >= \p m. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p batch_count, or \p batch_stride is invalid. !> \retval rocsparse_status_invalid_pointer \p dl, \p d, !> \p du, \p x, or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> !> \par Example interface rocsparse_sgtsv_no_pivot_strided_batch function rocsparse_sgtsv_no_pivot_strided_batch_(handle,m,dl,d,du,x,batch_count,batch_stride, & temp_buffer) & bind(c, name="rocsparse_sgtsv_no_pivot_strided_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_no_pivot_strided_batch_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_sgtsv_no_pivot_strided_batch_assumed_rank #else module procedure & rocsparse_sgtsv_no_pivot_strided_batch_rank_0,& rocsparse_sgtsv_no_pivot_strided_batch_rank_1 #endif #endif end interface interface rocsparse_dgtsv_no_pivot_strided_batch function rocsparse_dgtsv_no_pivot_strided_batch_(handle,m,dl,d,du,x,batch_count,batch_stride, & temp_buffer) & bind(c, name="rocsparse_dgtsv_no_pivot_strided_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_no_pivot_strided_batch_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dgtsv_no_pivot_strided_batch_assumed_rank #else module procedure & rocsparse_dgtsv_no_pivot_strided_batch_rank_0,& rocsparse_dgtsv_no_pivot_strided_batch_rank_1 #endif #endif end interface interface rocsparse_cgtsv_no_pivot_strided_batch function rocsparse_cgtsv_no_pivot_strided_batch_(handle,m,dl,d,du,x,batch_count,batch_stride, & temp_buffer) & bind(c, name="rocsparse_cgtsv_no_pivot_strided_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_no_pivot_strided_batch_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_cgtsv_no_pivot_strided_batch_assumed_rank #else module procedure & rocsparse_cgtsv_no_pivot_strided_batch_rank_0,& rocsparse_cgtsv_no_pivot_strided_batch_rank_1 #endif #endif end interface interface rocsparse_zgtsv_no_pivot_strided_batch function rocsparse_zgtsv_no_pivot_strided_batch_(handle,m,dl,d,du,x,batch_count,batch_stride, & temp_buffer) & bind(c, name="rocsparse_zgtsv_no_pivot_strided_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_no_pivot_strided_batch_ type(c_ptr),value :: handle integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride type(c_ptr),value :: temp_buffer end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zgtsv_no_pivot_strided_batch_assumed_rank #else module procedure & rocsparse_zgtsv_no_pivot_strided_batch_rank_0,& rocsparse_zgtsv_no_pivot_strided_batch_rank_1 #endif #endif end interface !> \ingroup precond_module !> \details !> \p rocsparse_gtsv_interleaved_batch_buffer_size returns the size of the temporary storage !> buffer !> that is required by \ref rocsparse_sgtsv_interleaved_batch !> "rocsparse_Xgtsv_interleaved_batch()". !> The temporary storage buffer must be allocated by the user. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] alg - algorithm to use when solving tridiagonal systems. Options are Thomas ( !> `rocsparse_gtsv_interleaved_alg_thomas` ), !> LU ( `rocsparse_gtsv_interleaved_alg_lu` ), or QR ( !> `rocsparse_gtsv_interleaved_alg_qr` ). Passing !> `rocsparse_gtsv_interleaved_alg_default` defaults to using the QR algorithm. The !> Thomas algorithm is the fastest but is not !> stable, while LU and QR are slower but are stable. !> @param[in] m - size of the tri-diagonal linear system. !> @param[in] dl - lower diagonal of tri-diagonal system. The first element of the lower !> diagonal must be zero. !> @param[in] d - main diagonal of tri-diagonal system. !> @param[in] du - upper diagonal of tri-diagonal system. The last element of the upper diagonal !> must be zero. !> @param[inout] x - dense array of right-hand sides with dimension \p batch_stride by \p m. !> @param[in] batch_count - the number of systems to solve. !> @param[in] batch_stride - the number of elements that separate consecutive elements in a !> system. Must satisfy \p batch_stride >= \p batch_count. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> \ref rocsparse_sgtsv_interleaved_batch "rocsparse_Xgtsv_interleaved_batch()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m, \p batch_count, \p batch_stride is invalid. !> \retval rocsparse_status_invalid_pointer \p dl, \p d, \p du, !> \p x, or \p buffer_size pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. interface rocsparse_sgtsv_interleaved_batch_buffer_size function rocsparse_sgtsv_interleaved_batch_buffer_size_(handle,alg,m,dl,d,du,x,batch_count, & batch_stride,buffer_size) & bind(c, name="rocsparse_sgtsv_interleaved_batch_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_interleaved_batch_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_gtsv_interleaved_alg_default)),value :: alg integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride integer(c_size_t) :: buffer_size end function end interface interface rocsparse_dgtsv_interleaved_batch_buffer_size function rocsparse_dgtsv_interleaved_batch_buffer_size_(handle,alg,m,dl,d,du,x,batch_count, & batch_stride,buffer_size) & bind(c, name="rocsparse_dgtsv_interleaved_batch_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_interleaved_batch_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_gtsv_interleaved_alg_default)),value :: alg integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride integer(c_size_t) :: buffer_size end function end interface interface rocsparse_cgtsv_interleaved_batch_buffer_size function rocsparse_cgtsv_interleaved_batch_buffer_size_(handle,alg,m,dl,d,du,x,batch_count, & batch_stride,buffer_size) & bind(c, name="rocsparse_cgtsv_interleaved_batch_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_interleaved_batch_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_gtsv_interleaved_alg_default)),value :: alg integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride integer(c_size_t) :: buffer_size end function end interface interface rocsparse_zgtsv_interleaved_batch_buffer_size function rocsparse_zgtsv_interleaved_batch_buffer_size_(handle,alg,m,dl,d,du,x,batch_count, & batch_stride,buffer_size) & bind(c, name="rocsparse_zgtsv_interleaved_batch_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_interleaved_batch_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_gtsv_interleaved_alg_default)),value :: alg integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride integer(c_size_t) :: buffer_size end function end interface !> \ingroup precond_module !> \brief Interleaved batch tridiagonal solver. !> !> \details !> \p rocsparse_gtsv_interleaved_batch solves a batched tridiagonal linear system !> \f[ !> T^{i}*x^{i} = x^{i} !> \f] !> where for each batch \f$i=0\ldots\f$ \p batch_count, \f$T^{i}\f$ is a sparse tridiagonal !> matrix and !> \f$x^{i}\f$ is a dense right-hand side vector. All of the tridiagonal matrices, \f$T^{i}\f$, !> are !> packed in an interleaved fashion into three vectors: \p dl for the lower diagonals, \p d for !> the main !> diagonals, and \p du for the upper diagonals. See below for a description of what this !> interleaved !> memory pattern looks like. !> !> Solving the batched tridiagonal system involves two steps. First, call !> \ref rocsparse_sgtsv_interleaved_batch_buffer_size !> "rocsparse_Xgtsv_interleaved_batch_buffer_size()" !> to determine the size of the required temporary storage buffer. After this is determined, !> allocate !> the buffer and pass it to \ref rocsparse_sgtsv_interleaved_batch !> "rocsparse_Xgtsv_interleaved_batch()" !> to perform the actual solve. The \f$x^{i}\f$ vectors, which initially stores the right-hand !> side values, are !> overwritten with the solution after the call to !> \ref rocsparse_sgtsv_interleaved_batch "rocsparse_Xgtsv_interleaved_batch()". !> !> The user can specify different algorithms for \p rocsparse_gtsv_interleaved_batch !> to use. Options are Thomas ( `rocsparse_gtsv_interleaved_alg_thomas` ), !> LU ( `rocsparse_gtsv_interleaved_alg_lu` ), or QR ( `rocsparse_gtsv_interleaved_alg_qr` ). !> Passing `rocsparse_gtsv_interleaved_alg_default` defaults to using the QR algorithm. !> !> Unlike the strided batch routines, which write each batch matrix one after the other in !> memory, the interleaved !> routines write the batch matrices such that each element from each matrix is written !> consecutively one after !> the other. For example, consider the following batch matrices: !> !> \f[ !> \begin{bmatrix} !> t^{0}_{00} & t^{0}_{01} & 0 \\% !> t^{0}_{10} & t^{0}_{11} & t^{0}_{12} \\% !> 0 & t^{0}_{21} & t^{0}_{22} !> \end{bmatrix} !> \begin{bmatrix} !> t^{1}_{00} & t^{1}_{01} & 0 \\% !> t^{1}_{10} & t^{1}_{11} & t^{1}_{12} \\% !> 0 & t^{1}_{21} & t^{1}_{22} !> \end{bmatrix} !> \begin{bmatrix} !> t^{2}_{00} & t^{2}_{01} & 0 \\% !> t^{2}_{10} & t^{2}_{11} & t^{2}_{12} \\% !> 0 & t^{2}_{21} & t^{2}_{22} !> \end{bmatrix} !> \f] !> !> In interleaved format, the upper, lower, and diagonal arrays would look like: !> \f[ !> \begin{align} !> \text{lower} &= \begin{bmatrix} 0 & 0 & 0 & t^{0}_{10} & t^{1}_{10} & t^{1}_{10} & !> t^{0}_{21} & t^{1}_{21} & t^{2}_{21} \end{bmatrix} \\% !> \text{diagonal} &= \begin{bmatrix} t^{0}_{00} & t^{1}_{00} & t^{2}_{00} & t^{0}_{11} & !> t^{1}_{11} & t^{2}_{11} & t^{0}_{22} & t^{1}_{22} & t^{2}_{22} \end{bmatrix} \\% !> \text{upper} &= \begin{bmatrix} t^{0}_{01} & t^{1}_{01} & t^{2}_{01} & t^{0}_{12} & !> t^{1}_{12} & t^{2}_{12} & 0 & 0 & 0 \end{bmatrix} \\% !> \end{align} !> \f] !> For the lower array, the first \p batch_count entries are zero, and for the upper array, the !> last \p batch_count !> entries are zero. !> !> \note !> This function is non-blocking and executed asynchronously with respect to the host. !> It can return before the actual computation has finished. !> !> \note !> This routine supports execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] alg - algorithm to use when solving tridiagonal systems. Options are Thomas ( !> `rocsparse_gtsv_interleaved_alg_thomas` ), !> LU ( `rocsparse_gtsv_interleaved_alg_lu` ), or QR ( !> `rocsparse_gtsv_interleaved_alg_qr` ). Passing !> `rocsparse_gtsv_interleaved_alg_default` defaults to using the QR algorithm. The !> Thomas algorithm is the fastest but is not !> stable, while LU and QR are slower but are stable. !> @param[in] m - size of the tri-diagonal linear system. !> @param[inout] dl - lower diagonal of tri-diagonal system. The first element of the lower !> diagonal must be zero. !> @param[inout] d - main diagonal of tri-diagonal system. !> @param[inout] du - upper diagonal of tri-diagonal system. The last element of the upper !> diagonal must be zero. !> @param[inout] x - dense array of right-hand sides, with dimension \p batch_stride by \p m. !> @param[in] batch_count - the number of systems to solve. !> @param[in] batch_stride - the number of elements that separate consecutive elements in a !> system. Must satisfy \p batch_stride >= \p batch_count. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p batch_count, or \p batch_stride is invalid. !> \retval rocsparse_status_invalid_pointer \p dl, \p d, !> \p du, \p x, or \p temp_buffer pointer is invalid. !> \retval rocsparse_status_internal_error an internal error occurred. !> !> \par Example interface rocsparse_sgtsv_interleaved_batch function rocsparse_sgtsv_interleaved_batch_(handle,alg,m,dl,d,du,x,batch_count,batch_stride, & temp_buffer) & bind(c, name="rocsparse_sgtsv_interleaved_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_interleaved_batch_ type(c_ptr),value :: handle integer(kind(rocsparse_gtsv_interleaved_alg_default)),value :: alg integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_dgtsv_interleaved_batch function rocsparse_dgtsv_interleaved_batch_(handle,alg,m,dl,d,du,x,batch_count,batch_stride, & temp_buffer) & bind(c, name="rocsparse_dgtsv_interleaved_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_interleaved_batch_ type(c_ptr),value :: handle integer(kind(rocsparse_gtsv_interleaved_alg_default)),value :: alg integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_cgtsv_interleaved_batch function rocsparse_cgtsv_interleaved_batch_(handle,alg,m,dl,d,du,x,batch_count,batch_stride, & temp_buffer) & bind(c, name="rocsparse_cgtsv_interleaved_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_interleaved_batch_ type(c_ptr),value :: handle integer(kind(rocsparse_gtsv_interleaved_alg_default)),value :: alg integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_zgtsv_interleaved_batch function rocsparse_zgtsv_interleaved_batch_(handle,alg,m,dl,d,du,x,batch_count,batch_stride, & temp_buffer) & bind(c, name="rocsparse_zgtsv_interleaved_batch") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_interleaved_batch_ type(c_ptr),value :: handle integer(kind(rocsparse_gtsv_interleaved_alg_default)),value :: alg integer(c_int),value :: m type(c_ptr),value :: dl type(c_ptr),value :: d type(c_ptr),value :: du type(c_ptr),value :: x integer(c_int),value :: batch_count integer(c_int),value :: batch_stride type(c_ptr),value :: temp_buffer end function end interface !> \ingroup reordering_module !> \brief Coloring of the adjacency graph of the matrix \f$A\f$ stored in the CSR format. !> !> \details !> \p rocsparse_csrcolor performs the coloring of the undirected graph represented by the !> (symmetric) sparsity pattern of the !> matrix \f$A\f$ stored in CSR format. Graph coloring is a way of coloring the nodes of a graph !> such that no two adjacent nodes !> are of the same color. The \p fraction_to_color is a parameter to only color a given !> percentage of the graph nodes, while the !> remaining uncolored nodes receive distinct new colors. The optional \p reordering array is a !> permutation array such that !> unknowns of the same color are grouped. The matrix \f$A\f$ must be stored as a general matrix !> with a symmetric sparsity pattern, !> and if the matrix \f$A\f$ is non-symmetric, then the user is responsible to provide the !> symmetric part \f$\frac{A+A^T}{2}\f$. !> !> \note !> This function is blocking with respect to the host. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of sparse matrix \f$A\f$. !> @param[in] nnz - number of non-zero entries of sparse matrix \f$A\f$. !> @param[in] descr - sparse matrix descriptor. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[in] fraction_to_color - fraction of nodes to be colored, which should be in the !> interval [0.0,1.0], for example, 0.8 implies that 80 percent of nodes will be colored. !> @param[out] ncolors - resulting number of distinct colors. !> @param[out] coloring - resulting mapping of colors. !> @param[out] reordering - optional resulting reordering permutation if \p reordering is a !> non-null pointer. !> @param[inout] myInfo - structure that holds the information collected during the coloring !> algorithm. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_size \p m or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p descr, \p csr_val, \p csr_row_ptr, \p !> csr_col_ind, \p fraction_to_color, \p ncolors, \p coloring, or \p info pointer is invalid. interface rocsparse_scsrcolor function rocsparse_scsrcolor_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & fraction_to_color,ncolors,coloring,reordering,myInfo) & bind(c, name="rocsparse_scsrcolor") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrcolor_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind real(c_float) :: fraction_to_color integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_scsrcolor_assumed_rank #else module procedure & rocsparse_scsrcolor_rank_0,& rocsparse_scsrcolor_rank_1 #endif #endif end interface interface rocsparse_dcsrcolor function rocsparse_dcsrcolor_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & fraction_to_color,ncolors,coloring,reordering,myInfo) & bind(c, name="rocsparse_dcsrcolor") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrcolor_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind real(c_double) :: fraction_to_color integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_dcsrcolor_assumed_rank #else module procedure & rocsparse_dcsrcolor_rank_0,& rocsparse_dcsrcolor_rank_1 #endif #endif end interface interface rocsparse_ccsrcolor function rocsparse_ccsrcolor_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & fraction_to_color,ncolors,coloring,reordering,myInfo) & bind(c, name="rocsparse_ccsrcolor") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrcolor_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind real(c_float) :: fraction_to_color integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_ccsrcolor_assumed_rank #else module procedure & rocsparse_ccsrcolor_rank_0,& rocsparse_ccsrcolor_rank_1 #endif #endif end interface interface rocsparse_zcsrcolor function rocsparse_zcsrcolor_(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & fraction_to_color,ncolors,coloring,reordering,myInfo) & bind(c, name="rocsparse_zcsrcolor") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrcolor_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: nnz type(c_ptr),value :: descr type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind real(c_double) :: fraction_to_color integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr),value :: myInfo end function #ifdef USE_FPOINTER_INTERFACES #ifdef USE_ASSUMED_RANK_INTERFACES module procedure rocsparse_zcsrcolor_assumed_rank #else module procedure & rocsparse_zcsrcolor_rank_0,& rocsparse_zcsrcolor_rank_1 #endif #endif end interface !> \ingroup utility_module !> \details !> \p rocsparse_check_matrix_coo_buffer_size computes the required buffer size needed when !> calling \ref rocsparse_scheck_matrix_coo "rocsparse_Xcheck_matrix_coo()". !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] coo_val - array of \p nnz elements of the sparse COO matrix. !> @param[in] coo_row_ind - array of \p nnz elements containing the row indices of the sparse !> COO matrix. !> @param[in] coo_col_ind - array of \p nnz elements containing the column indices of the sparse !> COO matrix. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] matrix_type - `rocsparse_matrix_type_general`, `rocsparse_matrix_type_symmetric`, !> `rocsparse_matrix_type_hermitian`, or `rocsparse_matrix_type_triangular`. !> @param[in] uplo - `rocsparse_fill_mode_lower` or `rocsparse_fill_mode_upper`. !> @param[in] storage - `rocsparse_storage_mode_sorted` or `rocsparse_storage_mode_sorted`. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> \ref rocsparse_scheck_matrix_coo "rocsparse_Xcheck_matrix_coo()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p idx_base, \p matrix_type, \p uplo, or \p storage is !> invalid. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p coo_val, \p coo_row_ind, \p coo_col_ind, or \p !> buffer_size pointer !> is invalid. interface rocsparse_scheck_matrix_coo_buffer_size function rocsparse_scheck_matrix_coo_buffer_size_(handle,m,n,nnz,coo_val,coo_row_ind, & coo_col_ind,idx_base,matrix_type,uplo,storage,buffer_size) & bind(c, name="rocsparse_scheck_matrix_coo_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scheck_matrix_coo_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface interface rocsparse_dcheck_matrix_coo_buffer_size function rocsparse_dcheck_matrix_coo_buffer_size_(handle,m,n,nnz,coo_val,coo_row_ind, & coo_col_ind,idx_base,matrix_type,uplo,storage,buffer_size) & bind(c, name="rocsparse_dcheck_matrix_coo_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcheck_matrix_coo_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface interface rocsparse_ccheck_matrix_coo_buffer_size function rocsparse_ccheck_matrix_coo_buffer_size_(handle,m,n,nnz,coo_val,coo_row_ind, & coo_col_ind,idx_base,matrix_type,uplo,storage,buffer_size) & bind(c, name="rocsparse_ccheck_matrix_coo_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccheck_matrix_coo_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface interface rocsparse_zcheck_matrix_coo_buffer_size function rocsparse_zcheck_matrix_coo_buffer_size_(handle,m,n,nnz,coo_val,coo_row_ind, & coo_col_ind,idx_base,matrix_type,uplo,storage,buffer_size) & bind(c, name="rocsparse_zcheck_matrix_coo_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcheck_matrix_coo_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface !> \ingroup utility_module !> \brief Check matrix to see if it is valid. !> !> \details !> \p rocsparse_check_matrix_coo checks whether the input COO matrix is valid. It performs basic !> sanity checks on the input !> matrix and tries to detect issues in the data. This includes looking for 'nan' or 'inf' !> values in the data arrays, !> invalid row/column indices, whether the matrix is triangular or not, whether there are !> duplicate row/column !> indices, or whether the row/column indices are not sorted when they should be. If an issue is !> found, it is written to the !> \p data_status parameter. !> !> Performing the above checks involves two steps. First, call \p !> rocsparse_Xcheck_matrix_coo_buffer_size !> to determine the required buffer size. Then allocate this buffer and pass it to \p !> rocsparse_Xcheck_matrix_coo. !> Any issues detected will be written to the \p data_status parameter, which is always a host !> variable regardless of the pointer mode. !> !> **Example** !> !> This example checks whether a COO matrix has the correct row indices. The input matrix !> is invalid because it contains a -1 entry in the row indices array. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse COO matrix. !> @param[in] n - number of columns of the sparse COO matrix. !> @param[in] nnz - number of non-zero entries of the sparse COO matrix. !> @param[in] coo_val - array of \p nnz elements of the sparse COO matrix. !> @param[in] coo_row_ind - array of \p nnz elements containing the row indices of the sparse !> COO matrix. !> @param[in] coo_col_ind - array of \p nnz elements containing the column indices of the sparse !> COO matrix. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] matrix_type - `rocsparse_matrix_type_general`, `rocsparse_matrix_type_symmetric`, !> `rocsparse_matrix_type_hermitian`, or `rocsparse_matrix_type_triangular`. !> @param[in] uplo - `rocsparse_fill_mode_lower` or `rocsparse_fill_mode_upper`. !> @param[in] storage - `rocsparse_storage_mode_sorted` or `rocsparse_storage_mode_sorted`. !> @param[out] data_status - modified to indicate the status of the data. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p idx_base, \p matrix_type, \p uplo, or \p storage is !> invalid. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p coo_val, \p coo_row_ind, \p coo_col_ind, \p !> temp_buffer, or \p data_status pointer !> is invalid. !> !> \code{.c} !> // 1 2 0 0 !> // 0 3 4 0 !> // 0 0 1 1 !> // 0 0 0 2 !> std::vector hcoo_row_ind = {0, 0, -1, 1, 2, 2, 3}; // <---- invalid row index !> std::vector hcoo_col_ind = {0, 1, 1, 2, 2, 3, 3}; !> std::vector hcoo_val = {1, 2, 3, 4, 1, 1, 2}; !> !> int m = 4; !> int n = 4; !> int nnz = 7; !> !> int* dcoo_row_ind = nullptr; !> int* dcoo_col_ind = nullptr; !> float* dcoo_val = nullptr; !> hipMalloc((void**)&dcoo_row_ind, sizeof(int) * nnz); !> hipMalloc((void**)&dcoo_col_ind, sizeof(int) * nnz); !> hipMalloc((void**)&dcoo_val, sizeof(float) * nnz); !> !> hipMemcpy(dcoo_row_ind, hcoo_row_ind.data(), sizeof(int) * nnz, hipMemcpyHostToDevice); !> hipMemcpy(dcoo_col_ind, hcoo_col_ind.data(), sizeof(int) * nnz, hipMemcpyHostToDevice); !> hipMemcpy(dcoo_val, hcoo_val.data(), sizeof(float) * nnz, hipMemcpyHostToDevice); !> !> rocsparse_handle handle; !> rocsparse_create_handle(&handle); !> !> const rocsparse_index_base idx_base = rocsparse_index_base_zero; !> const rocsparse_fill_mode fill_mode = rocsparse_fill_mode_upper; !> const rocsparse_matrix_type matrix_type = rocsparse_matrix_type_triangular; !> const rocsparse_storage_mode storage_mode = rocsparse_storage_mode_sorted; !> !> rocsparse_data_status data_status; !> !> size_t buffer_size; !> rocsparse_scheck_matrix_coo_buffer_size(handle, m, n, nnz, dcoo_val, dcoo_row_ind, !> dcoo_col_ind, !> idx_base, matrix_type, fill_mode, storage_mode, &buffer_size); !> !> void* dbuffer = nullptr; !> hipMalloc((void**)&dbuffer, buffer_size); !> !> rocsparse_scheck_matrix_coo(handle, m, n, nnz, dcoo_val, dcoo_row_ind, dcoo_col_ind, !> idx_base, !> matrix_type, fill_mode, storage_mode, &data_status, dbuffer); !> !> std::cout << "data_status: " << data_status << std::endl; !> !> hipFree(dbuffer); !> !> rocsparse_destroy_handle(handle); !> !> hipFree(dcoo_row_ind); !> hipFree(dcoo_col_ind); !> hipFree(dcoo_val); !> \endcode interface rocsparse_scheck_matrix_coo function rocsparse_scheck_matrix_coo_(handle,m,n,nnz,coo_val,coo_row_ind,coo_col_ind,idx_base, & matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_scheck_matrix_coo") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scheck_matrix_coo_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_dcheck_matrix_coo function rocsparse_dcheck_matrix_coo_(handle,m,n,nnz,coo_val,coo_row_ind,coo_col_ind,idx_base, & matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_dcheck_matrix_coo") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcheck_matrix_coo_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_ccheck_matrix_coo function rocsparse_ccheck_matrix_coo_(handle,m,n,nnz,coo_val,coo_row_ind,coo_col_ind,idx_base, & matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_ccheck_matrix_coo") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccheck_matrix_coo_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_zcheck_matrix_coo function rocsparse_zcheck_matrix_coo_(handle,m,n,nnz,coo_val,coo_row_ind,coo_col_ind,idx_base, & matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_zcheck_matrix_coo") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcheck_matrix_coo_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: coo_val type(c_ptr),value :: coo_row_ind type(c_ptr),value :: coo_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface !> \ingroup utility_module !> \details !> \p rocsparse_check_matrix_csc_buffer_size computes the required buffer size needed when !> calling \ref rocsparse_scheck_matrix_csc "rocsparse_Xcheck_matrix_csc()". !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSC matrix. !> @param[in] n - number of columns of the sparse CSC matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSC matrix. !> @param[in] csc_val - array of \p nnz elements of the sparse CSC matrix. !> @param[in] csc_col_ptr - array of \p m+1 elements that point to the start of every column of !> the !> sparse CSC matrix. !> @param[in] csc_row_ind - array of \p nnz elements containing the row indices of the sparse !> CSC matrix. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] matrix_type - `rocsparse_matrix_type_general`, `rocsparse_matrix_type_symmetric`, !> `rocsparse_matrix_type_hermitian`, or `rocsparse_matrix_type_triangular`. !> @param[in] uplo - `rocsparse_fill_mode_lower` or `rocsparse_fill_mode_upper`. !> @param[in] storage - `rocsparse_storage_mode_sorted` or `rocsparse_storage_mode_sorted`. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> \ref rocsparse_scheck_matrix_csc "rocsparse_Xcheck_matrix_csc()". !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p idx_base, \p matrix_type, \p uplo, or \p storage is !> invalid. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p csc_val, \p csc_col_ptr, \p csc_row_ind, or \p !> buffer_size pointer !> is invalid. interface rocsparse_scheck_matrix_csc_buffer_size function rocsparse_scheck_matrix_csc_buffer_size_(handle,m,n,nnz,csc_val,csc_col_ptr, & csc_row_ind,idx_base,matrix_type,uplo,storage,buffer_size) & bind(c, name="rocsparse_scheck_matrix_csc_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scheck_matrix_csc_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csc_val type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface interface rocsparse_dcheck_matrix_csc_buffer_size function rocsparse_dcheck_matrix_csc_buffer_size_(handle,m,n,nnz,csc_val,csc_col_ptr, & csc_row_ind,idx_base,matrix_type,uplo,storage,buffer_size) & bind(c, name="rocsparse_dcheck_matrix_csc_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcheck_matrix_csc_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csc_val type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface interface rocsparse_ccheck_matrix_csc_buffer_size function rocsparse_ccheck_matrix_csc_buffer_size_(handle,m,n,nnz,csc_val,csc_col_ptr, & csc_row_ind,idx_base,matrix_type,uplo,storage,buffer_size) & bind(c, name="rocsparse_ccheck_matrix_csc_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccheck_matrix_csc_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csc_val type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface interface rocsparse_zcheck_matrix_csc_buffer_size function rocsparse_zcheck_matrix_csc_buffer_size_(handle,m,n,nnz,csc_val,csc_col_ptr, & csc_row_ind,idx_base,matrix_type,uplo,storage,buffer_size) & bind(c, name="rocsparse_zcheck_matrix_csc_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcheck_matrix_csc_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csc_val type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface !> \ingroup utility_module !> \brief Check matrix to see if it is valid. !> !> \details !> \p rocsparse_check_matrix_csc checks if the input CSC matrix is valid. It performs basic !> sanity checks on the input !> matrix and tries to detect issues in the data. This includes looking for 'nan' or 'inf' !> values in the data arrays, !> invalid row indices or invalid column offsets, whether the matrix is triangular or not, !> whether there are duplicate row !> indices, or whether the row indices are not sorted when they should be. If an issue is found, !> it is written to the !> \p data_status parameter. !> !> Performing the above checks involves two steps. First, call \p !> rocsparse_Xcheck_matrix_csc_buffer_size !> to determine the required buffer size. Then allocate this buffer and pass it to \p !> rocsparse_Xcheck_matrix_csc. !> Any issues detected will be written to the \p data_status parameter, which is always a host !> variable regardless of the pointer mode. !> !> **Example** !> !> This example checks whether a CSC matrix has the correct row indices. The input matrix !> is invalid because it contains a duplicate entry in the row indices array. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSC matrix. !> @param[in] n - number of columns of the sparse CSC matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSC matrix. !> @param[in] csc_val - array of \p nnz elements of the sparse CSC matrix. !> @param[in] csc_col_ptr - array of \p m+1 elements that point to the start of every column of !> the !> sparse CSC matrix. !> @param[in] csc_row_ind - array of \p nnz elements containing the row indices of the sparse !> CSC matrix. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] matrix_type - `rocsparse_matrix_type_general`, `rocsparse_matrix_type_symmetric`, !> `rocsparse_matrix_type_hermitian`, or `rocsparse_matrix_type_triangular`. !> @param[in] uplo - `rocsparse_fill_mode_lower` or `rocsparse_fill_mode_upper`. !> @param[in] storage - `rocsparse_storage_mode_sorted` or `rocsparse_storage_mode_sorted`. !> @param[out] data_status - modified to indicate the status of the data. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p idx_base, \p matrix_type, \p uplo, or \p storage is !> invalid. !> \retval rocsparse_status_invalid_size \p m \p n or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p csc_val, \p csc_col_ptr, \p csc_row_ind, \p !> temp_buffer, or \p data_status pointer !> is invalid. !> !> \code{.c} !> // 1 2 0 0 !> // 0 3 4 0 !> // 2 0 1 1 !> // 0 3 0 2 !> std::vector hcsc_row_ind = {0, 2, 0, 1, 1, 1, 2, 2, 3}; //<---duplicate row index in !> second column !> std::vector hcsc_col_ptr = {0, 2, 5, 7, 9}; !> std::vector hcsc_val = {1, 2, 2, 3, 3, 4, 1, 1, 2}; !> !> int m = 4; !> int n = 4; !> int nnz = 9; !> !> int* dcsc_row_ind = nullptr; !> int* dcsc_col_ptr = nullptr; !> float* dcsc_val = nullptr; !> hipMalloc((void**)&dcsc_row_ind, sizeof(int) * nnz); !> hipMalloc((void**)&dcsc_col_ptr, sizeof(int) * (n + 1)); !> hipMalloc((void**)&dcsc_val, sizeof(float) * nnz); !> !> hipMemcpy(dcsc_row_ind, hcsc_row_ind.data(), sizeof(int) * nnz, hipMemcpyHostToDevice); !> hipMemcpy(dcsc_col_ptr, hcsc_col_ptr.data(), sizeof(int) * (n + 1), hipMemcpyHostToDevice); !> hipMemcpy(dcsc_val, hcsc_val.data(), sizeof(float) * nnz, hipMemcpyHostToDevice); !> !> rocsparse_handle handle; !> rocsparse_create_handle(&handle); !> !> const rocsparse_index_base idx_base = rocsparse_index_base_zero; !> const rocsparse_fill_mode fill_mode = rocsparse_fill_mode_upper; !> const rocsparse_matrix_type matrix_type = rocsparse_matrix_type_general; !> const rocsparse_storage_mode storage_mode = rocsparse_storage_mode_sorted; !> !> rocsparse_data_status data_status; !> !> size_t buffer_size; !> rocsparse_scheck_matrix_csc_buffer_size(handle, m, n, nnz, dcsc_val, dcsc_col_ptr, !> dcsc_row_ind, !> idx_base, matrix_type, fill_mode, storage_mode, &buffer_size); !> !> void* dbuffer = nullptr; !> hipMalloc((void**)&dbuffer, buffer_size); !> !> rocsparse_scheck_matrix_csc(handle, m, n, nnz, dcsc_val, dcsc_col_ptr, dcsc_row_ind, !> idx_base, !> matrix_type, fill_mode, storage_mode, &data_status, dbuffer); !> !> std::cout << "data_status: " << data_status << std::endl; !> !> hipFree(dbuffer); !> !> rocsparse_destroy_handle(handle); !> !> hipFree(dcsc_row_ind); !> hipFree(dcsc_col_ptr); !> hipFree(dcsc_val); !> \endcode interface rocsparse_scheck_matrix_csc function rocsparse_scheck_matrix_csc_(handle,m,n,nnz,csc_val,csc_col_ptr,csc_row_ind,idx_base, & matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_scheck_matrix_csc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scheck_matrix_csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csc_val type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_dcheck_matrix_csc function rocsparse_dcheck_matrix_csc_(handle,m,n,nnz,csc_val,csc_col_ptr,csc_row_ind,idx_base, & matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_dcheck_matrix_csc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcheck_matrix_csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csc_val type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_ccheck_matrix_csc function rocsparse_ccheck_matrix_csc_(handle,m,n,nnz,csc_val,csc_col_ptr,csc_row_ind,idx_base, & matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_ccheck_matrix_csc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccheck_matrix_csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csc_val type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_zcheck_matrix_csc function rocsparse_zcheck_matrix_csc_(handle,m,n,nnz,csc_val,csc_col_ptr,csc_row_ind,idx_base, & matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_zcheck_matrix_csc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcheck_matrix_csc_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csc_val type(c_ptr),value :: csc_col_ptr type(c_ptr),value :: csc_row_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface !> \ingroup utility_module !> \details !> \p rocsparse_check_matrix_csr_buffer_size computes the required buffer size needed when !> calling !> \ref rocsparse_scheck_matrix_csr "rocsparse_Xcheck_matrix_csr()". !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] matrix_type - `rocsparse_matrix_type_general`, `rocsparse_matrix_type_symmetric`, !> `rocsparse_matrix_type_hermitian`, or `rocsparse_matrix_type_triangular`. !> @param[in] uplo - `rocsparse_fill_mode_lower` or `rocsparse_fill_mode_upper`. !> @param[in] storage - `rocsparse_storage_mode_sorted` or `rocsparse_storage_mode_sorted`. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> rocsparse_scheck_matrix_csr(), rocsparse_dcheck_matrix_csr(), !> rocsparse_ccheck_matrix_csr(), and rocsparse_zcheck_matrix_csr(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p idx_base, \p matrix_type, \p uplo, or \p storage is !> invalid. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p csr_val, \p csr_row_ptr, \p csr_col_ind, or \p !> buffer_size pointer !> is invalid. interface rocsparse_scheck_matrix_csr_buffer_size function rocsparse_scheck_matrix_csr_buffer_size_(handle,m,n,nnz,csr_val,csr_row_ptr, & csr_col_ind,idx_base,matrix_type,uplo,storage,buffer_size) & bind(c, name="rocsparse_scheck_matrix_csr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scheck_matrix_csr_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface interface rocsparse_dcheck_matrix_csr_buffer_size function rocsparse_dcheck_matrix_csr_buffer_size_(handle,m,n,nnz,csr_val,csr_row_ptr, & csr_col_ind,idx_base,matrix_type,uplo,storage,buffer_size) & bind(c, name="rocsparse_dcheck_matrix_csr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcheck_matrix_csr_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface interface rocsparse_ccheck_matrix_csr_buffer_size function rocsparse_ccheck_matrix_csr_buffer_size_(handle,m,n,nnz,csr_val,csr_row_ptr, & csr_col_ind,idx_base,matrix_type,uplo,storage,buffer_size) & bind(c, name="rocsparse_ccheck_matrix_csr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccheck_matrix_csr_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface interface rocsparse_zcheck_matrix_csr_buffer_size function rocsparse_zcheck_matrix_csr_buffer_size_(handle,m,n,nnz,csr_val,csr_row_ptr, & csr_col_ind,idx_base,matrix_type,uplo,storage,buffer_size) & bind(c, name="rocsparse_zcheck_matrix_csr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcheck_matrix_csr_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface !> \ingroup utility_module !> \brief Check matrix to see if it is valid. !> !> \details !> \p rocsparse_check_matrix_csr checks whether the input CSR matrix is valid. It performs basic !> sanity checks on the input !> matrix and tries to detect issues in the data. This includes looking for 'nan' or 'inf' !> values in the data arrays, !> invalid column indices or row offsets, whether the matrix is triangular or not, whether there !> are duplicate !> indices, or whether the column indices are not sorted when they should be. If an issue is !> found, it is written to the !> \p data_status parameter. !> !> Performing the above checks involves two steps. First, call \p !> rocsparse_Xcheck_matrix_csr_buffer_size !> to determine the required buffer size. Then allocate this buffer and pass it to \p !> rocsparse_Xcheck_matrix_csr. !> Any issues detected will be written to the \p data_status parameter, which is always a host !> variable regardless of the pointer mode. !> !> **Example** !> !> This example checks whether a CSR matrix has the correct row pointer array. The input matrix !> is invalid because it contains a -1 entry in the row pointer array. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse CSR matrix. !> @param[in] n - number of columns of the sparse CSR matrix. !> @param[in] nnz - number of non-zero entries of the sparse CSR matrix. !> @param[in] csr_val - array of \p nnz elements of the sparse CSR matrix. !> @param[in] csr_row_ptr - array of \p m+1 elements that point to the start of every row of the !> sparse CSR matrix. !> @param[in] csr_col_ind - array of \p nnz elements containing the column indices of the sparse !> CSR matrix. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] matrix_type - `rocsparse_matrix_type_general`, `rocsparse_matrix_type_symmetric`, !> `rocsparse_matrix_type_hermitian`, or `rocsparse_matrix_type_triangular`. !> @param[in] uplo - `rocsparse_fill_mode_lower` or `rocsparse_fill_mode_upper`. !> @param[in] storage - `rocsparse_storage_mode_sorted` or `rocsparse_storage_mode_sorted`. !> @param[out] data_status - modified to indicate the status of the data. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p idx_base, \p matrix_type, \p uplo, or \p storage is !> invalid. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p nnz is invalid. !> \retval rocsparse_status_invalid_pointer \p csr_val, \p csr_row_ptr, \p csr_col_ind, \p !> temp_buffer, or \p data_status pointer !> is invalid. !> !> \code{.c} !> // 1 2 0 0 !> // 0 3 4 0 !> // 2 0 1 1 !> // 0 3 0 2 !> std::vector hcsr_row_ptr = {0, 2, -1, 7, 9}; // <---- invalid ptr array !> std::vector hcsr_col_ind = {0, 1, 1, 2, 0, 2, 3, 1, 3}; !> std::vector hcsr_val = {1, 2, 3, 4, 2, 1, 1, 3, 2}; !> !> int m = 4; !> int n = 4; !> int nnz = 9; !> !> int* dcsr_row_ptr = nullptr; !> int* dcsr_col_ind = nullptr; !> float* dcsr_val = nullptr; !> hipMalloc((void**)&dcsr_row_ptr, sizeof(int) * (m + 1)); !> hipMalloc((void**)&dcsr_col_ind, sizeof(int) * nnz); !> hipMalloc((void**)&dcsr_val, sizeof(float) * nnz); !> !> hipMemcpy(dcsr_row_ptr, hcsr_row_ptr.data(), sizeof(int) * (m + 1), hipMemcpyHostToDevice); !> hipMemcpy(dcsr_col_ind, hcsr_col_ind.data(), sizeof(int) * nnz, hipMemcpyHostToDevice); !> hipMemcpy(dcsr_val, hcsr_val.data(), sizeof(float) * nnz, hipMemcpyHostToDevice); !> !> rocsparse_handle handle; !> rocsparse_create_handle(&handle); !> !> const rocsparse_index_base idx_base = rocsparse_index_base_zero; !> const rocsparse_fill_mode fill_mode = rocsparse_fill_mode_upper; !> const rocsparse_matrix_type matrix_type = rocsparse_matrix_type_general; !> const rocsparse_storage_mode storage_mode = rocsparse_storage_mode_sorted; !> !> rocsparse_data_status data_status; !> !> size_t buffer_size; !> rocsparse_scheck_matrix_csr_buffer_size(handle, m, n, nnz, dcsr_val, dcsr_row_ptr, !> dcsr_col_ind, !> idx_base, matrix_type, fill_mode, storage_mode, &buffer_size); !> !> void* dbuffer = nullptr; !> hipMalloc((void**)&dbuffer, buffer_size); !> !> rocsparse_scheck_matrix_csr(handle, m, n, nnz, dcsr_val, dcsr_row_ptr, dcsr_col_ind, !> idx_base, !> matrix_type, fill_mode, storage_mode, &data_status, dbuffer); !> !> std::cout << "data_status: " << data_status << std::endl; !> !> hipFree(dbuffer); !> !> rocsparse_destroy_handle(handle); !> !> hipFree(dcsr_row_ptr); !> hipFree(dcsr_col_ind); !> hipFree(dcsr_val); !> \endcode interface rocsparse_scheck_matrix_csr function rocsparse_scheck_matrix_csr_(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind,idx_base, & matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_scheck_matrix_csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scheck_matrix_csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_dcheck_matrix_csr function rocsparse_dcheck_matrix_csr_(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind,idx_base, & matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_dcheck_matrix_csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcheck_matrix_csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_ccheck_matrix_csr function rocsparse_ccheck_matrix_csr_(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind,idx_base, & matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_ccheck_matrix_csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccheck_matrix_csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_zcheck_matrix_csr function rocsparse_zcheck_matrix_csr_(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind,idx_base, & matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_zcheck_matrix_csr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcheck_matrix_csr_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: nnz type(c_ptr),value :: csr_val type(c_ptr),value :: csr_row_ptr type(c_ptr),value :: csr_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface !> \ingroup utility_module !> \details !> \p rocsparse_check_matrix_ell_buffer_size computes the required buffer size needed when !> calling \ref rocsparse_scheck_matrix_ell "rocsparse_Xcheck_matrix_ell()". !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse ELL matrix. !> @param[in] n - number of columns of the sparse ELL matrix. !> @param[in] ell_width - number of non-zero elements per row of the sparse ELL matrix. !> @param[in] ell_val - array that contains the elements of the sparse ELL matrix. Padded !> elements should be zero. !> @param[in] ell_col_ind - array that contains the column indices of the sparse ELL matrix. !> Padded column indices should be -1. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] matrix_type - `rocsparse_matrix_type_general`, `rocsparse_matrix_type_symmetric`, !> `rocsparse_matrix_type_hermitian`, or `rocsparse_matrix_type_triangular`. !> @param[in] uplo - `rocsparse_fill_mode_lower` or `rocsparse_fill_mode_upper`. !> @param[in] storage - `rocsparse_storage_mode_sorted` or `rocsparse_storage_mode_sorted`. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> rocsparse_scheck_matrix_ell(), rocsparse_dcheck_matrix_ell(), !> rocsparse_ccheck_matrix_ell(), and rocsparse_zcheck_matrix_ell(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p idx_base, \p matrix_type, \p uplo, or \p storage is !> invalid. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p ell_width is invalid. !> \retval rocsparse_status_invalid_pointer \p ell_val, \p ell_col_ind, or \p buffer_size !> pointer !> is invalid. interface rocsparse_scheck_matrix_ell_buffer_size function rocsparse_scheck_matrix_ell_buffer_size_(handle,m,n,ell_width,ell_val,ell_col_ind, & idx_base,matrix_type,uplo,storage,buffer_size) & bind(c, name="rocsparse_scheck_matrix_ell_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scheck_matrix_ell_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: ell_width type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface interface rocsparse_dcheck_matrix_ell_buffer_size function rocsparse_dcheck_matrix_ell_buffer_size_(handle,m,n,ell_width,ell_val,ell_col_ind, & idx_base,matrix_type,uplo,storage,buffer_size) & bind(c, name="rocsparse_dcheck_matrix_ell_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcheck_matrix_ell_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: ell_width type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface interface rocsparse_ccheck_matrix_ell_buffer_size function rocsparse_ccheck_matrix_ell_buffer_size_(handle,m,n,ell_width,ell_val,ell_col_ind, & idx_base,matrix_type,uplo,storage,buffer_size) & bind(c, name="rocsparse_ccheck_matrix_ell_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccheck_matrix_ell_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: ell_width type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface interface rocsparse_zcheck_matrix_ell_buffer_size function rocsparse_zcheck_matrix_ell_buffer_size_(handle,m,n,ell_width,ell_val,ell_col_ind, & idx_base,matrix_type,uplo,storage,buffer_size) & bind(c, name="rocsparse_zcheck_matrix_ell_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcheck_matrix_ell_buffer_size_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: ell_width type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface !> \ingroup utility_module !> \brief Check matrix to see if it is valid. !> !> \details !> \p rocsparse_check_matrix_ell checks if the input ELL matrix is valid. It performs basic !> sanity checks on the input !> matrix and tries to detect issues in the data. This includes looking for 'nan' or 'inf' !> values in the data arrays, !> invalid column indices, whether there are duplicate indices, or whether the column indices !> are not sorted when they !> should be. If an issue is found, it is written to the \p data_status parameter. !> !> Performing the above checks involves two steps. First, call \p !> rocsparse_Xcheck_matrix_ell_buffer_size !> to determine the required buffer size. Then allocate this buffer and pass it to \p !> rocsparse_Xcheck_matrix_ell. !> Any issues detected will be written to the \p data_status parameter, which is always a host !> variable regardless of the pointer mode. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] m - number of rows of the sparse ELL matrix. !> @param[in] n - number of columns of the sparse ELL matrix. !> @param[in] ell_width - number of non-zero elements per row of the sparse ELL matrix. !> @param[in] ell_val - array that contains the elements of the sparse ELL matrix. Padded !> elements should be zero. !> @param[in] ell_col_ind - array that contains the column indices of the sparse ELL matrix. !> Padded column indices should be -1. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] matrix_type - `rocsparse_matrix_type_general`, `rocsparse_matrix_type_symmetric`, !> `rocsparse_matrix_type_hermitian`, or `rocsparse_matrix_type_triangular`. !> @param[in] uplo - `rocsparse_fill_mode_lower` or `rocsparse_fill_mode_upper`. !> @param[in] storage - `rocsparse_storage_mode_sorted` or `rocsparse_storage_mode_sorted`. !> @param[out] data_status - modified to indicate the status of the data. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p idx_base, \p matrix_type, \p uplo, or \p storage is !> invalid. !> \retval rocsparse_status_invalid_size \p m, \p n, or \p ell_width is invalid. !> \retval rocsparse_status_invalid_pointer \p ell_val, \p ell_col_ind, \p temp_buffer, or \p !> data_status pointer !> is invalid. interface rocsparse_scheck_matrix_ell function rocsparse_scheck_matrix_ell_(handle,m,n,ell_width,ell_val,ell_col_ind,idx_base, & matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_scheck_matrix_ell") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scheck_matrix_ell_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: ell_width type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_dcheck_matrix_ell function rocsparse_dcheck_matrix_ell_(handle,m,n,ell_width,ell_val,ell_col_ind,idx_base, & matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_dcheck_matrix_ell") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcheck_matrix_ell_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: ell_width type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_ccheck_matrix_ell function rocsparse_ccheck_matrix_ell_(handle,m,n,ell_width,ell_val,ell_col_ind,idx_base, & matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_ccheck_matrix_ell") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccheck_matrix_ell_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: ell_width type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_zcheck_matrix_ell function rocsparse_zcheck_matrix_ell_(handle,m,n,ell_width,ell_val,ell_col_ind,idx_base, & matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_zcheck_matrix_ell") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcheck_matrix_ell_ type(c_ptr),value :: handle integer(c_int),value :: m integer(c_int),value :: n integer(c_int),value :: ell_width type(c_ptr),value :: ell_val type(c_ptr),value :: ell_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface !> \ingroup utility_module !> \details !> \p rocsparse_check_matrix_gebsc_buffer_size computes the required buffer size needed when !> calling \ref rocsparse_scheck_matrix_gebsc "rocsparse_Xcheck_matrix_gebsc()". !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - matrix storage of GEBSC blocks. !> @param[in] mb - number of block rows of the sparse GEBSC matrix. !> @param[in] nb - number of block columns of the sparse GEBSC matrix. !> @param[in] nnzb - number of non-zero blocks of the sparse GEBSC matrix. !> @param[in] row_block_dim - row block dimension of the sparse GEBSC matrix. !> @param[in] col_block_dim - column block dimension of the sparse GEBSC matrix. !> @param[in] bsc_val - array of \p nnzb elements of the sparse GEBSC matrix. !> @param[in] bsc_col_ptr - array of \p nb+1 elements that point to the start of every column of !> the !> sparse GEBSC matrix. !> @param[in] bsc_row_ind - array of \p nnzb elements containing the row indices of the sparse !> GEBSC matrix. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] matrix_type - `rocsparse_matrix_type_general`, `rocsparse_matrix_type_symmetric`, !> `rocsparse_matrix_type_hermitian`, or `rocsparse_matrix_type_triangular`. !> @param[in] uplo - `rocsparse_fill_mode_lower` or `rocsparse_fill_mode_upper`. !> @param[in] storage - `rocsparse_storage_mode_sorted` or `rocsparse_storage_mode_sorted`. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> rocsparse_scheck_matrix_gebsc(), rocsparse_dcheck_matrix_gebsc(), !> rocsparse_ccheck_matrix_gebsc(), and rocsparse_zcheck_matrix_gebsc(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p dir, \p idx_base, \p matrix_type, \p uplo, or \p !> storage is invalid. !> \retval rocsparse_status_invalid_size \p mb, \p nb, \p nnzb, \p row_block_dim, or \p !> col_block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p bsc_val, \p bsc_col_ptr, \p bsc_row_ind, or \p !> buffer_size pointer !> is invalid. interface rocsparse_scheck_matrix_gebsc_buffer_size function rocsparse_scheck_matrix_gebsc_buffer_size_(handle,dir,mb,nb,nnzb,row_block_dim, & col_block_dim,bsc_val,bsc_col_ptr,bsc_row_ind,idx_base,matrix_type,uplo,storage, & buffer_size) & bind(c, name="rocsparse_scheck_matrix_gebsc_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scheck_matrix_gebsc_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsc_val type(c_ptr),value :: bsc_col_ptr type(c_ptr),value :: bsc_row_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface interface rocsparse_dcheck_matrix_gebsc_buffer_size function rocsparse_dcheck_matrix_gebsc_buffer_size_(handle,dir,mb,nb,nnzb,row_block_dim, & col_block_dim,bsc_val,bsc_col_ptr,bsc_row_ind,idx_base,matrix_type,uplo,storage, & buffer_size) & bind(c, name="rocsparse_dcheck_matrix_gebsc_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcheck_matrix_gebsc_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsc_val type(c_ptr),value :: bsc_col_ptr type(c_ptr),value :: bsc_row_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface interface rocsparse_ccheck_matrix_gebsc_buffer_size function rocsparse_ccheck_matrix_gebsc_buffer_size_(handle,dir,mb,nb,nnzb,row_block_dim, & col_block_dim,bsc_val,bsc_col_ptr,bsc_row_ind,idx_base,matrix_type,uplo,storage, & buffer_size) & bind(c, name="rocsparse_ccheck_matrix_gebsc_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccheck_matrix_gebsc_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsc_val type(c_ptr),value :: bsc_col_ptr type(c_ptr),value :: bsc_row_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface interface rocsparse_zcheck_matrix_gebsc_buffer_size function rocsparse_zcheck_matrix_gebsc_buffer_size_(handle,dir,mb,nb,nnzb,row_block_dim, & col_block_dim,bsc_val,bsc_col_ptr,bsc_row_ind,idx_base,matrix_type,uplo,storage, & buffer_size) & bind(c, name="rocsparse_zcheck_matrix_gebsc_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcheck_matrix_gebsc_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsc_val type(c_ptr),value :: bsc_col_ptr type(c_ptr),value :: bsc_row_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface !> \ingroup utility_module !> \brief Check matrix to see if it is valid. !> !> \details !> \p rocsparse_check_matrix_gebsc checks whether the input GEBSC matrix is valid. It performs !> basic sanity checks on the input !> matrix and tries to detect issues in the data. This includes looking for 'nan' or 'inf' !> values in the data arrays, !> invalid row indices or column offsets, whether the matrix is triangular or not, whether there !> are duplicate !> indices, or whether the row indices are not sorted when they should be. If an issue is found, !> it is written to the !> \p data_status parameter. !> !> Performing the above checks involves two steps. First, call \p !> rocsparse_Xcheck_matrix_gebsc_buffer_size !> to determine the required buffer size. Then allocate this buffer and pass it to \p !> rocsparse_Xcheck_matrix_gebsc. !> Any issues detected will be written to the \p data_status parameter, which is always a host !> variable regardless of the pointer mode. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - matrix storage of GEBSC blocks. !> @param[in] mb - number of block rows of the sparse GEBSC matrix. !> @param[in] nb - number of block columns of the sparse GEBSC matrix. !> @param[in] nnzb - number of non-zero blocks of the sparse GEBSC matrix. !> @param[in] row_block_dim - row block dimension of the sparse GEBSC matrix. !> @param[in] col_block_dim - column block dimension of the sparse GEBSC matrix. !> @param[in] bsc_val - array of \p nnzb elements of the sparse GEBSC matrix. !> @param[in] bsc_col_ptr - array of \p nb+1 elements that point to the start of every column of !> the !> sparse GEBSC matrix. !> @param[in] bsc_row_ind - array of \p nnzb elements containing the row indices of the sparse !> GEBSC matrix. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] matrix_type - `rocsparse_matrix_type_general`, `rocsparse_matrix_type_symmetric`, !> `rocsparse_matrix_type_hermitian`, or `rocsparse_matrix_type_triangular`. !> @param[in] uplo - `rocsparse_fill_mode_lower` or `rocsparse_fill_mode_upper`. !> @param[in] storage - `rocsparse_storage_mode_sorted` or `rocsparse_storage_mode_sorted`. !> @param[out] data_status - modified to indicate the status of the data. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p dir, \p idx_base, \p matrix_type, \p uplo, or \p !> storage is invalid. !> \retval rocsparse_status_invalid_size \p mb, \p nb, \p nnzb, \p row_block_dim, or \p !> col_block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p bsc_val, \p bsc_col_ptr, \p bsc_row_ind, \p !> temp_buffer, or \p data_status pointer !> is invalid. interface rocsparse_scheck_matrix_gebsc function rocsparse_scheck_matrix_gebsc_(handle,dir,mb,nb,nnzb,row_block_dim,col_block_dim, & bsc_val,bsc_col_ptr,bsc_row_ind,idx_base,matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_scheck_matrix_gebsc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scheck_matrix_gebsc_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsc_val type(c_ptr),value :: bsc_col_ptr type(c_ptr),value :: bsc_row_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_dcheck_matrix_gebsc function rocsparse_dcheck_matrix_gebsc_(handle,dir,mb,nb,nnzb,row_block_dim,col_block_dim, & bsc_val,bsc_col_ptr,bsc_row_ind,idx_base,matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_dcheck_matrix_gebsc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcheck_matrix_gebsc_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsc_val type(c_ptr),value :: bsc_col_ptr type(c_ptr),value :: bsc_row_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_ccheck_matrix_gebsc function rocsparse_ccheck_matrix_gebsc_(handle,dir,mb,nb,nnzb,row_block_dim,col_block_dim, & bsc_val,bsc_col_ptr,bsc_row_ind,idx_base,matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_ccheck_matrix_gebsc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccheck_matrix_gebsc_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsc_val type(c_ptr),value :: bsc_col_ptr type(c_ptr),value :: bsc_row_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_zcheck_matrix_gebsc function rocsparse_zcheck_matrix_gebsc_(handle,dir,mb,nb,nnzb,row_block_dim,col_block_dim, & bsc_val,bsc_col_ptr,bsc_row_ind,idx_base,matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_zcheck_matrix_gebsc") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcheck_matrix_gebsc_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsc_val type(c_ptr),value :: bsc_col_ptr type(c_ptr),value :: bsc_row_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface !> \ingroup utility_module !> \brief Check matrix to see if it is valid. !> !> \details !> \p rocsparse_check_matrix_gebsr_buffer_size computes the required buffer size needed when !> calling \ref rocsparse_scheck_matrix_gebsr "rocsparse_Xcheck_matrix_gebsr()". !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - matrix storage of GEBSR blocks. !> @param[in] mb - number of block rows of the sparse GEBSR matrix. !> @param[in] nb - number of block columns of the sparse GEBSR matrix. !> @param[in] nnzb - number of non-zero blocks of the sparse GEBSR matrix. !> @param[in] row_block_dim - row block dimension of the sparse GEBSR matrix. !> @param[in] col_block_dim - column block dimension of the sparse GEBSR matrix. !> @param[in] bsr_val - array of \p nnzb elements of the sparse GEBSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every row of !> the !> sparse GEBSR matrix. !> @param[in] bsr_col_ind - array of \p nnzb elements containing the column indices of the !> sparse !> GEBSR matrix. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] matrix_type - `rocsparse_matrix_type_general`, `rocsparse_matrix_type_symmetric`, !> `rocsparse_matrix_type_hermitian`, or `rocsparse_matrix_type_triangular`. !> @param[in] uplo - `rocsparse_fill_mode_lower` or `rocsparse_fill_mode_upper`. !> @param[in] storage - `rocsparse_storage_mode_sorted` or `rocsparse_storage_mode_sorted`. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> rocsparse_scheck_matrix_gebsr(), rocsparse_dcheck_matrix_gebsr(), !> rocsparse_ccheck_matrix_gebsr(), and rocsparse_zcheck_matrix_gebsr(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p dir, \p idx_base, \p matrix_type, \p uplo, or \p !> storage is invalid. !> \retval rocsparse_status_invalid_size \p mb, \p nb, \p nnzb, \p row_block_dim, or \p !> col_block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p bsr_val, \p bsr_row_ptr, \p bsr_col_ind, or \p !> buffer_size pointer !> is invalid. interface rocsparse_scheck_matrix_gebsr_buffer_size function rocsparse_scheck_matrix_gebsr_buffer_size_(handle,dir,mb,nb,nnzb,row_block_dim, & col_block_dim,bsr_val,bsr_row_ptr,bsr_col_ind,idx_base,matrix_type,uplo,storage, & buffer_size) & bind(c, name="rocsparse_scheck_matrix_gebsr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scheck_matrix_gebsr_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface interface rocsparse_dcheck_matrix_gebsr_buffer_size function rocsparse_dcheck_matrix_gebsr_buffer_size_(handle,dir,mb,nb,nnzb,row_block_dim, & col_block_dim,bsr_val,bsr_row_ptr,bsr_col_ind,idx_base,matrix_type,uplo,storage, & buffer_size) & bind(c, name="rocsparse_dcheck_matrix_gebsr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcheck_matrix_gebsr_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface interface rocsparse_ccheck_matrix_gebsr_buffer_size function rocsparse_ccheck_matrix_gebsr_buffer_size_(handle,dir,mb,nb,nnzb,row_block_dim, & col_block_dim,bsr_val,bsr_row_ptr,bsr_col_ind,idx_base,matrix_type,uplo,storage, & buffer_size) & bind(c, name="rocsparse_ccheck_matrix_gebsr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccheck_matrix_gebsr_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface interface rocsparse_zcheck_matrix_gebsr_buffer_size function rocsparse_zcheck_matrix_gebsr_buffer_size_(handle,dir,mb,nb,nnzb,row_block_dim, & col_block_dim,bsr_val,bsr_row_ptr,bsr_col_ind,idx_base,matrix_type,uplo,storage, & buffer_size) & bind(c, name="rocsparse_zcheck_matrix_gebsr_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcheck_matrix_gebsr_buffer_size_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface !> \ingroup utility_module !> \brief Check matrix to see if it is valid. !> !> \details !> \p rocsparse_check_matrix_gebsr checks whether the input GEBSR matrix is valid. It performs !> basic sanity checks on the input !> matrix and tries to detect issues in the data. This includes looking for 'nan' or 'inf' !> values in the data arrays, !> invalid column indices and row offsets, whether the matrix is triangular or not, whether !> there are duplicate !> indices, or whether the column indices are not sorted when they should be. If an issue is !> found, it is written to the !> \p data_status parameter. !> !> Performing the above checks involves two steps. First, call \p !> rocsparse_Xcheck_matrix_gebsr_buffer_size !> to determine the required buffer size. Then allocate this buffer and pass it to \p !> rocsparse_Xcheck_matrix_gebsr. !> Any issues detected will be written to the \p data_status parameter, which is always a host !> variable regardless of the pointer mode. !> !> **Example** !> !> This example checks whether a GEBSR matrix has valid values. The input matrix !> is invalid because it contains a nan entry in the values array. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] dir - matrix storage of GEBSR blocks. !> @param[in] mb - number of block rows of the sparse GEBSR matrix. !> @param[in] nb - number of block columns of the sparse GEBSR matrix. !> @param[in] nnzb - number of non-zero blocks of the sparse GEBSR matrix. !> @param[in] row_block_dim - row block dimension of the sparse GEBSR matrix. !> @param[in] col_block_dim - column block dimension of the sparse GEBSR matrix. !> @param[in] bsr_val - array of \p nnzb elements of the sparse GEBSR matrix. !> @param[in] bsr_row_ptr - array of \p mb+1 elements that point to the start of every row of !> the !> sparse GEBSR matrix. !> @param[in] bsr_col_ind - array of \p nnzb elements containing the column indices of the !> sparse !> GEBSR matrix. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] matrix_type - `rocsparse_matrix_type_general`, `rocsparse_matrix_type_symmetric`, !> `rocsparse_matrix_type_hermitian`, or `rocsparse_matrix_type_triangular`. !> @param[in] uplo - `rocsparse_fill_mode_lower` or `rocsparse_fill_mode_upper`. !> @param[in] storage - `rocsparse_storage_mode_sorted` or `rocsparse_storage_mode_sorted`. !> @param[out] data_status - modified to indicate the status of the data. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p dir, \p idx_base, \p matrix_type, \p uplo, or \p !> storage is invalid. !> \retval rocsparse_status_invalid_size \p mb, \p nb, \p nnzb, \p row_block_dim, or \p !> col_block_dim is invalid. !> \retval rocsparse_status_invalid_pointer \p bsr_val, \p bsr_row_ptr, \p bsr_col_ind, \p !> temp_buffer, or \p data_status pointer !> is invalid. !> !> \code{.c} !> // 1 2 | 0 0 !> // 0 3 | 0 0 !> // --------- !> // 4 5 | 7 8 !> // 0 6 | 0 9 !> std::vector hbsr_row_ptr = {0, 1, 3}; !> std::vector hbsr_col_ind = {0, 0, 1}; !> std::vector hbsr_val = {1, 2, 0, 3, 4, 5, 0, 6, 7, 8, !> std::numeric_limits::quiet_NaN(), 9}; //<---contains nan !> !> int mb = 2; !> int nb = 2; !> int nnzb = 3; !> int block_dim = 2; !> !> int* dbsr_row_ptr = nullptr; !> int* dbsr_col_ind = nullptr; !> float* dbsr_val = nullptr; !> hipMalloc((void**)&dbsr_row_ptr, sizeof(int) * (mb + 1)); !> hipMalloc((void**)&dbsr_col_ind, sizeof(int) * nnzb); !> hipMalloc((void**)&dbsr_val, sizeof(float) * nnzb * block_dim * block_dim); !> !> hipMemcpy(dbsr_row_ptr, hbsr_row_ptr.data(), sizeof(int) * (mb + 1), hipMemcpyHostToDevice); !> hipMemcpy(dbsr_col_ind, hbsr_col_ind.data(), sizeof(int) * nnzb, hipMemcpyHostToDevice); !> hipMemcpy(dbsr_val, hbsr_val.data(), sizeof(float) * nnzb * block_dim * block_dim, !> hipMemcpyHostToDevice); !> !> rocsparse_handle handle; !> rocsparse_create_handle(&handle); !> !> const rocsparse_direction direction = rocsparse_direction_row; !> const rocsparse_index_base idx_base = rocsparse_index_base_zero; !> const rocsparse_fill_mode fill_mode = rocsparse_fill_mode_upper; !> const rocsparse_matrix_type matrix_type = rocsparse_matrix_type_triangular; !> const rocsparse_storage_mode storage_mode = rocsparse_storage_mode_sorted; !> !> rocsparse_data_status data_status; !> !> size_t buffer_size; !> rocsparse_scheck_matrix_gebsr_buffer_size(handle, direction, mb, nb, nnzb, block_dim, !> block_dim, !> dbsr_val, dbsr_row_ptr, dbsr_col_ind, idx_base, matrix_type, fill_mode, storage_mode, !> &buffer_size); !> !> void* dbuffer = nullptr; !> hipMalloc((void**)&dbuffer, buffer_size); !> !> rocsparse_scheck_matrix_gebsr(handle, direction, mb, nb, nnzb, block_dim, block_dim, !> dbsr_val, dbsr_row_ptr, !> dbsr_col_ind, idx_base, matrix_type, fill_mode, storage_mode, &data_status, dbuffer); !> !> std::cout << "data_status: " << data_status << std::endl; !> !> hipFree(dbuffer); !> !> rocsparse_destroy_handle(handle); !> !> hipFree(dbsr_row_ptr); !> hipFree(dbsr_col_ind); !> hipFree(dbsr_val); !> \endcode interface rocsparse_scheck_matrix_gebsr function rocsparse_scheck_matrix_gebsr_(handle,dir,mb,nb,nnzb,row_block_dim,col_block_dim, & bsr_val,bsr_row_ptr,bsr_col_ind,idx_base,matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_scheck_matrix_gebsr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scheck_matrix_gebsr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_dcheck_matrix_gebsr function rocsparse_dcheck_matrix_gebsr_(handle,dir,mb,nb,nnzb,row_block_dim,col_block_dim, & bsr_val,bsr_row_ptr,bsr_col_ind,idx_base,matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_dcheck_matrix_gebsr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcheck_matrix_gebsr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_ccheck_matrix_gebsr function rocsparse_ccheck_matrix_gebsr_(handle,dir,mb,nb,nnzb,row_block_dim,col_block_dim, & bsr_val,bsr_row_ptr,bsr_col_ind,idx_base,matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_ccheck_matrix_gebsr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccheck_matrix_gebsr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface interface rocsparse_zcheck_matrix_gebsr function rocsparse_zcheck_matrix_gebsr_(handle,dir,mb,nb,nnzb,row_block_dim,col_block_dim, & bsr_val,bsr_row_ptr,bsr_col_ind,idx_base,matrix_type,uplo,storage,data_status,temp_buffer) & bind(c, name="rocsparse_zcheck_matrix_gebsr") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcheck_matrix_gebsr_ type(c_ptr),value :: handle integer(kind(rocsparse_direction_row)),value :: dir integer(c_int),value :: mb integer(c_int),value :: nb integer(c_int),value :: nnzb integer(c_int),value :: row_block_dim integer(c_int),value :: col_block_dim type(c_ptr),value :: bsr_val type(c_ptr),value :: bsr_row_ptr type(c_ptr),value :: bsr_col_ind integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface !> \ingroup utility_module !> \brief Check matrix to see if it is valid. !> !> \details !> \p rocsparse_check_matrix_hyb_buffer_size computes the required buffer size needed when !> calling \ref rocsparse_check_matrix_hyb. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] hyb - matrix in HYB storage format. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] matrix_type - `rocsparse_matrix_type_general`, `rocsparse_matrix_type_symmetric`, !> `rocsparse_matrix_type_hermitian`, or `rocsparse_matrix_type_triangular`. !> @param[in] uplo - `rocsparse_fill_mode_lower` or `rocsparse_fill_mode_upper`. !> @param[in] storage - `rocsparse_storage_mode_sorted` or `rocsparse_storage_mode_sorted`. !> @param[out] buffer_size - number of bytes of the temporary storage buffer required by !> rocsparse_check_matrix_hyb(). !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p idx_base, \p matrix_type, \p uplo, or \p storage is !> invalid. !> \retval rocsparse_status_invalid_pointer \p hyb or \p buffer_size pointer is invalid. interface rocsparse_check_matrix_hyb_buffer_size function rocsparse_check_matrix_hyb_buffer_size_(handle,hyb,idx_base,matrix_type,uplo,storage, & buffer_size) & bind(c, name="rocsparse_check_matrix_hyb_buffer_size") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_check_matrix_hyb_buffer_size_ type(c_ptr),value :: handle type(c_ptr),value :: hyb integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage integer(c_size_t) :: buffer_size end function end interface !> \ingroup utility_module !> \brief Check matrix to see if it is valid. !> !> \details !> \p rocsparse_check_matrix_hyb checks whether the input HYB matrix is valid. It performs basic !> sanity checks on the input !> matrix and tries to detect issues in the data. This includes looking for 'nan' or 'inf' !> values in the data arrays, !> invalid row/column indices, whether the matrix is triangular or not, whether there are !> duplicate indices, or whether !> the row/column indices are not sorted when they should be. If an issue is found, it is !> written to the \p data_status !> parameter. !> !> Performing the above checks involves two steps. First, call \p !> rocsparse_Xcheck_matrix_hyb_buffer_size !> to determine the required buffer size. Then allocate this buffer and pass it to \p !> rocsparse_Xcheck_matrix_hyb. !> Any issues detected will be written to the \p data_status parameter, which is always a host !> variable regardless of the pointer mode. !> !> \note !> This routine does not support execution in a hipGraph context. !> !> @param[in] handle - handle to the rocSPARSE library context queue. !> @param[in] hyb - matrix in HYB storage format. !> @param[in] idx_base - `rocsparse_index_base_zero` or `rocsparse_index_base_one`. !> @param[in] matrix_type - `rocsparse_matrix_type_general`, `rocsparse_matrix_type_symmetric`, !> `rocsparse_matrix_type_hermitian`, or `rocsparse_matrix_type_triangular`. !> @param[in] uplo - `rocsparse_fill_mode_lower` or `rocsparse_fill_mode_upper`. !> @param[in] storage - `rocsparse_storage_mode_sorted` or `rocsparse_storage_mode_sorted`. !> @param[out] data_status - modified to indicate the status of the data. !> @param[in] temp_buffer - temporary storage buffer allocated by the user. !> !> \retval rocsparse_status_success the operation completed successfully. !> \retval rocsparse_status_invalid_handle the library context was not initialized. !> \retval rocsparse_status_invalid_value \p idx_base, \p matrix_type, \p uplo, or \p storage is !> invalid. !> \retval rocsparse_status_invalid_pointer \p hyb or \p data_status pointer is invalid. interface rocsparse_check_matrix_hyb function rocsparse_check_matrix_hyb_(handle,hyb,idx_base,matrix_type,uplo,storage,data_status, & temp_buffer) & bind(c, name="rocsparse_check_matrix_hyb") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_check_matrix_hyb_ type(c_ptr),value :: handle type(c_ptr),value :: hyb integer(kind(rocsparse_index_base_zero)),value :: idx_base integer(kind(rocsparse_matrix_type_general)),value :: matrix_type integer(kind(rocsparse_fill_mode_lower)),value :: uplo integer(kind(rocsparse_storage_mode_sorted)),value :: storage type(c_ptr),value :: data_status type(c_ptr),value :: temp_buffer end function end interface !> \ingroup aux_module !> \details Enable rocTX instrumentation. !> \note This routine ignores the environment variable \p ROCSPARSE_ROCTX. interface rocsparse_enable_roctx subroutine rocsparse_enable_roctx_() bind(c, name="rocsparse_enable_roctx") use iso_c_binding use hipfort_rocsparse_enums implicit none end subroutine end interface !> \ingroup aux_module !> \details Disable rocTX instrumentation. !> \note This routine ignores the environment variable \p ROCSPARSE_ROCTX. interface rocsparse_disable_roctx subroutine rocsparse_disable_roctx_() bind(c, name="rocsparse_disable_roctx") use iso_c_binding use hipfort_rocsparse_enums implicit none end subroutine end interface !> \ingroup aux_module !> \details Query whether rocTX instrumentation has been enabled. See \ref !> rocsparse_enable_roctx. !> \return 1 if enabled, 0 otherwise. interface rocsparse_state_roctx function rocsparse_state_roctx_() bind(c, name="rocsparse_state_roctx") use iso_c_binding use hipfort_rocsparse_enums implicit none integer(c_int) :: rocsparse_state_roctx_ end function end interface #ifdef USE_FPOINTER_INTERFACES contains #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sbsr2csr_assumed_rank(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsr2csr_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: csr_descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind ! rocsparse_sbsr2csr_assumed_rank = rocsparse_sbsr2csr_(handle,dir,mb,nb,bsr_descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #else function rocsparse_sbsr2csr_rank_0(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsr2csr_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: csr_descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind ! rocsparse_sbsr2csr_rank_0 = rocsparse_sbsr2csr_(handle,dir,mb,nb,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function function rocsparse_sbsr2csr_rank_1(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsr2csr_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: csr_descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_sbsr2csr_rank_1 = rocsparse_sbsr2csr_(handle,dir,mb,nb,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dbsr2csr_assumed_rank(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsr2csr_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: csr_descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind ! rocsparse_dbsr2csr_assumed_rank = rocsparse_dbsr2csr_(handle,dir,mb,nb,bsr_descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #else function rocsparse_dbsr2csr_rank_0(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsr2csr_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: csr_descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind ! rocsparse_dbsr2csr_rank_0 = rocsparse_dbsr2csr_(handle,dir,mb,nb,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function function rocsparse_dbsr2csr_rank_1(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsr2csr_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: csr_descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_dbsr2csr_rank_1 = rocsparse_dbsr2csr_(handle,dir,mb,nb,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cbsr2csr_assumed_rank(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsr2csr_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: csr_descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind ! rocsparse_cbsr2csr_assumed_rank = rocsparse_cbsr2csr_(handle,dir,mb,nb,bsr_descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #else function rocsparse_cbsr2csr_rank_0(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsr2csr_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: csr_descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind ! rocsparse_cbsr2csr_rank_0 = rocsparse_cbsr2csr_(handle,dir,mb,nb,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function function rocsparse_cbsr2csr_rank_1(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsr2csr_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: csr_descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_cbsr2csr_rank_1 = rocsparse_cbsr2csr_(handle,dir,mb,nb,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zbsr2csr_assumed_rank(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsr2csr_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: csr_descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind ! rocsparse_zbsr2csr_assumed_rank = rocsparse_zbsr2csr_(handle,dir,mb,nb,bsr_descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #else function rocsparse_zbsr2csr_rank_0(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsr2csr_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: csr_descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind ! rocsparse_zbsr2csr_rank_0 = rocsparse_zbsr2csr_(handle,dir,mb,nb,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function function rocsparse_zbsr2csr_rank_1(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsr2csr_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: csr_descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_zbsr2csr_rank_1 = rocsparse_zbsr2csr_(handle,dir,mb,nb,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_coo2csr_assumed_rank(handle,coo_row_ind,nnz,m,csr_row_ptr,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coo2csr_assumed_rank type(c_ptr) :: handle integer(c_int),target,contiguous,dimension(..) :: coo_row_ind integer(c_int) :: nnz integer(c_int) :: m integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_coo2csr_assumed_rank = rocsparse_coo2csr_(handle,c_loc(coo_row_ind),nnz,m, & c_loc(csr_row_ptr),idx_base) end function #else function rocsparse_coo2csr_rank_0(handle,coo_row_ind,nnz,m,csr_row_ptr,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coo2csr_rank_0 type(c_ptr) :: handle integer(c_int),target :: coo_row_ind integer(c_int) :: nnz integer(c_int) :: m integer(c_int),target :: csr_row_ptr integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_coo2csr_rank_0 = rocsparse_coo2csr_(handle,c_loc(coo_row_ind),nnz,m, & c_loc(csr_row_ptr),idx_base) end function function rocsparse_coo2csr_rank_1(handle,coo_row_ind,nnz,m,csr_row_ptr,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coo2csr_rank_1 type(c_ptr) :: handle integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int) :: nnz integer(c_int) :: m integer(c_int),target,dimension(:) :: csr_row_ptr integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_coo2csr_rank_1 = rocsparse_coo2csr_(handle,c_loc(coo_row_ind),nnz,m, & c_loc(csr_row_ptr),idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scoo2dense_assumed_rank(handle,m,n,nnz,descr,coo_val,coo_row_ind, & coo_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scoo2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: coo_val integer(c_int),target,contiguous,dimension(..) :: coo_row_ind integer(c_int),target,contiguous,dimension(..) :: coo_col_ind real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! rocsparse_scoo2dense_assumed_rank = rocsparse_scoo2dense_(handle,m,n,nnz,descr, & c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(A),ld) end function #else function rocsparse_scoo2dense_rank_0(handle,m,n,nnz,descr,coo_val,coo_row_ind,coo_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scoo2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target :: coo_val integer(c_int),target :: coo_row_ind integer(c_int),target :: coo_col_ind real(c_float),target :: A integer(c_int) :: ld ! rocsparse_scoo2dense_rank_0 = rocsparse_scoo2dense_(handle,m,n,nnz,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(A),ld) end function function rocsparse_scoo2dense_rank_1(handle,m,n,nnz,descr,coo_val,coo_row_ind,coo_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scoo2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind real(c_float),target,dimension(:) :: A integer(c_int) :: ld ! rocsparse_scoo2dense_rank_1 = rocsparse_scoo2dense_(handle,m,n,nnz,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(A),ld) end function function rocsparse_scoo2dense_full_rank(handle,m,n,nnz,descr,coo_val,coo_row_ind,coo_col_ind, & A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scoo2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind real(c_float),target,dimension(:,:) :: A integer(c_int) :: ld ! rocsparse_scoo2dense_full_rank = rocsparse_scoo2dense_(handle,m,n,nnz,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(A),ld) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcoo2dense_assumed_rank(handle,m,n,nnz,descr,coo_val,coo_row_ind, & coo_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcoo2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: coo_val integer(c_int),target,contiguous,dimension(..) :: coo_row_ind integer(c_int),target,contiguous,dimension(..) :: coo_col_ind real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! rocsparse_dcoo2dense_assumed_rank = rocsparse_dcoo2dense_(handle,m,n,nnz,descr, & c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(A),ld) end function #else function rocsparse_dcoo2dense_rank_0(handle,m,n,nnz,descr,coo_val,coo_row_ind,coo_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcoo2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target :: coo_val integer(c_int),target :: coo_row_ind integer(c_int),target :: coo_col_ind real(c_double),target :: A integer(c_int) :: ld ! rocsparse_dcoo2dense_rank_0 = rocsparse_dcoo2dense_(handle,m,n,nnz,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(A),ld) end function function rocsparse_dcoo2dense_rank_1(handle,m,n,nnz,descr,coo_val,coo_row_ind,coo_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcoo2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind real(c_double),target,dimension(:) :: A integer(c_int) :: ld ! rocsparse_dcoo2dense_rank_1 = rocsparse_dcoo2dense_(handle,m,n,nnz,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(A),ld) end function function rocsparse_dcoo2dense_full_rank(handle,m,n,nnz,descr,coo_val,coo_row_ind,coo_col_ind, & A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcoo2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind real(c_double),target,dimension(:,:) :: A integer(c_int) :: ld ! rocsparse_dcoo2dense_full_rank = rocsparse_dcoo2dense_(handle,m,n,nnz,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(A),ld) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccoo2dense_assumed_rank(handle,m,n,nnz,descr,coo_val,coo_row_ind, & coo_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccoo2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: coo_val integer(c_int),target,contiguous,dimension(..) :: coo_row_ind integer(c_int),target,contiguous,dimension(..) :: coo_col_ind complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! rocsparse_ccoo2dense_assumed_rank = rocsparse_ccoo2dense_(handle,m,n,nnz,descr, & c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(A),ld) end function #else function rocsparse_ccoo2dense_rank_0(handle,m,n,nnz,descr,coo_val,coo_row_ind,coo_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccoo2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target :: coo_val integer(c_int),target :: coo_row_ind integer(c_int),target :: coo_col_ind complex(c_float_complex),target :: A integer(c_int) :: ld ! rocsparse_ccoo2dense_rank_0 = rocsparse_ccoo2dense_(handle,m,n,nnz,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(A),ld) end function function rocsparse_ccoo2dense_rank_1(handle,m,n,nnz,descr,coo_val,coo_row_ind,coo_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccoo2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: ld ! rocsparse_ccoo2dense_rank_1 = rocsparse_ccoo2dense_(handle,m,n,nnz,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(A),ld) end function function rocsparse_ccoo2dense_full_rank(handle,m,n,nnz,descr,coo_val,coo_row_ind,coo_col_ind, & A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccoo2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: ld ! rocsparse_ccoo2dense_full_rank = rocsparse_ccoo2dense_(handle,m,n,nnz,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(A),ld) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcoo2dense_assumed_rank(handle,m,n,nnz,descr,coo_val,coo_row_ind, & coo_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcoo2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: coo_val integer(c_int),target,contiguous,dimension(..) :: coo_row_ind integer(c_int),target,contiguous,dimension(..) :: coo_col_ind complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! rocsparse_zcoo2dense_assumed_rank = rocsparse_zcoo2dense_(handle,m,n,nnz,descr, & c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(A),ld) end function #else function rocsparse_zcoo2dense_rank_0(handle,m,n,nnz,descr,coo_val,coo_row_ind,coo_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcoo2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target :: coo_val integer(c_int),target :: coo_row_ind integer(c_int),target :: coo_col_ind complex(c_double_complex),target :: A integer(c_int) :: ld ! rocsparse_zcoo2dense_rank_0 = rocsparse_zcoo2dense_(handle,m,n,nnz,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(A),ld) end function function rocsparse_zcoo2dense_rank_1(handle,m,n,nnz,descr,coo_val,coo_row_ind,coo_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcoo2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: ld ! rocsparse_zcoo2dense_rank_1 = rocsparse_zcoo2dense_(handle,m,n,nnz,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(A),ld) end function function rocsparse_zcoo2dense_full_rank(handle,m,n,nnz,descr,coo_val,coo_row_ind,coo_col_ind, & A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcoo2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: ld ! rocsparse_zcoo2dense_full_rank = rocsparse_zcoo2dense_(handle,m,n,nnz,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(A),ld) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_coosort_buffer_size_assumed_rank(handle,m,n,nnz,coo_row_ind,coo_col_ind, & buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coosort_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,contiguous,dimension(..) :: coo_row_ind integer(c_int),target,contiguous,dimension(..) :: coo_col_ind integer(c_size_t) :: buffer_size ! rocsparse_coosort_buffer_size_assumed_rank = rocsparse_coosort_buffer_size_(handle,m,n,nnz, & c_loc(coo_row_ind),c_loc(coo_col_ind),buffer_size) end function #else function rocsparse_coosort_buffer_size_rank_0(handle,m,n,nnz,coo_row_ind,coo_col_ind, & buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coosort_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target :: coo_row_ind integer(c_int),target :: coo_col_ind integer(c_size_t) :: buffer_size ! rocsparse_coosort_buffer_size_rank_0 = rocsparse_coosort_buffer_size_(handle,m,n,nnz, & c_loc(coo_row_ind),c_loc(coo_col_ind),buffer_size) end function function rocsparse_coosort_buffer_size_rank_1(handle,m,n,nnz,coo_row_ind,coo_col_ind, & buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coosort_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind integer(c_size_t) :: buffer_size ! rocsparse_coosort_buffer_size_rank_1 = rocsparse_coosort_buffer_size_(handle,m,n,nnz, & c_loc(coo_row_ind),c_loc(coo_col_ind),buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_coosort_by_row_assumed_rank(handle,m,n,nnz,coo_row_ind,coo_col_ind,perm, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coosort_by_row_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,contiguous,dimension(..) :: coo_row_ind integer(c_int),target,contiguous,dimension(..) :: coo_col_ind integer(c_int),target,contiguous,dimension(..) :: perm type(c_ptr) :: temp_buffer ! rocsparse_coosort_by_row_assumed_rank = rocsparse_coosort_by_row_(handle,m,n,nnz, & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(perm),temp_buffer) end function #else function rocsparse_coosort_by_row_rank_0(handle,m,n,nnz,coo_row_ind,coo_col_ind,perm, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coosort_by_row_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target :: coo_row_ind integer(c_int),target :: coo_col_ind integer(c_int),target :: perm type(c_ptr) :: temp_buffer ! rocsparse_coosort_by_row_rank_0 = rocsparse_coosort_by_row_(handle,m,n,nnz, & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(perm),temp_buffer) end function function rocsparse_coosort_by_row_rank_1(handle,m,n,nnz,coo_row_ind,coo_col_ind,perm, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coosort_by_row_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind integer(c_int),target,dimension(:) :: perm type(c_ptr) :: temp_buffer ! rocsparse_coosort_by_row_rank_1 = rocsparse_coosort_by_row_(handle,m,n,nnz, & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(perm),temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_coosort_by_column_assumed_rank(handle,m,n,nnz,coo_row_ind,coo_col_ind,perm, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coosort_by_column_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,contiguous,dimension(..) :: coo_row_ind integer(c_int),target,contiguous,dimension(..) :: coo_col_ind integer(c_int),target,contiguous,dimension(..) :: perm type(c_ptr) :: temp_buffer ! rocsparse_coosort_by_column_assumed_rank = rocsparse_coosort_by_column_(handle,m,n,nnz, & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(perm),temp_buffer) end function #else function rocsparse_coosort_by_column_rank_0(handle,m,n,nnz,coo_row_ind,coo_col_ind,perm, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coosort_by_column_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target :: coo_row_ind integer(c_int),target :: coo_col_ind integer(c_int),target :: perm type(c_ptr) :: temp_buffer ! rocsparse_coosort_by_column_rank_0 = rocsparse_coosort_by_column_(handle,m,n,nnz, & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(perm),temp_buffer) end function function rocsparse_coosort_by_column_rank_1(handle,m,n,nnz,coo_row_ind,coo_col_ind,perm, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_coosort_by_column_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind integer(c_int),target,dimension(:) :: perm type(c_ptr) :: temp_buffer ! rocsparse_coosort_by_column_rank_1 = rocsparse_coosort_by_column_(handle,m,n,nnz, & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(perm),temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsc2dense_assumed_rank(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A, & ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsc2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csc_val integer(c_int),target,contiguous,dimension(..) :: csc_col_ptr integer(c_int),target,contiguous,dimension(..) :: csc_row_ind real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! rocsparse_scsc2dense_assumed_rank = rocsparse_scsc2dense_(handle,m,n,descr,c_loc(csc_val), & c_loc(csc_col_ptr),c_loc(csc_row_ind),c_loc(A),ld) end function #else function rocsparse_scsc2dense_rank_0(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsc2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target :: csc_val integer(c_int),target :: csc_col_ptr integer(c_int),target :: csc_row_ind real(c_float),target :: A integer(c_int) :: ld ! rocsparse_scsc2dense_rank_0 = rocsparse_scsc2dense_(handle,m,n,descr,c_loc(csc_val), & c_loc(csc_col_ptr),c_loc(csc_row_ind),c_loc(A),ld) end function function rocsparse_scsc2dense_rank_1(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsc2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_col_ptr integer(c_int),target,dimension(:) :: csc_row_ind real(c_float),target,dimension(:) :: A integer(c_int) :: ld ! rocsparse_scsc2dense_rank_1 = rocsparse_scsc2dense_(handle,m,n,descr,c_loc(csc_val), & c_loc(csc_col_ptr),c_loc(csc_row_ind),c_loc(A),ld) end function function rocsparse_scsc2dense_full_rank(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsc2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_col_ptr integer(c_int),target,dimension(:) :: csc_row_ind real(c_float),target,dimension(:,:) :: A integer(c_int) :: ld ! rocsparse_scsc2dense_full_rank = rocsparse_scsc2dense_(handle,m,n,descr,c_loc(csc_val), & c_loc(csc_col_ptr),c_loc(csc_row_ind),c_loc(A),ld) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsc2dense_assumed_rank(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A, & ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsc2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csc_val integer(c_int),target,contiguous,dimension(..) :: csc_col_ptr integer(c_int),target,contiguous,dimension(..) :: csc_row_ind real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! rocsparse_dcsc2dense_assumed_rank = rocsparse_dcsc2dense_(handle,m,n,descr,c_loc(csc_val), & c_loc(csc_col_ptr),c_loc(csc_row_ind),c_loc(A),ld) end function #else function rocsparse_dcsc2dense_rank_0(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsc2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target :: csc_val integer(c_int),target :: csc_col_ptr integer(c_int),target :: csc_row_ind real(c_double),target :: A integer(c_int) :: ld ! rocsparse_dcsc2dense_rank_0 = rocsparse_dcsc2dense_(handle,m,n,descr,c_loc(csc_val), & c_loc(csc_col_ptr),c_loc(csc_row_ind),c_loc(A),ld) end function function rocsparse_dcsc2dense_rank_1(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsc2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_col_ptr integer(c_int),target,dimension(:) :: csc_row_ind real(c_double),target,dimension(:) :: A integer(c_int) :: ld ! rocsparse_dcsc2dense_rank_1 = rocsparse_dcsc2dense_(handle,m,n,descr,c_loc(csc_val), & c_loc(csc_col_ptr),c_loc(csc_row_ind),c_loc(A),ld) end function function rocsparse_dcsc2dense_full_rank(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsc2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_col_ptr integer(c_int),target,dimension(:) :: csc_row_ind real(c_double),target,dimension(:,:) :: A integer(c_int) :: ld ! rocsparse_dcsc2dense_full_rank = rocsparse_dcsc2dense_(handle,m,n,descr,c_loc(csc_val), & c_loc(csc_col_ptr),c_loc(csc_row_ind),c_loc(A),ld) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsc2dense_assumed_rank(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A, & ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsc2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csc_val integer(c_int),target,contiguous,dimension(..) :: csc_col_ptr integer(c_int),target,contiguous,dimension(..) :: csc_row_ind complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! rocsparse_ccsc2dense_assumed_rank = rocsparse_ccsc2dense_(handle,m,n,descr,c_loc(csc_val), & c_loc(csc_col_ptr),c_loc(csc_row_ind),c_loc(A),ld) end function #else function rocsparse_ccsc2dense_rank_0(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsc2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target :: csc_val integer(c_int),target :: csc_col_ptr integer(c_int),target :: csc_row_ind complex(c_float_complex),target :: A integer(c_int) :: ld ! rocsparse_ccsc2dense_rank_0 = rocsparse_ccsc2dense_(handle,m,n,descr,c_loc(csc_val), & c_loc(csc_col_ptr),c_loc(csc_row_ind),c_loc(A),ld) end function function rocsparse_ccsc2dense_rank_1(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsc2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_col_ptr integer(c_int),target,dimension(:) :: csc_row_ind complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: ld ! rocsparse_ccsc2dense_rank_1 = rocsparse_ccsc2dense_(handle,m,n,descr,c_loc(csc_val), & c_loc(csc_col_ptr),c_loc(csc_row_ind),c_loc(A),ld) end function function rocsparse_ccsc2dense_full_rank(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsc2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_col_ptr integer(c_int),target,dimension(:) :: csc_row_ind complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: ld ! rocsparse_ccsc2dense_full_rank = rocsparse_ccsc2dense_(handle,m,n,descr,c_loc(csc_val), & c_loc(csc_col_ptr),c_loc(csc_row_ind),c_loc(A),ld) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsc2dense_assumed_rank(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A, & ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsc2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csc_val integer(c_int),target,contiguous,dimension(..) :: csc_col_ptr integer(c_int),target,contiguous,dimension(..) :: csc_row_ind complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! rocsparse_zcsc2dense_assumed_rank = rocsparse_zcsc2dense_(handle,m,n,descr,c_loc(csc_val), & c_loc(csc_col_ptr),c_loc(csc_row_ind),c_loc(A),ld) end function #else function rocsparse_zcsc2dense_rank_0(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsc2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target :: csc_val integer(c_int),target :: csc_col_ptr integer(c_int),target :: csc_row_ind complex(c_double_complex),target :: A integer(c_int) :: ld ! rocsparse_zcsc2dense_rank_0 = rocsparse_zcsc2dense_(handle,m,n,descr,c_loc(csc_val), & c_loc(csc_col_ptr),c_loc(csc_row_ind),c_loc(A),ld) end function function rocsparse_zcsc2dense_rank_1(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsc2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_col_ptr integer(c_int),target,dimension(:) :: csc_row_ind complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: ld ! rocsparse_zcsc2dense_rank_1 = rocsparse_zcsc2dense_(handle,m,n,descr,c_loc(csc_val), & c_loc(csc_col_ptr),c_loc(csc_row_ind),c_loc(A),ld) end function function rocsparse_zcsc2dense_full_rank(handle,m,n,descr,csc_val,csc_col_ptr,csc_row_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsc2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_col_ptr integer(c_int),target,dimension(:) :: csc_row_ind complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: ld ! rocsparse_zcsc2dense_full_rank = rocsparse_zcsc2dense_(handle,m,n,descr,c_loc(csc_val), & c_loc(csc_col_ptr),c_loc(csc_row_ind),c_loc(A),ld) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cscsort_buffer_size_assumed_rank(handle,m,n,nnz,csc_col_ptr,csc_row_ind, & buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cscsort_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,contiguous,dimension(..) :: csc_col_ptr integer(c_int),target,contiguous,dimension(..) :: csc_row_ind integer(c_size_t) :: buffer_size ! rocsparse_cscsort_buffer_size_assumed_rank = rocsparse_cscsort_buffer_size_(handle,m,n,nnz, & c_loc(csc_col_ptr),c_loc(csc_row_ind),buffer_size) end function #else function rocsparse_cscsort_buffer_size_rank_0(handle,m,n,nnz,csc_col_ptr,csc_row_ind, & buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cscsort_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target :: csc_col_ptr integer(c_int),target :: csc_row_ind integer(c_size_t) :: buffer_size ! rocsparse_cscsort_buffer_size_rank_0 = rocsparse_cscsort_buffer_size_(handle,m,n,nnz, & c_loc(csc_col_ptr),c_loc(csc_row_ind),buffer_size) end function function rocsparse_cscsort_buffer_size_rank_1(handle,m,n,nnz,csc_col_ptr,csc_row_ind, & buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cscsort_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,dimension(:) :: csc_col_ptr integer(c_int),target,dimension(:) :: csc_row_ind integer(c_size_t) :: buffer_size ! rocsparse_cscsort_buffer_size_rank_1 = rocsparse_cscsort_buffer_size_(handle,m,n,nnz, & c_loc(csc_col_ptr),c_loc(csc_row_ind),buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cscsort_assumed_rank(handle,m,n,nnz,descr,csc_col_ptr,csc_row_ind,perm, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cscsort_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr integer(c_int),target,contiguous,dimension(..) :: csc_col_ptr integer(c_int),target,contiguous,dimension(..) :: csc_row_ind integer(c_int),target,contiguous,dimension(..) :: perm type(c_ptr) :: temp_buffer ! rocsparse_cscsort_assumed_rank = rocsparse_cscsort_(handle,m,n,nnz,descr,c_loc(csc_col_ptr), & c_loc(csc_row_ind),c_loc(perm),temp_buffer) end function #else function rocsparse_cscsort_rank_0(handle,m,n,nnz,descr,csc_col_ptr,csc_row_ind,perm,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cscsort_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr integer(c_int),target :: csc_col_ptr integer(c_int),target :: csc_row_ind integer(c_int),target :: perm type(c_ptr) :: temp_buffer ! rocsparse_cscsort_rank_0 = rocsparse_cscsort_(handle,m,n,nnz,descr,c_loc(csc_col_ptr), & c_loc(csc_row_ind),c_loc(perm),temp_buffer) end function function rocsparse_cscsort_rank_1(handle,m,n,nnz,descr,csc_col_ptr,csc_row_ind,perm,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cscsort_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr integer(c_int),target,dimension(:) :: csc_col_ptr integer(c_int),target,dimension(:) :: csc_row_ind integer(c_int),target,dimension(:) :: perm type(c_ptr) :: temp_buffer ! rocsparse_cscsort_rank_1 = rocsparse_cscsort_(handle,m,n,nnz,descr,c_loc(csc_col_ptr), & c_loc(csc_row_ind),c_loc(perm),temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_csr2bsr_nnz_assumed_rank(handle,dir,m,n,csr_descr,csr_row_ptr,csr_col_ind, & block_dim,bsr_descr,bsr_row_ptr,bsr_nnz) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2bsr_nnz_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind integer(c_int) :: block_dim type(c_ptr) :: bsr_descr integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_nnz ! rocsparse_csr2bsr_nnz_assumed_rank = rocsparse_csr2bsr_nnz_(handle,dir,m,n,csr_descr, & c_loc(csr_row_ptr),c_loc(csr_col_ind),block_dim,bsr_descr,c_loc(bsr_row_ptr),c_loc(bsr_nnz)) end function #else function rocsparse_csr2bsr_nnz_rank_0(handle,dir,m,n,csr_descr,csr_row_ptr,csr_col_ind, & block_dim,bsr_descr,bsr_row_ptr,bsr_nnz) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2bsr_nnz_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind integer(c_int) :: block_dim type(c_ptr) :: bsr_descr integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_nnz ! rocsparse_csr2bsr_nnz_rank_0 = rocsparse_csr2bsr_nnz_(handle,dir,m,n,csr_descr, & c_loc(csr_row_ptr),c_loc(csr_col_ind),block_dim,bsr_descr,c_loc(bsr_row_ptr),c_loc(bsr_nnz)) end function function rocsparse_csr2bsr_nnz_rank_1(handle,dir,m,n,csr_descr,csr_row_ptr,csr_col_ind, & block_dim,bsr_descr,bsr_row_ptr,bsr_nnz) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2bsr_nnz_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind integer(c_int) :: block_dim type(c_ptr) :: bsr_descr integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_nnz ! rocsparse_csr2bsr_nnz_rank_1 = rocsparse_csr2bsr_nnz_(handle,dir,m,n,csr_descr, & c_loc(csr_row_ptr),c_loc(csr_col_ind),block_dim,bsr_descr,c_loc(bsr_row_ptr),c_loc(bsr_nnz)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsr2bsr_assumed_rank(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,block_dim,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2bsr_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind integer(c_int) :: block_dim type(c_ptr) :: bsr_descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind ! rocsparse_scsr2bsr_assumed_rank = rocsparse_scsr2bsr_(handle,dir,m,n,csr_descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),block_dim,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind)) end function #else function rocsparse_scsr2bsr_rank_0(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & block_dim,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2bsr_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind integer(c_int) :: block_dim type(c_ptr) :: bsr_descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind ! rocsparse_scsr2bsr_rank_0 = rocsparse_scsr2bsr_(handle,dir,m,n,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),block_dim,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind)) end function function rocsparse_scsr2bsr_rank_1(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & block_dim,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2bsr_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind integer(c_int) :: block_dim type(c_ptr) :: bsr_descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind ! rocsparse_scsr2bsr_rank_1 = rocsparse_scsr2bsr_(handle,dir,m,n,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),block_dim,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsr2bsr_assumed_rank(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,block_dim,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2bsr_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind integer(c_int) :: block_dim type(c_ptr) :: bsr_descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind ! rocsparse_dcsr2bsr_assumed_rank = rocsparse_dcsr2bsr_(handle,dir,m,n,csr_descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),block_dim,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind)) end function #else function rocsparse_dcsr2bsr_rank_0(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & block_dim,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2bsr_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind integer(c_int) :: block_dim type(c_ptr) :: bsr_descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind ! rocsparse_dcsr2bsr_rank_0 = rocsparse_dcsr2bsr_(handle,dir,m,n,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),block_dim,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind)) end function function rocsparse_dcsr2bsr_rank_1(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & block_dim,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2bsr_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind integer(c_int) :: block_dim type(c_ptr) :: bsr_descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind ! rocsparse_dcsr2bsr_rank_1 = rocsparse_dcsr2bsr_(handle,dir,m,n,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),block_dim,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsr2bsr_assumed_rank(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,block_dim,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2bsr_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind integer(c_int) :: block_dim type(c_ptr) :: bsr_descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind ! rocsparse_ccsr2bsr_assumed_rank = rocsparse_ccsr2bsr_(handle,dir,m,n,csr_descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),block_dim,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind)) end function #else function rocsparse_ccsr2bsr_rank_0(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & block_dim,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2bsr_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind integer(c_int) :: block_dim type(c_ptr) :: bsr_descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind ! rocsparse_ccsr2bsr_rank_0 = rocsparse_ccsr2bsr_(handle,dir,m,n,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),block_dim,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind)) end function function rocsparse_ccsr2bsr_rank_1(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & block_dim,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2bsr_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind integer(c_int) :: block_dim type(c_ptr) :: bsr_descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind ! rocsparse_ccsr2bsr_rank_1 = rocsparse_ccsr2bsr_(handle,dir,m,n,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),block_dim,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsr2bsr_assumed_rank(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,block_dim,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2bsr_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind integer(c_int) :: block_dim type(c_ptr) :: bsr_descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind ! rocsparse_zcsr2bsr_assumed_rank = rocsparse_zcsr2bsr_(handle,dir,m,n,csr_descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),block_dim,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind)) end function #else function rocsparse_zcsr2bsr_rank_0(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & block_dim,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2bsr_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind integer(c_int) :: block_dim type(c_ptr) :: bsr_descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind ! rocsparse_zcsr2bsr_rank_0 = rocsparse_zcsr2bsr_(handle,dir,m,n,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),block_dim,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind)) end function function rocsparse_zcsr2bsr_rank_1(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & block_dim,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2bsr_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind integer(c_int) :: block_dim type(c_ptr) :: bsr_descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind ! rocsparse_zcsr2bsr_rank_1 = rocsparse_zcsr2bsr_(handle,dir,m,n,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),block_dim,bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_csr2coo_assumed_rank(handle,csr_row_ptr,nnz,m,coo_row_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2coo_assumed_rank type(c_ptr) :: handle integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int) :: nnz integer(c_int) :: m integer(c_int),target,contiguous,dimension(..) :: coo_row_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_csr2coo_assumed_rank = rocsparse_csr2coo_(handle,c_loc(csr_row_ptr),nnz,m, & c_loc(coo_row_ind),idx_base) end function #else function rocsparse_csr2coo_rank_0(handle,csr_row_ptr,nnz,m,coo_row_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2coo_rank_0 type(c_ptr) :: handle integer(c_int),target :: csr_row_ptr integer(c_int) :: nnz integer(c_int) :: m integer(c_int),target :: coo_row_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_csr2coo_rank_0 = rocsparse_csr2coo_(handle,c_loc(csr_row_ptr),nnz,m, & c_loc(coo_row_ind),idx_base) end function function rocsparse_csr2coo_rank_1(handle,csr_row_ptr,nnz,m,coo_row_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2coo_rank_1 type(c_ptr) :: handle integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int) :: nnz integer(c_int) :: m integer(c_int),target,dimension(:) :: coo_row_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_csr2coo_rank_1 = rocsparse_csr2coo_(handle,c_loc(csr_row_ptr),nnz,m, & c_loc(coo_row_ind),idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_csr2csc_buffer_size_assumed_rank(handle,m,n,nnz,csr_row_ptr,csr_col_ind, & copy_values,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2csc_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind integer(kind(rocsparse_action_symbolic)) :: copy_values integer(c_size_t) :: buffer_size ! rocsparse_csr2csc_buffer_size_assumed_rank = rocsparse_csr2csc_buffer_size_(handle,m,n,nnz, & c_loc(csr_row_ptr),c_loc(csr_col_ind),copy_values,buffer_size) end function #else function rocsparse_csr2csc_buffer_size_rank_0(handle,m,n,nnz,csr_row_ptr,csr_col_ind, & copy_values,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2csc_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind integer(kind(rocsparse_action_symbolic)) :: copy_values integer(c_size_t) :: buffer_size ! rocsparse_csr2csc_buffer_size_rank_0 = rocsparse_csr2csc_buffer_size_(handle,m,n,nnz, & c_loc(csr_row_ptr),c_loc(csr_col_ind),copy_values,buffer_size) end function function rocsparse_csr2csc_buffer_size_rank_1(handle,m,n,nnz,csr_row_ptr,csr_col_ind, & copy_values,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2csc_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind integer(kind(rocsparse_action_symbolic)) :: copy_values integer(c_size_t) :: buffer_size ! rocsparse_csr2csc_buffer_size_rank_1 = rocsparse_csr2csc_buffer_size_(handle,m,n,nnz, & c_loc(csr_row_ptr),c_loc(csr_col_ind),copy_values,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsr2csc_assumed_rank(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind, & csc_val,csc_row_ind,csc_col_ptr,copy_values,idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2csc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind real(c_float),target,contiguous,dimension(..) :: csc_val integer(c_int),target,contiguous,dimension(..) :: csc_row_ind integer(c_int),target,contiguous,dimension(..) :: csc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_scsr2csc_assumed_rank = rocsparse_scsr2csc_(handle,m,n,nnz,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(csc_val),c_loc(csc_row_ind), & c_loc(csc_col_ptr),copy_values,idx_base,temp_buffer) end function #else function rocsparse_scsr2csc_rank_0(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind,csc_val, & csc_row_ind,csc_col_ptr,copy_values,idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2csc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind real(c_float),target :: csc_val integer(c_int),target :: csc_row_ind integer(c_int),target :: csc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_scsr2csc_rank_0 = rocsparse_scsr2csc_(handle,m,n,nnz,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(csc_val),c_loc(csc_row_ind), & c_loc(csc_col_ptr),copy_values,idx_base,temp_buffer) end function function rocsparse_scsr2csc_rank_1(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind,csc_val, & csc_row_ind,csc_col_ptr,copy_values,idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2csc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_float),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_row_ind integer(c_int),target,dimension(:) :: csc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_scsr2csc_rank_1 = rocsparse_scsr2csc_(handle,m,n,nnz,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(csc_val),c_loc(csc_row_ind), & c_loc(csc_col_ptr),copy_values,idx_base,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsr2csc_assumed_rank(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind, & csc_val,csc_row_ind,csc_col_ptr,copy_values,idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2csc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind real(c_double),target,contiguous,dimension(..) :: csc_val integer(c_int),target,contiguous,dimension(..) :: csc_row_ind integer(c_int),target,contiguous,dimension(..) :: csc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_dcsr2csc_assumed_rank = rocsparse_dcsr2csc_(handle,m,n,nnz,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(csc_val),c_loc(csc_row_ind), & c_loc(csc_col_ptr),copy_values,idx_base,temp_buffer) end function #else function rocsparse_dcsr2csc_rank_0(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind,csc_val, & csc_row_ind,csc_col_ptr,copy_values,idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2csc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind real(c_double),target :: csc_val integer(c_int),target :: csc_row_ind integer(c_int),target :: csc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_dcsr2csc_rank_0 = rocsparse_dcsr2csc_(handle,m,n,nnz,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(csc_val),c_loc(csc_row_ind), & c_loc(csc_col_ptr),copy_values,idx_base,temp_buffer) end function function rocsparse_dcsr2csc_rank_1(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind,csc_val, & csc_row_ind,csc_col_ptr,copy_values,idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2csc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_double),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_row_ind integer(c_int),target,dimension(:) :: csc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_dcsr2csc_rank_1 = rocsparse_dcsr2csc_(handle,m,n,nnz,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(csc_val),c_loc(csc_row_ind), & c_loc(csc_col_ptr),copy_values,idx_base,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsr2csc_assumed_rank(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind, & csc_val,csc_row_ind,csc_col_ptr,copy_values,idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2csc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind complex(c_float_complex),target,contiguous,dimension(..) :: csc_val integer(c_int),target,contiguous,dimension(..) :: csc_row_ind integer(c_int),target,contiguous,dimension(..) :: csc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_ccsr2csc_assumed_rank = rocsparse_ccsr2csc_(handle,m,n,nnz,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(csc_val),c_loc(csc_row_ind), & c_loc(csc_col_ptr),copy_values,idx_base,temp_buffer) end function #else function rocsparse_ccsr2csc_rank_0(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind,csc_val, & csc_row_ind,csc_col_ptr,copy_values,idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2csc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind complex(c_float_complex),target :: csc_val integer(c_int),target :: csc_row_ind integer(c_int),target :: csc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_ccsr2csc_rank_0 = rocsparse_ccsr2csc_(handle,m,n,nnz,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(csc_val),c_loc(csc_row_ind), & c_loc(csc_col_ptr),copy_values,idx_base,temp_buffer) end function function rocsparse_ccsr2csc_rank_1(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind,csc_val, & csc_row_ind,csc_col_ptr,copy_values,idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2csc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_float_complex),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_row_ind integer(c_int),target,dimension(:) :: csc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_ccsr2csc_rank_1 = rocsparse_ccsr2csc_(handle,m,n,nnz,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(csc_val),c_loc(csc_row_ind), & c_loc(csc_col_ptr),copy_values,idx_base,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsr2csc_assumed_rank(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind, & csc_val,csc_row_ind,csc_col_ptr,copy_values,idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2csc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind complex(c_double_complex),target,contiguous,dimension(..) :: csc_val integer(c_int),target,contiguous,dimension(..) :: csc_row_ind integer(c_int),target,contiguous,dimension(..) :: csc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_zcsr2csc_assumed_rank = rocsparse_zcsr2csc_(handle,m,n,nnz,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(csc_val),c_loc(csc_row_ind), & c_loc(csc_col_ptr),copy_values,idx_base,temp_buffer) end function #else function rocsparse_zcsr2csc_rank_0(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind,csc_val, & csc_row_ind,csc_col_ptr,copy_values,idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2csc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind complex(c_double_complex),target :: csc_val integer(c_int),target :: csc_row_ind integer(c_int),target :: csc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_zcsr2csc_rank_0 = rocsparse_zcsr2csc_(handle,m,n,nnz,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(csc_val),c_loc(csc_row_ind), & c_loc(csc_col_ptr),copy_values,idx_base,temp_buffer) end function function rocsparse_zcsr2csc_rank_1(handle,m,n,nnz,csr_val,csr_row_ptr,csr_col_ind,csc_val, & csc_row_ind,csc_col_ptr,copy_values,idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2csc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_double_complex),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_row_ind integer(c_int),target,dimension(:) :: csc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_zcsr2csc_rank_1 = rocsparse_zcsr2csc_(handle,m,n,nnz,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(csc_val),c_loc(csc_row_ind), & c_loc(csc_col_ptr),copy_values,idx_base,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsr2csr_compress_assumed_rank(handle,m,n,descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,nnz_A,nnz_per_row,csr_val_C,csr_row_ptr_C,csr_col_ind_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2csr_compress_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr_A real(c_float),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A integer(c_int) :: nnz_A integer(c_int),target,contiguous,dimension(..) :: nnz_per_row real(c_float),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C real(c_float) :: tol ! rocsparse_scsr2csr_compress_assumed_rank = rocsparse_scsr2csr_compress_(handle,m,n,descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),nnz_A,c_loc(nnz_per_row), & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),tol) end function #else function rocsparse_scsr2csr_compress_rank_0(handle,m,n,descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,nnz_A,nnz_per_row,csr_val_C,csr_row_ptr_C,csr_col_ind_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2csr_compress_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr_A real(c_float),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A integer(c_int) :: nnz_A integer(c_int),target :: nnz_per_row real(c_float),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C real(c_float) :: tol ! rocsparse_scsr2csr_compress_rank_0 = rocsparse_scsr2csr_compress_(handle,m,n,descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),nnz_A,c_loc(nnz_per_row), & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),tol) end function function rocsparse_scsr2csr_compress_rank_1(handle,m,n,descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,nnz_A,nnz_per_row,csr_val_C,csr_row_ptr_C,csr_col_ind_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2csr_compress_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr_A real(c_float),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A integer(c_int) :: nnz_A integer(c_int),target,dimension(:) :: nnz_per_row real(c_float),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C real(c_float) :: tol ! rocsparse_scsr2csr_compress_rank_1 = rocsparse_scsr2csr_compress_(handle,m,n,descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),nnz_A,c_loc(nnz_per_row), & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),tol) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsr2csr_compress_assumed_rank(handle,m,n,descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,nnz_A,nnz_per_row,csr_val_C,csr_row_ptr_C,csr_col_ind_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2csr_compress_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr_A real(c_double),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A integer(c_int) :: nnz_A integer(c_int),target,contiguous,dimension(..) :: nnz_per_row real(c_double),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C real(c_double) :: tol ! rocsparse_dcsr2csr_compress_assumed_rank = rocsparse_dcsr2csr_compress_(handle,m,n,descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),nnz_A,c_loc(nnz_per_row), & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),tol) end function #else function rocsparse_dcsr2csr_compress_rank_0(handle,m,n,descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,nnz_A,nnz_per_row,csr_val_C,csr_row_ptr_C,csr_col_ind_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2csr_compress_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr_A real(c_double),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A integer(c_int) :: nnz_A integer(c_int),target :: nnz_per_row real(c_double),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C real(c_double) :: tol ! rocsparse_dcsr2csr_compress_rank_0 = rocsparse_dcsr2csr_compress_(handle,m,n,descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),nnz_A,c_loc(nnz_per_row), & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),tol) end function function rocsparse_dcsr2csr_compress_rank_1(handle,m,n,descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,nnz_A,nnz_per_row,csr_val_C,csr_row_ptr_C,csr_col_ind_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2csr_compress_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr_A real(c_double),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A integer(c_int) :: nnz_A integer(c_int),target,dimension(:) :: nnz_per_row real(c_double),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C real(c_double) :: tol ! rocsparse_dcsr2csr_compress_rank_1 = rocsparse_dcsr2csr_compress_(handle,m,n,descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),nnz_A,c_loc(nnz_per_row), & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),tol) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsr2csr_compress_assumed_rank(handle,m,n,descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,nnz_A,nnz_per_row,csr_val_C,csr_row_ptr_C,csr_col_ind_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2csr_compress_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr_A complex(c_float_complex),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A integer(c_int) :: nnz_A integer(c_int),target,contiguous,dimension(..) :: nnz_per_row complex(c_float_complex),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C complex(c_float_complex) :: tol ! rocsparse_ccsr2csr_compress_assumed_rank = rocsparse_ccsr2csr_compress_(handle,m,n,descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),nnz_A,c_loc(nnz_per_row), & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),tol) end function #else function rocsparse_ccsr2csr_compress_rank_0(handle,m,n,descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,nnz_A,nnz_per_row,csr_val_C,csr_row_ptr_C,csr_col_ind_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2csr_compress_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr_A complex(c_float_complex),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A integer(c_int) :: nnz_A integer(c_int),target :: nnz_per_row complex(c_float_complex),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C complex(c_float_complex) :: tol ! rocsparse_ccsr2csr_compress_rank_0 = rocsparse_ccsr2csr_compress_(handle,m,n,descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),nnz_A,c_loc(nnz_per_row), & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),tol) end function function rocsparse_ccsr2csr_compress_rank_1(handle,m,n,descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,nnz_A,nnz_per_row,csr_val_C,csr_row_ptr_C,csr_col_ind_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2csr_compress_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr_A complex(c_float_complex),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A integer(c_int) :: nnz_A integer(c_int),target,dimension(:) :: nnz_per_row complex(c_float_complex),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C complex(c_float_complex) :: tol ! rocsparse_ccsr2csr_compress_rank_1 = rocsparse_ccsr2csr_compress_(handle,m,n,descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),nnz_A,c_loc(nnz_per_row), & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),tol) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsr2csr_compress_assumed_rank(handle,m,n,descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,nnz_A,nnz_per_row,csr_val_C,csr_row_ptr_C,csr_col_ind_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2csr_compress_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr_A complex(c_double_complex),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A integer(c_int) :: nnz_A integer(c_int),target,contiguous,dimension(..) :: nnz_per_row complex(c_double_complex),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C complex(c_double_complex) :: tol ! rocsparse_zcsr2csr_compress_assumed_rank = rocsparse_zcsr2csr_compress_(handle,m,n,descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),nnz_A,c_loc(nnz_per_row), & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),tol) end function #else function rocsparse_zcsr2csr_compress_rank_0(handle,m,n,descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,nnz_A,nnz_per_row,csr_val_C,csr_row_ptr_C,csr_col_ind_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2csr_compress_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr_A complex(c_double_complex),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A integer(c_int) :: nnz_A integer(c_int),target :: nnz_per_row complex(c_double_complex),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C complex(c_double_complex) :: tol ! rocsparse_zcsr2csr_compress_rank_0 = rocsparse_zcsr2csr_compress_(handle,m,n,descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),nnz_A,c_loc(nnz_per_row), & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),tol) end function function rocsparse_zcsr2csr_compress_rank_1(handle,m,n,descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,nnz_A,nnz_per_row,csr_val_C,csr_row_ptr_C,csr_col_ind_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2csr_compress_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr_A complex(c_double_complex),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A integer(c_int) :: nnz_A integer(c_int),target,dimension(:) :: nnz_per_row complex(c_double_complex),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C complex(c_double_complex) :: tol ! rocsparse_zcsr2csr_compress_rank_1 = rocsparse_zcsr2csr_compress_(handle,m,n,descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),nnz_A,c_loc(nnz_per_row), & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),tol) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsr2dense_assumed_rank(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A, & ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! rocsparse_scsr2dense_assumed_rank = rocsparse_scsr2dense_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(A),ld) end function #else function rocsparse_scsr2dense_rank_0(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind real(c_float),target :: A integer(c_int) :: ld ! rocsparse_scsr2dense_rank_0 = rocsparse_scsr2dense_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(A),ld) end function function rocsparse_scsr2dense_rank_1(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_float),target,dimension(:) :: A integer(c_int) :: ld ! rocsparse_scsr2dense_rank_1 = rocsparse_scsr2dense_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(A),ld) end function function rocsparse_scsr2dense_full_rank(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_float),target,dimension(:,:) :: A integer(c_int) :: ld ! rocsparse_scsr2dense_full_rank = rocsparse_scsr2dense_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(A),ld) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsr2dense_assumed_rank(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A, & ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! rocsparse_dcsr2dense_assumed_rank = rocsparse_dcsr2dense_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(A),ld) end function #else function rocsparse_dcsr2dense_rank_0(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind real(c_double),target :: A integer(c_int) :: ld ! rocsparse_dcsr2dense_rank_0 = rocsparse_dcsr2dense_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(A),ld) end function function rocsparse_dcsr2dense_rank_1(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_double),target,dimension(:) :: A integer(c_int) :: ld ! rocsparse_dcsr2dense_rank_1 = rocsparse_dcsr2dense_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(A),ld) end function function rocsparse_dcsr2dense_full_rank(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_double),target,dimension(:,:) :: A integer(c_int) :: ld ! rocsparse_dcsr2dense_full_rank = rocsparse_dcsr2dense_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(A),ld) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsr2dense_assumed_rank(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A, & ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! rocsparse_ccsr2dense_assumed_rank = rocsparse_ccsr2dense_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(A),ld) end function #else function rocsparse_ccsr2dense_rank_0(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind complex(c_float_complex),target :: A integer(c_int) :: ld ! rocsparse_ccsr2dense_rank_0 = rocsparse_ccsr2dense_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(A),ld) end function function rocsparse_ccsr2dense_rank_1(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: ld ! rocsparse_ccsr2dense_rank_1 = rocsparse_ccsr2dense_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(A),ld) end function function rocsparse_ccsr2dense_full_rank(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: ld ! rocsparse_ccsr2dense_full_rank = rocsparse_ccsr2dense_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(A),ld) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsr2dense_assumed_rank(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A, & ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2dense_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld ! rocsparse_zcsr2dense_assumed_rank = rocsparse_zcsr2dense_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(A),ld) end function #else function rocsparse_zcsr2dense_rank_0(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2dense_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind complex(c_double_complex),target :: A integer(c_int) :: ld ! rocsparse_zcsr2dense_rank_0 = rocsparse_zcsr2dense_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(A),ld) end function function rocsparse_zcsr2dense_rank_1(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2dense_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: ld ! rocsparse_zcsr2dense_rank_1 = rocsparse_zcsr2dense_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(A),ld) end function function rocsparse_zcsr2dense_full_rank(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,A,ld) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2dense_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: ld ! rocsparse_zcsr2dense_full_rank = rocsparse_zcsr2dense_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(A),ld) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_csr2ell_width_assumed_rank(handle,m,csr_descr,csr_row_ptr,ell_descr, & ell_width) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2ell_width_assumed_rank type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: csr_descr integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr type(c_ptr) :: ell_descr integer(c_int),target,contiguous,dimension(..) :: ell_width ! rocsparse_csr2ell_width_assumed_rank = rocsparse_csr2ell_width_(handle,m,csr_descr, & c_loc(csr_row_ptr),ell_descr,c_loc(ell_width)) end function #else function rocsparse_csr2ell_width_rank_0(handle,m,csr_descr,csr_row_ptr,ell_descr,ell_width) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2ell_width_rank_0 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: csr_descr integer(c_int),target :: csr_row_ptr type(c_ptr) :: ell_descr integer(c_int),target :: ell_width ! rocsparse_csr2ell_width_rank_0 = rocsparse_csr2ell_width_(handle,m,csr_descr, & c_loc(csr_row_ptr),ell_descr,c_loc(ell_width)) end function function rocsparse_csr2ell_width_rank_1(handle,m,csr_descr,csr_row_ptr,ell_descr,ell_width) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2ell_width_rank_1 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: csr_descr integer(c_int),target,dimension(:) :: csr_row_ptr type(c_ptr) :: ell_descr integer(c_int),target,dimension(:) :: ell_width ! rocsparse_csr2ell_width_rank_1 = rocsparse_csr2ell_width_(handle,m,csr_descr, & c_loc(csr_row_ptr),ell_descr,c_loc(ell_width)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsr2ell_assumed_rank(handle,m,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & ell_descr,ell_width,ell_val,ell_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2ell_assumed_rank type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: csr_descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: ell_descr integer(c_int) :: ell_width real(c_float),target,contiguous,dimension(..) :: ell_val integer(c_int),target,contiguous,dimension(..) :: ell_col_ind ! rocsparse_scsr2ell_assumed_rank = rocsparse_scsr2ell_(handle,m,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),ell_descr,ell_width,c_loc(ell_val),c_loc(ell_col_ind)) end function #else function rocsparse_scsr2ell_rank_0(handle,m,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & ell_descr,ell_width,ell_val,ell_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2ell_rank_0 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: csr_descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: ell_descr integer(c_int) :: ell_width real(c_float),target :: ell_val integer(c_int),target :: ell_col_ind ! rocsparse_scsr2ell_rank_0 = rocsparse_scsr2ell_(handle,m,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),ell_descr,ell_width,c_loc(ell_val),c_loc(ell_col_ind)) end function function rocsparse_scsr2ell_rank_1(handle,m,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & ell_descr,ell_width,ell_val,ell_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2ell_rank_1 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: csr_descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: ell_descr integer(c_int) :: ell_width real(c_float),target,dimension(:) :: ell_val integer(c_int),target,dimension(:) :: ell_col_ind ! rocsparse_scsr2ell_rank_1 = rocsparse_scsr2ell_(handle,m,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),ell_descr,ell_width,c_loc(ell_val),c_loc(ell_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsr2ell_assumed_rank(handle,m,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & ell_descr,ell_width,ell_val,ell_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2ell_assumed_rank type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: csr_descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: ell_descr integer(c_int) :: ell_width real(c_double),target,contiguous,dimension(..) :: ell_val integer(c_int),target,contiguous,dimension(..) :: ell_col_ind ! rocsparse_dcsr2ell_assumed_rank = rocsparse_dcsr2ell_(handle,m,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),ell_descr,ell_width,c_loc(ell_val),c_loc(ell_col_ind)) end function #else function rocsparse_dcsr2ell_rank_0(handle,m,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & ell_descr,ell_width,ell_val,ell_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2ell_rank_0 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: csr_descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: ell_descr integer(c_int) :: ell_width real(c_double),target :: ell_val integer(c_int),target :: ell_col_ind ! rocsparse_dcsr2ell_rank_0 = rocsparse_dcsr2ell_(handle,m,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),ell_descr,ell_width,c_loc(ell_val),c_loc(ell_col_ind)) end function function rocsparse_dcsr2ell_rank_1(handle,m,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & ell_descr,ell_width,ell_val,ell_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2ell_rank_1 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: csr_descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: ell_descr integer(c_int) :: ell_width real(c_double),target,dimension(:) :: ell_val integer(c_int),target,dimension(:) :: ell_col_ind ! rocsparse_dcsr2ell_rank_1 = rocsparse_dcsr2ell_(handle,m,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),ell_descr,ell_width,c_loc(ell_val),c_loc(ell_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsr2ell_assumed_rank(handle,m,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & ell_descr,ell_width,ell_val,ell_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2ell_assumed_rank type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: csr_descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: ell_descr integer(c_int) :: ell_width complex(c_float_complex),target,contiguous,dimension(..) :: ell_val integer(c_int),target,contiguous,dimension(..) :: ell_col_ind ! rocsparse_ccsr2ell_assumed_rank = rocsparse_ccsr2ell_(handle,m,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),ell_descr,ell_width,c_loc(ell_val),c_loc(ell_col_ind)) end function #else function rocsparse_ccsr2ell_rank_0(handle,m,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & ell_descr,ell_width,ell_val,ell_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2ell_rank_0 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: csr_descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: ell_descr integer(c_int) :: ell_width complex(c_float_complex),target :: ell_val integer(c_int),target :: ell_col_ind ! rocsparse_ccsr2ell_rank_0 = rocsparse_ccsr2ell_(handle,m,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),ell_descr,ell_width,c_loc(ell_val),c_loc(ell_col_ind)) end function function rocsparse_ccsr2ell_rank_1(handle,m,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & ell_descr,ell_width,ell_val,ell_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2ell_rank_1 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: csr_descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: ell_descr integer(c_int) :: ell_width complex(c_float_complex),target,dimension(:) :: ell_val integer(c_int),target,dimension(:) :: ell_col_ind ! rocsparse_ccsr2ell_rank_1 = rocsparse_ccsr2ell_(handle,m,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),ell_descr,ell_width,c_loc(ell_val),c_loc(ell_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsr2ell_assumed_rank(handle,m,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & ell_descr,ell_width,ell_val,ell_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2ell_assumed_rank type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: csr_descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: ell_descr integer(c_int) :: ell_width complex(c_double_complex),target,contiguous,dimension(..) :: ell_val integer(c_int),target,contiguous,dimension(..) :: ell_col_ind ! rocsparse_zcsr2ell_assumed_rank = rocsparse_zcsr2ell_(handle,m,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),ell_descr,ell_width,c_loc(ell_val),c_loc(ell_col_ind)) end function #else function rocsparse_zcsr2ell_rank_0(handle,m,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & ell_descr,ell_width,ell_val,ell_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2ell_rank_0 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: csr_descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: ell_descr integer(c_int) :: ell_width complex(c_double_complex),target :: ell_val integer(c_int),target :: ell_col_ind ! rocsparse_zcsr2ell_rank_0 = rocsparse_zcsr2ell_(handle,m,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),ell_descr,ell_width,c_loc(ell_val),c_loc(ell_col_ind)) end function function rocsparse_zcsr2ell_rank_1(handle,m,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & ell_descr,ell_width,ell_val,ell_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2ell_rank_1 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: csr_descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: ell_descr integer(c_int) :: ell_width complex(c_double_complex),target,dimension(:) :: ell_val integer(c_int),target,dimension(:) :: ell_col_ind ! rocsparse_zcsr2ell_rank_1 = rocsparse_zcsr2ell_(handle,m,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),ell_descr,ell_width,c_loc(ell_val),c_loc(ell_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsr2gebsr_buffer_size_assumed_rank(handle,dir,m,n,csr_descr,csr_val, & csr_row_ptr,csr_col_ind,row_block_dim,col_block_dim,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2gebsr_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim integer(c_size_t) :: buffer_size ! rocsparse_scsr2gebsr_buffer_size_assumed_rank = rocsparse_scsr2gebsr_buffer_size_(handle, & dir,m,n,csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),row_block_dim, & col_block_dim,buffer_size) end function #else function rocsparse_scsr2gebsr_buffer_size_rank_0(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,row_block_dim,col_block_dim,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2gebsr_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim integer(c_size_t) :: buffer_size ! rocsparse_scsr2gebsr_buffer_size_rank_0 = rocsparse_scsr2gebsr_buffer_size_(handle,dir,m,n, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),row_block_dim, & col_block_dim,buffer_size) end function function rocsparse_scsr2gebsr_buffer_size_rank_1(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,row_block_dim,col_block_dim,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2gebsr_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim integer(c_size_t) :: buffer_size ! rocsparse_scsr2gebsr_buffer_size_rank_1 = rocsparse_scsr2gebsr_buffer_size_(handle,dir,m,n, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),row_block_dim, & col_block_dim,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsr2gebsr_buffer_size_assumed_rank(handle,dir,m,n,csr_descr,csr_val, & csr_row_ptr,csr_col_ind,row_block_dim,col_block_dim,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2gebsr_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim integer(c_size_t) :: buffer_size ! rocsparse_dcsr2gebsr_buffer_size_assumed_rank = rocsparse_dcsr2gebsr_buffer_size_(handle, & dir,m,n,csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),row_block_dim, & col_block_dim,buffer_size) end function #else function rocsparse_dcsr2gebsr_buffer_size_rank_0(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,row_block_dim,col_block_dim,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2gebsr_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim integer(c_size_t) :: buffer_size ! rocsparse_dcsr2gebsr_buffer_size_rank_0 = rocsparse_dcsr2gebsr_buffer_size_(handle,dir,m,n, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),row_block_dim, & col_block_dim,buffer_size) end function function rocsparse_dcsr2gebsr_buffer_size_rank_1(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,row_block_dim,col_block_dim,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2gebsr_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim integer(c_size_t) :: buffer_size ! rocsparse_dcsr2gebsr_buffer_size_rank_1 = rocsparse_dcsr2gebsr_buffer_size_(handle,dir,m,n, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),row_block_dim, & col_block_dim,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsr2gebsr_buffer_size_assumed_rank(handle,dir,m,n,csr_descr,csr_val, & csr_row_ptr,csr_col_ind,row_block_dim,col_block_dim,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2gebsr_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim integer(c_size_t) :: buffer_size ! rocsparse_ccsr2gebsr_buffer_size_assumed_rank = rocsparse_ccsr2gebsr_buffer_size_(handle, & dir,m,n,csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),row_block_dim, & col_block_dim,buffer_size) end function #else function rocsparse_ccsr2gebsr_buffer_size_rank_0(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,row_block_dim,col_block_dim,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2gebsr_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim integer(c_size_t) :: buffer_size ! rocsparse_ccsr2gebsr_buffer_size_rank_0 = rocsparse_ccsr2gebsr_buffer_size_(handle,dir,m,n, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),row_block_dim, & col_block_dim,buffer_size) end function function rocsparse_ccsr2gebsr_buffer_size_rank_1(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,row_block_dim,col_block_dim,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2gebsr_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim integer(c_size_t) :: buffer_size ! rocsparse_ccsr2gebsr_buffer_size_rank_1 = rocsparse_ccsr2gebsr_buffer_size_(handle,dir,m,n, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),row_block_dim, & col_block_dim,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsr2gebsr_buffer_size_assumed_rank(handle,dir,m,n,csr_descr,csr_val, & csr_row_ptr,csr_col_ind,row_block_dim,col_block_dim,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2gebsr_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim integer(c_size_t) :: buffer_size ! rocsparse_zcsr2gebsr_buffer_size_assumed_rank = rocsparse_zcsr2gebsr_buffer_size_(handle, & dir,m,n,csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),row_block_dim, & col_block_dim,buffer_size) end function #else function rocsparse_zcsr2gebsr_buffer_size_rank_0(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,row_block_dim,col_block_dim,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2gebsr_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim integer(c_size_t) :: buffer_size ! rocsparse_zcsr2gebsr_buffer_size_rank_0 = rocsparse_zcsr2gebsr_buffer_size_(handle,dir,m,n, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),row_block_dim, & col_block_dim,buffer_size) end function function rocsparse_zcsr2gebsr_buffer_size_rank_1(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,row_block_dim,col_block_dim,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2gebsr_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim integer(c_size_t) :: buffer_size ! rocsparse_zcsr2gebsr_buffer_size_rank_1 = rocsparse_zcsr2gebsr_buffer_size_(handle,dir,m,n, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),row_block_dim, & col_block_dim,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_csr2gebsr_nnz_assumed_rank(handle,dir,m,n,csr_descr,csr_row_ptr, & csr_col_ind,bsr_descr,bsr_row_ptr,row_block_dim,col_block_dim,bsr_nnz_devhost,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2gebsr_nnz_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: bsr_descr integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: bsr_nnz_devhost type(c_ptr) :: temp_buffer ! rocsparse_csr2gebsr_nnz_assumed_rank = rocsparse_csr2gebsr_nnz_(handle,dir,m,n,csr_descr, & c_loc(csr_row_ptr),c_loc(csr_col_ind),bsr_descr,c_loc(bsr_row_ptr),row_block_dim, & col_block_dim,bsr_nnz_devhost,temp_buffer) end function #else function rocsparse_csr2gebsr_nnz_rank_0(handle,dir,m,n,csr_descr,csr_row_ptr,csr_col_ind, & bsr_descr,bsr_row_ptr,row_block_dim,col_block_dim,bsr_nnz_devhost,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2gebsr_nnz_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: bsr_descr integer(c_int),target :: bsr_row_ptr integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: bsr_nnz_devhost type(c_ptr) :: temp_buffer ! rocsparse_csr2gebsr_nnz_rank_0 = rocsparse_csr2gebsr_nnz_(handle,dir,m,n,csr_descr, & c_loc(csr_row_ptr),c_loc(csr_col_ind),bsr_descr,c_loc(bsr_row_ptr),row_block_dim, & col_block_dim,bsr_nnz_devhost,temp_buffer) end function function rocsparse_csr2gebsr_nnz_rank_1(handle,dir,m,n,csr_descr,csr_row_ptr,csr_col_ind, & bsr_descr,bsr_row_ptr,row_block_dim,col_block_dim,bsr_nnz_devhost,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csr2gebsr_nnz_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: bsr_descr integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: bsr_nnz_devhost type(c_ptr) :: temp_buffer ! rocsparse_csr2gebsr_nnz_rank_1 = rocsparse_csr2gebsr_nnz_(handle,dir,m,n,csr_descr, & c_loc(csr_row_ptr),c_loc(csr_col_ind),bsr_descr,c_loc(bsr_row_ptr),row_block_dim, & col_block_dim,bsr_nnz_devhost,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsr2gebsr_assumed_rank(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2gebsr_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: bsr_descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: temp_buffer ! rocsparse_scsr2gebsr_assumed_rank = rocsparse_scsr2gebsr_(handle,dir,m,n,csr_descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,temp_buffer) end function #else function rocsparse_scsr2gebsr_rank_0(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2gebsr_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: bsr_descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: temp_buffer ! rocsparse_scsr2gebsr_rank_0 = rocsparse_scsr2gebsr_(handle,dir,m,n,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),bsr_descr,c_loc(bsr_val),c_loc(bsr_row_ptr), & c_loc(bsr_col_ind),row_block_dim,col_block_dim,temp_buffer) end function function rocsparse_scsr2gebsr_rank_1(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2gebsr_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: bsr_descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: temp_buffer ! rocsparse_scsr2gebsr_rank_1 = rocsparse_scsr2gebsr_(handle,dir,m,n,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),bsr_descr,c_loc(bsr_val),c_loc(bsr_row_ptr), & c_loc(bsr_col_ind),row_block_dim,col_block_dim,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsr2gebsr_assumed_rank(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2gebsr_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: bsr_descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: temp_buffer ! rocsparse_dcsr2gebsr_assumed_rank = rocsparse_dcsr2gebsr_(handle,dir,m,n,csr_descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,temp_buffer) end function #else function rocsparse_dcsr2gebsr_rank_0(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2gebsr_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: bsr_descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: temp_buffer ! rocsparse_dcsr2gebsr_rank_0 = rocsparse_dcsr2gebsr_(handle,dir,m,n,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),bsr_descr,c_loc(bsr_val),c_loc(bsr_row_ptr), & c_loc(bsr_col_ind),row_block_dim,col_block_dim,temp_buffer) end function function rocsparse_dcsr2gebsr_rank_1(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2gebsr_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: bsr_descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: temp_buffer ! rocsparse_dcsr2gebsr_rank_1 = rocsparse_dcsr2gebsr_(handle,dir,m,n,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),bsr_descr,c_loc(bsr_val),c_loc(bsr_row_ptr), & c_loc(bsr_col_ind),row_block_dim,col_block_dim,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsr2gebsr_assumed_rank(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2gebsr_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: bsr_descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: temp_buffer ! rocsparse_ccsr2gebsr_assumed_rank = rocsparse_ccsr2gebsr_(handle,dir,m,n,csr_descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,temp_buffer) end function #else function rocsparse_ccsr2gebsr_rank_0(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2gebsr_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: bsr_descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: temp_buffer ! rocsparse_ccsr2gebsr_rank_0 = rocsparse_ccsr2gebsr_(handle,dir,m,n,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),bsr_descr,c_loc(bsr_val),c_loc(bsr_row_ptr), & c_loc(bsr_col_ind),row_block_dim,col_block_dim,temp_buffer) end function function rocsparse_ccsr2gebsr_rank_1(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2gebsr_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: bsr_descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: temp_buffer ! rocsparse_ccsr2gebsr_rank_1 = rocsparse_ccsr2gebsr_(handle,dir,m,n,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),bsr_descr,c_loc(bsr_val),c_loc(bsr_row_ptr), & c_loc(bsr_col_ind),row_block_dim,col_block_dim,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsr2gebsr_assumed_rank(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr, & csr_col_ind,bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2gebsr_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: bsr_descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: temp_buffer ! rocsparse_zcsr2gebsr_assumed_rank = rocsparse_zcsr2gebsr_(handle,dir,m,n,csr_descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),bsr_descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,temp_buffer) end function #else function rocsparse_zcsr2gebsr_rank_0(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2gebsr_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: bsr_descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: temp_buffer ! rocsparse_zcsr2gebsr_rank_0 = rocsparse_zcsr2gebsr_(handle,dir,m,n,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),bsr_descr,c_loc(bsr_val),c_loc(bsr_row_ptr), & c_loc(bsr_col_ind),row_block_dim,col_block_dim,temp_buffer) end function function rocsparse_zcsr2gebsr_rank_1(handle,dir,m,n,csr_descr,csr_val,csr_row_ptr,csr_col_ind, & bsr_descr,bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2gebsr_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: csr_descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: bsr_descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: temp_buffer ! rocsparse_zcsr2gebsr_rank_1 = rocsparse_zcsr2gebsr_(handle,dir,m,n,csr_descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),bsr_descr,c_loc(bsr_val),c_loc(bsr_row_ptr), & c_loc(bsr_col_ind),row_block_dim,col_block_dim,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsr2hyb_assumed_rank(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,hyb, & user_ell_width,partition_type) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2hyb_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: hyb integer(c_int) :: user_ell_width integer(kind(rocsparse_hyb_partition_auto)) :: partition_type ! rocsparse_scsr2hyb_assumed_rank = rocsparse_scsr2hyb_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),hyb,user_ell_width,partition_type) end function #else function rocsparse_scsr2hyb_rank_0(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,hyb, & user_ell_width,partition_type) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2hyb_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: hyb integer(c_int) :: user_ell_width integer(kind(rocsparse_hyb_partition_auto)) :: partition_type ! rocsparse_scsr2hyb_rank_0 = rocsparse_scsr2hyb_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),hyb,user_ell_width,partition_type) end function function rocsparse_scsr2hyb_rank_1(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,hyb, & user_ell_width,partition_type) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsr2hyb_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: hyb integer(c_int) :: user_ell_width integer(kind(rocsparse_hyb_partition_auto)) :: partition_type ! rocsparse_scsr2hyb_rank_1 = rocsparse_scsr2hyb_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),hyb,user_ell_width,partition_type) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsr2hyb_assumed_rank(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,hyb, & user_ell_width,partition_type) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2hyb_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: hyb integer(c_int) :: user_ell_width integer(kind(rocsparse_hyb_partition_auto)) :: partition_type ! rocsparse_dcsr2hyb_assumed_rank = rocsparse_dcsr2hyb_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),hyb,user_ell_width,partition_type) end function #else function rocsparse_dcsr2hyb_rank_0(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,hyb, & user_ell_width,partition_type) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2hyb_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: hyb integer(c_int) :: user_ell_width integer(kind(rocsparse_hyb_partition_auto)) :: partition_type ! rocsparse_dcsr2hyb_rank_0 = rocsparse_dcsr2hyb_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),hyb,user_ell_width,partition_type) end function function rocsparse_dcsr2hyb_rank_1(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,hyb, & user_ell_width,partition_type) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsr2hyb_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: hyb integer(c_int) :: user_ell_width integer(kind(rocsparse_hyb_partition_auto)) :: partition_type ! rocsparse_dcsr2hyb_rank_1 = rocsparse_dcsr2hyb_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),hyb,user_ell_width,partition_type) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsr2hyb_assumed_rank(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,hyb, & user_ell_width,partition_type) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2hyb_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: hyb integer(c_int) :: user_ell_width integer(kind(rocsparse_hyb_partition_auto)) :: partition_type ! rocsparse_ccsr2hyb_assumed_rank = rocsparse_ccsr2hyb_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),hyb,user_ell_width,partition_type) end function #else function rocsparse_ccsr2hyb_rank_0(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,hyb, & user_ell_width,partition_type) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2hyb_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: hyb integer(c_int) :: user_ell_width integer(kind(rocsparse_hyb_partition_auto)) :: partition_type ! rocsparse_ccsr2hyb_rank_0 = rocsparse_ccsr2hyb_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),hyb,user_ell_width,partition_type) end function function rocsparse_ccsr2hyb_rank_1(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,hyb, & user_ell_width,partition_type) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsr2hyb_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: hyb integer(c_int) :: user_ell_width integer(kind(rocsparse_hyb_partition_auto)) :: partition_type ! rocsparse_ccsr2hyb_rank_1 = rocsparse_ccsr2hyb_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),hyb,user_ell_width,partition_type) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsr2hyb_assumed_rank(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,hyb, & user_ell_width,partition_type) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2hyb_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: hyb integer(c_int) :: user_ell_width integer(kind(rocsparse_hyb_partition_auto)) :: partition_type ! rocsparse_zcsr2hyb_assumed_rank = rocsparse_zcsr2hyb_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),hyb,user_ell_width,partition_type) end function #else function rocsparse_zcsr2hyb_rank_0(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,hyb, & user_ell_width,partition_type) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2hyb_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: hyb integer(c_int) :: user_ell_width integer(kind(rocsparse_hyb_partition_auto)) :: partition_type ! rocsparse_zcsr2hyb_rank_0 = rocsparse_zcsr2hyb_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),hyb,user_ell_width,partition_type) end function function rocsparse_zcsr2hyb_rank_1(handle,m,n,descr,csr_val,csr_row_ptr,csr_col_ind,hyb, & user_ell_width,partition_type) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsr2hyb_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: hyb integer(c_int) :: user_ell_width integer(kind(rocsparse_hyb_partition_auto)) :: partition_type ! rocsparse_zcsr2hyb_rank_1 = rocsparse_zcsr2hyb_(handle,m,n,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),hyb,user_ell_width,partition_type) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_csrsort_buffer_size_assumed_rank(handle,m,n,nnz,csr_row_ptr,csr_col_ind, & buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrsort_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind integer(c_size_t) :: buffer_size ! rocsparse_csrsort_buffer_size_assumed_rank = rocsparse_csrsort_buffer_size_(handle,m,n,nnz, & c_loc(csr_row_ptr),c_loc(csr_col_ind),buffer_size) end function #else function rocsparse_csrsort_buffer_size_rank_0(handle,m,n,nnz,csr_row_ptr,csr_col_ind, & buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrsort_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind integer(c_size_t) :: buffer_size ! rocsparse_csrsort_buffer_size_rank_0 = rocsparse_csrsort_buffer_size_(handle,m,n,nnz, & c_loc(csr_row_ptr),c_loc(csr_col_ind),buffer_size) end function function rocsparse_csrsort_buffer_size_rank_1(handle,m,n,nnz,csr_row_ptr,csr_col_ind, & buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrsort_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind integer(c_size_t) :: buffer_size ! rocsparse_csrsort_buffer_size_rank_1 = rocsparse_csrsort_buffer_size_(handle,m,n,nnz, & c_loc(csr_row_ptr),c_loc(csr_col_ind),buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_csrsort_assumed_rank(handle,m,n,nnz,descr,csr_row_ptr,csr_col_ind,perm, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrsort_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind integer(c_int),target,contiguous,dimension(..) :: perm type(c_ptr) :: temp_buffer ! rocsparse_csrsort_assumed_rank = rocsparse_csrsort_(handle,m,n,nnz,descr,c_loc(csr_row_ptr), & c_loc(csr_col_ind),c_loc(perm),temp_buffer) end function #else function rocsparse_csrsort_rank_0(handle,m,n,nnz,descr,csr_row_ptr,csr_col_ind,perm,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrsort_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind integer(c_int),target :: perm type(c_ptr) :: temp_buffer ! rocsparse_csrsort_rank_0 = rocsparse_csrsort_(handle,m,n,nnz,descr,c_loc(csr_row_ptr), & c_loc(csr_col_ind),c_loc(perm),temp_buffer) end function function rocsparse_csrsort_rank_1(handle,m,n,nnz,descr,csr_row_ptr,csr_col_ind,perm,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrsort_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind integer(c_int),target,dimension(:) :: perm type(c_ptr) :: temp_buffer ! rocsparse_csrsort_rank_1 = rocsparse_csrsort_(handle,m,n,nnz,descr,c_loc(csr_row_ptr), & c_loc(csr_col_ind),c_loc(perm),temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sdense2coo_assumed_rank(handle,m,n,descr,A,ld,nnz_per_rows,coo_val, & coo_row_ind,coo_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sdense2coo_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnz_per_rows real(c_float),target,contiguous,dimension(..) :: coo_val integer(c_int),target,contiguous,dimension(..) :: coo_row_ind integer(c_int),target,contiguous,dimension(..) :: coo_col_ind ! rocsparse_sdense2coo_assumed_rank = rocsparse_sdense2coo_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind)) end function #else function rocsparse_sdense2coo_rank_0(handle,m,n,descr,A,ld,nnz_per_rows,coo_val,coo_row_ind, & coo_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sdense2coo_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target :: A integer(c_int) :: ld integer(c_int),target :: nnz_per_rows real(c_float),target :: coo_val integer(c_int),target :: coo_row_ind integer(c_int),target :: coo_col_ind ! rocsparse_sdense2coo_rank_0 = rocsparse_sdense2coo_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind)) end function function rocsparse_sdense2coo_rank_1(handle,m,n,descr,A,ld,nnz_per_rows,coo_val,coo_row_ind, & coo_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sdense2coo_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_rows real(c_float),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind ! rocsparse_sdense2coo_rank_1 = rocsparse_sdense2coo_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind)) end function function rocsparse_sdense2coo_full_rank(handle,m,n,descr,A,ld,nnz_per_rows,coo_val, & coo_row_ind,coo_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sdense2coo_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_rows real(c_float),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind ! rocsparse_sdense2coo_full_rank = rocsparse_sdense2coo_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ddense2coo_assumed_rank(handle,m,n,descr,A,ld,nnz_per_rows,coo_val, & coo_row_ind,coo_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ddense2coo_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnz_per_rows real(c_double),target,contiguous,dimension(..) :: coo_val integer(c_int),target,contiguous,dimension(..) :: coo_row_ind integer(c_int),target,contiguous,dimension(..) :: coo_col_ind ! rocsparse_ddense2coo_assumed_rank = rocsparse_ddense2coo_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind)) end function #else function rocsparse_ddense2coo_rank_0(handle,m,n,descr,A,ld,nnz_per_rows,coo_val,coo_row_ind, & coo_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ddense2coo_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target :: A integer(c_int) :: ld integer(c_int),target :: nnz_per_rows real(c_double),target :: coo_val integer(c_int),target :: coo_row_ind integer(c_int),target :: coo_col_ind ! rocsparse_ddense2coo_rank_0 = rocsparse_ddense2coo_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind)) end function function rocsparse_ddense2coo_rank_1(handle,m,n,descr,A,ld,nnz_per_rows,coo_val,coo_row_ind, & coo_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ddense2coo_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_rows real(c_double),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind ! rocsparse_ddense2coo_rank_1 = rocsparse_ddense2coo_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind)) end function function rocsparse_ddense2coo_full_rank(handle,m,n,descr,A,ld,nnz_per_rows,coo_val, & coo_row_ind,coo_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ddense2coo_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_rows real(c_double),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind ! rocsparse_ddense2coo_full_rank = rocsparse_ddense2coo_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cdense2coo_assumed_rank(handle,m,n,descr,A,ld,nnz_per_rows,coo_val, & coo_row_ind,coo_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdense2coo_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnz_per_rows complex(c_float_complex),target,contiguous,dimension(..) :: coo_val integer(c_int),target,contiguous,dimension(..) :: coo_row_ind integer(c_int),target,contiguous,dimension(..) :: coo_col_ind ! rocsparse_cdense2coo_assumed_rank = rocsparse_cdense2coo_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind)) end function #else function rocsparse_cdense2coo_rank_0(handle,m,n,descr,A,ld,nnz_per_rows,coo_val,coo_row_ind, & coo_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdense2coo_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target :: A integer(c_int) :: ld integer(c_int),target :: nnz_per_rows complex(c_float_complex),target :: coo_val integer(c_int),target :: coo_row_ind integer(c_int),target :: coo_col_ind ! rocsparse_cdense2coo_rank_0 = rocsparse_cdense2coo_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind)) end function function rocsparse_cdense2coo_rank_1(handle,m,n,descr,A,ld,nnz_per_rows,coo_val,coo_row_ind, & coo_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdense2coo_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_rows complex(c_float_complex),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind ! rocsparse_cdense2coo_rank_1 = rocsparse_cdense2coo_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind)) end function function rocsparse_cdense2coo_full_rank(handle,m,n,descr,A,ld,nnz_per_rows,coo_val, & coo_row_ind,coo_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdense2coo_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_rows complex(c_float_complex),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind ! rocsparse_cdense2coo_full_rank = rocsparse_cdense2coo_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zdense2coo_assumed_rank(handle,m,n,descr,A,ld,nnz_per_rows,coo_val, & coo_row_ind,coo_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdense2coo_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnz_per_rows complex(c_double_complex),target,contiguous,dimension(..) :: coo_val integer(c_int),target,contiguous,dimension(..) :: coo_row_ind integer(c_int),target,contiguous,dimension(..) :: coo_col_ind ! rocsparse_zdense2coo_assumed_rank = rocsparse_zdense2coo_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind)) end function #else function rocsparse_zdense2coo_rank_0(handle,m,n,descr,A,ld,nnz_per_rows,coo_val,coo_row_ind, & coo_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdense2coo_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target :: A integer(c_int) :: ld integer(c_int),target :: nnz_per_rows complex(c_double_complex),target :: coo_val integer(c_int),target :: coo_row_ind integer(c_int),target :: coo_col_ind ! rocsparse_zdense2coo_rank_0 = rocsparse_zdense2coo_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind)) end function function rocsparse_zdense2coo_rank_1(handle,m,n,descr,A,ld,nnz_per_rows,coo_val,coo_row_ind, & coo_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdense2coo_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_rows complex(c_double_complex),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind ! rocsparse_zdense2coo_rank_1 = rocsparse_zdense2coo_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind)) end function function rocsparse_zdense2coo_full_rank(handle,m,n,descr,A,ld,nnz_per_rows,coo_val, & coo_row_ind,coo_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdense2coo_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_rows complex(c_double_complex),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind ! rocsparse_zdense2coo_full_rank = rocsparse_zdense2coo_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sdense2csc_assumed_rank(handle,m,n,descr,A,ld,nnz_per_columns,csc_val, & csc_col_ptr,csc_row_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sdense2csc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnz_per_columns real(c_float),target,contiguous,dimension(..) :: csc_val integer(c_int),target,contiguous,dimension(..) :: csc_col_ptr integer(c_int),target,contiguous,dimension(..) :: csc_row_ind ! rocsparse_sdense2csc_assumed_rank = rocsparse_sdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_columns),c_loc(csc_val),c_loc(csc_col_ptr),c_loc(csc_row_ind)) end function #else function rocsparse_sdense2csc_rank_0(handle,m,n,descr,A,ld,nnz_per_columns,csc_val, & csc_col_ptr,csc_row_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sdense2csc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target :: A integer(c_int) :: ld integer(c_int),target :: nnz_per_columns real(c_float),target :: csc_val integer(c_int),target :: csc_col_ptr integer(c_int),target :: csc_row_ind ! rocsparse_sdense2csc_rank_0 = rocsparse_sdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_columns),c_loc(csc_val),c_loc(csc_col_ptr),c_loc(csc_row_ind)) end function function rocsparse_sdense2csc_rank_1(handle,m,n,descr,A,ld,nnz_per_columns,csc_val, & csc_col_ptr,csc_row_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sdense2csc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_columns real(c_float),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_col_ptr integer(c_int),target,dimension(:) :: csc_row_ind ! rocsparse_sdense2csc_rank_1 = rocsparse_sdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_columns),c_loc(csc_val),c_loc(csc_col_ptr),c_loc(csc_row_ind)) end function function rocsparse_sdense2csc_full_rank(handle,m,n,descr,A,ld,nnz_per_columns,csc_val, & csc_col_ptr,csc_row_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sdense2csc_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_columns real(c_float),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_col_ptr integer(c_int),target,dimension(:) :: csc_row_ind ! rocsparse_sdense2csc_full_rank = rocsparse_sdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_columns),c_loc(csc_val),c_loc(csc_col_ptr),c_loc(csc_row_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ddense2csc_assumed_rank(handle,m,n,descr,A,ld,nnz_per_columns,csc_val, & csc_col_ptr,csc_row_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ddense2csc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnz_per_columns real(c_double),target,contiguous,dimension(..) :: csc_val integer(c_int),target,contiguous,dimension(..) :: csc_col_ptr integer(c_int),target,contiguous,dimension(..) :: csc_row_ind ! rocsparse_ddense2csc_assumed_rank = rocsparse_ddense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_columns),c_loc(csc_val),c_loc(csc_col_ptr),c_loc(csc_row_ind)) end function #else function rocsparse_ddense2csc_rank_0(handle,m,n,descr,A,ld,nnz_per_columns,csc_val, & csc_col_ptr,csc_row_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ddense2csc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target :: A integer(c_int) :: ld integer(c_int),target :: nnz_per_columns real(c_double),target :: csc_val integer(c_int),target :: csc_col_ptr integer(c_int),target :: csc_row_ind ! rocsparse_ddense2csc_rank_0 = rocsparse_ddense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_columns),c_loc(csc_val),c_loc(csc_col_ptr),c_loc(csc_row_ind)) end function function rocsparse_ddense2csc_rank_1(handle,m,n,descr,A,ld,nnz_per_columns,csc_val, & csc_col_ptr,csc_row_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ddense2csc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_columns real(c_double),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_col_ptr integer(c_int),target,dimension(:) :: csc_row_ind ! rocsparse_ddense2csc_rank_1 = rocsparse_ddense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_columns),c_loc(csc_val),c_loc(csc_col_ptr),c_loc(csc_row_ind)) end function function rocsparse_ddense2csc_full_rank(handle,m,n,descr,A,ld,nnz_per_columns,csc_val, & csc_col_ptr,csc_row_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ddense2csc_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_columns real(c_double),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_col_ptr integer(c_int),target,dimension(:) :: csc_row_ind ! rocsparse_ddense2csc_full_rank = rocsparse_ddense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_columns),c_loc(csc_val),c_loc(csc_col_ptr),c_loc(csc_row_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cdense2csc_assumed_rank(handle,m,n,descr,A,ld,nnz_per_columns,csc_val, & csc_col_ptr,csc_row_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdense2csc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnz_per_columns complex(c_float_complex),target,contiguous,dimension(..) :: csc_val integer(c_int),target,contiguous,dimension(..) :: csc_col_ptr integer(c_int),target,contiguous,dimension(..) :: csc_row_ind ! rocsparse_cdense2csc_assumed_rank = rocsparse_cdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_columns),c_loc(csc_val),c_loc(csc_col_ptr),c_loc(csc_row_ind)) end function #else function rocsparse_cdense2csc_rank_0(handle,m,n,descr,A,ld,nnz_per_columns,csc_val, & csc_col_ptr,csc_row_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdense2csc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target :: A integer(c_int) :: ld integer(c_int),target :: nnz_per_columns complex(c_float_complex),target :: csc_val integer(c_int),target :: csc_col_ptr integer(c_int),target :: csc_row_ind ! rocsparse_cdense2csc_rank_0 = rocsparse_cdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_columns),c_loc(csc_val),c_loc(csc_col_ptr),c_loc(csc_row_ind)) end function function rocsparse_cdense2csc_rank_1(handle,m,n,descr,A,ld,nnz_per_columns,csc_val, & csc_col_ptr,csc_row_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdense2csc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_columns complex(c_float_complex),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_col_ptr integer(c_int),target,dimension(:) :: csc_row_ind ! rocsparse_cdense2csc_rank_1 = rocsparse_cdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_columns),c_loc(csc_val),c_loc(csc_col_ptr),c_loc(csc_row_ind)) end function function rocsparse_cdense2csc_full_rank(handle,m,n,descr,A,ld,nnz_per_columns,csc_val, & csc_col_ptr,csc_row_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdense2csc_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_columns complex(c_float_complex),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_col_ptr integer(c_int),target,dimension(:) :: csc_row_ind ! rocsparse_cdense2csc_full_rank = rocsparse_cdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_columns),c_loc(csc_val),c_loc(csc_col_ptr),c_loc(csc_row_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zdense2csc_assumed_rank(handle,m,n,descr,A,ld,nnz_per_columns,csc_val, & csc_col_ptr,csc_row_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdense2csc_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnz_per_columns complex(c_double_complex),target,contiguous,dimension(..) :: csc_val integer(c_int),target,contiguous,dimension(..) :: csc_col_ptr integer(c_int),target,contiguous,dimension(..) :: csc_row_ind ! rocsparse_zdense2csc_assumed_rank = rocsparse_zdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_columns),c_loc(csc_val),c_loc(csc_col_ptr),c_loc(csc_row_ind)) end function #else function rocsparse_zdense2csc_rank_0(handle,m,n,descr,A,ld,nnz_per_columns,csc_val, & csc_col_ptr,csc_row_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdense2csc_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target :: A integer(c_int) :: ld integer(c_int),target :: nnz_per_columns complex(c_double_complex),target :: csc_val integer(c_int),target :: csc_col_ptr integer(c_int),target :: csc_row_ind ! rocsparse_zdense2csc_rank_0 = rocsparse_zdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_columns),c_loc(csc_val),c_loc(csc_col_ptr),c_loc(csc_row_ind)) end function function rocsparse_zdense2csc_rank_1(handle,m,n,descr,A,ld,nnz_per_columns,csc_val, & csc_col_ptr,csc_row_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdense2csc_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_columns complex(c_double_complex),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_col_ptr integer(c_int),target,dimension(:) :: csc_row_ind ! rocsparse_zdense2csc_rank_1 = rocsparse_zdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_columns),c_loc(csc_val),c_loc(csc_col_ptr),c_loc(csc_row_ind)) end function function rocsparse_zdense2csc_full_rank(handle,m,n,descr,A,ld,nnz_per_columns,csc_val, & csc_col_ptr,csc_row_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdense2csc_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_columns complex(c_double_complex),target,dimension(:) :: csc_val integer(c_int),target,dimension(:) :: csc_col_ptr integer(c_int),target,dimension(:) :: csc_row_ind ! rocsparse_zdense2csc_full_rank = rocsparse_zdense2csc_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_columns),c_loc(csc_val),c_loc(csc_col_ptr),c_loc(csc_row_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sdense2csr_assumed_rank(handle,m,n,descr,A,ld,nnz_per_rows,csr_val, & csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sdense2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnz_per_rows real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind ! rocsparse_sdense2csr_assumed_rank = rocsparse_sdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #else function rocsparse_sdense2csr_rank_0(handle,m,n,descr,A,ld,nnz_per_rows,csr_val,csr_row_ptr, & csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sdense2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target :: A integer(c_int) :: ld integer(c_int),target :: nnz_per_rows real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind ! rocsparse_sdense2csr_rank_0 = rocsparse_sdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function function rocsparse_sdense2csr_rank_1(handle,m,n,descr,A,ld,nnz_per_rows,csr_val,csr_row_ptr, & csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sdense2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_rows real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_sdense2csr_rank_1 = rocsparse_sdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function function rocsparse_sdense2csr_full_rank(handle,m,n,descr,A,ld,nnz_per_rows,csr_val, & csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sdense2csr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_rows real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_sdense2csr_full_rank = rocsparse_sdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ddense2csr_assumed_rank(handle,m,n,descr,A,ld,nnz_per_rows,csr_val, & csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ddense2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnz_per_rows real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind ! rocsparse_ddense2csr_assumed_rank = rocsparse_ddense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #else function rocsparse_ddense2csr_rank_0(handle,m,n,descr,A,ld,nnz_per_rows,csr_val,csr_row_ptr, & csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ddense2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target :: A integer(c_int) :: ld integer(c_int),target :: nnz_per_rows real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind ! rocsparse_ddense2csr_rank_0 = rocsparse_ddense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function function rocsparse_ddense2csr_rank_1(handle,m,n,descr,A,ld,nnz_per_rows,csr_val,csr_row_ptr, & csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ddense2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_rows real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_ddense2csr_rank_1 = rocsparse_ddense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function function rocsparse_ddense2csr_full_rank(handle,m,n,descr,A,ld,nnz_per_rows,csr_val, & csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ddense2csr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_rows real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_ddense2csr_full_rank = rocsparse_ddense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cdense2csr_assumed_rank(handle,m,n,descr,A,ld,nnz_per_rows,csr_val, & csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdense2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnz_per_rows complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind ! rocsparse_cdense2csr_assumed_rank = rocsparse_cdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #else function rocsparse_cdense2csr_rank_0(handle,m,n,descr,A,ld,nnz_per_rows,csr_val,csr_row_ptr, & csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdense2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target :: A integer(c_int) :: ld integer(c_int),target :: nnz_per_rows complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind ! rocsparse_cdense2csr_rank_0 = rocsparse_cdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function function rocsparse_cdense2csr_rank_1(handle,m,n,descr,A,ld,nnz_per_rows,csr_val,csr_row_ptr, & csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdense2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_rows complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_cdense2csr_rank_1 = rocsparse_cdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function function rocsparse_cdense2csr_full_rank(handle,m,n,descr,A,ld,nnz_per_rows,csr_val, & csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdense2csr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_rows complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_cdense2csr_full_rank = rocsparse_cdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zdense2csr_assumed_rank(handle,m,n,descr,A,ld,nnz_per_rows,csr_val, & csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdense2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnz_per_rows complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind ! rocsparse_zdense2csr_assumed_rank = rocsparse_zdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #else function rocsparse_zdense2csr_rank_0(handle,m,n,descr,A,ld,nnz_per_rows,csr_val,csr_row_ptr, & csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdense2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target :: A integer(c_int) :: ld integer(c_int),target :: nnz_per_rows complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind ! rocsparse_zdense2csr_rank_0 = rocsparse_zdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function function rocsparse_zdense2csr_rank_1(handle,m,n,descr,A,ld,nnz_per_rows,csr_val,csr_row_ptr, & csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdense2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_rows complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_zdense2csr_rank_1 = rocsparse_zdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function function rocsparse_zdense2csr_full_rank(handle,m,n,descr,A,ld,nnz_per_rows,csr_val, & csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdense2csr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_rows complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_zdense2csr_full_rank = rocsparse_zdense2csr_(handle,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_rows),c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ell2csr_nnz_assumed_rank(handle,m,n,ell_descr,ell_width,ell_col_ind, & csr_descr,csr_row_ptr,csr_nnz) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ell2csr_nnz_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: ell_descr integer(c_int) :: ell_width integer(c_int),target,contiguous,dimension(..) :: ell_col_ind type(c_ptr) :: csr_descr integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_nnz ! rocsparse_ell2csr_nnz_assumed_rank = rocsparse_ell2csr_nnz_(handle,m,n,ell_descr,ell_width, & c_loc(ell_col_ind),csr_descr,c_loc(csr_row_ptr),c_loc(csr_nnz)) end function #else function rocsparse_ell2csr_nnz_rank_0(handle,m,n,ell_descr,ell_width,ell_col_ind,csr_descr, & csr_row_ptr,csr_nnz) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ell2csr_nnz_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: ell_descr integer(c_int) :: ell_width integer(c_int),target :: ell_col_ind type(c_ptr) :: csr_descr integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_nnz ! rocsparse_ell2csr_nnz_rank_0 = rocsparse_ell2csr_nnz_(handle,m,n,ell_descr,ell_width, & c_loc(ell_col_ind),csr_descr,c_loc(csr_row_ptr),c_loc(csr_nnz)) end function function rocsparse_ell2csr_nnz_rank_1(handle,m,n,ell_descr,ell_width,ell_col_ind,csr_descr, & csr_row_ptr,csr_nnz) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ell2csr_nnz_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: ell_descr integer(c_int) :: ell_width integer(c_int),target,dimension(:) :: ell_col_ind type(c_ptr) :: csr_descr integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_nnz ! rocsparse_ell2csr_nnz_rank_1 = rocsparse_ell2csr_nnz_(handle,m,n,ell_descr,ell_width, & c_loc(ell_col_ind),csr_descr,c_loc(csr_row_ptr),c_loc(csr_nnz)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sell2csr_assumed_rank(handle,m,n,ell_descr,ell_width,ell_val,ell_col_ind, & csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sell2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: ell_descr integer(c_int) :: ell_width real(c_float),target,contiguous,dimension(..) :: ell_val integer(c_int),target,contiguous,dimension(..) :: ell_col_ind type(c_ptr) :: csr_descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind ! rocsparse_sell2csr_assumed_rank = rocsparse_sell2csr_(handle,m,n,ell_descr,ell_width, & c_loc(ell_val),c_loc(ell_col_ind),csr_descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind)) end function #else function rocsparse_sell2csr_rank_0(handle,m,n,ell_descr,ell_width,ell_val,ell_col_ind, & csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sell2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: ell_descr integer(c_int) :: ell_width real(c_float),target :: ell_val integer(c_int),target :: ell_col_ind type(c_ptr) :: csr_descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind ! rocsparse_sell2csr_rank_0 = rocsparse_sell2csr_(handle,m,n,ell_descr,ell_width, & c_loc(ell_val),c_loc(ell_col_ind),csr_descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind)) end function function rocsparse_sell2csr_rank_1(handle,m,n,ell_descr,ell_width,ell_val,ell_col_ind, & csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sell2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: ell_descr integer(c_int) :: ell_width real(c_float),target,dimension(:) :: ell_val integer(c_int),target,dimension(:) :: ell_col_ind type(c_ptr) :: csr_descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_sell2csr_rank_1 = rocsparse_sell2csr_(handle,m,n,ell_descr,ell_width, & c_loc(ell_val),c_loc(ell_col_ind),csr_descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dell2csr_assumed_rank(handle,m,n,ell_descr,ell_width,ell_val,ell_col_ind, & csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dell2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: ell_descr integer(c_int) :: ell_width real(c_double),target,contiguous,dimension(..) :: ell_val integer(c_int),target,contiguous,dimension(..) :: ell_col_ind type(c_ptr) :: csr_descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind ! rocsparse_dell2csr_assumed_rank = rocsparse_dell2csr_(handle,m,n,ell_descr,ell_width, & c_loc(ell_val),c_loc(ell_col_ind),csr_descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind)) end function #else function rocsparse_dell2csr_rank_0(handle,m,n,ell_descr,ell_width,ell_val,ell_col_ind, & csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dell2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: ell_descr integer(c_int) :: ell_width real(c_double),target :: ell_val integer(c_int),target :: ell_col_ind type(c_ptr) :: csr_descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind ! rocsparse_dell2csr_rank_0 = rocsparse_dell2csr_(handle,m,n,ell_descr,ell_width, & c_loc(ell_val),c_loc(ell_col_ind),csr_descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind)) end function function rocsparse_dell2csr_rank_1(handle,m,n,ell_descr,ell_width,ell_val,ell_col_ind, & csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dell2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: ell_descr integer(c_int) :: ell_width real(c_double),target,dimension(:) :: ell_val integer(c_int),target,dimension(:) :: ell_col_ind type(c_ptr) :: csr_descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_dell2csr_rank_1 = rocsparse_dell2csr_(handle,m,n,ell_descr,ell_width, & c_loc(ell_val),c_loc(ell_col_ind),csr_descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cell2csr_assumed_rank(handle,m,n,ell_descr,ell_width,ell_val,ell_col_ind, & csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cell2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: ell_descr integer(c_int) :: ell_width complex(c_float_complex),target,contiguous,dimension(..) :: ell_val integer(c_int),target,contiguous,dimension(..) :: ell_col_ind type(c_ptr) :: csr_descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind ! rocsparse_cell2csr_assumed_rank = rocsparse_cell2csr_(handle,m,n,ell_descr,ell_width, & c_loc(ell_val),c_loc(ell_col_ind),csr_descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind)) end function #else function rocsparse_cell2csr_rank_0(handle,m,n,ell_descr,ell_width,ell_val,ell_col_ind, & csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cell2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: ell_descr integer(c_int) :: ell_width complex(c_float_complex),target :: ell_val integer(c_int),target :: ell_col_ind type(c_ptr) :: csr_descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind ! rocsparse_cell2csr_rank_0 = rocsparse_cell2csr_(handle,m,n,ell_descr,ell_width, & c_loc(ell_val),c_loc(ell_col_ind),csr_descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind)) end function function rocsparse_cell2csr_rank_1(handle,m,n,ell_descr,ell_width,ell_val,ell_col_ind, & csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cell2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: ell_descr integer(c_int) :: ell_width complex(c_float_complex),target,dimension(:) :: ell_val integer(c_int),target,dimension(:) :: ell_col_ind type(c_ptr) :: csr_descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_cell2csr_rank_1 = rocsparse_cell2csr_(handle,m,n,ell_descr,ell_width, & c_loc(ell_val),c_loc(ell_col_ind),csr_descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zell2csr_assumed_rank(handle,m,n,ell_descr,ell_width,ell_val,ell_col_ind, & csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zell2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: ell_descr integer(c_int) :: ell_width complex(c_double_complex),target,contiguous,dimension(..) :: ell_val integer(c_int),target,contiguous,dimension(..) :: ell_col_ind type(c_ptr) :: csr_descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind ! rocsparse_zell2csr_assumed_rank = rocsparse_zell2csr_(handle,m,n,ell_descr,ell_width, & c_loc(ell_val),c_loc(ell_col_ind),csr_descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind)) end function #else function rocsparse_zell2csr_rank_0(handle,m,n,ell_descr,ell_width,ell_val,ell_col_ind, & csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zell2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: ell_descr integer(c_int) :: ell_width complex(c_double_complex),target :: ell_val integer(c_int),target :: ell_col_ind type(c_ptr) :: csr_descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind ! rocsparse_zell2csr_rank_0 = rocsparse_zell2csr_(handle,m,n,ell_descr,ell_width, & c_loc(ell_val),c_loc(ell_col_ind),csr_descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind)) end function function rocsparse_zell2csr_rank_1(handle,m,n,ell_descr,ell_width,ell_val,ell_col_ind, & csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zell2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: ell_descr integer(c_int) :: ell_width complex(c_double_complex),target,dimension(:) :: ell_val integer(c_int),target,dimension(:) :: ell_col_ind type(c_ptr) :: csr_descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_zell2csr_rank_1 = rocsparse_zell2csr_(handle,m,n,ell_descr,ell_width, & c_loc(ell_val),c_loc(ell_col_ind),csr_descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sgebsr2csr_assumed_rank(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsr2csr_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: csr_descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind ! rocsparse_sgebsr2csr_assumed_rank = rocsparse_sgebsr2csr_(handle,dir,mb,nb,bsr_descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #else function rocsparse_sgebsr2csr_rank_0(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsr2csr_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: csr_descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind ! rocsparse_sgebsr2csr_rank_0 = rocsparse_sgebsr2csr_(handle,dir,mb,nb,bsr_descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function function rocsparse_sgebsr2csr_rank_1(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsr2csr_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: csr_descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_sgebsr2csr_rank_1 = rocsparse_sgebsr2csr_(handle,dir,mb,nb,bsr_descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dgebsr2csr_assumed_rank(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsr2csr_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: csr_descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind ! rocsparse_dgebsr2csr_assumed_rank = rocsparse_dgebsr2csr_(handle,dir,mb,nb,bsr_descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #else function rocsparse_dgebsr2csr_rank_0(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsr2csr_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: csr_descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind ! rocsparse_dgebsr2csr_rank_0 = rocsparse_dgebsr2csr_(handle,dir,mb,nb,bsr_descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function function rocsparse_dgebsr2csr_rank_1(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsr2csr_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: csr_descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_dgebsr2csr_rank_1 = rocsparse_dgebsr2csr_(handle,dir,mb,nb,bsr_descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cgebsr2csr_assumed_rank(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsr2csr_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: csr_descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind ! rocsparse_cgebsr2csr_assumed_rank = rocsparse_cgebsr2csr_(handle,dir,mb,nb,bsr_descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #else function rocsparse_cgebsr2csr_rank_0(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsr2csr_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: csr_descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind ! rocsparse_cgebsr2csr_rank_0 = rocsparse_cgebsr2csr_(handle,dir,mb,nb,bsr_descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function function rocsparse_cgebsr2csr_rank_1(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsr2csr_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: csr_descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_cgebsr2csr_rank_1 = rocsparse_cgebsr2csr_(handle,dir,mb,nb,bsr_descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zgebsr2csr_assumed_rank(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsr2csr_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: csr_descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind ! rocsparse_zgebsr2csr_assumed_rank = rocsparse_zgebsr2csr_(handle,dir,mb,nb,bsr_descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #else function rocsparse_zgebsr2csr_rank_0(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsr2csr_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: csr_descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind ! rocsparse_zgebsr2csr_rank_0 = rocsparse_zgebsr2csr_(handle,dir,mb,nb,bsr_descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function function rocsparse_zgebsr2csr_rank_1(handle,dir,mb,nb,bsr_descr,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,csr_descr,csr_val,csr_row_ptr,csr_col_ind) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsr2csr_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nb type(c_ptr) :: bsr_descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: csr_descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind ! rocsparse_zgebsr2csr_rank_1 = rocsparse_zgebsr2csr_(handle,dir,mb,nb,bsr_descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & csr_descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sgebsr2gebsc_buffer_size_assumed_rank(handle,mb,nb,nnzb,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,p_buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsr2gebsc_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: p_buffer_size ! rocsparse_sgebsr2gebsc_buffer_size_assumed_rank = rocsparse_sgebsr2gebsc_buffer_size_( & handle,mb,nb,nnzb,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,p_buffer_size) end function #else function rocsparse_sgebsr2gebsc_buffer_size_rank_0(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,p_buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsr2gebsc_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: p_buffer_size ! rocsparse_sgebsr2gebsc_buffer_size_rank_0 = rocsparse_sgebsr2gebsc_buffer_size_(handle,mb, & nb,nnzb,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & p_buffer_size) end function function rocsparse_sgebsr2gebsc_buffer_size_rank_1(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,p_buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsr2gebsc_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: p_buffer_size ! rocsparse_sgebsr2gebsc_buffer_size_rank_1 = rocsparse_sgebsr2gebsc_buffer_size_(handle,mb, & nb,nnzb,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & p_buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dgebsr2gebsc_buffer_size_assumed_rank(handle,mb,nb,nnzb,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,p_buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsr2gebsc_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: p_buffer_size ! rocsparse_dgebsr2gebsc_buffer_size_assumed_rank = rocsparse_dgebsr2gebsc_buffer_size_( & handle,mb,nb,nnzb,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,p_buffer_size) end function #else function rocsparse_dgebsr2gebsc_buffer_size_rank_0(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,p_buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsr2gebsc_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: p_buffer_size ! rocsparse_dgebsr2gebsc_buffer_size_rank_0 = rocsparse_dgebsr2gebsc_buffer_size_(handle,mb, & nb,nnzb,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & p_buffer_size) end function function rocsparse_dgebsr2gebsc_buffer_size_rank_1(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,p_buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsr2gebsc_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: p_buffer_size ! rocsparse_dgebsr2gebsc_buffer_size_rank_1 = rocsparse_dgebsr2gebsc_buffer_size_(handle,mb, & nb,nnzb,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & p_buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cgebsr2gebsc_buffer_size_assumed_rank(handle,mb,nb,nnzb,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,p_buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsr2gebsc_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: p_buffer_size ! rocsparse_cgebsr2gebsc_buffer_size_assumed_rank = rocsparse_cgebsr2gebsc_buffer_size_( & handle,mb,nb,nnzb,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,p_buffer_size) end function #else function rocsparse_cgebsr2gebsc_buffer_size_rank_0(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,p_buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsr2gebsc_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: p_buffer_size ! rocsparse_cgebsr2gebsc_buffer_size_rank_0 = rocsparse_cgebsr2gebsc_buffer_size_(handle,mb, & nb,nnzb,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & p_buffer_size) end function function rocsparse_cgebsr2gebsc_buffer_size_rank_1(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,p_buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsr2gebsc_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: p_buffer_size ! rocsparse_cgebsr2gebsc_buffer_size_rank_1 = rocsparse_cgebsr2gebsc_buffer_size_(handle,mb, & nb,nnzb,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & p_buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zgebsr2gebsc_buffer_size_assumed_rank(handle,mb,nb,nnzb,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,p_buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsr2gebsc_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: p_buffer_size ! rocsparse_zgebsr2gebsc_buffer_size_assumed_rank = rocsparse_zgebsr2gebsc_buffer_size_( & handle,mb,nb,nnzb,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,p_buffer_size) end function #else function rocsparse_zgebsr2gebsc_buffer_size_rank_0(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,p_buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsr2gebsc_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: p_buffer_size ! rocsparse_zgebsr2gebsc_buffer_size_rank_0 = rocsparse_zgebsr2gebsc_buffer_size_(handle,mb, & nb,nnzb,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & p_buffer_size) end function function rocsparse_zgebsr2gebsc_buffer_size_rank_1(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,p_buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsr2gebsc_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim type(c_ptr) :: p_buffer_size ! rocsparse_zgebsr2gebsc_buffer_size_rank_1 = rocsparse_zgebsr2gebsc_buffer_size_(handle,mb, & nb,nnzb,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & p_buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sgebsr2gebsc_assumed_rank(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,bsc_val,bsc_row_ind,bsc_col_ptr,copy_values, & idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsr2gebsc_assumed_rank type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_float),target,contiguous,dimension(..) :: bsc_val integer(c_int),target,contiguous,dimension(..) :: bsc_row_ind integer(c_int),target,contiguous,dimension(..) :: bsc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_sgebsr2gebsc_assumed_rank = rocsparse_sgebsr2gebsc_(handle,mb,nb,nnzb, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & c_loc(bsc_val),c_loc(bsc_row_ind),c_loc(bsc_col_ptr),copy_values,idx_base,temp_buffer) end function #else function rocsparse_sgebsr2gebsc_rank_0(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr,bsr_col_ind, & row_block_dim,col_block_dim,bsc_val,bsc_row_ind,bsc_col_ptr,copy_values,idx_base, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsr2gebsc_rank_0 type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_float),target :: bsc_val integer(c_int),target :: bsc_row_ind integer(c_int),target :: bsc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_sgebsr2gebsc_rank_0 = rocsparse_sgebsr2gebsc_(handle,mb,nb,nnzb,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,c_loc(bsc_val), & c_loc(bsc_row_ind),c_loc(bsc_col_ptr),copy_values,idx_base,temp_buffer) end function function rocsparse_sgebsr2gebsc_rank_1(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr,bsr_col_ind, & row_block_dim,col_block_dim,bsc_val,bsc_row_ind,bsc_col_ptr,copy_values,idx_base, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsr2gebsc_rank_1 type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_float),target,dimension(:) :: bsc_val integer(c_int),target,dimension(:) :: bsc_row_ind integer(c_int),target,dimension(:) :: bsc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_sgebsr2gebsc_rank_1 = rocsparse_sgebsr2gebsc_(handle,mb,nb,nnzb,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,c_loc(bsc_val), & c_loc(bsc_row_ind),c_loc(bsc_col_ptr),copy_values,idx_base,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dgebsr2gebsc_assumed_rank(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,bsc_val,bsc_row_ind,bsc_col_ptr,copy_values, & idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsr2gebsc_assumed_rank type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_double),target,contiguous,dimension(..) :: bsc_val integer(c_int),target,contiguous,dimension(..) :: bsc_row_ind integer(c_int),target,contiguous,dimension(..) :: bsc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_dgebsr2gebsc_assumed_rank = rocsparse_dgebsr2gebsc_(handle,mb,nb,nnzb, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & c_loc(bsc_val),c_loc(bsc_row_ind),c_loc(bsc_col_ptr),copy_values,idx_base,temp_buffer) end function #else function rocsparse_dgebsr2gebsc_rank_0(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr,bsr_col_ind, & row_block_dim,col_block_dim,bsc_val,bsc_row_ind,bsc_col_ptr,copy_values,idx_base, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsr2gebsc_rank_0 type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_double),target :: bsc_val integer(c_int),target :: bsc_row_ind integer(c_int),target :: bsc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_dgebsr2gebsc_rank_0 = rocsparse_dgebsr2gebsc_(handle,mb,nb,nnzb,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,c_loc(bsc_val), & c_loc(bsc_row_ind),c_loc(bsc_col_ptr),copy_values,idx_base,temp_buffer) end function function rocsparse_dgebsr2gebsc_rank_1(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr,bsr_col_ind, & row_block_dim,col_block_dim,bsc_val,bsc_row_ind,bsc_col_ptr,copy_values,idx_base, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsr2gebsc_rank_1 type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_double),target,dimension(:) :: bsc_val integer(c_int),target,dimension(:) :: bsc_row_ind integer(c_int),target,dimension(:) :: bsc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_dgebsr2gebsc_rank_1 = rocsparse_dgebsr2gebsc_(handle,mb,nb,nnzb,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,c_loc(bsc_val), & c_loc(bsc_row_ind),c_loc(bsc_col_ptr),copy_values,idx_base,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cgebsr2gebsc_assumed_rank(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,bsc_val,bsc_row_ind,bsc_col_ptr,copy_values, & idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsr2gebsc_assumed_rank type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_float_complex),target,contiguous,dimension(..) :: bsc_val integer(c_int),target,contiguous,dimension(..) :: bsc_row_ind integer(c_int),target,contiguous,dimension(..) :: bsc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_cgebsr2gebsc_assumed_rank = rocsparse_cgebsr2gebsc_(handle,mb,nb,nnzb, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & c_loc(bsc_val),c_loc(bsc_row_ind),c_loc(bsc_col_ptr),copy_values,idx_base,temp_buffer) end function #else function rocsparse_cgebsr2gebsc_rank_0(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr,bsr_col_ind, & row_block_dim,col_block_dim,bsc_val,bsc_row_ind,bsc_col_ptr,copy_values,idx_base, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsr2gebsc_rank_0 type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_float_complex),target :: bsc_val integer(c_int),target :: bsc_row_ind integer(c_int),target :: bsc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_cgebsr2gebsc_rank_0 = rocsparse_cgebsr2gebsc_(handle,mb,nb,nnzb,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,c_loc(bsc_val), & c_loc(bsc_row_ind),c_loc(bsc_col_ptr),copy_values,idx_base,temp_buffer) end function function rocsparse_cgebsr2gebsc_rank_1(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr,bsr_col_ind, & row_block_dim,col_block_dim,bsc_val,bsc_row_ind,bsc_col_ptr,copy_values,idx_base, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsr2gebsc_rank_1 type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_float_complex),target,dimension(:) :: bsc_val integer(c_int),target,dimension(:) :: bsc_row_ind integer(c_int),target,dimension(:) :: bsc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_cgebsr2gebsc_rank_1 = rocsparse_cgebsr2gebsc_(handle,mb,nb,nnzb,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,c_loc(bsc_val), & c_loc(bsc_row_ind),c_loc(bsc_col_ptr),copy_values,idx_base,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zgebsr2gebsc_assumed_rank(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr, & bsr_col_ind,row_block_dim,col_block_dim,bsc_val,bsc_row_ind,bsc_col_ptr,copy_values, & idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsr2gebsc_assumed_rank type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_double_complex),target,contiguous,dimension(..) :: bsc_val integer(c_int),target,contiguous,dimension(..) :: bsc_row_ind integer(c_int),target,contiguous,dimension(..) :: bsc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_zgebsr2gebsc_assumed_rank = rocsparse_zgebsr2gebsc_(handle,mb,nb,nnzb, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & c_loc(bsc_val),c_loc(bsc_row_ind),c_loc(bsc_col_ptr),copy_values,idx_base,temp_buffer) end function #else function rocsparse_zgebsr2gebsc_rank_0(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr,bsr_col_ind, & row_block_dim,col_block_dim,bsc_val,bsc_row_ind,bsc_col_ptr,copy_values,idx_base, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsr2gebsc_rank_0 type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_double_complex),target :: bsc_val integer(c_int),target :: bsc_row_ind integer(c_int),target :: bsc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_zgebsr2gebsc_rank_0 = rocsparse_zgebsr2gebsc_(handle,mb,nb,nnzb,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,c_loc(bsc_val), & c_loc(bsc_row_ind),c_loc(bsc_col_ptr),copy_values,idx_base,temp_buffer) end function function rocsparse_zgebsr2gebsc_rank_1(handle,mb,nb,nnzb,bsr_val,bsr_row_ptr,bsr_col_ind, & row_block_dim,col_block_dim,bsc_val,bsc_row_ind,bsc_col_ptr,copy_values,idx_base, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsr2gebsc_rank_1 type(c_ptr) :: handle integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_double_complex),target,dimension(:) :: bsc_val integer(c_int),target,dimension(:) :: bsc_row_ind integer(c_int),target,dimension(:) :: bsc_col_ptr integer(kind(rocsparse_action_symbolic)) :: copy_values integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_zgebsr2gebsc_rank_1 = rocsparse_zgebsr2gebsc_(handle,mb,nb,nnzb,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,c_loc(bsc_val), & c_loc(bsc_row_ind),c_loc(bsc_col_ptr),copy_values,idx_base,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_hyb2csr_buffer_size_assumed_rank(handle,descr,hyb,csr_row_ptr,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_hyb2csr_buffer_size_assumed_rank type(c_ptr) :: handle type(c_ptr) :: descr type(c_ptr) :: hyb integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_size_t) :: buffer_size ! rocsparse_hyb2csr_buffer_size_assumed_rank = rocsparse_hyb2csr_buffer_size_(handle,descr, & hyb,c_loc(csr_row_ptr),buffer_size) end function #else function rocsparse_hyb2csr_buffer_size_rank_0(handle,descr,hyb,csr_row_ptr,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_hyb2csr_buffer_size_rank_0 type(c_ptr) :: handle type(c_ptr) :: descr type(c_ptr) :: hyb integer(c_int),target :: csr_row_ptr integer(c_size_t) :: buffer_size ! rocsparse_hyb2csr_buffer_size_rank_0 = rocsparse_hyb2csr_buffer_size_(handle,descr,hyb, & c_loc(csr_row_ptr),buffer_size) end function function rocsparse_hyb2csr_buffer_size_rank_1(handle,descr,hyb,csr_row_ptr,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_hyb2csr_buffer_size_rank_1 type(c_ptr) :: handle type(c_ptr) :: descr type(c_ptr) :: hyb integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_size_t) :: buffer_size ! rocsparse_hyb2csr_buffer_size_rank_1 = rocsparse_hyb2csr_buffer_size_(handle,descr,hyb, & c_loc(csr_row_ptr),buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_shyb2csr_assumed_rank(handle,descr,hyb,csr_val,csr_row_ptr,csr_col_ind, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_shyb2csr_assumed_rank type(c_ptr) :: handle type(c_ptr) :: descr type(c_ptr) :: hyb real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_shyb2csr_assumed_rank = rocsparse_shyb2csr_(handle,descr,hyb,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function #else function rocsparse_shyb2csr_rank_0(handle,descr,hyb,csr_val,csr_row_ptr,csr_col_ind,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_shyb2csr_rank_0 type(c_ptr) :: handle type(c_ptr) :: descr type(c_ptr) :: hyb real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_shyb2csr_rank_0 = rocsparse_shyb2csr_(handle,descr,hyb,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function function rocsparse_shyb2csr_rank_1(handle,descr,hyb,csr_val,csr_row_ptr,csr_col_ind,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_shyb2csr_rank_1 type(c_ptr) :: handle type(c_ptr) :: descr type(c_ptr) :: hyb real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_shyb2csr_rank_1 = rocsparse_shyb2csr_(handle,descr,hyb,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dhyb2csr_assumed_rank(handle,descr,hyb,csr_val,csr_row_ptr,csr_col_ind, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dhyb2csr_assumed_rank type(c_ptr) :: handle type(c_ptr) :: descr type(c_ptr) :: hyb real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_dhyb2csr_assumed_rank = rocsparse_dhyb2csr_(handle,descr,hyb,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function #else function rocsparse_dhyb2csr_rank_0(handle,descr,hyb,csr_val,csr_row_ptr,csr_col_ind,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dhyb2csr_rank_0 type(c_ptr) :: handle type(c_ptr) :: descr type(c_ptr) :: hyb real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_dhyb2csr_rank_0 = rocsparse_dhyb2csr_(handle,descr,hyb,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function function rocsparse_dhyb2csr_rank_1(handle,descr,hyb,csr_val,csr_row_ptr,csr_col_ind,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dhyb2csr_rank_1 type(c_ptr) :: handle type(c_ptr) :: descr type(c_ptr) :: hyb real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_dhyb2csr_rank_1 = rocsparse_dhyb2csr_(handle,descr,hyb,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_chyb2csr_assumed_rank(handle,descr,hyb,csr_val,csr_row_ptr,csr_col_ind, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_chyb2csr_assumed_rank type(c_ptr) :: handle type(c_ptr) :: descr type(c_ptr) :: hyb complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_chyb2csr_assumed_rank = rocsparse_chyb2csr_(handle,descr,hyb,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function #else function rocsparse_chyb2csr_rank_0(handle,descr,hyb,csr_val,csr_row_ptr,csr_col_ind,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_chyb2csr_rank_0 type(c_ptr) :: handle type(c_ptr) :: descr type(c_ptr) :: hyb complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_chyb2csr_rank_0 = rocsparse_chyb2csr_(handle,descr,hyb,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function function rocsparse_chyb2csr_rank_1(handle,descr,hyb,csr_val,csr_row_ptr,csr_col_ind,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_chyb2csr_rank_1 type(c_ptr) :: handle type(c_ptr) :: descr type(c_ptr) :: hyb complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_chyb2csr_rank_1 = rocsparse_chyb2csr_(handle,descr,hyb,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zhyb2csr_assumed_rank(handle,descr,hyb,csr_val,csr_row_ptr,csr_col_ind, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zhyb2csr_assumed_rank type(c_ptr) :: handle type(c_ptr) :: descr type(c_ptr) :: hyb complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_zhyb2csr_assumed_rank = rocsparse_zhyb2csr_(handle,descr,hyb,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function #else function rocsparse_zhyb2csr_rank_0(handle,descr,hyb,csr_val,csr_row_ptr,csr_col_ind,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zhyb2csr_rank_0 type(c_ptr) :: handle type(c_ptr) :: descr type(c_ptr) :: hyb complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_zhyb2csr_rank_0 = rocsparse_zhyb2csr_(handle,descr,hyb,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function function rocsparse_zhyb2csr_rank_1(handle,descr,hyb,csr_val,csr_row_ptr,csr_col_ind,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zhyb2csr_rank_1 type(c_ptr) :: handle type(c_ptr) :: descr type(c_ptr) :: hyb complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_zhyb2csr_rank_1 = rocsparse_zhyb2csr_(handle,descr,hyb,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_create_identity_permutation_assumed_rank(handle,n,p) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_identity_permutation_assumed_rank type(c_ptr) :: handle integer(c_int) :: n integer(c_int),target,contiguous,dimension(..) :: p ! rocsparse_create_identity_permutation_assumed_rank = rocsparse_create_identity_permutation_( & handle,n,c_loc(p)) end function #else function rocsparse_create_identity_permutation_rank_0(handle,n,p) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_identity_permutation_rank_0 type(c_ptr) :: handle integer(c_int) :: n integer(c_int),target :: p ! rocsparse_create_identity_permutation_rank_0 = rocsparse_create_identity_permutation_( & handle,n,c_loc(p)) end function function rocsparse_create_identity_permutation_rank_1(handle,n,p) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_create_identity_permutation_rank_1 type(c_ptr) :: handle integer(c_int) :: n integer(c_int),target,dimension(:) :: p ! rocsparse_create_identity_permutation_rank_1 = rocsparse_create_identity_permutation_( & handle,n,c_loc(p)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_snnz_assumed_rank(handle,dir,m,n,descr,A,ld,nnz_per_row_columns, & nnz_total_dev_host_ptr) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_snnz_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr ! rocsparse_snnz_assumed_rank = rocsparse_snnz_(handle,dir,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_row_columns),nnz_total_dev_host_ptr) end function #else function rocsparse_snnz_rank_0(handle,dir,m,n,descr,A,ld,nnz_per_row_columns, & nnz_total_dev_host_ptr) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_snnz_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target :: A integer(c_int) :: ld integer(c_int),target :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr ! rocsparse_snnz_rank_0 = rocsparse_snnz_(handle,dir,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_row_columns),nnz_total_dev_host_ptr) end function function rocsparse_snnz_rank_1(handle,dir,m,n,descr,A,ld,nnz_per_row_columns, & nnz_total_dev_host_ptr) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_snnz_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr ! rocsparse_snnz_rank_1 = rocsparse_snnz_(handle,dir,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_row_columns),nnz_total_dev_host_ptr) end function function rocsparse_snnz_full_rank(handle,dir,m,n,descr,A,ld,nnz_per_row_columns, & nnz_total_dev_host_ptr) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_snnz_full_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_float),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr ! rocsparse_snnz_full_rank = rocsparse_snnz_(handle,dir,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_row_columns),nnz_total_dev_host_ptr) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dnnz_assumed_rank(handle,dir,m,n,descr,A,ld,nnz_per_row_columns, & nnz_total_dev_host_ptr) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dnnz_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr ! rocsparse_dnnz_assumed_rank = rocsparse_dnnz_(handle,dir,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_row_columns),nnz_total_dev_host_ptr) end function #else function rocsparse_dnnz_rank_0(handle,dir,m,n,descr,A,ld,nnz_per_row_columns, & nnz_total_dev_host_ptr) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dnnz_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target :: A integer(c_int) :: ld integer(c_int),target :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr ! rocsparse_dnnz_rank_0 = rocsparse_dnnz_(handle,dir,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_row_columns),nnz_total_dev_host_ptr) end function function rocsparse_dnnz_rank_1(handle,dir,m,n,descr,A,ld,nnz_per_row_columns, & nnz_total_dev_host_ptr) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dnnz_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr ! rocsparse_dnnz_rank_1 = rocsparse_dnnz_(handle,dir,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_row_columns),nnz_total_dev_host_ptr) end function function rocsparse_dnnz_full_rank(handle,dir,m,n,descr,A,ld,nnz_per_row_columns, & nnz_total_dev_host_ptr) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dnnz_full_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr real(c_double),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr ! rocsparse_dnnz_full_rank = rocsparse_dnnz_(handle,dir,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_row_columns),nnz_total_dev_host_ptr) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cnnz_assumed_rank(handle,dir,m,n,descr,A,ld,nnz_per_row_columns, & nnz_total_dev_host_ptr) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cnnz_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr ! rocsparse_cnnz_assumed_rank = rocsparse_cnnz_(handle,dir,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_row_columns),nnz_total_dev_host_ptr) end function #else function rocsparse_cnnz_rank_0(handle,dir,m,n,descr,A,ld,nnz_per_row_columns, & nnz_total_dev_host_ptr) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cnnz_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target :: A integer(c_int) :: ld integer(c_int),target :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr ! rocsparse_cnnz_rank_0 = rocsparse_cnnz_(handle,dir,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_row_columns),nnz_total_dev_host_ptr) end function function rocsparse_cnnz_rank_1(handle,dir,m,n,descr,A,ld,nnz_per_row_columns, & nnz_total_dev_host_ptr) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cnnz_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr ! rocsparse_cnnz_rank_1 = rocsparse_cnnz_(handle,dir,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_row_columns),nnz_total_dev_host_ptr) end function function rocsparse_cnnz_full_rank(handle,dir,m,n,descr,A,ld,nnz_per_row_columns, & nnz_total_dev_host_ptr) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cnnz_full_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr ! rocsparse_cnnz_full_rank = rocsparse_cnnz_(handle,dir,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_row_columns),nnz_total_dev_host_ptr) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_znnz_assumed_rank(handle,dir,m,n,descr,A,ld,nnz_per_row_columns, & nnz_total_dev_host_ptr) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_znnz_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: ld integer(c_int),target,contiguous,dimension(..) :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr ! rocsparse_znnz_assumed_rank = rocsparse_znnz_(handle,dir,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_row_columns),nnz_total_dev_host_ptr) end function #else function rocsparse_znnz_rank_0(handle,dir,m,n,descr,A,ld,nnz_per_row_columns, & nnz_total_dev_host_ptr) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_znnz_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target :: A integer(c_int) :: ld integer(c_int),target :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr ! rocsparse_znnz_rank_0 = rocsparse_znnz_(handle,dir,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_row_columns),nnz_total_dev_host_ptr) end function function rocsparse_znnz_rank_1(handle,dir,m,n,descr,A,ld,nnz_per_row_columns, & nnz_total_dev_host_ptr) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_znnz_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr ! rocsparse_znnz_rank_1 = rocsparse_znnz_(handle,dir,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_row_columns),nnz_total_dev_host_ptr) end function function rocsparse_znnz_full_rank(handle,dir,m,n,descr,A,ld,nnz_per_row_columns, & nnz_total_dev_host_ptr) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_znnz_full_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: ld integer(c_int),target,dimension(:) :: nnz_per_row_columns integer(c_int) :: nnz_total_dev_host_ptr ! rocsparse_znnz_full_rank = rocsparse_znnz_(handle,dir,m,n,descr,c_loc(A),ld, & c_loc(nnz_per_row_columns),nnz_total_dev_host_ptr) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_snnz_compress_assumed_rank(handle,m,descr_A,csr_val_A,csr_row_ptr_A, & nnz_per_row,nnz_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_snnz_compress_assumed_rank type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descr_A real(c_float),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: nnz_per_row integer(c_int),target,contiguous,dimension(..) :: nnz_C real(c_float) :: tol ! rocsparse_snnz_compress_assumed_rank = rocsparse_snnz_compress_(handle,m,descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(nnz_per_row),c_loc(nnz_C),tol) end function #else function rocsparse_snnz_compress_rank_0(handle,m,descr_A,csr_val_A,csr_row_ptr_A,nnz_per_row, & nnz_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_snnz_compress_rank_0 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descr_A real(c_float),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: nnz_per_row integer(c_int),target :: nnz_C real(c_float) :: tol ! rocsparse_snnz_compress_rank_0 = rocsparse_snnz_compress_(handle,m,descr_A,c_loc(csr_val_A), & c_loc(csr_row_ptr_A),c_loc(nnz_per_row),c_loc(nnz_C),tol) end function function rocsparse_snnz_compress_rank_1(handle,m,descr_A,csr_val_A,csr_row_ptr_A,nnz_per_row, & nnz_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_snnz_compress_rank_1 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descr_A real(c_float),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: nnz_per_row integer(c_int),target,dimension(:) :: nnz_C real(c_float) :: tol ! rocsparse_snnz_compress_rank_1 = rocsparse_snnz_compress_(handle,m,descr_A,c_loc(csr_val_A), & c_loc(csr_row_ptr_A),c_loc(nnz_per_row),c_loc(nnz_C),tol) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dnnz_compress_assumed_rank(handle,m,descr_A,csr_val_A,csr_row_ptr_A, & nnz_per_row,nnz_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dnnz_compress_assumed_rank type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descr_A real(c_double),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: nnz_per_row integer(c_int),target,contiguous,dimension(..) :: nnz_C real(c_double) :: tol ! rocsparse_dnnz_compress_assumed_rank = rocsparse_dnnz_compress_(handle,m,descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(nnz_per_row),c_loc(nnz_C),tol) end function #else function rocsparse_dnnz_compress_rank_0(handle,m,descr_A,csr_val_A,csr_row_ptr_A,nnz_per_row, & nnz_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dnnz_compress_rank_0 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descr_A real(c_double),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: nnz_per_row integer(c_int),target :: nnz_C real(c_double) :: tol ! rocsparse_dnnz_compress_rank_0 = rocsparse_dnnz_compress_(handle,m,descr_A,c_loc(csr_val_A), & c_loc(csr_row_ptr_A),c_loc(nnz_per_row),c_loc(nnz_C),tol) end function function rocsparse_dnnz_compress_rank_1(handle,m,descr_A,csr_val_A,csr_row_ptr_A,nnz_per_row, & nnz_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dnnz_compress_rank_1 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descr_A real(c_double),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: nnz_per_row integer(c_int),target,dimension(:) :: nnz_C real(c_double) :: tol ! rocsparse_dnnz_compress_rank_1 = rocsparse_dnnz_compress_(handle,m,descr_A,c_loc(csr_val_A), & c_loc(csr_row_ptr_A),c_loc(nnz_per_row),c_loc(nnz_C),tol) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cnnz_compress_assumed_rank(handle,m,descr_A,csr_val_A,csr_row_ptr_A, & nnz_per_row,nnz_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cnnz_compress_assumed_rank type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descr_A complex(c_float_complex),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: nnz_per_row integer(c_int),target,contiguous,dimension(..) :: nnz_C complex(c_float_complex) :: tol ! rocsparse_cnnz_compress_assumed_rank = rocsparse_cnnz_compress_(handle,m,descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(nnz_per_row),c_loc(nnz_C),tol) end function #else function rocsparse_cnnz_compress_rank_0(handle,m,descr_A,csr_val_A,csr_row_ptr_A,nnz_per_row, & nnz_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cnnz_compress_rank_0 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descr_A complex(c_float_complex),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: nnz_per_row integer(c_int),target :: nnz_C complex(c_float_complex) :: tol ! rocsparse_cnnz_compress_rank_0 = rocsparse_cnnz_compress_(handle,m,descr_A,c_loc(csr_val_A), & c_loc(csr_row_ptr_A),c_loc(nnz_per_row),c_loc(nnz_C),tol) end function function rocsparse_cnnz_compress_rank_1(handle,m,descr_A,csr_val_A,csr_row_ptr_A,nnz_per_row, & nnz_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cnnz_compress_rank_1 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descr_A complex(c_float_complex),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: nnz_per_row integer(c_int),target,dimension(:) :: nnz_C complex(c_float_complex) :: tol ! rocsparse_cnnz_compress_rank_1 = rocsparse_cnnz_compress_(handle,m,descr_A,c_loc(csr_val_A), & c_loc(csr_row_ptr_A),c_loc(nnz_per_row),c_loc(nnz_C),tol) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_znnz_compress_assumed_rank(handle,m,descr_A,csr_val_A,csr_row_ptr_A, & nnz_per_row,nnz_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_znnz_compress_assumed_rank type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descr_A complex(c_double_complex),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: nnz_per_row integer(c_int),target,contiguous,dimension(..) :: nnz_C complex(c_double_complex) :: tol ! rocsparse_znnz_compress_assumed_rank = rocsparse_znnz_compress_(handle,m,descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(nnz_per_row),c_loc(nnz_C),tol) end function #else function rocsparse_znnz_compress_rank_0(handle,m,descr_A,csr_val_A,csr_row_ptr_A,nnz_per_row, & nnz_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_znnz_compress_rank_0 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descr_A complex(c_double_complex),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: nnz_per_row integer(c_int),target :: nnz_C complex(c_double_complex) :: tol ! rocsparse_znnz_compress_rank_0 = rocsparse_znnz_compress_(handle,m,descr_A,c_loc(csr_val_A), & c_loc(csr_row_ptr_A),c_loc(nnz_per_row),c_loc(nnz_C),tol) end function function rocsparse_znnz_compress_rank_1(handle,m,descr_A,csr_val_A,csr_row_ptr_A,nnz_per_row, & nnz_C,tol) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_znnz_compress_rank_1 type(c_ptr) :: handle integer(c_int) :: m type(c_ptr) :: descr_A complex(c_double_complex),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: nnz_per_row integer(c_int),target,dimension(:) :: nnz_C complex(c_double_complex) :: tol ! rocsparse_znnz_compress_rank_1 = rocsparse_znnz_compress_(handle,m,descr_A,c_loc(csr_val_A), & c_loc(csr_row_ptr_A),c_loc(nnz_per_row),c_loc(nnz_C),tol) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sprune_csr2csr_buffer_size_assumed_rank(handle,m,n,nnz_A,csr_descr_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,threshold,csr_descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_float),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A real(c_float) :: threshold type(c_ptr) :: csr_descr_C real(c_float),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C integer(c_size_t) :: buffer_size ! rocsparse_sprune_csr2csr_buffer_size_assumed_rank = rocsparse_sprune_csr2csr_buffer_size_( & handle,m,n,nnz_A,csr_descr_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A), & threshold,csr_descr_C,c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C), & buffer_size) end function #else function rocsparse_sprune_csr2csr_buffer_size_rank_0(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,threshold,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C, & buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_float),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A real(c_float) :: threshold type(c_ptr) :: csr_descr_C real(c_float),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C integer(c_size_t) :: buffer_size ! rocsparse_sprune_csr2csr_buffer_size_rank_0 = rocsparse_sprune_csr2csr_buffer_size_(handle, & m,n,nnz_A,csr_descr_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A), & threshold,csr_descr_C,c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C), & buffer_size) end function function rocsparse_sprune_csr2csr_buffer_size_rank_1(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,threshold,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C, & buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_float),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A real(c_float) :: threshold type(c_ptr) :: csr_descr_C real(c_float),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C integer(c_size_t) :: buffer_size ! rocsparse_sprune_csr2csr_buffer_size_rank_1 = rocsparse_sprune_csr2csr_buffer_size_(handle, & m,n,nnz_A,csr_descr_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A), & threshold,csr_descr_C,c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C), & buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dprune_csr2csr_buffer_size_assumed_rank(handle,m,n,nnz_A,csr_descr_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,threshold,csr_descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_double),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A real(c_double) :: threshold type(c_ptr) :: csr_descr_C real(c_double),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C integer(c_size_t) :: buffer_size ! rocsparse_dprune_csr2csr_buffer_size_assumed_rank = rocsparse_dprune_csr2csr_buffer_size_( & handle,m,n,nnz_A,csr_descr_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A), & threshold,csr_descr_C,c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C), & buffer_size) end function #else function rocsparse_dprune_csr2csr_buffer_size_rank_0(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,threshold,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C, & buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_double),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A real(c_double) :: threshold type(c_ptr) :: csr_descr_C real(c_double),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C integer(c_size_t) :: buffer_size ! rocsparse_dprune_csr2csr_buffer_size_rank_0 = rocsparse_dprune_csr2csr_buffer_size_(handle, & m,n,nnz_A,csr_descr_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A), & threshold,csr_descr_C,c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C), & buffer_size) end function function rocsparse_dprune_csr2csr_buffer_size_rank_1(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,threshold,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C, & buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_double),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A real(c_double) :: threshold type(c_ptr) :: csr_descr_C real(c_double),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C integer(c_size_t) :: buffer_size ! rocsparse_dprune_csr2csr_buffer_size_rank_1 = rocsparse_dprune_csr2csr_buffer_size_(handle, & m,n,nnz_A,csr_descr_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A), & threshold,csr_descr_C,c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C), & buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sprune_csr2csr_nnz_assumed_rank(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,threshold,csr_descr_C,csr_row_ptr_C,nnz_total_dev_host_ptr, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_nnz_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_float),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A real(c_float) :: threshold type(c_ptr) :: csr_descr_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: temp_buffer ! rocsparse_sprune_csr2csr_nnz_assumed_rank = rocsparse_sprune_csr2csr_nnz_(handle,m,n,nnz_A, & csr_descr_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),threshold, & csr_descr_C,c_loc(csr_row_ptr_C),nnz_total_dev_host_ptr,temp_buffer) end function #else function rocsparse_sprune_csr2csr_nnz_rank_0(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,threshold,csr_descr_C,csr_row_ptr_C,nnz_total_dev_host_ptr, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_nnz_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_float),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A real(c_float) :: threshold type(c_ptr) :: csr_descr_C integer(c_int),target :: csr_row_ptr_C integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: temp_buffer ! rocsparse_sprune_csr2csr_nnz_rank_0 = rocsparse_sprune_csr2csr_nnz_(handle,m,n,nnz_A, & csr_descr_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),threshold, & csr_descr_C,c_loc(csr_row_ptr_C),nnz_total_dev_host_ptr,temp_buffer) end function function rocsparse_sprune_csr2csr_nnz_rank_1(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,threshold,csr_descr_C,csr_row_ptr_C,nnz_total_dev_host_ptr, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_nnz_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_float),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A real(c_float) :: threshold type(c_ptr) :: csr_descr_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: temp_buffer ! rocsparse_sprune_csr2csr_nnz_rank_1 = rocsparse_sprune_csr2csr_nnz_(handle,m,n,nnz_A, & csr_descr_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),threshold, & csr_descr_C,c_loc(csr_row_ptr_C),nnz_total_dev_host_ptr,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dprune_csr2csr_nnz_assumed_rank(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,threshold,csr_descr_C,csr_row_ptr_C,nnz_total_dev_host_ptr, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_nnz_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_double),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A real(c_double) :: threshold type(c_ptr) :: csr_descr_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: temp_buffer ! rocsparse_dprune_csr2csr_nnz_assumed_rank = rocsparse_dprune_csr2csr_nnz_(handle,m,n,nnz_A, & csr_descr_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),threshold, & csr_descr_C,c_loc(csr_row_ptr_C),nnz_total_dev_host_ptr,temp_buffer) end function #else function rocsparse_dprune_csr2csr_nnz_rank_0(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,threshold,csr_descr_C,csr_row_ptr_C,nnz_total_dev_host_ptr, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_nnz_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_double),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A real(c_double) :: threshold type(c_ptr) :: csr_descr_C integer(c_int),target :: csr_row_ptr_C integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: temp_buffer ! rocsparse_dprune_csr2csr_nnz_rank_0 = rocsparse_dprune_csr2csr_nnz_(handle,m,n,nnz_A, & csr_descr_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),threshold, & csr_descr_C,c_loc(csr_row_ptr_C),nnz_total_dev_host_ptr,temp_buffer) end function function rocsparse_dprune_csr2csr_nnz_rank_1(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,threshold,csr_descr_C,csr_row_ptr_C,nnz_total_dev_host_ptr, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_nnz_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_double),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A real(c_double) :: threshold type(c_ptr) :: csr_descr_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: temp_buffer ! rocsparse_dprune_csr2csr_nnz_rank_1 = rocsparse_dprune_csr2csr_nnz_(handle,m,n,nnz_A, & csr_descr_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),threshold, & csr_descr_C,c_loc(csr_row_ptr_C),nnz_total_dev_host_ptr,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sprune_csr2csr_assumed_rank(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,threshold,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_float),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A real(c_float) :: threshold type(c_ptr) :: csr_descr_C real(c_float),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C type(c_ptr) :: temp_buffer ! rocsparse_sprune_csr2csr_assumed_rank = rocsparse_sprune_csr2csr_(handle,m,n,nnz_A, & csr_descr_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),threshold, & csr_descr_C,c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),temp_buffer) end function #else function rocsparse_sprune_csr2csr_rank_0(handle,m,n,nnz_A,csr_descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,threshold,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_float),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A real(c_float) :: threshold type(c_ptr) :: csr_descr_C real(c_float),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C type(c_ptr) :: temp_buffer ! rocsparse_sprune_csr2csr_rank_0 = rocsparse_sprune_csr2csr_(handle,m,n,nnz_A,csr_descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),threshold,csr_descr_C, & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),temp_buffer) end function function rocsparse_sprune_csr2csr_rank_1(handle,m,n,nnz_A,csr_descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,threshold,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_float),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A real(c_float) :: threshold type(c_ptr) :: csr_descr_C real(c_float),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C type(c_ptr) :: temp_buffer ! rocsparse_sprune_csr2csr_rank_1 = rocsparse_sprune_csr2csr_(handle,m,n,nnz_A,csr_descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),threshold,csr_descr_C, & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dprune_csr2csr_assumed_rank(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,threshold,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_double),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A real(c_double) :: threshold type(c_ptr) :: csr_descr_C real(c_double),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C type(c_ptr) :: temp_buffer ! rocsparse_dprune_csr2csr_assumed_rank = rocsparse_dprune_csr2csr_(handle,m,n,nnz_A, & csr_descr_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),threshold, & csr_descr_C,c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),temp_buffer) end function #else function rocsparse_dprune_csr2csr_rank_0(handle,m,n,nnz_A,csr_descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,threshold,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_double),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A real(c_double) :: threshold type(c_ptr) :: csr_descr_C real(c_double),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C type(c_ptr) :: temp_buffer ! rocsparse_dprune_csr2csr_rank_0 = rocsparse_dprune_csr2csr_(handle,m,n,nnz_A,csr_descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),threshold,csr_descr_C, & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),temp_buffer) end function function rocsparse_dprune_csr2csr_rank_1(handle,m,n,nnz_A,csr_descr_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,threshold,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_double),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A real(c_double) :: threshold type(c_ptr) :: csr_descr_C real(c_double),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C type(c_ptr) :: temp_buffer ! rocsparse_dprune_csr2csr_rank_1 = rocsparse_dprune_csr2csr_(handle,m,n,nnz_A,csr_descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),threshold,csr_descr_C, & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sprune_csr2csr_by_percentage_buffer_size_assumed_rank(handle,m,n,nnz_A, & csr_descr_A,csr_val_A,csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_by_percentage_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_float),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A real(c_float) :: percentage type(c_ptr) :: csr_descr_C real(c_float),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_sprune_csr2csr_by_percentage_buffer_size_assumed_rank = & rocsparse_sprune_csr2csr_by_percentage_buffer_size_(handle,m,n,nnz_A,csr_descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),percentage,csr_descr_C, & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),myInfo,buffer_size) end function #else function rocsparse_sprune_csr2csr_by_percentage_buffer_size_rank_0(handle,m,n,nnz_A, & csr_descr_A,csr_val_A,csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_by_percentage_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_float),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A real(c_float) :: percentage type(c_ptr) :: csr_descr_C real(c_float),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_sprune_csr2csr_by_percentage_buffer_size_rank_0 = & rocsparse_sprune_csr2csr_by_percentage_buffer_size_(handle,m,n,nnz_A,csr_descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),percentage,csr_descr_C, & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),myInfo,buffer_size) end function function rocsparse_sprune_csr2csr_by_percentage_buffer_size_rank_1(handle,m,n,nnz_A, & csr_descr_A,csr_val_A,csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_by_percentage_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_float),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A real(c_float) :: percentage type(c_ptr) :: csr_descr_C real(c_float),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_sprune_csr2csr_by_percentage_buffer_size_rank_1 = & rocsparse_sprune_csr2csr_by_percentage_buffer_size_(handle,m,n,nnz_A,csr_descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),percentage,csr_descr_C, & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dprune_csr2csr_by_percentage_buffer_size_assumed_rank(handle,m,n,nnz_A, & csr_descr_A,csr_val_A,csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_by_percentage_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_double),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A real(c_double) :: percentage type(c_ptr) :: csr_descr_C real(c_double),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dprune_csr2csr_by_percentage_buffer_size_assumed_rank = & rocsparse_dprune_csr2csr_by_percentage_buffer_size_(handle,m,n,nnz_A,csr_descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),percentage,csr_descr_C, & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),myInfo,buffer_size) end function #else function rocsparse_dprune_csr2csr_by_percentage_buffer_size_rank_0(handle,m,n,nnz_A, & csr_descr_A,csr_val_A,csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_by_percentage_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_double),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A real(c_double) :: percentage type(c_ptr) :: csr_descr_C real(c_double),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dprune_csr2csr_by_percentage_buffer_size_rank_0 = & rocsparse_dprune_csr2csr_by_percentage_buffer_size_(handle,m,n,nnz_A,csr_descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),percentage,csr_descr_C, & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),myInfo,buffer_size) end function function rocsparse_dprune_csr2csr_by_percentage_buffer_size_rank_1(handle,m,n,nnz_A, & csr_descr_A,csr_val_A,csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_by_percentage_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_double),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A real(c_double) :: percentage type(c_ptr) :: csr_descr_C real(c_double),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dprune_csr2csr_by_percentage_buffer_size_rank_1 = & rocsparse_dprune_csr2csr_by_percentage_buffer_size_(handle,m,n,nnz_A,csr_descr_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),percentage,csr_descr_C, & c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sprune_csr2csr_nnz_by_percentage_assumed_rank(handle,m,n,nnz_A,csr_descr_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_row_ptr_C, & nnz_total_dev_host_ptr,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_nnz_by_percentage_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_float),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A real(c_float) :: percentage type(c_ptr) :: csr_descr_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_sprune_csr2csr_nnz_by_percentage_assumed_rank = & rocsparse_sprune_csr2csr_nnz_by_percentage_(handle,m,n,nnz_A,csr_descr_A,c_loc(csr_val_A), & c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),percentage,csr_descr_C,c_loc(csr_row_ptr_C), & nnz_total_dev_host_ptr,myInfo,temp_buffer) end function #else function rocsparse_sprune_csr2csr_nnz_by_percentage_rank_0(handle,m,n,nnz_A,csr_descr_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_row_ptr_C, & nnz_total_dev_host_ptr,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_nnz_by_percentage_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_float),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A real(c_float) :: percentage type(c_ptr) :: csr_descr_C integer(c_int),target :: csr_row_ptr_C integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_sprune_csr2csr_nnz_by_percentage_rank_0 = & rocsparse_sprune_csr2csr_nnz_by_percentage_(handle,m,n,nnz_A,csr_descr_A,c_loc(csr_val_A), & c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),percentage,csr_descr_C,c_loc(csr_row_ptr_C), & nnz_total_dev_host_ptr,myInfo,temp_buffer) end function function rocsparse_sprune_csr2csr_nnz_by_percentage_rank_1(handle,m,n,nnz_A,csr_descr_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_row_ptr_C, & nnz_total_dev_host_ptr,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_nnz_by_percentage_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_float),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A real(c_float) :: percentage type(c_ptr) :: csr_descr_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_sprune_csr2csr_nnz_by_percentage_rank_1 = & rocsparse_sprune_csr2csr_nnz_by_percentage_(handle,m,n,nnz_A,csr_descr_A,c_loc(csr_val_A), & c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),percentage,csr_descr_C,c_loc(csr_row_ptr_C), & nnz_total_dev_host_ptr,myInfo,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dprune_csr2csr_nnz_by_percentage_assumed_rank(handle,m,n,nnz_A,csr_descr_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_row_ptr_C, & nnz_total_dev_host_ptr,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_nnz_by_percentage_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_double),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A real(c_double) :: percentage type(c_ptr) :: csr_descr_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_dprune_csr2csr_nnz_by_percentage_assumed_rank = & rocsparse_dprune_csr2csr_nnz_by_percentage_(handle,m,n,nnz_A,csr_descr_A,c_loc(csr_val_A), & c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),percentage,csr_descr_C,c_loc(csr_row_ptr_C), & nnz_total_dev_host_ptr,myInfo,temp_buffer) end function #else function rocsparse_dprune_csr2csr_nnz_by_percentage_rank_0(handle,m,n,nnz_A,csr_descr_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_row_ptr_C, & nnz_total_dev_host_ptr,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_nnz_by_percentage_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_double),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A real(c_double) :: percentage type(c_ptr) :: csr_descr_C integer(c_int),target :: csr_row_ptr_C integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_dprune_csr2csr_nnz_by_percentage_rank_0 = & rocsparse_dprune_csr2csr_nnz_by_percentage_(handle,m,n,nnz_A,csr_descr_A,c_loc(csr_val_A), & c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),percentage,csr_descr_C,c_loc(csr_row_ptr_C), & nnz_total_dev_host_ptr,myInfo,temp_buffer) end function function rocsparse_dprune_csr2csr_nnz_by_percentage_rank_1(handle,m,n,nnz_A,csr_descr_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_row_ptr_C, & nnz_total_dev_host_ptr,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_nnz_by_percentage_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_double),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A real(c_double) :: percentage type(c_ptr) :: csr_descr_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_dprune_csr2csr_nnz_by_percentage_rank_1 = & rocsparse_dprune_csr2csr_nnz_by_percentage_(handle,m,n,nnz_A,csr_descr_A,c_loc(csr_val_A), & c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),percentage,csr_descr_C,c_loc(csr_row_ptr_C), & nnz_total_dev_host_ptr,myInfo,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sprune_csr2csr_by_percentage_assumed_rank(handle,m,n,nnz_A,csr_descr_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_by_percentage_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_float),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A real(c_float) :: percentage type(c_ptr) :: csr_descr_C real(c_float),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_sprune_csr2csr_by_percentage_assumed_rank = & rocsparse_sprune_csr2csr_by_percentage_(handle,m,n,nnz_A,csr_descr_A,c_loc(csr_val_A), & c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),percentage,csr_descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),myInfo,temp_buffer) end function #else function rocsparse_sprune_csr2csr_by_percentage_rank_0(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C, & myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_by_percentage_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_float),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A real(c_float) :: percentage type(c_ptr) :: csr_descr_C real(c_float),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_sprune_csr2csr_by_percentage_rank_0 = rocsparse_sprune_csr2csr_by_percentage_( & handle,m,n,nnz_A,csr_descr_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A), & percentage,csr_descr_C,c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),myInfo, & temp_buffer) end function function rocsparse_sprune_csr2csr_by_percentage_rank_1(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C, & myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_csr2csr_by_percentage_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_float),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A real(c_float) :: percentage type(c_ptr) :: csr_descr_C real(c_float),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_sprune_csr2csr_by_percentage_rank_1 = rocsparse_sprune_csr2csr_by_percentage_( & handle,m,n,nnz_A,csr_descr_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A), & percentage,csr_descr_C,c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),myInfo, & temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dprune_csr2csr_by_percentage_assumed_rank(handle,m,n,nnz_A,csr_descr_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_by_percentage_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_double),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A real(c_double) :: percentage type(c_ptr) :: csr_descr_C real(c_double),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_dprune_csr2csr_by_percentage_assumed_rank = & rocsparse_dprune_csr2csr_by_percentage_(handle,m,n,nnz_A,csr_descr_A,c_loc(csr_val_A), & c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),percentage,csr_descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),myInfo,temp_buffer) end function #else function rocsparse_dprune_csr2csr_by_percentage_rank_0(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C, & myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_by_percentage_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_double),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A real(c_double) :: percentage type(c_ptr) :: csr_descr_C real(c_double),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_dprune_csr2csr_by_percentage_rank_0 = rocsparse_dprune_csr2csr_by_percentage_( & handle,m,n,nnz_A,csr_descr_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A), & percentage,csr_descr_C,c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),myInfo, & temp_buffer) end function function rocsparse_dprune_csr2csr_by_percentage_rank_1(handle,m,n,nnz_A,csr_descr_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,percentage,csr_descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C, & myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_csr2csr_by_percentage_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz_A type(c_ptr) :: csr_descr_A real(c_double),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A real(c_double) :: percentage type(c_ptr) :: csr_descr_C real(c_double),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_dprune_csr2csr_by_percentage_rank_1 = rocsparse_dprune_csr2csr_by_percentage_( & handle,m,n,nnz_A,csr_descr_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A), & percentage,csr_descr_C,c_loc(csr_val_C),c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),myInfo, & temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sprune_dense2csr_buffer_size_assumed_rank(handle,m,n,A,lda,threshold,descr, & csr_val,csr_row_ptr,csr_col_ind,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind integer(c_size_t) :: buffer_size ! rocsparse_sprune_dense2csr_buffer_size_assumed_rank = & rocsparse_sprune_dense2csr_buffer_size_(handle,m,n,c_loc(A),lda,threshold,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),buffer_size) end function #else function rocsparse_sprune_dense2csr_buffer_size_rank_0(handle,m,n,A,lda,threshold,descr, & csr_val,csr_row_ptr,csr_col_ind,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind integer(c_size_t) :: buffer_size ! rocsparse_sprune_dense2csr_buffer_size_rank_0 = rocsparse_sprune_dense2csr_buffer_size_( & handle,m,n,c_loc(A),lda,threshold,descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind),buffer_size) end function function rocsparse_sprune_dense2csr_buffer_size_rank_1(handle,m,n,A,lda,threshold,descr, & csr_val,csr_row_ptr,csr_col_ind,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind integer(c_size_t) :: buffer_size ! rocsparse_sprune_dense2csr_buffer_size_rank_1 = rocsparse_sprune_dense2csr_buffer_size_( & handle,m,n,c_loc(A),lda,threshold,descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind),buffer_size) end function function rocsparse_sprune_dense2csr_buffer_size_full_rank(handle,m,n,A,lda,threshold,descr, & csr_val,csr_row_ptr,csr_col_ind,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_buffer_size_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind integer(c_size_t) :: buffer_size ! rocsparse_sprune_dense2csr_buffer_size_full_rank = rocsparse_sprune_dense2csr_buffer_size_( & handle,m,n,c_loc(A),lda,threshold,descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind),buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dprune_dense2csr_buffer_size_assumed_rank(handle,m,n,A,lda,threshold,descr, & csr_val,csr_row_ptr,csr_col_ind,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind integer(c_size_t) :: buffer_size ! rocsparse_dprune_dense2csr_buffer_size_assumed_rank = & rocsparse_dprune_dense2csr_buffer_size_(handle,m,n,c_loc(A),lda,threshold,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),buffer_size) end function #else function rocsparse_dprune_dense2csr_buffer_size_rank_0(handle,m,n,A,lda,threshold,descr, & csr_val,csr_row_ptr,csr_col_ind,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind integer(c_size_t) :: buffer_size ! rocsparse_dprune_dense2csr_buffer_size_rank_0 = rocsparse_dprune_dense2csr_buffer_size_( & handle,m,n,c_loc(A),lda,threshold,descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind),buffer_size) end function function rocsparse_dprune_dense2csr_buffer_size_rank_1(handle,m,n,A,lda,threshold,descr, & csr_val,csr_row_ptr,csr_col_ind,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind integer(c_size_t) :: buffer_size ! rocsparse_dprune_dense2csr_buffer_size_rank_1 = rocsparse_dprune_dense2csr_buffer_size_( & handle,m,n,c_loc(A),lda,threshold,descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind),buffer_size) end function function rocsparse_dprune_dense2csr_buffer_size_full_rank(handle,m,n,A,lda,threshold,descr, & csr_val,csr_row_ptr,csr_col_ind,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_buffer_size_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind integer(c_size_t) :: buffer_size ! rocsparse_dprune_dense2csr_buffer_size_full_rank = rocsparse_dprune_dense2csr_buffer_size_( & handle,m,n,c_loc(A),lda,threshold,descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind),buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sprune_dense2csr_nnz_assumed_rank(handle,m,n,A,lda,threshold,descr, & csr_row_ptr,nnz_total_dev_host_ptr,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_nnz_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: temp_buffer ! rocsparse_sprune_dense2csr_nnz_assumed_rank = rocsparse_sprune_dense2csr_nnz_(handle,m,n, & c_loc(A),lda,threshold,descr,c_loc(csr_row_ptr),nnz_total_dev_host_ptr,temp_buffer) end function #else function rocsparse_sprune_dense2csr_nnz_rank_0(handle,m,n,A,lda,threshold,descr,csr_row_ptr, & nnz_total_dev_host_ptr,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_nnz_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr integer(c_int),target :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: temp_buffer ! rocsparse_sprune_dense2csr_nnz_rank_0 = rocsparse_sprune_dense2csr_nnz_(handle,m,n,c_loc(A), & lda,threshold,descr,c_loc(csr_row_ptr),nnz_total_dev_host_ptr,temp_buffer) end function function rocsparse_sprune_dense2csr_nnz_rank_1(handle,m,n,A,lda,threshold,descr,csr_row_ptr, & nnz_total_dev_host_ptr,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_nnz_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: temp_buffer ! rocsparse_sprune_dense2csr_nnz_rank_1 = rocsparse_sprune_dense2csr_nnz_(handle,m,n,c_loc(A), & lda,threshold,descr,c_loc(csr_row_ptr),nnz_total_dev_host_ptr,temp_buffer) end function function rocsparse_sprune_dense2csr_nnz_full_rank(handle,m,n,A,lda,threshold,descr, & csr_row_ptr,nnz_total_dev_host_ptr,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_nnz_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: temp_buffer ! rocsparse_sprune_dense2csr_nnz_full_rank = rocsparse_sprune_dense2csr_nnz_(handle,m,n, & c_loc(A),lda,threshold,descr,c_loc(csr_row_ptr),nnz_total_dev_host_ptr,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dprune_dense2csr_nnz_assumed_rank(handle,m,n,A,lda,threshold,descr, & csr_row_ptr,nnz_total_dev_host_ptr,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_nnz_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: temp_buffer ! rocsparse_dprune_dense2csr_nnz_assumed_rank = rocsparse_dprune_dense2csr_nnz_(handle,m,n, & c_loc(A),lda,threshold,descr,c_loc(csr_row_ptr),nnz_total_dev_host_ptr,temp_buffer) end function #else function rocsparse_dprune_dense2csr_nnz_rank_0(handle,m,n,A,lda,threshold,descr,csr_row_ptr, & nnz_total_dev_host_ptr,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_nnz_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr integer(c_int),target :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: temp_buffer ! rocsparse_dprune_dense2csr_nnz_rank_0 = rocsparse_dprune_dense2csr_nnz_(handle,m,n,c_loc(A), & lda,threshold,descr,c_loc(csr_row_ptr),nnz_total_dev_host_ptr,temp_buffer) end function function rocsparse_dprune_dense2csr_nnz_rank_1(handle,m,n,A,lda,threshold,descr,csr_row_ptr, & nnz_total_dev_host_ptr,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_nnz_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: temp_buffer ! rocsparse_dprune_dense2csr_nnz_rank_1 = rocsparse_dprune_dense2csr_nnz_(handle,m,n,c_loc(A), & lda,threshold,descr,c_loc(csr_row_ptr),nnz_total_dev_host_ptr,temp_buffer) end function function rocsparse_dprune_dense2csr_nnz_full_rank(handle,m,n,A,lda,threshold,descr, & csr_row_ptr,nnz_total_dev_host_ptr,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_nnz_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: temp_buffer ! rocsparse_dprune_dense2csr_nnz_full_rank = rocsparse_dprune_dense2csr_nnz_(handle,m,n, & c_loc(A),lda,threshold,descr,c_loc(csr_row_ptr),nnz_total_dev_host_ptr,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sprune_dense2csr_assumed_rank(handle,m,n,A,lda,threshold,descr,csr_val, & csr_row_ptr,csr_col_ind,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_sprune_dense2csr_assumed_rank = rocsparse_sprune_dense2csr_(handle,m,n,c_loc(A), & lda,threshold,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function #else function rocsparse_sprune_dense2csr_rank_0(handle,m,n,A,lda,threshold,descr,csr_val, & csr_row_ptr,csr_col_ind,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_sprune_dense2csr_rank_0 = rocsparse_sprune_dense2csr_(handle,m,n,c_loc(A),lda, & threshold,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function function rocsparse_sprune_dense2csr_rank_1(handle,m,n,A,lda,threshold,descr,csr_val, & csr_row_ptr,csr_col_ind,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_sprune_dense2csr_rank_1 = rocsparse_sprune_dense2csr_(handle,m,n,c_loc(A),lda, & threshold,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function function rocsparse_sprune_dense2csr_full_rank(handle,m,n,A,lda,threshold,descr,csr_val, & csr_row_ptr,csr_col_ind,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: threshold type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_sprune_dense2csr_full_rank = rocsparse_sprune_dense2csr_(handle,m,n,c_loc(A),lda, & threshold,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dprune_dense2csr_assumed_rank(handle,m,n,A,lda,threshold,descr,csr_val, & csr_row_ptr,csr_col_ind,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_dprune_dense2csr_assumed_rank = rocsparse_dprune_dense2csr_(handle,m,n,c_loc(A), & lda,threshold,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function #else function rocsparse_dprune_dense2csr_rank_0(handle,m,n,A,lda,threshold,descr,csr_val, & csr_row_ptr,csr_col_ind,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_dprune_dense2csr_rank_0 = rocsparse_dprune_dense2csr_(handle,m,n,c_loc(A),lda, & threshold,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function function rocsparse_dprune_dense2csr_rank_1(handle,m,n,A,lda,threshold,descr,csr_val, & csr_row_ptr,csr_col_ind,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_dprune_dense2csr_rank_1 = rocsparse_dprune_dense2csr_(handle,m,n,c_loc(A),lda, & threshold,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function function rocsparse_dprune_dense2csr_full_rank(handle,m,n,A,lda,threshold,descr,csr_val, & csr_row_ptr,csr_col_ind,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: threshold type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: temp_buffer ! rocsparse_dprune_dense2csr_full_rank = rocsparse_dprune_dense2csr_(handle,m,n,c_loc(A),lda, & threshold,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sprune_dense2csr_by_percentage_buffer_si_assumed_rank(handle,m,n,A,lda, & percentage,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_by_percentage_buffer_si_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_sprune_dense2csr_by_percentage_buffer_si_assumed_rank = & rocsparse_sprune_dense2csr_by_percentage_buffer_size_(handle,m,n,c_loc(A),lda,percentage, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #else function rocsparse_sprune_dense2csr_by_percentage_buffer_size_rank_0(handle,m,n,A,lda, & percentage,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_by_percentage_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_sprune_dense2csr_by_percentage_buffer_size_rank_0 = & rocsparse_sprune_dense2csr_by_percentage_buffer_size_(handle,m,n,c_loc(A),lda,percentage, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function function rocsparse_sprune_dense2csr_by_percentage_buffer_size_rank_1(handle,m,n,A,lda, & percentage,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_by_percentage_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_sprune_dense2csr_by_percentage_buffer_size_rank_1 = & rocsparse_sprune_dense2csr_by_percentage_buffer_size_(handle,m,n,c_loc(A),lda,percentage, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function function rocsparse_sprune_dense2csr_by_percentage_buffer_size_full_rank(handle,m,n,A,lda, & percentage,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_by_percentage_buffer_size_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_sprune_dense2csr_by_percentage_buffer_size_full_rank = & rocsparse_sprune_dense2csr_by_percentage_buffer_size_(handle,m,n,c_loc(A),lda,percentage, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dprune_dense2csr_by_percentage_buffer_si_assumed_rank(handle,m,n,A,lda, & percentage,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_by_percentage_buffer_si_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dprune_dense2csr_by_percentage_buffer_si_assumed_rank = & rocsparse_dprune_dense2csr_by_percentage_buffer_size_(handle,m,n,c_loc(A),lda,percentage, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #else function rocsparse_dprune_dense2csr_by_percentage_buffer_size_rank_0(handle,m,n,A,lda, & percentage,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_by_percentage_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dprune_dense2csr_by_percentage_buffer_size_rank_0 = & rocsparse_dprune_dense2csr_by_percentage_buffer_size_(handle,m,n,c_loc(A),lda,percentage, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function function rocsparse_dprune_dense2csr_by_percentage_buffer_size_rank_1(handle,m,n,A,lda, & percentage,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_by_percentage_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dprune_dense2csr_by_percentage_buffer_size_rank_1 = & rocsparse_dprune_dense2csr_by_percentage_buffer_size_(handle,m,n,c_loc(A),lda,percentage, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function function rocsparse_dprune_dense2csr_by_percentage_buffer_size_full_rank(handle,m,n,A,lda, & percentage,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_by_percentage_buffer_size_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dprune_dense2csr_by_percentage_buffer_size_full_rank = & rocsparse_dprune_dense2csr_by_percentage_buffer_size_(handle,m,n,c_loc(A),lda,percentage, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sprune_dense2csr_nnz_by_percentage_assumed_rank(handle,m,n,A,lda, & percentage,descr,csr_row_ptr,nnz_total_dev_host_ptr,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_nnz_by_percentage_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_sprune_dense2csr_nnz_by_percentage_assumed_rank = & rocsparse_sprune_dense2csr_nnz_by_percentage_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csr_row_ptr),nnz_total_dev_host_ptr,myInfo,temp_buffer) end function #else function rocsparse_sprune_dense2csr_nnz_by_percentage_rank_0(handle,m,n,A,lda,percentage, & descr,csr_row_ptr,nnz_total_dev_host_ptr,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_nnz_by_percentage_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr integer(c_int),target :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_sprune_dense2csr_nnz_by_percentage_rank_0 = & rocsparse_sprune_dense2csr_nnz_by_percentage_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csr_row_ptr),nnz_total_dev_host_ptr,myInfo,temp_buffer) end function function rocsparse_sprune_dense2csr_nnz_by_percentage_rank_1(handle,m,n,A,lda,percentage, & descr,csr_row_ptr,nnz_total_dev_host_ptr,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_nnz_by_percentage_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_sprune_dense2csr_nnz_by_percentage_rank_1 = & rocsparse_sprune_dense2csr_nnz_by_percentage_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csr_row_ptr),nnz_total_dev_host_ptr,myInfo,temp_buffer) end function function rocsparse_sprune_dense2csr_nnz_by_percentage_full_rank(handle,m,n,A,lda,percentage, & descr,csr_row_ptr,nnz_total_dev_host_ptr,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_nnz_by_percentage_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_sprune_dense2csr_nnz_by_percentage_full_rank = & rocsparse_sprune_dense2csr_nnz_by_percentage_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csr_row_ptr),nnz_total_dev_host_ptr,myInfo,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dprune_dense2csr_nnz_by_percentage_assumed_rank(handle,m,n,A,lda, & percentage,descr,csr_row_ptr,nnz_total_dev_host_ptr,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_nnz_by_percentage_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_dprune_dense2csr_nnz_by_percentage_assumed_rank = & rocsparse_dprune_dense2csr_nnz_by_percentage_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csr_row_ptr),nnz_total_dev_host_ptr,myInfo,temp_buffer) end function #else function rocsparse_dprune_dense2csr_nnz_by_percentage_rank_0(handle,m,n,A,lda,percentage, & descr,csr_row_ptr,nnz_total_dev_host_ptr,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_nnz_by_percentage_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr integer(c_int),target :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_dprune_dense2csr_nnz_by_percentage_rank_0 = & rocsparse_dprune_dense2csr_nnz_by_percentage_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csr_row_ptr),nnz_total_dev_host_ptr,myInfo,temp_buffer) end function function rocsparse_dprune_dense2csr_nnz_by_percentage_rank_1(handle,m,n,A,lda,percentage, & descr,csr_row_ptr,nnz_total_dev_host_ptr,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_nnz_by_percentage_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_dprune_dense2csr_nnz_by_percentage_rank_1 = & rocsparse_dprune_dense2csr_nnz_by_percentage_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csr_row_ptr),nnz_total_dev_host_ptr,myInfo,temp_buffer) end function function rocsparse_dprune_dense2csr_nnz_by_percentage_full_rank(handle,m,n,A,lda,percentage, & descr,csr_row_ptr,nnz_total_dev_host_ptr,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_nnz_by_percentage_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int) :: nnz_total_dev_host_ptr type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_dprune_dense2csr_nnz_by_percentage_full_rank = & rocsparse_dprune_dense2csr_nnz_by_percentage_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csr_row_ptr),nnz_total_dev_host_ptr,myInfo,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sprune_dense2csr_by_percentage_assumed_rank(handle,m,n,A,lda,percentage, & descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_by_percentage_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_sprune_dense2csr_by_percentage_assumed_rank = & rocsparse_sprune_dense2csr_by_percentage_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,temp_buffer) end function #else function rocsparse_sprune_dense2csr_by_percentage_rank_0(handle,m,n,A,lda,percentage,descr, & csr_val,csr_row_ptr,csr_col_ind,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_by_percentage_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_sprune_dense2csr_by_percentage_rank_0 = rocsparse_sprune_dense2csr_by_percentage_( & handle,m,n,c_loc(A),lda,percentage,descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind),myInfo,temp_buffer) end function function rocsparse_sprune_dense2csr_by_percentage_rank_1(handle,m,n,A,lda,percentage,descr, & csr_val,csr_row_ptr,csr_col_ind,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_by_percentage_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_sprune_dense2csr_by_percentage_rank_1 = rocsparse_sprune_dense2csr_by_percentage_( & handle,m,n,c_loc(A),lda,percentage,descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind),myInfo,temp_buffer) end function function rocsparse_sprune_dense2csr_by_percentage_full_rank(handle,m,n,A,lda,percentage,descr, & csr_val,csr_row_ptr,csr_col_ind,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sprune_dense2csr_by_percentage_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda real(c_float) :: percentage type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_sprune_dense2csr_by_percentage_full_rank = & rocsparse_sprune_dense2csr_by_percentage_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dprune_dense2csr_by_percentage_assumed_rank(handle,m,n,A,lda,percentage, & descr,csr_val,csr_row_ptr,csr_col_ind,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_by_percentage_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_dprune_dense2csr_by_percentage_assumed_rank = & rocsparse_dprune_dense2csr_by_percentage_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,temp_buffer) end function #else function rocsparse_dprune_dense2csr_by_percentage_rank_0(handle,m,n,A,lda,percentage,descr, & csr_val,csr_row_ptr,csr_col_ind,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_by_percentage_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_dprune_dense2csr_by_percentage_rank_0 = rocsparse_dprune_dense2csr_by_percentage_( & handle,m,n,c_loc(A),lda,percentage,descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind),myInfo,temp_buffer) end function function rocsparse_dprune_dense2csr_by_percentage_rank_1(handle,m,n,A,lda,percentage,descr, & csr_val,csr_row_ptr,csr_col_ind,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_by_percentage_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_dprune_dense2csr_by_percentage_rank_1 = rocsparse_dprune_dense2csr_by_percentage_( & handle,m,n,c_loc(A),lda,percentage,descr,c_loc(csr_val),c_loc(csr_row_ptr), & c_loc(csr_col_ind),myInfo,temp_buffer) end function function rocsparse_dprune_dense2csr_by_percentage_full_rank(handle,m,n,A,lda,percentage,descr, & csr_val,csr_row_ptr,csr_col_ind,myInfo,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dprune_dense2csr_by_percentage_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda real(c_double) :: percentage type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo type(c_ptr) :: temp_buffer ! rocsparse_dprune_dense2csr_by_percentage_full_rank = & rocsparse_dprune_dense2csr_by_percentage_(handle,m,n,c_loc(A),lda,percentage,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_csrgeam_nnz_assumed_rank(handle,m,n,descr_A,nnz_A,csr_row_ptr_A, & csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,descr_C,csr_row_ptr_C,nnz_C) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrgeam_nnz_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr_A integer(c_int) :: nnz_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_B integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_B type(c_ptr) :: descr_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: nnz_C ! rocsparse_csrgeam_nnz_assumed_rank = rocsparse_csrgeam_nnz_(handle,m,n,descr_A,nnz_A, & c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B,c_loc(csr_row_ptr_B), & c_loc(csr_col_ind_B),descr_C,c_loc(csr_row_ptr_C),c_loc(nnz_C)) end function #else function rocsparse_csrgeam_nnz_rank_0(handle,m,n,descr_A,nnz_A,csr_row_ptr_A,csr_col_ind_A, & descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,descr_C,csr_row_ptr_C,nnz_C) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrgeam_nnz_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr_A integer(c_int) :: nnz_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B integer(c_int),target :: csr_row_ptr_B integer(c_int),target :: csr_col_ind_B type(c_ptr) :: descr_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: nnz_C ! rocsparse_csrgeam_nnz_rank_0 = rocsparse_csrgeam_nnz_(handle,m,n,descr_A,nnz_A, & c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B,c_loc(csr_row_ptr_B), & c_loc(csr_col_ind_B),descr_C,c_loc(csr_row_ptr_C),c_loc(nnz_C)) end function function rocsparse_csrgeam_nnz_rank_1(handle,m,n,descr_A,nnz_A,csr_row_ptr_A,csr_col_ind_A, & descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,descr_C,csr_row_ptr_C,nnz_C) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrgeam_nnz_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n type(c_ptr) :: descr_A integer(c_int) :: nnz_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B integer(c_int),target,dimension(:) :: csr_row_ptr_B integer(c_int),target,dimension(:) :: csr_col_ind_B type(c_ptr) :: descr_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: nnz_C ! rocsparse_csrgeam_nnz_rank_1 = rocsparse_csrgeam_nnz_(handle,m,n,descr_A,nnz_A, & c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B,c_loc(csr_row_ptr_B), & c_loc(csr_col_ind_B),descr_C,c_loc(csr_row_ptr_C),c_loc(nnz_C)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsrgeam_assumed_rank(handle,m,n,alpha,descr_A,nnz_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,beta,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B, & descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrgeam_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A real(c_float),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A real(c_float) :: beta type(c_ptr) :: descr_B integer(c_int) :: nnz_B real(c_float),target,contiguous,dimension(..) :: csr_val_B integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_B integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_B type(c_ptr) :: descr_C real(c_float),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C ! rocsparse_scsrgeam_assumed_rank = rocsparse_scsrgeam_(handle,m,n,alpha,descr_A,nnz_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),beta,descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C)) end function #else function rocsparse_scsrgeam_rank_0(handle,m,n,alpha,descr_A,nnz_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,beta,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,descr_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrgeam_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A real(c_float),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A real(c_float) :: beta type(c_ptr) :: descr_B integer(c_int) :: nnz_B real(c_float),target :: csr_val_B integer(c_int),target :: csr_row_ptr_B integer(c_int),target :: csr_col_ind_B type(c_ptr) :: descr_C real(c_float),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C ! rocsparse_scsrgeam_rank_0 = rocsparse_scsrgeam_(handle,m,n,alpha,descr_A,nnz_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),beta,descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C)) end function function rocsparse_scsrgeam_rank_1(handle,m,n,alpha,descr_A,nnz_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,beta,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,descr_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrgeam_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A real(c_float),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A real(c_float) :: beta type(c_ptr) :: descr_B integer(c_int) :: nnz_B real(c_float),target,dimension(:) :: csr_val_B integer(c_int),target,dimension(:) :: csr_row_ptr_B integer(c_int),target,dimension(:) :: csr_col_ind_B type(c_ptr) :: descr_C real(c_float),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C ! rocsparse_scsrgeam_rank_1 = rocsparse_scsrgeam_(handle,m,n,alpha,descr_A,nnz_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),beta,descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsrgeam_assumed_rank(handle,m,n,alpha,descr_A,nnz_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,beta,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B, & descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrgeam_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A real(c_double),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A real(c_double) :: beta type(c_ptr) :: descr_B integer(c_int) :: nnz_B real(c_double),target,contiguous,dimension(..) :: csr_val_B integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_B integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_B type(c_ptr) :: descr_C real(c_double),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C ! rocsparse_dcsrgeam_assumed_rank = rocsparse_dcsrgeam_(handle,m,n,alpha,descr_A,nnz_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),beta,descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C)) end function #else function rocsparse_dcsrgeam_rank_0(handle,m,n,alpha,descr_A,nnz_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,beta,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,descr_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrgeam_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A real(c_double),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A real(c_double) :: beta type(c_ptr) :: descr_B integer(c_int) :: nnz_B real(c_double),target :: csr_val_B integer(c_int),target :: csr_row_ptr_B integer(c_int),target :: csr_col_ind_B type(c_ptr) :: descr_C real(c_double),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C ! rocsparse_dcsrgeam_rank_0 = rocsparse_dcsrgeam_(handle,m,n,alpha,descr_A,nnz_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),beta,descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C)) end function function rocsparse_dcsrgeam_rank_1(handle,m,n,alpha,descr_A,nnz_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,beta,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,descr_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrgeam_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A real(c_double),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A real(c_double) :: beta type(c_ptr) :: descr_B integer(c_int) :: nnz_B real(c_double),target,dimension(:) :: csr_val_B integer(c_int),target,dimension(:) :: csr_row_ptr_B integer(c_int),target,dimension(:) :: csr_col_ind_B type(c_ptr) :: descr_C real(c_double),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C ! rocsparse_dcsrgeam_rank_1 = rocsparse_dcsrgeam_(handle,m,n,alpha,descr_A,nnz_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),beta,descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsrgeam_assumed_rank(handle,m,n,alpha,descr_A,nnz_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,beta,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B, & descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrgeam_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A complex(c_float_complex),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A complex(c_float_complex) :: beta type(c_ptr) :: descr_B integer(c_int) :: nnz_B complex(c_float_complex),target,contiguous,dimension(..) :: csr_val_B integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_B integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_B type(c_ptr) :: descr_C complex(c_float_complex),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C ! rocsparse_ccsrgeam_assumed_rank = rocsparse_ccsrgeam_(handle,m,n,alpha,descr_A,nnz_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),beta,descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C)) end function #else function rocsparse_ccsrgeam_rank_0(handle,m,n,alpha,descr_A,nnz_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,beta,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,descr_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrgeam_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A complex(c_float_complex),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A complex(c_float_complex) :: beta type(c_ptr) :: descr_B integer(c_int) :: nnz_B complex(c_float_complex),target :: csr_val_B integer(c_int),target :: csr_row_ptr_B integer(c_int),target :: csr_col_ind_B type(c_ptr) :: descr_C complex(c_float_complex),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C ! rocsparse_ccsrgeam_rank_0 = rocsparse_ccsrgeam_(handle,m,n,alpha,descr_A,nnz_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),beta,descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C)) end function function rocsparse_ccsrgeam_rank_1(handle,m,n,alpha,descr_A,nnz_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,beta,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,descr_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrgeam_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A complex(c_float_complex),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A complex(c_float_complex) :: beta type(c_ptr) :: descr_B integer(c_int) :: nnz_B complex(c_float_complex),target,dimension(:) :: csr_val_B integer(c_int),target,dimension(:) :: csr_row_ptr_B integer(c_int),target,dimension(:) :: csr_col_ind_B type(c_ptr) :: descr_C complex(c_float_complex),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C ! rocsparse_ccsrgeam_rank_1 = rocsparse_ccsrgeam_(handle,m,n,alpha,descr_A,nnz_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),beta,descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsrgeam_assumed_rank(handle,m,n,alpha,descr_A,nnz_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,beta,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B, & descr_C,csr_val_C,csr_row_ptr_C,csr_col_ind_C) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrgeam_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A complex(c_double_complex),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A complex(c_double_complex) :: beta type(c_ptr) :: descr_B integer(c_int) :: nnz_B complex(c_double_complex),target,contiguous,dimension(..) :: csr_val_B integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_B integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_B type(c_ptr) :: descr_C complex(c_double_complex),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C ! rocsparse_zcsrgeam_assumed_rank = rocsparse_zcsrgeam_(handle,m,n,alpha,descr_A,nnz_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),beta,descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C)) end function #else function rocsparse_zcsrgeam_rank_0(handle,m,n,alpha,descr_A,nnz_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,beta,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,descr_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrgeam_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A complex(c_double_complex),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A complex(c_double_complex) :: beta type(c_ptr) :: descr_B integer(c_int) :: nnz_B complex(c_double_complex),target :: csr_val_B integer(c_int),target :: csr_row_ptr_B integer(c_int),target :: csr_col_ind_B type(c_ptr) :: descr_C complex(c_double_complex),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C ! rocsparse_zcsrgeam_rank_0 = rocsparse_zcsrgeam_(handle,m,n,alpha,descr_A,nnz_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),beta,descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C)) end function function rocsparse_zcsrgeam_rank_1(handle,m,n,alpha,descr_A,nnz_A,csr_val_A,csr_row_ptr_A, & csr_col_ind_A,beta,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,descr_C,csr_val_C, & csr_row_ptr_C,csr_col_ind_C) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrgeam_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A complex(c_double_complex),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A complex(c_double_complex) :: beta type(c_ptr) :: descr_B integer(c_int) :: nnz_B complex(c_double_complex),target,dimension(:) :: csr_val_B integer(c_int),target,dimension(:) :: csr_row_ptr_B integer(c_int),target,dimension(:) :: csr_col_ind_B type(c_ptr) :: descr_C complex(c_double_complex),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C ! rocsparse_zcsrgeam_rank_1 = rocsparse_zcsrgeam_(handle,m,n,alpha,descr_A,nnz_A, & c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),beta,descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsrgemm_buffer_size_assumed_rank(handle,trans_A,trans_B,m,n,k,alpha, & descr_A,nnz_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,beta, & descr_D,nnz_D,csr_row_ptr_D,csr_col_ind_D,info_C,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrgemm_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_B integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_B real(c_float) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_D integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_D type(c_ptr) :: info_C integer(c_size_t) :: buffer_size ! rocsparse_scsrgemm_buffer_size_assumed_rank = rocsparse_scsrgemm_buffer_size_(handle, & trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A,c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A), & descr_B,nnz_B,c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D, & c_loc(csr_row_ptr_D),c_loc(csr_col_ind_D),info_C,buffer_size) end function #else function rocsparse_scsrgemm_buffer_size_rank_0(handle,trans_A,trans_B,m,n,k,alpha,descr_A, & nnz_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,beta,descr_D, & nnz_D,csr_row_ptr_D,csr_col_ind_D,info_C,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrgemm_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B integer(c_int),target :: csr_row_ptr_B integer(c_int),target :: csr_col_ind_B real(c_float) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D integer(c_int),target :: csr_row_ptr_D integer(c_int),target :: csr_col_ind_D type(c_ptr) :: info_C integer(c_size_t) :: buffer_size ! rocsparse_scsrgemm_buffer_size_rank_0 = rocsparse_scsrgemm_buffer_size_(handle,trans_A, & trans_B,m,n,k,alpha,descr_A,nnz_A,c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D,c_loc(csr_row_ptr_D), & c_loc(csr_col_ind_D),info_C,buffer_size) end function function rocsparse_scsrgemm_buffer_size_rank_1(handle,trans_A,trans_B,m,n,k,alpha,descr_A, & nnz_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,beta,descr_D, & nnz_D,csr_row_ptr_D,csr_col_ind_D,info_C,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrgemm_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B integer(c_int),target,dimension(:) :: csr_row_ptr_B integer(c_int),target,dimension(:) :: csr_col_ind_B real(c_float) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D integer(c_int),target,dimension(:) :: csr_row_ptr_D integer(c_int),target,dimension(:) :: csr_col_ind_D type(c_ptr) :: info_C integer(c_size_t) :: buffer_size ! rocsparse_scsrgemm_buffer_size_rank_1 = rocsparse_scsrgemm_buffer_size_(handle,trans_A, & trans_B,m,n,k,alpha,descr_A,nnz_A,c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D,c_loc(csr_row_ptr_D), & c_loc(csr_col_ind_D),info_C,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsrgemm_buffer_size_assumed_rank(handle,trans_A,trans_B,m,n,k,alpha, & descr_A,nnz_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,beta, & descr_D,nnz_D,csr_row_ptr_D,csr_col_ind_D,info_C,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrgemm_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_B integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_B real(c_double) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_D integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_D type(c_ptr) :: info_C integer(c_size_t) :: buffer_size ! rocsparse_dcsrgemm_buffer_size_assumed_rank = rocsparse_dcsrgemm_buffer_size_(handle, & trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A,c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A), & descr_B,nnz_B,c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D, & c_loc(csr_row_ptr_D),c_loc(csr_col_ind_D),info_C,buffer_size) end function #else function rocsparse_dcsrgemm_buffer_size_rank_0(handle,trans_A,trans_B,m,n,k,alpha,descr_A, & nnz_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,beta,descr_D, & nnz_D,csr_row_ptr_D,csr_col_ind_D,info_C,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrgemm_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B integer(c_int),target :: csr_row_ptr_B integer(c_int),target :: csr_col_ind_B real(c_double) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D integer(c_int),target :: csr_row_ptr_D integer(c_int),target :: csr_col_ind_D type(c_ptr) :: info_C integer(c_size_t) :: buffer_size ! rocsparse_dcsrgemm_buffer_size_rank_0 = rocsparse_dcsrgemm_buffer_size_(handle,trans_A, & trans_B,m,n,k,alpha,descr_A,nnz_A,c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D,c_loc(csr_row_ptr_D), & c_loc(csr_col_ind_D),info_C,buffer_size) end function function rocsparse_dcsrgemm_buffer_size_rank_1(handle,trans_A,trans_B,m,n,k,alpha,descr_A, & nnz_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,beta,descr_D, & nnz_D,csr_row_ptr_D,csr_col_ind_D,info_C,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrgemm_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B integer(c_int),target,dimension(:) :: csr_row_ptr_B integer(c_int),target,dimension(:) :: csr_col_ind_B real(c_double) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D integer(c_int),target,dimension(:) :: csr_row_ptr_D integer(c_int),target,dimension(:) :: csr_col_ind_D type(c_ptr) :: info_C integer(c_size_t) :: buffer_size ! rocsparse_dcsrgemm_buffer_size_rank_1 = rocsparse_dcsrgemm_buffer_size_(handle,trans_A, & trans_B,m,n,k,alpha,descr_A,nnz_A,c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D,c_loc(csr_row_ptr_D), & c_loc(csr_col_ind_D),info_C,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsrgemm_buffer_size_assumed_rank(handle,trans_A,trans_B,m,n,k,alpha, & descr_A,nnz_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,beta, & descr_D,nnz_D,csr_row_ptr_D,csr_col_ind_D,info_C,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrgemm_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_B integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_B complex(c_float_complex) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_D integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_D type(c_ptr) :: info_C integer(c_size_t) :: buffer_size ! rocsparse_ccsrgemm_buffer_size_assumed_rank = rocsparse_ccsrgemm_buffer_size_(handle, & trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A,c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A), & descr_B,nnz_B,c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D, & c_loc(csr_row_ptr_D),c_loc(csr_col_ind_D),info_C,buffer_size) end function #else function rocsparse_ccsrgemm_buffer_size_rank_0(handle,trans_A,trans_B,m,n,k,alpha,descr_A, & nnz_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,beta,descr_D, & nnz_D,csr_row_ptr_D,csr_col_ind_D,info_C,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrgemm_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B integer(c_int),target :: csr_row_ptr_B integer(c_int),target :: csr_col_ind_B complex(c_float_complex) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D integer(c_int),target :: csr_row_ptr_D integer(c_int),target :: csr_col_ind_D type(c_ptr) :: info_C integer(c_size_t) :: buffer_size ! rocsparse_ccsrgemm_buffer_size_rank_0 = rocsparse_ccsrgemm_buffer_size_(handle,trans_A, & trans_B,m,n,k,alpha,descr_A,nnz_A,c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D,c_loc(csr_row_ptr_D), & c_loc(csr_col_ind_D),info_C,buffer_size) end function function rocsparse_ccsrgemm_buffer_size_rank_1(handle,trans_A,trans_B,m,n,k,alpha,descr_A, & nnz_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,beta,descr_D, & nnz_D,csr_row_ptr_D,csr_col_ind_D,info_C,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrgemm_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B integer(c_int),target,dimension(:) :: csr_row_ptr_B integer(c_int),target,dimension(:) :: csr_col_ind_B complex(c_float_complex) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D integer(c_int),target,dimension(:) :: csr_row_ptr_D integer(c_int),target,dimension(:) :: csr_col_ind_D type(c_ptr) :: info_C integer(c_size_t) :: buffer_size ! rocsparse_ccsrgemm_buffer_size_rank_1 = rocsparse_ccsrgemm_buffer_size_(handle,trans_A, & trans_B,m,n,k,alpha,descr_A,nnz_A,c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D,c_loc(csr_row_ptr_D), & c_loc(csr_col_ind_D),info_C,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsrgemm_buffer_size_assumed_rank(handle,trans_A,trans_B,m,n,k,alpha, & descr_A,nnz_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,beta, & descr_D,nnz_D,csr_row_ptr_D,csr_col_ind_D,info_C,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrgemm_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_B integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_B complex(c_double_complex) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_D integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_D type(c_ptr) :: info_C integer(c_size_t) :: buffer_size ! rocsparse_zcsrgemm_buffer_size_assumed_rank = rocsparse_zcsrgemm_buffer_size_(handle, & trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A,c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A), & descr_B,nnz_B,c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D, & c_loc(csr_row_ptr_D),c_loc(csr_col_ind_D),info_C,buffer_size) end function #else function rocsparse_zcsrgemm_buffer_size_rank_0(handle,trans_A,trans_B,m,n,k,alpha,descr_A, & nnz_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,beta,descr_D, & nnz_D,csr_row_ptr_D,csr_col_ind_D,info_C,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrgemm_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B integer(c_int),target :: csr_row_ptr_B integer(c_int),target :: csr_col_ind_B complex(c_double_complex) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D integer(c_int),target :: csr_row_ptr_D integer(c_int),target :: csr_col_ind_D type(c_ptr) :: info_C integer(c_size_t) :: buffer_size ! rocsparse_zcsrgemm_buffer_size_rank_0 = rocsparse_zcsrgemm_buffer_size_(handle,trans_A, & trans_B,m,n,k,alpha,descr_A,nnz_A,c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D,c_loc(csr_row_ptr_D), & c_loc(csr_col_ind_D),info_C,buffer_size) end function function rocsparse_zcsrgemm_buffer_size_rank_1(handle,trans_A,trans_B,m,n,k,alpha,descr_A, & nnz_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,beta,descr_D, & nnz_D,csr_row_ptr_D,csr_col_ind_D,info_C,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrgemm_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B integer(c_int),target,dimension(:) :: csr_row_ptr_B integer(c_int),target,dimension(:) :: csr_col_ind_B complex(c_double_complex) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D integer(c_int),target,dimension(:) :: csr_row_ptr_D integer(c_int),target,dimension(:) :: csr_col_ind_D type(c_ptr) :: info_C integer(c_size_t) :: buffer_size ! rocsparse_zcsrgemm_buffer_size_rank_1 = rocsparse_zcsrgemm_buffer_size_(handle,trans_A, & trans_B,m,n,k,alpha,descr_A,nnz_A,c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D,c_loc(csr_row_ptr_D), & c_loc(csr_col_ind_D),info_C,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_csrgemm_nnz_assumed_rank(handle,trans_A,trans_B,m,n,k,descr_A,nnz_A, & csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,descr_D,nnz_D, & csr_row_ptr_D,csr_col_ind_D,descr_C,csr_row_ptr_C,nnz_C,info_C,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrgemm_nnz_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descr_A integer(c_int) :: nnz_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_B integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_B type(c_ptr) :: descr_D integer(c_int) :: nnz_D integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_D integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_D type(c_ptr) :: descr_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: nnz_C type(c_ptr) :: info_C type(c_ptr) :: temp_buffer ! rocsparse_csrgemm_nnz_assumed_rank = rocsparse_csrgemm_nnz_(handle,trans_A,trans_B,m,n,k, & descr_A,nnz_A,c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),descr_D,nnz_D,c_loc(csr_row_ptr_D), & c_loc(csr_col_ind_D),descr_C,c_loc(csr_row_ptr_C),c_loc(nnz_C),info_C,temp_buffer) end function #else function rocsparse_csrgemm_nnz_rank_0(handle,trans_A,trans_B,m,n,k,descr_A,nnz_A, & csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,descr_D,nnz_D, & csr_row_ptr_D,csr_col_ind_D,descr_C,csr_row_ptr_C,nnz_C,info_C,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrgemm_nnz_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descr_A integer(c_int) :: nnz_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B integer(c_int),target :: csr_row_ptr_B integer(c_int),target :: csr_col_ind_B type(c_ptr) :: descr_D integer(c_int) :: nnz_D integer(c_int),target :: csr_row_ptr_D integer(c_int),target :: csr_col_ind_D type(c_ptr) :: descr_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: nnz_C type(c_ptr) :: info_C type(c_ptr) :: temp_buffer ! rocsparse_csrgemm_nnz_rank_0 = rocsparse_csrgemm_nnz_(handle,trans_A,trans_B,m,n,k,descr_A, & nnz_A,c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B,c_loc(csr_row_ptr_B), & c_loc(csr_col_ind_B),descr_D,nnz_D,c_loc(csr_row_ptr_D),c_loc(csr_col_ind_D),descr_C, & c_loc(csr_row_ptr_C),c_loc(nnz_C),info_C,temp_buffer) end function function rocsparse_csrgemm_nnz_rank_1(handle,trans_A,trans_B,m,n,k,descr_A,nnz_A, & csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_row_ptr_B,csr_col_ind_B,descr_D,nnz_D, & csr_row_ptr_D,csr_col_ind_D,descr_C,csr_row_ptr_C,nnz_C,info_C,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csrgemm_nnz_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k type(c_ptr) :: descr_A integer(c_int) :: nnz_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B integer(c_int),target,dimension(:) :: csr_row_ptr_B integer(c_int),target,dimension(:) :: csr_col_ind_B type(c_ptr) :: descr_D integer(c_int) :: nnz_D integer(c_int),target,dimension(:) :: csr_row_ptr_D integer(c_int),target,dimension(:) :: csr_col_ind_D type(c_ptr) :: descr_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: nnz_C type(c_ptr) :: info_C type(c_ptr) :: temp_buffer ! rocsparse_csrgemm_nnz_rank_1 = rocsparse_csrgemm_nnz_(handle,trans_A,trans_B,m,n,k,descr_A, & nnz_A,c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B,c_loc(csr_row_ptr_B), & c_loc(csr_col_ind_B),descr_D,nnz_D,c_loc(csr_row_ptr_D),c_loc(csr_col_ind_D),descr_C, & c_loc(csr_row_ptr_C),c_loc(nnz_C),info_C,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsrgemm_assumed_rank(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B, & beta,descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,info_C,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrgemm_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A real(c_float),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B real(c_float),target,contiguous,dimension(..) :: csr_val_B integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_B integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_B real(c_float) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D real(c_float),target,contiguous,dimension(..) :: csr_val_D integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_D integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_D type(c_ptr) :: descr_C real(c_float),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C type(c_ptr) :: info_C type(c_ptr) :: temp_buffer ! rocsparse_scsrgemm_assumed_rank = rocsparse_scsrgemm_(handle,trans_A,trans_B,m,n,k,alpha, & descr_A,nnz_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D, & c_loc(csr_val_D),c_loc(csr_row_ptr_D),c_loc(csr_col_ind_D),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),info_C,temp_buffer) end function #else function rocsparse_scsrgemm_rank_0(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,beta, & descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,info_C,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrgemm_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A real(c_float),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B real(c_float),target :: csr_val_B integer(c_int),target :: csr_row_ptr_B integer(c_int),target :: csr_col_ind_B real(c_float) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D real(c_float),target :: csr_val_D integer(c_int),target :: csr_row_ptr_D integer(c_int),target :: csr_col_ind_D type(c_ptr) :: descr_C real(c_float),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C type(c_ptr) :: info_C type(c_ptr) :: temp_buffer ! rocsparse_scsrgemm_rank_0 = rocsparse_scsrgemm_(handle,trans_A,trans_B,m,n,k,alpha,descr_A, & nnz_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D, & c_loc(csr_val_D),c_loc(csr_row_ptr_D),c_loc(csr_col_ind_D),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),info_C,temp_buffer) end function function rocsparse_scsrgemm_rank_1(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,beta, & descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,info_C,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrgemm_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_float) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A real(c_float),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B real(c_float),target,dimension(:) :: csr_val_B integer(c_int),target,dimension(:) :: csr_row_ptr_B integer(c_int),target,dimension(:) :: csr_col_ind_B real(c_float) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D real(c_float),target,dimension(:) :: csr_val_D integer(c_int),target,dimension(:) :: csr_row_ptr_D integer(c_int),target,dimension(:) :: csr_col_ind_D type(c_ptr) :: descr_C real(c_float),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C type(c_ptr) :: info_C type(c_ptr) :: temp_buffer ! rocsparse_scsrgemm_rank_1 = rocsparse_scsrgemm_(handle,trans_A,trans_B,m,n,k,alpha,descr_A, & nnz_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D, & c_loc(csr_val_D),c_loc(csr_row_ptr_D),c_loc(csr_col_ind_D),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),info_C,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsrgemm_assumed_rank(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B, & beta,descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,info_C,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrgemm_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A real(c_double),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B real(c_double),target,contiguous,dimension(..) :: csr_val_B integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_B integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_B real(c_double) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D real(c_double),target,contiguous,dimension(..) :: csr_val_D integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_D integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_D type(c_ptr) :: descr_C real(c_double),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C type(c_ptr) :: info_C type(c_ptr) :: temp_buffer ! rocsparse_dcsrgemm_assumed_rank = rocsparse_dcsrgemm_(handle,trans_A,trans_B,m,n,k,alpha, & descr_A,nnz_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D, & c_loc(csr_val_D),c_loc(csr_row_ptr_D),c_loc(csr_col_ind_D),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),info_C,temp_buffer) end function #else function rocsparse_dcsrgemm_rank_0(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,beta, & descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,info_C,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrgemm_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A real(c_double),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B real(c_double),target :: csr_val_B integer(c_int),target :: csr_row_ptr_B integer(c_int),target :: csr_col_ind_B real(c_double) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D real(c_double),target :: csr_val_D integer(c_int),target :: csr_row_ptr_D integer(c_int),target :: csr_col_ind_D type(c_ptr) :: descr_C real(c_double),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C type(c_ptr) :: info_C type(c_ptr) :: temp_buffer ! rocsparse_dcsrgemm_rank_0 = rocsparse_dcsrgemm_(handle,trans_A,trans_B,m,n,k,alpha,descr_A, & nnz_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D, & c_loc(csr_val_D),c_loc(csr_row_ptr_D),c_loc(csr_col_ind_D),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),info_C,temp_buffer) end function function rocsparse_dcsrgemm_rank_1(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,beta, & descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,info_C,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrgemm_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k real(c_double) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A real(c_double),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B real(c_double),target,dimension(:) :: csr_val_B integer(c_int),target,dimension(:) :: csr_row_ptr_B integer(c_int),target,dimension(:) :: csr_col_ind_B real(c_double) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D real(c_double),target,dimension(:) :: csr_val_D integer(c_int),target,dimension(:) :: csr_row_ptr_D integer(c_int),target,dimension(:) :: csr_col_ind_D type(c_ptr) :: descr_C real(c_double),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C type(c_ptr) :: info_C type(c_ptr) :: temp_buffer ! rocsparse_dcsrgemm_rank_1 = rocsparse_dcsrgemm_(handle,trans_A,trans_B,m,n,k,alpha,descr_A, & nnz_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D, & c_loc(csr_val_D),c_loc(csr_row_ptr_D),c_loc(csr_col_ind_D),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),info_C,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsrgemm_assumed_rank(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B, & beta,descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,info_C,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrgemm_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A complex(c_float_complex),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B complex(c_float_complex),target,contiguous,dimension(..) :: csr_val_B integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_B integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_B complex(c_float_complex) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D complex(c_float_complex),target,contiguous,dimension(..) :: csr_val_D integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_D integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_D type(c_ptr) :: descr_C complex(c_float_complex),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C type(c_ptr) :: info_C type(c_ptr) :: temp_buffer ! rocsparse_ccsrgemm_assumed_rank = rocsparse_ccsrgemm_(handle,trans_A,trans_B,m,n,k,alpha, & descr_A,nnz_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D, & c_loc(csr_val_D),c_loc(csr_row_ptr_D),c_loc(csr_col_ind_D),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),info_C,temp_buffer) end function #else function rocsparse_ccsrgemm_rank_0(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,beta, & descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,info_C,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrgemm_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A complex(c_float_complex),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B complex(c_float_complex),target :: csr_val_B integer(c_int),target :: csr_row_ptr_B integer(c_int),target :: csr_col_ind_B complex(c_float_complex) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D complex(c_float_complex),target :: csr_val_D integer(c_int),target :: csr_row_ptr_D integer(c_int),target :: csr_col_ind_D type(c_ptr) :: descr_C complex(c_float_complex),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C type(c_ptr) :: info_C type(c_ptr) :: temp_buffer ! rocsparse_ccsrgemm_rank_0 = rocsparse_ccsrgemm_(handle,trans_A,trans_B,m,n,k,alpha,descr_A, & nnz_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D, & c_loc(csr_val_D),c_loc(csr_row_ptr_D),c_loc(csr_col_ind_D),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),info_C,temp_buffer) end function function rocsparse_ccsrgemm_rank_1(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,beta, & descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,info_C,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrgemm_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_float_complex) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A complex(c_float_complex),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B complex(c_float_complex),target,dimension(:) :: csr_val_B integer(c_int),target,dimension(:) :: csr_row_ptr_B integer(c_int),target,dimension(:) :: csr_col_ind_B complex(c_float_complex) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D complex(c_float_complex),target,dimension(:) :: csr_val_D integer(c_int),target,dimension(:) :: csr_row_ptr_D integer(c_int),target,dimension(:) :: csr_col_ind_D type(c_ptr) :: descr_C complex(c_float_complex),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C type(c_ptr) :: info_C type(c_ptr) :: temp_buffer ! rocsparse_ccsrgemm_rank_1 = rocsparse_ccsrgemm_(handle,trans_A,trans_B,m,n,k,alpha,descr_A, & nnz_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D, & c_loc(csr_val_D),c_loc(csr_row_ptr_D),c_loc(csr_col_ind_D),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),info_C,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsrgemm_assumed_rank(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A, & csr_val_A,csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B, & beta,descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,info_C,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrgemm_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A complex(c_double_complex),target,contiguous,dimension(..) :: csr_val_A integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_A integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B complex(c_double_complex),target,contiguous,dimension(..) :: csr_val_B integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_B integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_B complex(c_double_complex) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D complex(c_double_complex),target,contiguous,dimension(..) :: csr_val_D integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_D integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_D type(c_ptr) :: descr_C complex(c_double_complex),target,contiguous,dimension(..) :: csr_val_C integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr_C integer(c_int),target,contiguous,dimension(..) :: csr_col_ind_C type(c_ptr) :: info_C type(c_ptr) :: temp_buffer ! rocsparse_zcsrgemm_assumed_rank = rocsparse_zcsrgemm_(handle,trans_A,trans_B,m,n,k,alpha, & descr_A,nnz_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D, & c_loc(csr_val_D),c_loc(csr_row_ptr_D),c_loc(csr_col_ind_D),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),info_C,temp_buffer) end function #else function rocsparse_zcsrgemm_rank_0(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,beta, & descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,info_C,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrgemm_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A complex(c_double_complex),target :: csr_val_A integer(c_int),target :: csr_row_ptr_A integer(c_int),target :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B complex(c_double_complex),target :: csr_val_B integer(c_int),target :: csr_row_ptr_B integer(c_int),target :: csr_col_ind_B complex(c_double_complex) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D complex(c_double_complex),target :: csr_val_D integer(c_int),target :: csr_row_ptr_D integer(c_int),target :: csr_col_ind_D type(c_ptr) :: descr_C complex(c_double_complex),target :: csr_val_C integer(c_int),target :: csr_row_ptr_C integer(c_int),target :: csr_col_ind_C type(c_ptr) :: info_C type(c_ptr) :: temp_buffer ! rocsparse_zcsrgemm_rank_0 = rocsparse_zcsrgemm_(handle,trans_A,trans_B,m,n,k,alpha,descr_A, & nnz_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D, & c_loc(csr_val_D),c_loc(csr_row_ptr_D),c_loc(csr_col_ind_D),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),info_C,temp_buffer) end function function rocsparse_zcsrgemm_rank_1(handle,trans_A,trans_B,m,n,k,alpha,descr_A,nnz_A,csr_val_A, & csr_row_ptr_A,csr_col_ind_A,descr_B,nnz_B,csr_val_B,csr_row_ptr_B,csr_col_ind_B,beta, & descr_D,nnz_D,csr_val_D,csr_row_ptr_D,csr_col_ind_D,descr_C,csr_val_C,csr_row_ptr_C, & csr_col_ind_C,info_C,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrgemm_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k complex(c_double_complex) :: alpha type(c_ptr) :: descr_A integer(c_int) :: nnz_A complex(c_double_complex),target,dimension(:) :: csr_val_A integer(c_int),target,dimension(:) :: csr_row_ptr_A integer(c_int),target,dimension(:) :: csr_col_ind_A type(c_ptr) :: descr_B integer(c_int) :: nnz_B complex(c_double_complex),target,dimension(:) :: csr_val_B integer(c_int),target,dimension(:) :: csr_row_ptr_B integer(c_int),target,dimension(:) :: csr_col_ind_B complex(c_double_complex) :: beta type(c_ptr) :: descr_D integer(c_int) :: nnz_D complex(c_double_complex),target,dimension(:) :: csr_val_D integer(c_int),target,dimension(:) :: csr_row_ptr_D integer(c_int),target,dimension(:) :: csr_col_ind_D type(c_ptr) :: descr_C complex(c_double_complex),target,dimension(:) :: csr_val_C integer(c_int),target,dimension(:) :: csr_row_ptr_C integer(c_int),target,dimension(:) :: csr_col_ind_C type(c_ptr) :: info_C type(c_ptr) :: temp_buffer ! rocsparse_zcsrgemm_rank_1 = rocsparse_zcsrgemm_(handle,trans_A,trans_B,m,n,k,alpha,descr_A, & nnz_A,c_loc(csr_val_A),c_loc(csr_row_ptr_A),c_loc(csr_col_ind_A),descr_B,nnz_B, & c_loc(csr_val_B),c_loc(csr_row_ptr_B),c_loc(csr_col_ind_B),beta,descr_D,nnz_D, & c_loc(csr_val_D),c_loc(csr_row_ptr_D),c_loc(csr_col_ind_D),descr_C,c_loc(csr_val_C), & c_loc(csr_row_ptr_C),c_loc(csr_col_ind_C),info_C,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_saxpyi_assumed_rank(handle,nnz,alpha,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_saxpyi_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind real(c_float),target,contiguous,dimension(..) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_saxpyi_assumed_rank = rocsparse_saxpyi_(handle,nnz,alpha,c_loc(x_val), & c_loc(x_ind),c_loc(y),idx_base) end function #else function rocsparse_saxpyi_rank_0(handle,nnz,alpha,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_saxpyi_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float) :: alpha real(c_float),target :: x_val integer(c_int),target :: x_ind real(c_float),target :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_saxpyi_rank_0 = rocsparse_saxpyi_(handle,nnz,alpha,c_loc(x_val),c_loc(x_ind), & c_loc(y),idx_base) end function function rocsparse_saxpyi_rank_1(handle,nnz,alpha,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_saxpyi_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float) :: alpha real(c_float),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind real(c_float),target,dimension(:) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_saxpyi_rank_1 = rocsparse_saxpyi_(handle,nnz,alpha,c_loc(x_val),c_loc(x_ind), & c_loc(y),idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_daxpyi_assumed_rank(handle,nnz,alpha,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_daxpyi_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind real(c_double),target,contiguous,dimension(..) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_daxpyi_assumed_rank = rocsparse_daxpyi_(handle,nnz,alpha,c_loc(x_val), & c_loc(x_ind),c_loc(y),idx_base) end function #else function rocsparse_daxpyi_rank_0(handle,nnz,alpha,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_daxpyi_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double) :: alpha real(c_double),target :: x_val integer(c_int),target :: x_ind real(c_double),target :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_daxpyi_rank_0 = rocsparse_daxpyi_(handle,nnz,alpha,c_loc(x_val),c_loc(x_ind), & c_loc(y),idx_base) end function function rocsparse_daxpyi_rank_1(handle,nnz,alpha,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_daxpyi_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double) :: alpha real(c_double),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind real(c_double),target,dimension(:) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_daxpyi_rank_1 = rocsparse_daxpyi_(handle,nnz,alpha,c_loc(x_val),c_loc(x_ind), & c_loc(y),idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_caxpyi_assumed_rank(handle,nnz,alpha,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_caxpyi_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind complex(c_float_complex),target,contiguous,dimension(..) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_caxpyi_assumed_rank = rocsparse_caxpyi_(handle,nnz,alpha,c_loc(x_val), & c_loc(x_ind),c_loc(y),idx_base) end function #else function rocsparse_caxpyi_rank_0(handle,nnz,alpha,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_caxpyi_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex) :: alpha complex(c_float_complex),target :: x_val integer(c_int),target :: x_ind complex(c_float_complex),target :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_caxpyi_rank_0 = rocsparse_caxpyi_(handle,nnz,alpha,c_loc(x_val),c_loc(x_ind), & c_loc(y),idx_base) end function function rocsparse_caxpyi_rank_1(handle,nnz,alpha,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_caxpyi_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind complex(c_float_complex),target,dimension(:) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_caxpyi_rank_1 = rocsparse_caxpyi_(handle,nnz,alpha,c_loc(x_val),c_loc(x_ind), & c_loc(y),idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zaxpyi_assumed_rank(handle,nnz,alpha,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zaxpyi_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind complex(c_double_complex),target,contiguous,dimension(..) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_zaxpyi_assumed_rank = rocsparse_zaxpyi_(handle,nnz,alpha,c_loc(x_val), & c_loc(x_ind),c_loc(y),idx_base) end function #else function rocsparse_zaxpyi_rank_0(handle,nnz,alpha,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zaxpyi_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex) :: alpha complex(c_double_complex),target :: x_val integer(c_int),target :: x_ind complex(c_double_complex),target :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_zaxpyi_rank_0 = rocsparse_zaxpyi_(handle,nnz,alpha,c_loc(x_val),c_loc(x_ind), & c_loc(y),idx_base) end function function rocsparse_zaxpyi_rank_1(handle,nnz,alpha,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zaxpyi_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind complex(c_double_complex),target,dimension(:) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_zaxpyi_rank_1 = rocsparse_zaxpyi_(handle,nnz,alpha,c_loc(x_val),c_loc(x_ind), & c_loc(y),idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cdotci_assumed_rank(handle,nnz,x_val,x_ind,y,myResult,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdotci_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind complex(c_float_complex),target,contiguous,dimension(..) :: y complex(c_float_complex),target,contiguous,dimension(..) :: myResult integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_cdotci_assumed_rank = rocsparse_cdotci_(handle,nnz,c_loc(x_val),c_loc(x_ind), & c_loc(y),c_loc(myResult),idx_base) end function #else function rocsparse_cdotci_rank_0(handle,nnz,x_val,x_ind,y,myResult,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdotci_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target :: x_val integer(c_int),target :: x_ind complex(c_float_complex),target :: y complex(c_float_complex),target :: myResult integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_cdotci_rank_0 = rocsparse_cdotci_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & c_loc(myResult),idx_base) end function function rocsparse_cdotci_rank_1(handle,nnz,x_val,x_ind,y,myResult,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdotci_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind complex(c_float_complex),target,dimension(:) :: y complex(c_float_complex),target,dimension(:) :: myResult integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_cdotci_rank_1 = rocsparse_cdotci_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & c_loc(myResult),idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zdotci_assumed_rank(handle,nnz,x_val,x_ind,y,myResult,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdotci_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind complex(c_double_complex),target,contiguous,dimension(..) :: y complex(c_double_complex),target,contiguous,dimension(..) :: myResult integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_zdotci_assumed_rank = rocsparse_zdotci_(handle,nnz,c_loc(x_val),c_loc(x_ind), & c_loc(y),c_loc(myResult),idx_base) end function #else function rocsparse_zdotci_rank_0(handle,nnz,x_val,x_ind,y,myResult,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdotci_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target :: x_val integer(c_int),target :: x_ind complex(c_double_complex),target :: y complex(c_double_complex),target :: myResult integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_zdotci_rank_0 = rocsparse_zdotci_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & c_loc(myResult),idx_base) end function function rocsparse_zdotci_rank_1(handle,nnz,x_val,x_ind,y,myResult,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdotci_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind complex(c_double_complex),target,dimension(:) :: y complex(c_double_complex),target,dimension(:) :: myResult integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_zdotci_rank_1 = rocsparse_zdotci_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & c_loc(myResult),idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sdoti_assumed_rank(handle,nnz,x_val,x_ind,y,myResult,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sdoti_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind real(c_float),target,contiguous,dimension(..) :: y real(c_float),target,contiguous,dimension(..) :: myResult integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_sdoti_assumed_rank = rocsparse_sdoti_(handle,nnz,c_loc(x_val),c_loc(x_ind), & c_loc(y),c_loc(myResult),idx_base) end function #else function rocsparse_sdoti_rank_0(handle,nnz,x_val,x_ind,y,myResult,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sdoti_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target :: x_val integer(c_int),target :: x_ind real(c_float),target :: y real(c_float),target :: myResult integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_sdoti_rank_0 = rocsparse_sdoti_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & c_loc(myResult),idx_base) end function function rocsparse_sdoti_rank_1(handle,nnz,x_val,x_ind,y,myResult,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sdoti_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind real(c_float),target,dimension(:) :: y real(c_float),target,dimension(:) :: myResult integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_sdoti_rank_1 = rocsparse_sdoti_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & c_loc(myResult),idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ddoti_assumed_rank(handle,nnz,x_val,x_ind,y,myResult,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ddoti_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind real(c_double),target,contiguous,dimension(..) :: y real(c_double),target,contiguous,dimension(..) :: myResult integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_ddoti_assumed_rank = rocsparse_ddoti_(handle,nnz,c_loc(x_val),c_loc(x_ind), & c_loc(y),c_loc(myResult),idx_base) end function #else function rocsparse_ddoti_rank_0(handle,nnz,x_val,x_ind,y,myResult,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ddoti_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target :: x_val integer(c_int),target :: x_ind real(c_double),target :: y real(c_double),target :: myResult integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_ddoti_rank_0 = rocsparse_ddoti_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & c_loc(myResult),idx_base) end function function rocsparse_ddoti_rank_1(handle,nnz,x_val,x_ind,y,myResult,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ddoti_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind real(c_double),target,dimension(:) :: y real(c_double),target,dimension(:) :: myResult integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_ddoti_rank_1 = rocsparse_ddoti_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & c_loc(myResult),idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cdoti_assumed_rank(handle,nnz,x_val,x_ind,y,myResult,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdoti_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind complex(c_float_complex),target,contiguous,dimension(..) :: y complex(c_float_complex),target,contiguous,dimension(..) :: myResult integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_cdoti_assumed_rank = rocsparse_cdoti_(handle,nnz,c_loc(x_val),c_loc(x_ind), & c_loc(y),c_loc(myResult),idx_base) end function #else function rocsparse_cdoti_rank_0(handle,nnz,x_val,x_ind,y,myResult,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdoti_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target :: x_val integer(c_int),target :: x_ind complex(c_float_complex),target :: y complex(c_float_complex),target :: myResult integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_cdoti_rank_0 = rocsparse_cdoti_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & c_loc(myResult),idx_base) end function function rocsparse_cdoti_rank_1(handle,nnz,x_val,x_ind,y,myResult,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cdoti_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind complex(c_float_complex),target,dimension(:) :: y complex(c_float_complex),target,dimension(:) :: myResult integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_cdoti_rank_1 = rocsparse_cdoti_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & c_loc(myResult),idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zdoti_assumed_rank(handle,nnz,x_val,x_ind,y,myResult,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdoti_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind complex(c_double_complex),target,contiguous,dimension(..) :: y complex(c_double_complex),target,contiguous,dimension(..) :: myResult integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_zdoti_assumed_rank = rocsparse_zdoti_(handle,nnz,c_loc(x_val),c_loc(x_ind), & c_loc(y),c_loc(myResult),idx_base) end function #else function rocsparse_zdoti_rank_0(handle,nnz,x_val,x_ind,y,myResult,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdoti_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target :: x_val integer(c_int),target :: x_ind complex(c_double_complex),target :: y complex(c_double_complex),target :: myResult integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_zdoti_rank_0 = rocsparse_zdoti_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & c_loc(myResult),idx_base) end function function rocsparse_zdoti_rank_1(handle,nnz,x_val,x_ind,y,myResult,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zdoti_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind complex(c_double_complex),target,dimension(:) :: y complex(c_double_complex),target,dimension(:) :: myResult integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_zdoti_rank_1 = rocsparse_zdoti_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & c_loc(myResult),idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sgthr_assumed_rank(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgthr_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,contiguous,dimension(..) :: y real(c_float),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_sgthr_assumed_rank = rocsparse_sgthr_(handle,nnz,c_loc(y),c_loc(x_val), & c_loc(x_ind),idx_base) end function #else function rocsparse_sgthr_rank_0(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgthr_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target :: y real(c_float),target :: x_val integer(c_int),target :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_sgthr_rank_0 = rocsparse_sgthr_(handle,nnz,c_loc(y),c_loc(x_val),c_loc(x_ind), & idx_base) end function function rocsparse_sgthr_rank_1(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgthr_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,dimension(:) :: y real(c_float),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_sgthr_rank_1 = rocsparse_sgthr_(handle,nnz,c_loc(y),c_loc(x_val),c_loc(x_ind), & idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dgthr_assumed_rank(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgthr_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,contiguous,dimension(..) :: y real(c_double),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_dgthr_assumed_rank = rocsparse_dgthr_(handle,nnz,c_loc(y),c_loc(x_val), & c_loc(x_ind),idx_base) end function #else function rocsparse_dgthr_rank_0(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgthr_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target :: y real(c_double),target :: x_val integer(c_int),target :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_dgthr_rank_0 = rocsparse_dgthr_(handle,nnz,c_loc(y),c_loc(x_val),c_loc(x_ind), & idx_base) end function function rocsparse_dgthr_rank_1(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgthr_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,dimension(:) :: y real(c_double),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_dgthr_rank_1 = rocsparse_dgthr_(handle,nnz,c_loc(y),c_loc(x_val),c_loc(x_ind), & idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cgthr_assumed_rank(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgthr_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,contiguous,dimension(..) :: y complex(c_float_complex),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_cgthr_assumed_rank = rocsparse_cgthr_(handle,nnz,c_loc(y),c_loc(x_val), & c_loc(x_ind),idx_base) end function #else function rocsparse_cgthr_rank_0(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgthr_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target :: y complex(c_float_complex),target :: x_val integer(c_int),target :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_cgthr_rank_0 = rocsparse_cgthr_(handle,nnz,c_loc(y),c_loc(x_val),c_loc(x_ind), & idx_base) end function function rocsparse_cgthr_rank_1(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgthr_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,dimension(:) :: y complex(c_float_complex),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_cgthr_rank_1 = rocsparse_cgthr_(handle,nnz,c_loc(y),c_loc(x_val),c_loc(x_ind), & idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zgthr_assumed_rank(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgthr_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,contiguous,dimension(..) :: y complex(c_double_complex),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_zgthr_assumed_rank = rocsparse_zgthr_(handle,nnz,c_loc(y),c_loc(x_val), & c_loc(x_ind),idx_base) end function #else function rocsparse_zgthr_rank_0(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgthr_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target :: y complex(c_double_complex),target :: x_val integer(c_int),target :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_zgthr_rank_0 = rocsparse_zgthr_(handle,nnz,c_loc(y),c_loc(x_val),c_loc(x_ind), & idx_base) end function function rocsparse_zgthr_rank_1(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgthr_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,dimension(:) :: y complex(c_double_complex),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_zgthr_rank_1 = rocsparse_zgthr_(handle,nnz,c_loc(y),c_loc(x_val),c_loc(x_ind), & idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sgthrz_assumed_rank(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgthrz_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,contiguous,dimension(..) :: y real(c_float),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_sgthrz_assumed_rank = rocsparse_sgthrz_(handle,nnz,c_loc(y),c_loc(x_val), & c_loc(x_ind),idx_base) end function #else function rocsparse_sgthrz_rank_0(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgthrz_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target :: y real(c_float),target :: x_val integer(c_int),target :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_sgthrz_rank_0 = rocsparse_sgthrz_(handle,nnz,c_loc(y),c_loc(x_val),c_loc(x_ind), & idx_base) end function function rocsparse_sgthrz_rank_1(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgthrz_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,dimension(:) :: y real(c_float),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_sgthrz_rank_1 = rocsparse_sgthrz_(handle,nnz,c_loc(y),c_loc(x_val),c_loc(x_ind), & idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dgthrz_assumed_rank(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgthrz_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,contiguous,dimension(..) :: y real(c_double),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_dgthrz_assumed_rank = rocsparse_dgthrz_(handle,nnz,c_loc(y),c_loc(x_val), & c_loc(x_ind),idx_base) end function #else function rocsparse_dgthrz_rank_0(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgthrz_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target :: y real(c_double),target :: x_val integer(c_int),target :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_dgthrz_rank_0 = rocsparse_dgthrz_(handle,nnz,c_loc(y),c_loc(x_val),c_loc(x_ind), & idx_base) end function function rocsparse_dgthrz_rank_1(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgthrz_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,dimension(:) :: y real(c_double),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_dgthrz_rank_1 = rocsparse_dgthrz_(handle,nnz,c_loc(y),c_loc(x_val),c_loc(x_ind), & idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cgthrz_assumed_rank(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgthrz_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,contiguous,dimension(..) :: y complex(c_float_complex),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_cgthrz_assumed_rank = rocsparse_cgthrz_(handle,nnz,c_loc(y),c_loc(x_val), & c_loc(x_ind),idx_base) end function #else function rocsparse_cgthrz_rank_0(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgthrz_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target :: y complex(c_float_complex),target :: x_val integer(c_int),target :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_cgthrz_rank_0 = rocsparse_cgthrz_(handle,nnz,c_loc(y),c_loc(x_val),c_loc(x_ind), & idx_base) end function function rocsparse_cgthrz_rank_1(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgthrz_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,dimension(:) :: y complex(c_float_complex),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_cgthrz_rank_1 = rocsparse_cgthrz_(handle,nnz,c_loc(y),c_loc(x_val),c_loc(x_ind), & idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zgthrz_assumed_rank(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgthrz_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,contiguous,dimension(..) :: y complex(c_double_complex),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_zgthrz_assumed_rank = rocsparse_zgthrz_(handle,nnz,c_loc(y),c_loc(x_val), & c_loc(x_ind),idx_base) end function #else function rocsparse_zgthrz_rank_0(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgthrz_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target :: y complex(c_double_complex),target :: x_val integer(c_int),target :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_zgthrz_rank_0 = rocsparse_zgthrz_(handle,nnz,c_loc(y),c_loc(x_val),c_loc(x_ind), & idx_base) end function function rocsparse_zgthrz_rank_1(handle,nnz,y,x_val,x_ind,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgthrz_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,dimension(:) :: y complex(c_double_complex),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_zgthrz_rank_1 = rocsparse_zgthrz_(handle,nnz,c_loc(y),c_loc(x_val),c_loc(x_ind), & idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sroti_assumed_rank(handle,nnz,x_val,x_ind,y,c,s,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sroti_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind real(c_float),target,contiguous,dimension(..) :: y real(c_float) :: c real(c_float) :: s integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_sroti_assumed_rank = rocsparse_sroti_(handle,nnz,c_loc(x_val),c_loc(x_ind), & c_loc(y),c,s,idx_base) end function #else function rocsparse_sroti_rank_0(handle,nnz,x_val,x_ind,y,c,s,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sroti_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target :: x_val integer(c_int),target :: x_ind real(c_float),target :: y real(c_float) :: c real(c_float) :: s integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_sroti_rank_0 = rocsparse_sroti_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y),c,s, & idx_base) end function function rocsparse_sroti_rank_1(handle,nnz,x_val,x_ind,y,c,s,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sroti_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind real(c_float),target,dimension(:) :: y real(c_float) :: c real(c_float) :: s integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_sroti_rank_1 = rocsparse_sroti_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y),c,s, & idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_droti_assumed_rank(handle,nnz,x_val,x_ind,y,c,s,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_droti_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind real(c_double),target,contiguous,dimension(..) :: y real(c_double) :: c real(c_double) :: s integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_droti_assumed_rank = rocsparse_droti_(handle,nnz,c_loc(x_val),c_loc(x_ind), & c_loc(y),c,s,idx_base) end function #else function rocsparse_droti_rank_0(handle,nnz,x_val,x_ind,y,c,s,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_droti_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target :: x_val integer(c_int),target :: x_ind real(c_double),target :: y real(c_double) :: c real(c_double) :: s integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_droti_rank_0 = rocsparse_droti_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y),c,s, & idx_base) end function function rocsparse_droti_rank_1(handle,nnz,x_val,x_ind,y,c,s,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_droti_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind real(c_double),target,dimension(:) :: y real(c_double) :: c real(c_double) :: s integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_droti_rank_1 = rocsparse_droti_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y),c,s, & idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ssctr_assumed_rank(handle,nnz,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ssctr_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind real(c_float),target,contiguous,dimension(..) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_ssctr_assumed_rank = rocsparse_ssctr_(handle,nnz,c_loc(x_val),c_loc(x_ind), & c_loc(y),idx_base) end function #else function rocsparse_ssctr_rank_0(handle,nnz,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ssctr_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target :: x_val integer(c_int),target :: x_ind real(c_float),target :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_ssctr_rank_0 = rocsparse_ssctr_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & idx_base) end function function rocsparse_ssctr_rank_1(handle,nnz,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ssctr_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_float),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind real(c_float),target,dimension(:) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_ssctr_rank_1 = rocsparse_ssctr_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dsctr_assumed_rank(handle,nnz,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dsctr_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind real(c_double),target,contiguous,dimension(..) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_dsctr_assumed_rank = rocsparse_dsctr_(handle,nnz,c_loc(x_val),c_loc(x_ind), & c_loc(y),idx_base) end function #else function rocsparse_dsctr_rank_0(handle,nnz,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dsctr_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target :: x_val integer(c_int),target :: x_ind real(c_double),target :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_dsctr_rank_0 = rocsparse_dsctr_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & idx_base) end function function rocsparse_dsctr_rank_1(handle,nnz,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dsctr_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz real(c_double),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind real(c_double),target,dimension(:) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_dsctr_rank_1 = rocsparse_dsctr_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_csctr_assumed_rank(handle,nnz,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csctr_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind complex(c_float_complex),target,contiguous,dimension(..) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_csctr_assumed_rank = rocsparse_csctr_(handle,nnz,c_loc(x_val),c_loc(x_ind), & c_loc(y),idx_base) end function #else function rocsparse_csctr_rank_0(handle,nnz,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csctr_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target :: x_val integer(c_int),target :: x_ind complex(c_float_complex),target :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_csctr_rank_0 = rocsparse_csctr_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & idx_base) end function function rocsparse_csctr_rank_1(handle,nnz,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_csctr_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_float_complex),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind complex(c_float_complex),target,dimension(:) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_csctr_rank_1 = rocsparse_csctr_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zsctr_assumed_rank(handle,nnz,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zsctr_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind complex(c_double_complex),target,contiguous,dimension(..) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_zsctr_assumed_rank = rocsparse_zsctr_(handle,nnz,c_loc(x_val),c_loc(x_ind), & c_loc(y),idx_base) end function #else function rocsparse_zsctr_rank_0(handle,nnz,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zsctr_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target :: x_val integer(c_int),target :: x_ind complex(c_double_complex),target :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_zsctr_rank_0 = rocsparse_zsctr_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & idx_base) end function function rocsparse_zsctr_rank_1(handle,nnz,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zsctr_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz complex(c_double_complex),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind complex(c_double_complex),target,dimension(:) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_zsctr_rank_1 = rocsparse_zsctr_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_isctr_assumed_rank(handle,nnz,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_isctr_assumed_rank type(c_ptr) :: handle integer(c_int) :: nnz integer(c_int),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind integer(c_int),target,contiguous,dimension(..) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_isctr_assumed_rank = rocsparse_isctr_(handle,nnz,c_loc(x_val),c_loc(x_ind), & c_loc(y),idx_base) end function #else function rocsparse_isctr_rank_0(handle,nnz,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_isctr_rank_0 type(c_ptr) :: handle integer(c_int) :: nnz integer(c_int),target :: x_val integer(c_int),target :: x_ind integer(c_int),target :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_isctr_rank_0 = rocsparse_isctr_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & idx_base) end function function rocsparse_isctr_rank_1(handle,nnz,x_val,x_ind,y,idx_base) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_isctr_rank_1 type(c_ptr) :: handle integer(c_int) :: nnz integer(c_int),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind integer(c_int),target,dimension(:) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base ! rocsparse_isctr_rank_1 = rocsparse_isctr_(handle,nnz,c_loc(x_val),c_loc(x_ind),c_loc(y), & idx_base) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sbsrmv_assumed_rank(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_float),target,contiguous,dimension(..) :: x real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y ! rocsparse_sbsrmv_assumed_rank = rocsparse_sbsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x),beta, & c_loc(y)) end function #else function rocsparse_sbsrmv_rank_0(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_float),target :: x real(c_float) :: beta real(c_float),target :: y ! rocsparse_sbsrmv_rank_0 = rocsparse_sbsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x),beta, & c_loc(y)) end function function rocsparse_sbsrmv_rank_1(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_float),target,dimension(:) :: x real(c_float) :: beta real(c_float),target,dimension(:) :: y ! rocsparse_sbsrmv_rank_1 = rocsparse_sbsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x),beta, & c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dbsrmv_assumed_rank(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_double),target,contiguous,dimension(..) :: x real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y ! rocsparse_dbsrmv_assumed_rank = rocsparse_dbsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x),beta, & c_loc(y)) end function #else function rocsparse_dbsrmv_rank_0(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_double),target :: x real(c_double) :: beta real(c_double),target :: y ! rocsparse_dbsrmv_rank_0 = rocsparse_dbsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x),beta, & c_loc(y)) end function function rocsparse_dbsrmv_rank_1(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_double),target,dimension(:) :: x real(c_double) :: beta real(c_double),target,dimension(:) :: y ! rocsparse_dbsrmv_rank_1 = rocsparse_dbsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x),beta, & c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cbsrmv_assumed_rank(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_float_complex),target,contiguous,dimension(..) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y ! rocsparse_cbsrmv_assumed_rank = rocsparse_cbsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x),beta, & c_loc(y)) end function #else function rocsparse_cbsrmv_rank_0(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_float_complex),target :: x complex(c_float_complex) :: beta complex(c_float_complex),target :: y ! rocsparse_cbsrmv_rank_0 = rocsparse_cbsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x),beta, & c_loc(y)) end function function rocsparse_cbsrmv_rank_1(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_float_complex),target,dimension(:) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y ! rocsparse_cbsrmv_rank_1 = rocsparse_cbsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x),beta, & c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zbsrmv_assumed_rank(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_double_complex),target,contiguous,dimension(..) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y ! rocsparse_zbsrmv_assumed_rank = rocsparse_zbsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x),beta, & c_loc(y)) end function #else function rocsparse_zbsrmv_rank_0(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_double_complex),target :: x complex(c_double_complex) :: beta complex(c_double_complex),target :: y ! rocsparse_zbsrmv_rank_0 = rocsparse_zbsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x),beta, & c_loc(y)) end function function rocsparse_zbsrmv_rank_1(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_double_complex),target,dimension(:) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y ! rocsparse_zbsrmv_rank_1 = rocsparse_zbsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x),beta, & c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sbsrsv_buffer_size_assumed_rank(handle,dir,trans,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsv_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_sbsrsv_buffer_size_assumed_rank = rocsparse_sbsrsv_buffer_size_(handle,dir,trans, & mb,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function #else function rocsparse_sbsrsv_buffer_size_rank_0(handle,dir,trans,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsv_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_sbsrsv_buffer_size_rank_0 = rocsparse_sbsrsv_buffer_size_(handle,dir,trans,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function function rocsparse_sbsrsv_buffer_size_rank_1(handle,dir,trans,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsv_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_sbsrsv_buffer_size_rank_1 = rocsparse_sbsrsv_buffer_size_(handle,dir,trans,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dbsrsv_buffer_size_assumed_rank(handle,dir,trans,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsv_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dbsrsv_buffer_size_assumed_rank = rocsparse_dbsrsv_buffer_size_(handle,dir,trans, & mb,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function #else function rocsparse_dbsrsv_buffer_size_rank_0(handle,dir,trans,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsv_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dbsrsv_buffer_size_rank_0 = rocsparse_dbsrsv_buffer_size_(handle,dir,trans,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function function rocsparse_dbsrsv_buffer_size_rank_1(handle,dir,trans,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsv_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dbsrsv_buffer_size_rank_1 = rocsparse_dbsrsv_buffer_size_(handle,dir,trans,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cbsrsv_buffer_size_assumed_rank(handle,dir,trans,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsv_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_cbsrsv_buffer_size_assumed_rank = rocsparse_cbsrsv_buffer_size_(handle,dir,trans, & mb,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function #else function rocsparse_cbsrsv_buffer_size_rank_0(handle,dir,trans,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsv_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_cbsrsv_buffer_size_rank_0 = rocsparse_cbsrsv_buffer_size_(handle,dir,trans,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function function rocsparse_cbsrsv_buffer_size_rank_1(handle,dir,trans,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsv_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_cbsrsv_buffer_size_rank_1 = rocsparse_cbsrsv_buffer_size_(handle,dir,trans,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zbsrsv_buffer_size_assumed_rank(handle,dir,trans,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsv_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zbsrsv_buffer_size_assumed_rank = rocsparse_zbsrsv_buffer_size_(handle,dir,trans, & mb,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function #else function rocsparse_zbsrsv_buffer_size_rank_0(handle,dir,trans,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsv_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zbsrsv_buffer_size_rank_0 = rocsparse_zbsrsv_buffer_size_(handle,dir,trans,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function function rocsparse_zbsrsv_buffer_size_rank_1(handle,dir,trans,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsv_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zbsrsv_buffer_size_rank_1 = rocsparse_zbsrsv_buffer_size_(handle,dir,trans,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sbsrsv_analysis_assumed_rank(handle,dir,trans,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsv_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_sbsrsv_analysis_assumed_rank = rocsparse_sbsrsv_analysis_(handle,dir,trans,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function #else function rocsparse_sbsrsv_analysis_rank_0(handle,dir,trans,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsv_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_sbsrsv_analysis_rank_0 = rocsparse_sbsrsv_analysis_(handle,dir,trans,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function function rocsparse_sbsrsv_analysis_rank_1(handle,dir,trans,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsv_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_sbsrsv_analysis_rank_1 = rocsparse_sbsrsv_analysis_(handle,dir,trans,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dbsrsv_analysis_assumed_rank(handle,dir,trans,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsv_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dbsrsv_analysis_assumed_rank = rocsparse_dbsrsv_analysis_(handle,dir,trans,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function #else function rocsparse_dbsrsv_analysis_rank_0(handle,dir,trans,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsv_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dbsrsv_analysis_rank_0 = rocsparse_dbsrsv_analysis_(handle,dir,trans,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function function rocsparse_dbsrsv_analysis_rank_1(handle,dir,trans,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsv_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dbsrsv_analysis_rank_1 = rocsparse_dbsrsv_analysis_(handle,dir,trans,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cbsrsv_analysis_assumed_rank(handle,dir,trans,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsv_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_cbsrsv_analysis_assumed_rank = rocsparse_cbsrsv_analysis_(handle,dir,trans,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function #else function rocsparse_cbsrsv_analysis_rank_0(handle,dir,trans,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsv_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_cbsrsv_analysis_rank_0 = rocsparse_cbsrsv_analysis_(handle,dir,trans,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function function rocsparse_cbsrsv_analysis_rank_1(handle,dir,trans,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsv_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_cbsrsv_analysis_rank_1 = rocsparse_cbsrsv_analysis_(handle,dir,trans,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zbsrsv_analysis_assumed_rank(handle,dir,trans,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsv_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zbsrsv_analysis_assumed_rank = rocsparse_zbsrsv_analysis_(handle,dir,trans,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function #else function rocsparse_zbsrsv_analysis_rank_0(handle,dir,trans,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsv_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zbsrsv_analysis_rank_0 = rocsparse_zbsrsv_analysis_(handle,dir,trans,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function function rocsparse_zbsrsv_analysis_rank_1(handle,dir,trans,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsv_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zbsrsv_analysis_rank_1 = rocsparse_zbsrsv_analysis_(handle,dir,trans,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sbsrsv_solve_assumed_rank(handle,dir,trans,mb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsv_solve_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_float),target,contiguous,dimension(..) :: x real(c_float),target,contiguous,dimension(..) :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_sbsrsv_solve_assumed_rank = rocsparse_sbsrsv_solve_(handle,dir,trans,mb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & c_loc(x),c_loc(y),policy,temp_buffer) end function #else function rocsparse_sbsrsv_solve_rank_0(handle,dir,trans,mb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsv_solve_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_float),target :: x real(c_float),target :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_sbsrsv_solve_rank_0 = rocsparse_sbsrsv_solve_(handle,dir,trans,mb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x), & c_loc(y),policy,temp_buffer) end function function rocsparse_sbsrsv_solve_rank_1(handle,dir,trans,mb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsv_solve_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_float),target,dimension(:) :: x real(c_float),target,dimension(:) :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_sbsrsv_solve_rank_1 = rocsparse_sbsrsv_solve_(handle,dir,trans,mb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x), & c_loc(y),policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dbsrsv_solve_assumed_rank(handle,dir,trans,mb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsv_solve_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_double),target,contiguous,dimension(..) :: x real(c_double),target,contiguous,dimension(..) :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dbsrsv_solve_assumed_rank = rocsparse_dbsrsv_solve_(handle,dir,trans,mb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & c_loc(x),c_loc(y),policy,temp_buffer) end function #else function rocsparse_dbsrsv_solve_rank_0(handle,dir,trans,mb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsv_solve_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_double),target :: x real(c_double),target :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dbsrsv_solve_rank_0 = rocsparse_dbsrsv_solve_(handle,dir,trans,mb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x), & c_loc(y),policy,temp_buffer) end function function rocsparse_dbsrsv_solve_rank_1(handle,dir,trans,mb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsv_solve_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_double),target,dimension(:) :: x real(c_double),target,dimension(:) :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dbsrsv_solve_rank_1 = rocsparse_dbsrsv_solve_(handle,dir,trans,mb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x), & c_loc(y),policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cbsrsv_solve_assumed_rank(handle,dir,trans,mb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsv_solve_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_float_complex),target,contiguous,dimension(..) :: x complex(c_float_complex),target,contiguous,dimension(..) :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_cbsrsv_solve_assumed_rank = rocsparse_cbsrsv_solve_(handle,dir,trans,mb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & c_loc(x),c_loc(y),policy,temp_buffer) end function #else function rocsparse_cbsrsv_solve_rank_0(handle,dir,trans,mb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsv_solve_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_float_complex),target :: x complex(c_float_complex),target :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_cbsrsv_solve_rank_0 = rocsparse_cbsrsv_solve_(handle,dir,trans,mb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x), & c_loc(y),policy,temp_buffer) end function function rocsparse_cbsrsv_solve_rank_1(handle,dir,trans,mb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsv_solve_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_float_complex),target,dimension(:) :: x complex(c_float_complex),target,dimension(:) :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_cbsrsv_solve_rank_1 = rocsparse_cbsrsv_solve_(handle,dir,trans,mb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x), & c_loc(y),policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zbsrsv_solve_assumed_rank(handle,dir,trans,mb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsv_solve_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_double_complex),target,contiguous,dimension(..) :: x complex(c_double_complex),target,contiguous,dimension(..) :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zbsrsv_solve_assumed_rank = rocsparse_zbsrsv_solve_(handle,dir,trans,mb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & c_loc(x),c_loc(y),policy,temp_buffer) end function #else function rocsparse_zbsrsv_solve_rank_0(handle,dir,trans,mb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsv_solve_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_double_complex),target :: x complex(c_double_complex),target :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zbsrsv_solve_rank_0 = rocsparse_zbsrsv_solve_(handle,dir,trans,mb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x), & c_loc(y),policy,temp_buffer) end function function rocsparse_zbsrsv_solve_rank_1(handle,dir,trans,mb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsv_solve_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_double_complex),target,dimension(:) :: x complex(c_double_complex),target,dimension(:) :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zbsrsv_solve_rank_1 = rocsparse_zbsrsv_solve_(handle,dir,trans,mb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,c_loc(x), & c_loc(y),policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sbsrxmv_assumed_rank(handle,dir,trans,size_of_mask,mb,nb,nnzb,alpha,descr, & bsr_val,bsr_mask_ptr,bsr_row_ptr,bsr_end_ptr,bsr_col_ind,block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrxmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: size_of_mask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_mask_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_end_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim real(c_float),target,contiguous,dimension(..) :: x real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y ! rocsparse_sbsrxmv_assumed_rank = rocsparse_sbsrxmv_(handle,dir,trans,size_of_mask,mb,nb, & nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_mask_ptr),c_loc(bsr_row_ptr),c_loc(bsr_end_ptr), & c_loc(bsr_col_ind),block_dim,c_loc(x),beta,c_loc(y)) end function #else function rocsparse_sbsrxmv_rank_0(handle,dir,trans,size_of_mask,mb,nb,nnzb,alpha,descr, & bsr_val,bsr_mask_ptr,bsr_row_ptr,bsr_end_ptr,bsr_col_ind,block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrxmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: size_of_mask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_mask_ptr integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_end_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim real(c_float),target :: x real(c_float) :: beta real(c_float),target :: y ! rocsparse_sbsrxmv_rank_0 = rocsparse_sbsrxmv_(handle,dir,trans,size_of_mask,mb,nb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_mask_ptr),c_loc(bsr_row_ptr),c_loc(bsr_end_ptr), & c_loc(bsr_col_ind),block_dim,c_loc(x),beta,c_loc(y)) end function function rocsparse_sbsrxmv_rank_1(handle,dir,trans,size_of_mask,mb,nb,nnzb,alpha,descr, & bsr_val,bsr_mask_ptr,bsr_row_ptr,bsr_end_ptr,bsr_col_ind,block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrxmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: size_of_mask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_mask_ptr integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_end_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim real(c_float),target,dimension(:) :: x real(c_float) :: beta real(c_float),target,dimension(:) :: y ! rocsparse_sbsrxmv_rank_1 = rocsparse_sbsrxmv_(handle,dir,trans,size_of_mask,mb,nb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_mask_ptr),c_loc(bsr_row_ptr),c_loc(bsr_end_ptr), & c_loc(bsr_col_ind),block_dim,c_loc(x),beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dbsrxmv_assumed_rank(handle,dir,trans,size_of_mask,mb,nb,nnzb,alpha,descr, & bsr_val,bsr_mask_ptr,bsr_row_ptr,bsr_end_ptr,bsr_col_ind,block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrxmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: size_of_mask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_mask_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_end_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim real(c_double),target,contiguous,dimension(..) :: x real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y ! rocsparse_dbsrxmv_assumed_rank = rocsparse_dbsrxmv_(handle,dir,trans,size_of_mask,mb,nb, & nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_mask_ptr),c_loc(bsr_row_ptr),c_loc(bsr_end_ptr), & c_loc(bsr_col_ind),block_dim,c_loc(x),beta,c_loc(y)) end function #else function rocsparse_dbsrxmv_rank_0(handle,dir,trans,size_of_mask,mb,nb,nnzb,alpha,descr, & bsr_val,bsr_mask_ptr,bsr_row_ptr,bsr_end_ptr,bsr_col_ind,block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrxmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: size_of_mask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_mask_ptr integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_end_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim real(c_double),target :: x real(c_double) :: beta real(c_double),target :: y ! rocsparse_dbsrxmv_rank_0 = rocsparse_dbsrxmv_(handle,dir,trans,size_of_mask,mb,nb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_mask_ptr),c_loc(bsr_row_ptr),c_loc(bsr_end_ptr), & c_loc(bsr_col_ind),block_dim,c_loc(x),beta,c_loc(y)) end function function rocsparse_dbsrxmv_rank_1(handle,dir,trans,size_of_mask,mb,nb,nnzb,alpha,descr, & bsr_val,bsr_mask_ptr,bsr_row_ptr,bsr_end_ptr,bsr_col_ind,block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrxmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: size_of_mask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_mask_ptr integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_end_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim real(c_double),target,dimension(:) :: x real(c_double) :: beta real(c_double),target,dimension(:) :: y ! rocsparse_dbsrxmv_rank_1 = rocsparse_dbsrxmv_(handle,dir,trans,size_of_mask,mb,nb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_mask_ptr),c_loc(bsr_row_ptr),c_loc(bsr_end_ptr), & c_loc(bsr_col_ind),block_dim,c_loc(x),beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cbsrxmv_assumed_rank(handle,dir,trans,size_of_mask,mb,nb,nnzb,alpha,descr, & bsr_val,bsr_mask_ptr,bsr_row_ptr,bsr_end_ptr,bsr_col_ind,block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrxmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: size_of_mask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_mask_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_end_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim complex(c_float_complex),target,contiguous,dimension(..) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y ! rocsparse_cbsrxmv_assumed_rank = rocsparse_cbsrxmv_(handle,dir,trans,size_of_mask,mb,nb, & nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_mask_ptr),c_loc(bsr_row_ptr),c_loc(bsr_end_ptr), & c_loc(bsr_col_ind),block_dim,c_loc(x),beta,c_loc(y)) end function #else function rocsparse_cbsrxmv_rank_0(handle,dir,trans,size_of_mask,mb,nb,nnzb,alpha,descr, & bsr_val,bsr_mask_ptr,bsr_row_ptr,bsr_end_ptr,bsr_col_ind,block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrxmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: size_of_mask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_mask_ptr integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_end_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim complex(c_float_complex),target :: x complex(c_float_complex) :: beta complex(c_float_complex),target :: y ! rocsparse_cbsrxmv_rank_0 = rocsparse_cbsrxmv_(handle,dir,trans,size_of_mask,mb,nb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_mask_ptr),c_loc(bsr_row_ptr),c_loc(bsr_end_ptr), & c_loc(bsr_col_ind),block_dim,c_loc(x),beta,c_loc(y)) end function function rocsparse_cbsrxmv_rank_1(handle,dir,trans,size_of_mask,mb,nb,nnzb,alpha,descr, & bsr_val,bsr_mask_ptr,bsr_row_ptr,bsr_end_ptr,bsr_col_ind,block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrxmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: size_of_mask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_mask_ptr integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_end_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim complex(c_float_complex),target,dimension(:) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y ! rocsparse_cbsrxmv_rank_1 = rocsparse_cbsrxmv_(handle,dir,trans,size_of_mask,mb,nb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_mask_ptr),c_loc(bsr_row_ptr),c_loc(bsr_end_ptr), & c_loc(bsr_col_ind),block_dim,c_loc(x),beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zbsrxmv_assumed_rank(handle,dir,trans,size_of_mask,mb,nb,nnzb,alpha,descr, & bsr_val,bsr_mask_ptr,bsr_row_ptr,bsr_end_ptr,bsr_col_ind,block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrxmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: size_of_mask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_mask_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_end_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim complex(c_double_complex),target,contiguous,dimension(..) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y ! rocsparse_zbsrxmv_assumed_rank = rocsparse_zbsrxmv_(handle,dir,trans,size_of_mask,mb,nb, & nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_mask_ptr),c_loc(bsr_row_ptr),c_loc(bsr_end_ptr), & c_loc(bsr_col_ind),block_dim,c_loc(x),beta,c_loc(y)) end function #else function rocsparse_zbsrxmv_rank_0(handle,dir,trans,size_of_mask,mb,nb,nnzb,alpha,descr, & bsr_val,bsr_mask_ptr,bsr_row_ptr,bsr_end_ptr,bsr_col_ind,block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrxmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: size_of_mask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_mask_ptr integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_end_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim complex(c_double_complex),target :: x complex(c_double_complex) :: beta complex(c_double_complex),target :: y ! rocsparse_zbsrxmv_rank_0 = rocsparse_zbsrxmv_(handle,dir,trans,size_of_mask,mb,nb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_mask_ptr),c_loc(bsr_row_ptr),c_loc(bsr_end_ptr), & c_loc(bsr_col_ind),block_dim,c_loc(x),beta,c_loc(y)) end function function rocsparse_zbsrxmv_rank_1(handle,dir,trans,size_of_mask,mb,nb,nnzb,alpha,descr, & bsr_val,bsr_mask_ptr,bsr_row_ptr,bsr_end_ptr,bsr_col_ind,block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrxmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: size_of_mask integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_mask_ptr integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_end_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim complex(c_double_complex),target,dimension(:) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y ! rocsparse_zbsrxmv_rank_1 = rocsparse_zbsrxmv_(handle,dir,trans,size_of_mask,mb,nb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_mask_ptr),c_loc(bsr_row_ptr),c_loc(bsr_end_ptr), & c_loc(bsr_col_ind),block_dim,c_loc(x),beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scoomv_assumed_rank(handle,trans,m,n,nnz,alpha,descr,coo_val,coo_row_ind, & coo_col_ind,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scoomv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: coo_val integer(c_int),target,contiguous,dimension(..) :: coo_row_ind integer(c_int),target,contiguous,dimension(..) :: coo_col_ind real(c_float),target,contiguous,dimension(..) :: x real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y ! rocsparse_scoomv_assumed_rank = rocsparse_scoomv_(handle,trans,m,n,nnz,alpha,descr, & c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(x),beta,c_loc(y)) end function #else function rocsparse_scoomv_rank_0(handle,trans,m,n,nnz,alpha,descr,coo_val,coo_row_ind, & coo_col_ind,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scoomv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target :: coo_val integer(c_int),target :: coo_row_ind integer(c_int),target :: coo_col_ind real(c_float),target :: x real(c_float) :: beta real(c_float),target :: y ! rocsparse_scoomv_rank_0 = rocsparse_scoomv_(handle,trans,m,n,nnz,alpha,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(x),beta,c_loc(y)) end function function rocsparse_scoomv_rank_1(handle,trans,m,n,nnz,alpha,descr,coo_val,coo_row_ind, & coo_col_ind,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scoomv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind real(c_float),target,dimension(:) :: x real(c_float) :: beta real(c_float),target,dimension(:) :: y ! rocsparse_scoomv_rank_1 = rocsparse_scoomv_(handle,trans,m,n,nnz,alpha,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(x),beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcoomv_assumed_rank(handle,trans,m,n,nnz,alpha,descr,coo_val,coo_row_ind, & coo_col_ind,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcoomv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: coo_val integer(c_int),target,contiguous,dimension(..) :: coo_row_ind integer(c_int),target,contiguous,dimension(..) :: coo_col_ind real(c_double),target,contiguous,dimension(..) :: x real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y ! rocsparse_dcoomv_assumed_rank = rocsparse_dcoomv_(handle,trans,m,n,nnz,alpha,descr, & c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(x),beta,c_loc(y)) end function #else function rocsparse_dcoomv_rank_0(handle,trans,m,n,nnz,alpha,descr,coo_val,coo_row_ind, & coo_col_ind,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcoomv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target :: coo_val integer(c_int),target :: coo_row_ind integer(c_int),target :: coo_col_ind real(c_double),target :: x real(c_double) :: beta real(c_double),target :: y ! rocsparse_dcoomv_rank_0 = rocsparse_dcoomv_(handle,trans,m,n,nnz,alpha,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(x),beta,c_loc(y)) end function function rocsparse_dcoomv_rank_1(handle,trans,m,n,nnz,alpha,descr,coo_val,coo_row_ind, & coo_col_ind,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcoomv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind real(c_double),target,dimension(:) :: x real(c_double) :: beta real(c_double),target,dimension(:) :: y ! rocsparse_dcoomv_rank_1 = rocsparse_dcoomv_(handle,trans,m,n,nnz,alpha,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(x),beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccoomv_assumed_rank(handle,trans,m,n,nnz,alpha,descr,coo_val,coo_row_ind, & coo_col_ind,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccoomv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: coo_val integer(c_int),target,contiguous,dimension(..) :: coo_row_ind integer(c_int),target,contiguous,dimension(..) :: coo_col_ind complex(c_float_complex),target,contiguous,dimension(..) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y ! rocsparse_ccoomv_assumed_rank = rocsparse_ccoomv_(handle,trans,m,n,nnz,alpha,descr, & c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(x),beta,c_loc(y)) end function #else function rocsparse_ccoomv_rank_0(handle,trans,m,n,nnz,alpha,descr,coo_val,coo_row_ind, & coo_col_ind,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccoomv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target :: coo_val integer(c_int),target :: coo_row_ind integer(c_int),target :: coo_col_ind complex(c_float_complex),target :: x complex(c_float_complex) :: beta complex(c_float_complex),target :: y ! rocsparse_ccoomv_rank_0 = rocsparse_ccoomv_(handle,trans,m,n,nnz,alpha,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(x),beta,c_loc(y)) end function function rocsparse_ccoomv_rank_1(handle,trans,m,n,nnz,alpha,descr,coo_val,coo_row_ind, & coo_col_ind,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccoomv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind complex(c_float_complex),target,dimension(:) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y ! rocsparse_ccoomv_rank_1 = rocsparse_ccoomv_(handle,trans,m,n,nnz,alpha,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(x),beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcoomv_assumed_rank(handle,trans,m,n,nnz,alpha,descr,coo_val,coo_row_ind, & coo_col_ind,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcoomv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: coo_val integer(c_int),target,contiguous,dimension(..) :: coo_row_ind integer(c_int),target,contiguous,dimension(..) :: coo_col_ind complex(c_double_complex),target,contiguous,dimension(..) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y ! rocsparse_zcoomv_assumed_rank = rocsparse_zcoomv_(handle,trans,m,n,nnz,alpha,descr, & c_loc(coo_val),c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(x),beta,c_loc(y)) end function #else function rocsparse_zcoomv_rank_0(handle,trans,m,n,nnz,alpha,descr,coo_val,coo_row_ind, & coo_col_ind,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcoomv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target :: coo_val integer(c_int),target :: coo_row_ind integer(c_int),target :: coo_col_ind complex(c_double_complex),target :: x complex(c_double_complex) :: beta complex(c_double_complex),target :: y ! rocsparse_zcoomv_rank_0 = rocsparse_zcoomv_(handle,trans,m,n,nnz,alpha,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(x),beta,c_loc(y)) end function function rocsparse_zcoomv_rank_1(handle,trans,m,n,nnz,alpha,descr,coo_val,coo_row_ind, & coo_col_ind,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcoomv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: coo_val integer(c_int),target,dimension(:) :: coo_row_ind integer(c_int),target,dimension(:) :: coo_col_ind complex(c_double_complex),target,dimension(:) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y ! rocsparse_zcoomv_rank_1 = rocsparse_zcoomv_(handle,trans,m,n,nnz,alpha,descr,c_loc(coo_val), & c_loc(coo_row_ind),c_loc(coo_col_ind),c_loc(x),beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsrmv_analysis_assumed_rank(handle,trans,m,n,nnz,descr,csr_val, & csr_row_ptr,csr_col_ind,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrmv_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo ! rocsparse_scsrmv_analysis_assumed_rank = rocsparse_scsrmv_analysis_(handle,trans,m,n,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo) end function #else function rocsparse_scsrmv_analysis_rank_0(handle,trans,m,n,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrmv_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo ! rocsparse_scsrmv_analysis_rank_0 = rocsparse_scsrmv_analysis_(handle,trans,m,n,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo) end function function rocsparse_scsrmv_analysis_rank_1(handle,trans,m,n,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrmv_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo ! rocsparse_scsrmv_analysis_rank_1 = rocsparse_scsrmv_analysis_(handle,trans,m,n,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsrmv_analysis_assumed_rank(handle,trans,m,n,nnz,descr,csr_val, & csr_row_ptr,csr_col_ind,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrmv_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo ! rocsparse_dcsrmv_analysis_assumed_rank = rocsparse_dcsrmv_analysis_(handle,trans,m,n,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo) end function #else function rocsparse_dcsrmv_analysis_rank_0(handle,trans,m,n,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrmv_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo ! rocsparse_dcsrmv_analysis_rank_0 = rocsparse_dcsrmv_analysis_(handle,trans,m,n,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo) end function function rocsparse_dcsrmv_analysis_rank_1(handle,trans,m,n,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrmv_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo ! rocsparse_dcsrmv_analysis_rank_1 = rocsparse_dcsrmv_analysis_(handle,trans,m,n,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsrmv_analysis_assumed_rank(handle,trans,m,n,nnz,descr,csr_val, & csr_row_ptr,csr_col_ind,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrmv_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo ! rocsparse_ccsrmv_analysis_assumed_rank = rocsparse_ccsrmv_analysis_(handle,trans,m,n,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo) end function #else function rocsparse_ccsrmv_analysis_rank_0(handle,trans,m,n,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrmv_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo ! rocsparse_ccsrmv_analysis_rank_0 = rocsparse_ccsrmv_analysis_(handle,trans,m,n,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo) end function function rocsparse_ccsrmv_analysis_rank_1(handle,trans,m,n,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrmv_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo ! rocsparse_ccsrmv_analysis_rank_1 = rocsparse_ccsrmv_analysis_(handle,trans,m,n,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsrmv_analysis_assumed_rank(handle,trans,m,n,nnz,descr,csr_val, & csr_row_ptr,csr_col_ind,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrmv_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo ! rocsparse_zcsrmv_analysis_assumed_rank = rocsparse_zcsrmv_analysis_(handle,trans,m,n,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo) end function #else function rocsparse_zcsrmv_analysis_rank_0(handle,trans,m,n,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrmv_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo ! rocsparse_zcsrmv_analysis_rank_0 = rocsparse_zcsrmv_analysis_(handle,trans,m,n,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo) end function function rocsparse_zcsrmv_analysis_rank_1(handle,trans,m,n,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrmv_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo ! rocsparse_zcsrmv_analysis_rank_1 = rocsparse_zcsrmv_analysis_(handle,trans,m,n,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsrmv_assumed_rank(handle,trans,m,n,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo real(c_float),target,contiguous,dimension(..) :: x real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y ! rocsparse_scsrmv_assumed_rank = rocsparse_scsrmv_(handle,trans,m,n,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),beta,c_loc(y)) end function #else function rocsparse_scsrmv_rank_0(handle,trans,m,n,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo real(c_float),target :: x real(c_float) :: beta real(c_float),target :: y ! rocsparse_scsrmv_rank_0 = rocsparse_scsrmv_(handle,trans,m,n,nnz,alpha,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),beta,c_loc(y)) end function function rocsparse_scsrmv_rank_1(handle,trans,m,n,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo real(c_float),target,dimension(:) :: x real(c_float) :: beta real(c_float),target,dimension(:) :: y ! rocsparse_scsrmv_rank_1 = rocsparse_scsrmv_(handle,trans,m,n,nnz,alpha,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsrmv_assumed_rank(handle,trans,m,n,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo real(c_double),target,contiguous,dimension(..) :: x real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y ! rocsparse_dcsrmv_assumed_rank = rocsparse_dcsrmv_(handle,trans,m,n,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),beta,c_loc(y)) end function #else function rocsparse_dcsrmv_rank_0(handle,trans,m,n,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo real(c_double),target :: x real(c_double) :: beta real(c_double),target :: y ! rocsparse_dcsrmv_rank_0 = rocsparse_dcsrmv_(handle,trans,m,n,nnz,alpha,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),beta,c_loc(y)) end function function rocsparse_dcsrmv_rank_1(handle,trans,m,n,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo real(c_double),target,dimension(:) :: x real(c_double) :: beta real(c_double),target,dimension(:) :: y ! rocsparse_dcsrmv_rank_1 = rocsparse_dcsrmv_(handle,trans,m,n,nnz,alpha,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsrmv_assumed_rank(handle,trans,m,n,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo complex(c_float_complex),target,contiguous,dimension(..) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y ! rocsparse_ccsrmv_assumed_rank = rocsparse_ccsrmv_(handle,trans,m,n,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),beta,c_loc(y)) end function #else function rocsparse_ccsrmv_rank_0(handle,trans,m,n,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo complex(c_float_complex),target :: x complex(c_float_complex) :: beta complex(c_float_complex),target :: y ! rocsparse_ccsrmv_rank_0 = rocsparse_ccsrmv_(handle,trans,m,n,nnz,alpha,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),beta,c_loc(y)) end function function rocsparse_ccsrmv_rank_1(handle,trans,m,n,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo complex(c_float_complex),target,dimension(:) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y ! rocsparse_ccsrmv_rank_1 = rocsparse_ccsrmv_(handle,trans,m,n,nnz,alpha,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsrmv_assumed_rank(handle,trans,m,n,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo complex(c_double_complex),target,contiguous,dimension(..) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y ! rocsparse_zcsrmv_assumed_rank = rocsparse_zcsrmv_(handle,trans,m,n,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),beta,c_loc(y)) end function #else function rocsparse_zcsrmv_rank_0(handle,trans,m,n,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo complex(c_double_complex),target :: x complex(c_double_complex) :: beta complex(c_double_complex),target :: y ! rocsparse_zcsrmv_rank_0 = rocsparse_zcsrmv_(handle,trans,m,n,nnz,alpha,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),beta,c_loc(y)) end function function rocsparse_zcsrmv_rank_1(handle,trans,m,n,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo complex(c_double_complex),target,dimension(:) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y ! rocsparse_zcsrmv_rank_1 = rocsparse_zcsrmv_(handle,trans,m,n,nnz,alpha,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsrsv_buffer_size_assumed_rank(handle,trans,m,nnz,descr,csr_val, & csr_row_ptr,csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsv_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_scsrsv_buffer_size_assumed_rank = rocsparse_scsrsv_buffer_size_(handle,trans,m, & nnz,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #else function rocsparse_scsrsv_buffer_size_rank_0(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsv_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_scsrsv_buffer_size_rank_0 = rocsparse_scsrsv_buffer_size_(handle,trans,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function function rocsparse_scsrsv_buffer_size_rank_1(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsv_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_scsrsv_buffer_size_rank_1 = rocsparse_scsrsv_buffer_size_(handle,trans,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsrsv_buffer_size_assumed_rank(handle,trans,m,nnz,descr,csr_val, & csr_row_ptr,csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsv_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dcsrsv_buffer_size_assumed_rank = rocsparse_dcsrsv_buffer_size_(handle,trans,m, & nnz,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #else function rocsparse_dcsrsv_buffer_size_rank_0(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsv_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dcsrsv_buffer_size_rank_0 = rocsparse_dcsrsv_buffer_size_(handle,trans,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function function rocsparse_dcsrsv_buffer_size_rank_1(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsv_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dcsrsv_buffer_size_rank_1 = rocsparse_dcsrsv_buffer_size_(handle,trans,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsrsv_buffer_size_assumed_rank(handle,trans,m,nnz,descr,csr_val, & csr_row_ptr,csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsv_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_ccsrsv_buffer_size_assumed_rank = rocsparse_ccsrsv_buffer_size_(handle,trans,m, & nnz,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #else function rocsparse_ccsrsv_buffer_size_rank_0(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsv_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_ccsrsv_buffer_size_rank_0 = rocsparse_ccsrsv_buffer_size_(handle,trans,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function function rocsparse_ccsrsv_buffer_size_rank_1(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsv_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_ccsrsv_buffer_size_rank_1 = rocsparse_ccsrsv_buffer_size_(handle,trans,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsrsv_buffer_size_assumed_rank(handle,trans,m,nnz,descr,csr_val, & csr_row_ptr,csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsv_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zcsrsv_buffer_size_assumed_rank = rocsparse_zcsrsv_buffer_size_(handle,trans,m, & nnz,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #else function rocsparse_zcsrsv_buffer_size_rank_0(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsv_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zcsrsv_buffer_size_rank_0 = rocsparse_zcsrsv_buffer_size_(handle,trans,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function function rocsparse_zcsrsv_buffer_size_rank_1(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsv_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zcsrsv_buffer_size_rank_1 = rocsparse_zcsrsv_buffer_size_(handle,trans,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsrsv_analysis_assumed_rank(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsv_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_scsrsv_analysis_assumed_rank = rocsparse_scsrsv_analysis_(handle,trans,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve, & temp_buffer) end function #else function rocsparse_scsrsv_analysis_rank_0(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsv_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_scsrsv_analysis_rank_0 = rocsparse_scsrsv_analysis_(handle,trans,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function function rocsparse_scsrsv_analysis_rank_1(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsv_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_scsrsv_analysis_rank_1 = rocsparse_scsrsv_analysis_(handle,trans,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsrsv_analysis_assumed_rank(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsv_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dcsrsv_analysis_assumed_rank = rocsparse_dcsrsv_analysis_(handle,trans,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve, & temp_buffer) end function #else function rocsparse_dcsrsv_analysis_rank_0(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsv_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dcsrsv_analysis_rank_0 = rocsparse_dcsrsv_analysis_(handle,trans,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function function rocsparse_dcsrsv_analysis_rank_1(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsv_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dcsrsv_analysis_rank_1 = rocsparse_dcsrsv_analysis_(handle,trans,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsrsv_analysis_assumed_rank(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsv_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_ccsrsv_analysis_assumed_rank = rocsparse_ccsrsv_analysis_(handle,trans,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve, & temp_buffer) end function #else function rocsparse_ccsrsv_analysis_rank_0(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsv_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_ccsrsv_analysis_rank_0 = rocsparse_ccsrsv_analysis_(handle,trans,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function function rocsparse_ccsrsv_analysis_rank_1(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsv_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_ccsrsv_analysis_rank_1 = rocsparse_ccsrsv_analysis_(handle,trans,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsrsv_analysis_assumed_rank(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsv_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zcsrsv_analysis_assumed_rank = rocsparse_zcsrsv_analysis_(handle,trans,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve, & temp_buffer) end function #else function rocsparse_zcsrsv_analysis_rank_0(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsv_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zcsrsv_analysis_rank_0 = rocsparse_zcsrsv_analysis_(handle,trans,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function function rocsparse_zcsrsv_analysis_rank_1(handle,trans,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsv_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zcsrsv_analysis_rank_1 = rocsparse_zcsrsv_analysis_(handle,trans,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsrsv_solve_assumed_rank(handle,trans,m,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsv_solve_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo real(c_float),target,contiguous,dimension(..) :: x real(c_float),target,contiguous,dimension(..) :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_scsrsv_solve_assumed_rank = rocsparse_scsrsv_solve_(handle,trans,m,nnz,alpha, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),c_loc(y), & policy,temp_buffer) end function #else function rocsparse_scsrsv_solve_rank_0(handle,trans,m,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsv_solve_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo real(c_float),target :: x real(c_float),target :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_scsrsv_solve_rank_0 = rocsparse_scsrsv_solve_(handle,trans,m,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),c_loc(y),policy, & temp_buffer) end function function rocsparse_scsrsv_solve_rank_1(handle,trans,m,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsv_solve_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo real(c_float),target,dimension(:) :: x real(c_float),target,dimension(:) :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_scsrsv_solve_rank_1 = rocsparse_scsrsv_solve_(handle,trans,m,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),c_loc(y),policy, & temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsrsv_solve_assumed_rank(handle,trans,m,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsv_solve_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo real(c_double),target,contiguous,dimension(..) :: x real(c_double),target,contiguous,dimension(..) :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dcsrsv_solve_assumed_rank = rocsparse_dcsrsv_solve_(handle,trans,m,nnz,alpha, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),c_loc(y), & policy,temp_buffer) end function #else function rocsparse_dcsrsv_solve_rank_0(handle,trans,m,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsv_solve_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo real(c_double),target :: x real(c_double),target :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dcsrsv_solve_rank_0 = rocsparse_dcsrsv_solve_(handle,trans,m,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),c_loc(y),policy, & temp_buffer) end function function rocsparse_dcsrsv_solve_rank_1(handle,trans,m,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsv_solve_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo real(c_double),target,dimension(:) :: x real(c_double),target,dimension(:) :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dcsrsv_solve_rank_1 = rocsparse_dcsrsv_solve_(handle,trans,m,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),c_loc(y),policy, & temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsrsv_solve_assumed_rank(handle,trans,m,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsv_solve_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo complex(c_float_complex),target,contiguous,dimension(..) :: x complex(c_float_complex),target,contiguous,dimension(..) :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_ccsrsv_solve_assumed_rank = rocsparse_ccsrsv_solve_(handle,trans,m,nnz,alpha, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),c_loc(y), & policy,temp_buffer) end function #else function rocsparse_ccsrsv_solve_rank_0(handle,trans,m,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsv_solve_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo complex(c_float_complex),target :: x complex(c_float_complex),target :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_ccsrsv_solve_rank_0 = rocsparse_ccsrsv_solve_(handle,trans,m,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),c_loc(y),policy, & temp_buffer) end function function rocsparse_ccsrsv_solve_rank_1(handle,trans,m,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsv_solve_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo complex(c_float_complex),target,dimension(:) :: x complex(c_float_complex),target,dimension(:) :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_ccsrsv_solve_rank_1 = rocsparse_ccsrsv_solve_(handle,trans,m,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),c_loc(y),policy, & temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsrsv_solve_assumed_rank(handle,trans,m,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsv_solve_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo complex(c_double_complex),target,contiguous,dimension(..) :: x complex(c_double_complex),target,contiguous,dimension(..) :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zcsrsv_solve_assumed_rank = rocsparse_zcsrsv_solve_(handle,trans,m,nnz,alpha, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),c_loc(y), & policy,temp_buffer) end function #else function rocsparse_zcsrsv_solve_rank_0(handle,trans,m,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsv_solve_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo complex(c_double_complex),target :: x complex(c_double_complex),target :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zcsrsv_solve_rank_0 = rocsparse_zcsrsv_solve_(handle,trans,m,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),c_loc(y),policy, & temp_buffer) end function function rocsparse_zcsrsv_solve_rank_1(handle,trans,m,nnz,alpha,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,x,y,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsv_solve_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo complex(c_double_complex),target,dimension(:) :: x complex(c_double_complex),target,dimension(:) :: y integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zcsrsv_solve_rank_1 = rocsparse_zcsrsv_solve_(handle,trans,m,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,c_loc(x),c_loc(y),policy, & temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sellmv_assumed_rank(handle,trans,m,n,alpha,descr,ell_val,ell_col_ind, & ell_width,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sellmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: ell_val integer(c_int),target,contiguous,dimension(..) :: ell_col_ind integer(c_int) :: ell_width real(c_float),target,contiguous,dimension(..) :: x real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y ! rocsparse_sellmv_assumed_rank = rocsparse_sellmv_(handle,trans,m,n,alpha,descr, & c_loc(ell_val),c_loc(ell_col_ind),ell_width,c_loc(x),beta,c_loc(y)) end function #else function rocsparse_sellmv_rank_0(handle,trans,m,n,alpha,descr,ell_val,ell_col_ind,ell_width,x, & beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sellmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target :: ell_val integer(c_int),target :: ell_col_ind integer(c_int) :: ell_width real(c_float),target :: x real(c_float) :: beta real(c_float),target :: y ! rocsparse_sellmv_rank_0 = rocsparse_sellmv_(handle,trans,m,n,alpha,descr,c_loc(ell_val), & c_loc(ell_col_ind),ell_width,c_loc(x),beta,c_loc(y)) end function function rocsparse_sellmv_rank_1(handle,trans,m,n,alpha,descr,ell_val,ell_col_ind,ell_width,x, & beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sellmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: ell_val integer(c_int),target,dimension(:) :: ell_col_ind integer(c_int) :: ell_width real(c_float),target,dimension(:) :: x real(c_float) :: beta real(c_float),target,dimension(:) :: y ! rocsparse_sellmv_rank_1 = rocsparse_sellmv_(handle,trans,m,n,alpha,descr,c_loc(ell_val), & c_loc(ell_col_ind),ell_width,c_loc(x),beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dellmv_assumed_rank(handle,trans,m,n,alpha,descr,ell_val,ell_col_ind, & ell_width,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dellmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: ell_val integer(c_int),target,contiguous,dimension(..) :: ell_col_ind integer(c_int) :: ell_width real(c_double),target,contiguous,dimension(..) :: x real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y ! rocsparse_dellmv_assumed_rank = rocsparse_dellmv_(handle,trans,m,n,alpha,descr, & c_loc(ell_val),c_loc(ell_col_ind),ell_width,c_loc(x),beta,c_loc(y)) end function #else function rocsparse_dellmv_rank_0(handle,trans,m,n,alpha,descr,ell_val,ell_col_ind,ell_width,x, & beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dellmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target :: ell_val integer(c_int),target :: ell_col_ind integer(c_int) :: ell_width real(c_double),target :: x real(c_double) :: beta real(c_double),target :: y ! rocsparse_dellmv_rank_0 = rocsparse_dellmv_(handle,trans,m,n,alpha,descr,c_loc(ell_val), & c_loc(ell_col_ind),ell_width,c_loc(x),beta,c_loc(y)) end function function rocsparse_dellmv_rank_1(handle,trans,m,n,alpha,descr,ell_val,ell_col_ind,ell_width,x, & beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dellmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: ell_val integer(c_int),target,dimension(:) :: ell_col_ind integer(c_int) :: ell_width real(c_double),target,dimension(:) :: x real(c_double) :: beta real(c_double),target,dimension(:) :: y ! rocsparse_dellmv_rank_1 = rocsparse_dellmv_(handle,trans,m,n,alpha,descr,c_loc(ell_val), & c_loc(ell_col_ind),ell_width,c_loc(x),beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cellmv_assumed_rank(handle,trans,m,n,alpha,descr,ell_val,ell_col_ind, & ell_width,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cellmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: ell_val integer(c_int),target,contiguous,dimension(..) :: ell_col_ind integer(c_int) :: ell_width complex(c_float_complex),target,contiguous,dimension(..) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y ! rocsparse_cellmv_assumed_rank = rocsparse_cellmv_(handle,trans,m,n,alpha,descr, & c_loc(ell_val),c_loc(ell_col_ind),ell_width,c_loc(x),beta,c_loc(y)) end function #else function rocsparse_cellmv_rank_0(handle,trans,m,n,alpha,descr,ell_val,ell_col_ind,ell_width,x, & beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cellmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target :: ell_val integer(c_int),target :: ell_col_ind integer(c_int) :: ell_width complex(c_float_complex),target :: x complex(c_float_complex) :: beta complex(c_float_complex),target :: y ! rocsparse_cellmv_rank_0 = rocsparse_cellmv_(handle,trans,m,n,alpha,descr,c_loc(ell_val), & c_loc(ell_col_ind),ell_width,c_loc(x),beta,c_loc(y)) end function function rocsparse_cellmv_rank_1(handle,trans,m,n,alpha,descr,ell_val,ell_col_ind,ell_width,x, & beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cellmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: ell_val integer(c_int),target,dimension(:) :: ell_col_ind integer(c_int) :: ell_width complex(c_float_complex),target,dimension(:) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y ! rocsparse_cellmv_rank_1 = rocsparse_cellmv_(handle,trans,m,n,alpha,descr,c_loc(ell_val), & c_loc(ell_col_ind),ell_width,c_loc(x),beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zellmv_assumed_rank(handle,trans,m,n,alpha,descr,ell_val,ell_col_ind, & ell_width,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zellmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: ell_val integer(c_int),target,contiguous,dimension(..) :: ell_col_ind integer(c_int) :: ell_width complex(c_double_complex),target,contiguous,dimension(..) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y ! rocsparse_zellmv_assumed_rank = rocsparse_zellmv_(handle,trans,m,n,alpha,descr, & c_loc(ell_val),c_loc(ell_col_ind),ell_width,c_loc(x),beta,c_loc(y)) end function #else function rocsparse_zellmv_rank_0(handle,trans,m,n,alpha,descr,ell_val,ell_col_ind,ell_width,x, & beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zellmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target :: ell_val integer(c_int),target :: ell_col_ind integer(c_int) :: ell_width complex(c_double_complex),target :: x complex(c_double_complex) :: beta complex(c_double_complex),target :: y ! rocsparse_zellmv_rank_0 = rocsparse_zellmv_(handle,trans,m,n,alpha,descr,c_loc(ell_val), & c_loc(ell_col_ind),ell_width,c_loc(x),beta,c_loc(y)) end function function rocsparse_zellmv_rank_1(handle,trans,m,n,alpha,descr,ell_val,ell_col_ind,ell_width,x, & beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zellmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: ell_val integer(c_int),target,dimension(:) :: ell_col_ind integer(c_int) :: ell_width complex(c_double_complex),target,dimension(:) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y ! rocsparse_zellmv_rank_1 = rocsparse_zellmv_(handle,trans,m,n,alpha,descr,c_loc(ell_val), & c_loc(ell_col_ind),ell_width,c_loc(x),beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sgebsrmv_assumed_rank(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsrmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_float),target,contiguous,dimension(..) :: x real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y ! rocsparse_sgebsrmv_assumed_rank = rocsparse_sgebsrmv_(handle,dir,trans,mb,nb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & c_loc(x),beta,c_loc(y)) end function #else function rocsparse_sgebsrmv_rank_0(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsrmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_float),target :: x real(c_float) :: beta real(c_float),target :: y ! rocsparse_sgebsrmv_rank_0 = rocsparse_sgebsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,c_loc(x), & beta,c_loc(y)) end function function rocsparse_sgebsrmv_rank_1(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsrmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_float),target,dimension(:) :: x real(c_float) :: beta real(c_float),target,dimension(:) :: y ! rocsparse_sgebsrmv_rank_1 = rocsparse_sgebsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,c_loc(x), & beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dgebsrmv_assumed_rank(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsrmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_double),target,contiguous,dimension(..) :: x real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y ! rocsparse_dgebsrmv_assumed_rank = rocsparse_dgebsrmv_(handle,dir,trans,mb,nb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & c_loc(x),beta,c_loc(y)) end function #else function rocsparse_dgebsrmv_rank_0(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsrmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_double),target :: x real(c_double) :: beta real(c_double),target :: y ! rocsparse_dgebsrmv_rank_0 = rocsparse_dgebsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,c_loc(x), & beta,c_loc(y)) end function function rocsparse_dgebsrmv_rank_1(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsrmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_double),target,dimension(:) :: x real(c_double) :: beta real(c_double),target,dimension(:) :: y ! rocsparse_dgebsrmv_rank_1 = rocsparse_dgebsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,c_loc(x), & beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cgebsrmv_assumed_rank(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsrmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_float_complex),target,contiguous,dimension(..) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y ! rocsparse_cgebsrmv_assumed_rank = rocsparse_cgebsrmv_(handle,dir,trans,mb,nb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & c_loc(x),beta,c_loc(y)) end function #else function rocsparse_cgebsrmv_rank_0(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsrmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_float_complex),target :: x complex(c_float_complex) :: beta complex(c_float_complex),target :: y ! rocsparse_cgebsrmv_rank_0 = rocsparse_cgebsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,c_loc(x), & beta,c_loc(y)) end function function rocsparse_cgebsrmv_rank_1(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsrmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_float_complex),target,dimension(:) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y ! rocsparse_cgebsrmv_rank_1 = rocsparse_cgebsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,c_loc(x), & beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zgebsrmv_assumed_rank(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsrmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_double_complex),target,contiguous,dimension(..) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y ! rocsparse_zgebsrmv_assumed_rank = rocsparse_zgebsrmv_(handle,dir,trans,mb,nb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim, & c_loc(x),beta,c_loc(y)) end function #else function rocsparse_zgebsrmv_rank_0(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsrmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_double_complex),target :: x complex(c_double_complex) :: beta complex(c_double_complex),target :: y ! rocsparse_zgebsrmv_rank_0 = rocsparse_zgebsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,c_loc(x), & beta,c_loc(y)) end function function rocsparse_zgebsrmv_rank_1(handle,dir,trans,mb,nb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsrmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: mb integer(c_int) :: nb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_double_complex),target,dimension(:) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y ! rocsparse_zgebsrmv_rank_1 = rocsparse_zgebsrmv_(handle,dir,trans,mb,nb,nnzb,alpha,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim,col_block_dim,c_loc(x), & beta,c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sgemvi_assumed_rank(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y, & idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgemvi_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: nnz real(c_float),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_sgemvi_assumed_rank = rocsparse_sgemvi_(handle,trans,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x_val),c_loc(x_ind),beta,c_loc(y),idx_base,temp_buffer) end function #else function rocsparse_sgemvi_rank_0(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y,idx_base, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgemvi_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda integer(c_int) :: nnz real(c_float),target :: x_val integer(c_int),target :: x_ind real(c_float) :: beta real(c_float),target :: y integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_sgemvi_rank_0 = rocsparse_sgemvi_(handle,trans,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x_val),c_loc(x_ind),beta,c_loc(y),idx_base,temp_buffer) end function function rocsparse_sgemvi_rank_1(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y,idx_base, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgemvi_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: nnz real(c_float),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_sgemvi_rank_1 = rocsparse_sgemvi_(handle,trans,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x_val),c_loc(x_ind),beta,c_loc(y),idx_base,temp_buffer) end function function rocsparse_sgemvi_full_rank(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y, & idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgemvi_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: nnz real(c_float),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind real(c_float) :: beta real(c_float),target,dimension(:) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_sgemvi_full_rank = rocsparse_sgemvi_(handle,trans,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x_val),c_loc(x_ind),beta,c_loc(y),idx_base,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dgemvi_assumed_rank(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y, & idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgemvi_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: nnz real(c_double),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_dgemvi_assumed_rank = rocsparse_dgemvi_(handle,trans,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x_val),c_loc(x_ind),beta,c_loc(y),idx_base,temp_buffer) end function #else function rocsparse_dgemvi_rank_0(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y,idx_base, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgemvi_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda integer(c_int) :: nnz real(c_double),target :: x_val integer(c_int),target :: x_ind real(c_double) :: beta real(c_double),target :: y integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_dgemvi_rank_0 = rocsparse_dgemvi_(handle,trans,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x_val),c_loc(x_ind),beta,c_loc(y),idx_base,temp_buffer) end function function rocsparse_dgemvi_rank_1(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y,idx_base, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgemvi_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: nnz real(c_double),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_dgemvi_rank_1 = rocsparse_dgemvi_(handle,trans,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x_val),c_loc(x_ind),beta,c_loc(y),idx_base,temp_buffer) end function function rocsparse_dgemvi_full_rank(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y, & idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgemvi_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: nnz real(c_double),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind real(c_double) :: beta real(c_double),target,dimension(:) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_dgemvi_full_rank = rocsparse_dgemvi_(handle,trans,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x_val),c_loc(x_ind),beta,c_loc(y),idx_base,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cgemvi_assumed_rank(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y, & idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgemvi_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: nnz complex(c_float_complex),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_cgemvi_assumed_rank = rocsparse_cgemvi_(handle,trans,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x_val),c_loc(x_ind),beta,c_loc(y),idx_base,temp_buffer) end function #else function rocsparse_cgemvi_rank_0(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y,idx_base, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgemvi_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda integer(c_int) :: nnz complex(c_float_complex),target :: x_val integer(c_int),target :: x_ind complex(c_float_complex) :: beta complex(c_float_complex),target :: y integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_cgemvi_rank_0 = rocsparse_cgemvi_(handle,trans,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x_val),c_loc(x_ind),beta,c_loc(y),idx_base,temp_buffer) end function function rocsparse_cgemvi_rank_1(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y,idx_base, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgemvi_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: nnz complex(c_float_complex),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_cgemvi_rank_1 = rocsparse_cgemvi_(handle,trans,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x_val),c_loc(x_ind),beta,c_loc(y),idx_base,temp_buffer) end function function rocsparse_cgemvi_full_rank(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y, & idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgemvi_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: nnz complex(c_float_complex),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_cgemvi_full_rank = rocsparse_cgemvi_(handle,trans,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x_val),c_loc(x_ind),beta,c_loc(y),idx_base,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zgemvi_assumed_rank(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y, & idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgemvi_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda integer(c_int) :: nnz complex(c_double_complex),target,contiguous,dimension(..) :: x_val integer(c_int),target,contiguous,dimension(..) :: x_ind complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_zgemvi_assumed_rank = rocsparse_zgemvi_(handle,trans,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x_val),c_loc(x_ind),beta,c_loc(y),idx_base,temp_buffer) end function #else function rocsparse_zgemvi_rank_0(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y,idx_base, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgemvi_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda integer(c_int) :: nnz complex(c_double_complex),target :: x_val integer(c_int),target :: x_ind complex(c_double_complex) :: beta complex(c_double_complex),target :: y integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_zgemvi_rank_0 = rocsparse_zgemvi_(handle,trans,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x_val),c_loc(x_ind),beta,c_loc(y),idx_base,temp_buffer) end function function rocsparse_zgemvi_rank_1(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y,idx_base, & temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgemvi_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda integer(c_int) :: nnz complex(c_double_complex),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_zgemvi_rank_1 = rocsparse_zgemvi_(handle,trans,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x_val),c_loc(x_ind),beta,c_loc(y),idx_base,temp_buffer) end function function rocsparse_zgemvi_full_rank(handle,trans,m,n,alpha,A,lda,nnz,x_val,x_ind,beta,y, & idx_base,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgemvi_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans integer(c_int) :: m integer(c_int) :: n complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda integer(c_int) :: nnz complex(c_double_complex),target,dimension(:) :: x_val integer(c_int),target,dimension(:) :: x_ind complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y integer(kind(rocsparse_index_base_zero)) :: idx_base type(c_ptr) :: temp_buffer ! rocsparse_zgemvi_full_rank = rocsparse_zgemvi_(handle,trans,m,n,alpha,c_loc(A),lda,nnz, & c_loc(x_val),c_loc(x_ind),beta,c_loc(y),idx_base,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_shybmv_assumed_rank(handle,trans,alpha,descr,hyb,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_shybmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans real(c_float) :: alpha type(c_ptr) :: descr type(c_ptr) :: hyb real(c_float),target,contiguous,dimension(..) :: x real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: y ! rocsparse_shybmv_assumed_rank = rocsparse_shybmv_(handle,trans,alpha,descr,hyb,c_loc(x), & beta,c_loc(y)) end function #else function rocsparse_shybmv_rank_0(handle,trans,alpha,descr,hyb,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_shybmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans real(c_float) :: alpha type(c_ptr) :: descr type(c_ptr) :: hyb real(c_float),target :: x real(c_float) :: beta real(c_float),target :: y ! rocsparse_shybmv_rank_0 = rocsparse_shybmv_(handle,trans,alpha,descr,hyb,c_loc(x),beta, & c_loc(y)) end function function rocsparse_shybmv_rank_1(handle,trans,alpha,descr,hyb,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_shybmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans real(c_float) :: alpha type(c_ptr) :: descr type(c_ptr) :: hyb real(c_float),target,dimension(:) :: x real(c_float) :: beta real(c_float),target,dimension(:) :: y ! rocsparse_shybmv_rank_1 = rocsparse_shybmv_(handle,trans,alpha,descr,hyb,c_loc(x),beta, & c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dhybmv_assumed_rank(handle,trans,alpha,descr,hyb,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dhybmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans real(c_double) :: alpha type(c_ptr) :: descr type(c_ptr) :: hyb real(c_double),target,contiguous,dimension(..) :: x real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: y ! rocsparse_dhybmv_assumed_rank = rocsparse_dhybmv_(handle,trans,alpha,descr,hyb,c_loc(x), & beta,c_loc(y)) end function #else function rocsparse_dhybmv_rank_0(handle,trans,alpha,descr,hyb,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dhybmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans real(c_double) :: alpha type(c_ptr) :: descr type(c_ptr) :: hyb real(c_double),target :: x real(c_double) :: beta real(c_double),target :: y ! rocsparse_dhybmv_rank_0 = rocsparse_dhybmv_(handle,trans,alpha,descr,hyb,c_loc(x),beta, & c_loc(y)) end function function rocsparse_dhybmv_rank_1(handle,trans,alpha,descr,hyb,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dhybmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans real(c_double) :: alpha type(c_ptr) :: descr type(c_ptr) :: hyb real(c_double),target,dimension(:) :: x real(c_double) :: beta real(c_double),target,dimension(:) :: y ! rocsparse_dhybmv_rank_1 = rocsparse_dhybmv_(handle,trans,alpha,descr,hyb,c_loc(x),beta, & c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_chybmv_assumed_rank(handle,trans,alpha,descr,hyb,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_chybmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans complex(c_float_complex) :: alpha type(c_ptr) :: descr type(c_ptr) :: hyb complex(c_float_complex),target,contiguous,dimension(..) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: y ! rocsparse_chybmv_assumed_rank = rocsparse_chybmv_(handle,trans,alpha,descr,hyb,c_loc(x), & beta,c_loc(y)) end function #else function rocsparse_chybmv_rank_0(handle,trans,alpha,descr,hyb,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_chybmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans complex(c_float_complex) :: alpha type(c_ptr) :: descr type(c_ptr) :: hyb complex(c_float_complex),target :: x complex(c_float_complex) :: beta complex(c_float_complex),target :: y ! rocsparse_chybmv_rank_0 = rocsparse_chybmv_(handle,trans,alpha,descr,hyb,c_loc(x),beta, & c_loc(y)) end function function rocsparse_chybmv_rank_1(handle,trans,alpha,descr,hyb,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_chybmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans complex(c_float_complex) :: alpha type(c_ptr) :: descr type(c_ptr) :: hyb complex(c_float_complex),target,dimension(:) :: x complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: y ! rocsparse_chybmv_rank_1 = rocsparse_chybmv_(handle,trans,alpha,descr,hyb,c_loc(x),beta, & c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zhybmv_assumed_rank(handle,trans,alpha,descr,hyb,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zhybmv_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans complex(c_double_complex) :: alpha type(c_ptr) :: descr type(c_ptr) :: hyb complex(c_double_complex),target,contiguous,dimension(..) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: y ! rocsparse_zhybmv_assumed_rank = rocsparse_zhybmv_(handle,trans,alpha,descr,hyb,c_loc(x), & beta,c_loc(y)) end function #else function rocsparse_zhybmv_rank_0(handle,trans,alpha,descr,hyb,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zhybmv_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans complex(c_double_complex) :: alpha type(c_ptr) :: descr type(c_ptr) :: hyb complex(c_double_complex),target :: x complex(c_double_complex) :: beta complex(c_double_complex),target :: y ! rocsparse_zhybmv_rank_0 = rocsparse_zhybmv_(handle,trans,alpha,descr,hyb,c_loc(x),beta, & c_loc(y)) end function function rocsparse_zhybmv_rank_1(handle,trans,alpha,descr,hyb,x,beta,y) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zhybmv_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans complex(c_double_complex) :: alpha type(c_ptr) :: descr type(c_ptr) :: hyb complex(c_double_complex),target,dimension(:) :: x complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: y ! rocsparse_zhybmv_rank_1 = rocsparse_zhybmv_(handle,trans,alpha,descr,hyb,c_loc(x),beta, & c_loc(y)) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sbsrmm_assumed_rank(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrmm_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsparse_sbsrmm_assumed_rank = rocsparse_sbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,c_loc(B),ldb, & beta,c_loc(C),ldc) end function #else function rocsparse_sbsrmm_rank_0(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrmm_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim real(c_float),target :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target :: C integer(c_int) :: ldc ! rocsparse_sbsrmm_rank_0 = rocsparse_sbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function function rocsparse_sbsrmm_rank_1(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrmm_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocsparse_sbsrmm_rank_1 = rocsparse_sbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function function rocsparse_sbsrmm_full_rank(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrmm_full_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsparse_sbsrmm_full_rank = rocsparse_sbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,c_loc(B),ldb, & beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dbsrmm_assumed_rank(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrmm_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsparse_dbsrmm_assumed_rank = rocsparse_dbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,c_loc(B),ldb, & beta,c_loc(C),ldc) end function #else function rocsparse_dbsrmm_rank_0(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrmm_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim real(c_double),target :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target :: C integer(c_int) :: ldc ! rocsparse_dbsrmm_rank_0 = rocsparse_dbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function function rocsparse_dbsrmm_rank_1(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrmm_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocsparse_dbsrmm_rank_1 = rocsparse_dbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function function rocsparse_dbsrmm_full_rank(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrmm_full_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsparse_dbsrmm_full_rank = rocsparse_dbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,c_loc(B),ldb, & beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cbsrmm_assumed_rank(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrmm_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsparse_cbsrmm_assumed_rank = rocsparse_cbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,c_loc(B),ldb, & beta,c_loc(C),ldc) end function #else function rocsparse_cbsrmm_rank_0(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrmm_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim complex(c_float_complex),target :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocsparse_cbsrmm_rank_0 = rocsparse_cbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function function rocsparse_cbsrmm_rank_1(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrmm_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsparse_cbsrmm_rank_1 = rocsparse_cbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function function rocsparse_cbsrmm_full_rank(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrmm_full_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsparse_cbsrmm_full_rank = rocsparse_cbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,c_loc(B),ldb, & beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zbsrmm_assumed_rank(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrmm_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsparse_zbsrmm_assumed_rank = rocsparse_zbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,c_loc(B),ldb, & beta,c_loc(C),ldc) end function #else function rocsparse_zbsrmm_rank_0(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrmm_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim complex(c_double_complex),target :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocsparse_zbsrmm_rank_0 = rocsparse_zbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function function rocsparse_zbsrmm_rank_1(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrmm_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsparse_zbsrmm_rank_1 = rocsparse_zbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,c_loc(B),ldb,beta, & c_loc(C),ldc) end function function rocsparse_zbsrmm_full_rank(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrmm_full_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsparse_zbsrmm_full_rank = rocsparse_zbsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,c_loc(B),ldb, & beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sbsrsm_buffer_size_assumed_rank(handle,dir,trans_A,trans_X,mb,nrhs,nnzb, & descr,bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsm_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_sbsrsm_buffer_size_assumed_rank = rocsparse_sbsrsm_buffer_size_(handle,dir, & trans_A,trans_X,mb,nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind), & block_dim,myInfo,buffer_size) end function #else function rocsparse_sbsrsm_buffer_size_rank_0(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsm_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_sbsrsm_buffer_size_rank_0 = rocsparse_sbsrsm_buffer_size_(handle,dir,trans_A, & trans_X,mb,nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,buffer_size) end function function rocsparse_sbsrsm_buffer_size_rank_1(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsm_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_sbsrsm_buffer_size_rank_1 = rocsparse_sbsrsm_buffer_size_(handle,dir,trans_A, & trans_X,mb,nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dbsrsm_buffer_size_assumed_rank(handle,dir,trans_A,trans_X,mb,nrhs,nnzb, & descr,bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsm_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dbsrsm_buffer_size_assumed_rank = rocsparse_dbsrsm_buffer_size_(handle,dir, & trans_A,trans_X,mb,nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind), & block_dim,myInfo,buffer_size) end function #else function rocsparse_dbsrsm_buffer_size_rank_0(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsm_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dbsrsm_buffer_size_rank_0 = rocsparse_dbsrsm_buffer_size_(handle,dir,trans_A, & trans_X,mb,nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,buffer_size) end function function rocsparse_dbsrsm_buffer_size_rank_1(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsm_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dbsrsm_buffer_size_rank_1 = rocsparse_dbsrsm_buffer_size_(handle,dir,trans_A, & trans_X,mb,nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cbsrsm_buffer_size_assumed_rank(handle,dir,trans_A,trans_X,mb,nrhs,nnzb, & descr,bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsm_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_cbsrsm_buffer_size_assumed_rank = rocsparse_cbsrsm_buffer_size_(handle,dir, & trans_A,trans_X,mb,nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind), & block_dim,myInfo,buffer_size) end function #else function rocsparse_cbsrsm_buffer_size_rank_0(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsm_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_cbsrsm_buffer_size_rank_0 = rocsparse_cbsrsm_buffer_size_(handle,dir,trans_A, & trans_X,mb,nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,buffer_size) end function function rocsparse_cbsrsm_buffer_size_rank_1(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsm_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_cbsrsm_buffer_size_rank_1 = rocsparse_cbsrsm_buffer_size_(handle,dir,trans_A, & trans_X,mb,nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zbsrsm_buffer_size_assumed_rank(handle,dir,trans_A,trans_X,mb,nrhs,nnzb, & descr,bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsm_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zbsrsm_buffer_size_assumed_rank = rocsparse_zbsrsm_buffer_size_(handle,dir, & trans_A,trans_X,mb,nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind), & block_dim,myInfo,buffer_size) end function #else function rocsparse_zbsrsm_buffer_size_rank_0(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsm_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zbsrsm_buffer_size_rank_0 = rocsparse_zbsrsm_buffer_size_(handle,dir,trans_A, & trans_X,mb,nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,buffer_size) end function function rocsparse_zbsrsm_buffer_size_rank_1(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsm_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zbsrsm_buffer_size_rank_1 = rocsparse_zbsrsm_buffer_size_(handle,dir,trans_A, & trans_X,mb,nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sbsrsm_analysis_assumed_rank(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsm_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_sbsrsm_analysis_assumed_rank = rocsparse_sbsrsm_analysis_(handle,dir,trans_A, & trans_X,mb,nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,analysis,solve,temp_buffer) end function #else function rocsparse_sbsrsm_analysis_rank_0(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsm_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_sbsrsm_analysis_rank_0 = rocsparse_sbsrsm_analysis_(handle,dir,trans_A,trans_X,mb, & nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & analysis,solve,temp_buffer) end function function rocsparse_sbsrsm_analysis_rank_1(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsm_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_sbsrsm_analysis_rank_1 = rocsparse_sbsrsm_analysis_(handle,dir,trans_A,trans_X,mb, & nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dbsrsm_analysis_assumed_rank(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsm_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dbsrsm_analysis_assumed_rank = rocsparse_dbsrsm_analysis_(handle,dir,trans_A, & trans_X,mb,nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,analysis,solve,temp_buffer) end function #else function rocsparse_dbsrsm_analysis_rank_0(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsm_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dbsrsm_analysis_rank_0 = rocsparse_dbsrsm_analysis_(handle,dir,trans_A,trans_X,mb, & nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & analysis,solve,temp_buffer) end function function rocsparse_dbsrsm_analysis_rank_1(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsm_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dbsrsm_analysis_rank_1 = rocsparse_dbsrsm_analysis_(handle,dir,trans_A,trans_X,mb, & nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cbsrsm_analysis_assumed_rank(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsm_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_cbsrsm_analysis_assumed_rank = rocsparse_cbsrsm_analysis_(handle,dir,trans_A, & trans_X,mb,nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,analysis,solve,temp_buffer) end function #else function rocsparse_cbsrsm_analysis_rank_0(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsm_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_cbsrsm_analysis_rank_0 = rocsparse_cbsrsm_analysis_(handle,dir,trans_A,trans_X,mb, & nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & analysis,solve,temp_buffer) end function function rocsparse_cbsrsm_analysis_rank_1(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsm_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_cbsrsm_analysis_rank_1 = rocsparse_cbsrsm_analysis_(handle,dir,trans_A,trans_X,mb, & nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zbsrsm_analysis_assumed_rank(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsm_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zbsrsm_analysis_assumed_rank = rocsparse_zbsrsm_analysis_(handle,dir,trans_A, & trans_X,mb,nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,analysis,solve,temp_buffer) end function #else function rocsparse_zbsrsm_analysis_rank_0(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsm_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zbsrsm_analysis_rank_0 = rocsparse_zbsrsm_analysis_(handle,dir,trans_A,trans_X,mb, & nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & analysis,solve,temp_buffer) end function function rocsparse_zbsrsm_analysis_rank_1(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsm_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zbsrsm_analysis_rank_1 = rocsparse_zbsrsm_analysis_(handle,dir,trans_A,trans_X,mb, & nrhs,nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sbsrsm_solve_assumed_rank(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha, & descr,bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsm_solve_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float),target,contiguous,dimension(..) :: X integer(c_int) :: ldx integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_sbsrsm_solve_assumed_rank = rocsparse_sbsrsm_solve_(handle,dir,trans_A,trans_X,mb, & nrhs,nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,temp_buffer) end function #else function rocsparse_sbsrsm_solve_rank_0(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsm_solve_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_float),target :: B integer(c_int) :: ldb real(c_float),target :: X integer(c_int) :: ldx integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_sbsrsm_solve_rank_0 = rocsparse_sbsrsm_solve_(handle,dir,trans_A,trans_X,mb,nrhs, & nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & c_loc(B),ldb,c_loc(X),ldx,policy,temp_buffer) end function function rocsparse_sbsrsm_solve_rank_1(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsm_solve_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:) :: X integer(c_int) :: ldx integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_sbsrsm_solve_rank_1 = rocsparse_sbsrsm_solve_(handle,dir,trans_A,trans_X,mb,nrhs, & nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & c_loc(B),ldb,c_loc(X),ldx,policy,temp_buffer) end function function rocsparse_sbsrsm_solve_full_rank(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrsm_solve_full_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float),target,dimension(:,:) :: X integer(c_int) :: ldx integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_sbsrsm_solve_full_rank = rocsparse_sbsrsm_solve_(handle,dir,trans_A,trans_X,mb, & nrhs,nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dbsrsm_solve_assumed_rank(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha, & descr,bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsm_solve_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double),target,contiguous,dimension(..) :: X integer(c_int) :: ldx integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dbsrsm_solve_assumed_rank = rocsparse_dbsrsm_solve_(handle,dir,trans_A,trans_X,mb, & nrhs,nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,temp_buffer) end function #else function rocsparse_dbsrsm_solve_rank_0(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsm_solve_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_double),target :: B integer(c_int) :: ldb real(c_double),target :: X integer(c_int) :: ldx integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dbsrsm_solve_rank_0 = rocsparse_dbsrsm_solve_(handle,dir,trans_A,trans_X,mb,nrhs, & nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & c_loc(B),ldb,c_loc(X),ldx,policy,temp_buffer) end function function rocsparse_dbsrsm_solve_rank_1(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsm_solve_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:) :: X integer(c_int) :: ldx integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dbsrsm_solve_rank_1 = rocsparse_dbsrsm_solve_(handle,dir,trans_A,trans_X,mb,nrhs, & nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & c_loc(B),ldb,c_loc(X),ldx,policy,temp_buffer) end function function rocsparse_dbsrsm_solve_full_rank(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrsm_solve_full_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double),target,dimension(:,:) :: X integer(c_int) :: ldx integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dbsrsm_solve_full_rank = rocsparse_dbsrsm_solve_(handle,dir,trans_A,trans_X,mb, & nrhs,nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cbsrsm_solve_assumed_rank(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha, & descr,bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsm_solve_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_float_complex),target,contiguous,dimension(..) :: X integer(c_int) :: ldx integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_cbsrsm_solve_assumed_rank = rocsparse_cbsrsm_solve_(handle,dir,trans_A,trans_X,mb, & nrhs,nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,temp_buffer) end function #else function rocsparse_cbsrsm_solve_rank_0(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsm_solve_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_float_complex),target :: B integer(c_int) :: ldb complex(c_float_complex),target :: X integer(c_int) :: ldx integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_cbsrsm_solve_rank_0 = rocsparse_cbsrsm_solve_(handle,dir,trans_A,trans_X,mb,nrhs, & nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & c_loc(B),ldb,c_loc(X),ldx,policy,temp_buffer) end function function rocsparse_cbsrsm_solve_rank_1(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsm_solve_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_float_complex),target,dimension(:) :: X integer(c_int) :: ldx integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_cbsrsm_solve_rank_1 = rocsparse_cbsrsm_solve_(handle,dir,trans_A,trans_X,mb,nrhs, & nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & c_loc(B),ldb,c_loc(X),ldx,policy,temp_buffer) end function function rocsparse_cbsrsm_solve_full_rank(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrsm_solve_full_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_float_complex),target,dimension(:,:) :: X integer(c_int) :: ldx integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_cbsrsm_solve_full_rank = rocsparse_cbsrsm_solve_(handle,dir,trans_A,trans_X,mb, & nrhs,nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zbsrsm_solve_assumed_rank(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha, & descr,bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsm_solve_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_double_complex),target,contiguous,dimension(..) :: X integer(c_int) :: ldx integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zbsrsm_solve_assumed_rank = rocsparse_zbsrsm_solve_(handle,dir,trans_A,trans_X,mb, & nrhs,nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,temp_buffer) end function #else function rocsparse_zbsrsm_solve_rank_0(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsm_solve_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_double_complex),target :: B integer(c_int) :: ldb complex(c_double_complex),target :: X integer(c_int) :: ldx integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zbsrsm_solve_rank_0 = rocsparse_zbsrsm_solve_(handle,dir,trans_A,trans_X,mb,nrhs, & nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & c_loc(B),ldb,c_loc(X),ldx,policy,temp_buffer) end function function rocsparse_zbsrsm_solve_rank_1(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsm_solve_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_double_complex),target,dimension(:) :: X integer(c_int) :: ldx integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zbsrsm_solve_rank_1 = rocsparse_zbsrsm_solve_(handle,dir,trans_A,trans_X,mb,nrhs, & nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & c_loc(B),ldb,c_loc(X),ldx,policy,temp_buffer) end function function rocsparse_zbsrsm_solve_full_rank(handle,dir,trans_A,trans_X,mb,nrhs,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,block_dim,myInfo,B,ldb,X,ldx,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrsm_solve_full_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_X integer(c_int) :: mb integer(c_int) :: nrhs integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_double_complex),target,dimension(:,:) :: X integer(c_int) :: ldx integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zbsrsm_solve_full_rank = rocsparse_zbsrsm_solve_(handle,dir,trans_A,trans_X,mb, & nrhs,nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim, & myInfo,c_loc(B),ldb,c_loc(X),ldx,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsrmm_assumed_rank(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrmm_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsparse_scsrmm_assumed_rank = rocsparse_scsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocsparse_scsrmm_rank_0(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrmm_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind real(c_float),target :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target :: C integer(c_int) :: ldc ! rocsparse_scsrmm_rank_0 = rocsparse_scsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocsparse_scsrmm_rank_1(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrmm_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocsparse_scsrmm_rank_1 = rocsparse_scsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocsparse_scsrmm_full_rank(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrmm_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsparse_scsrmm_full_rank = rocsparse_scsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsrmm_assumed_rank(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrmm_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsparse_dcsrmm_assumed_rank = rocsparse_dcsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocsparse_dcsrmm_rank_0(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrmm_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind real(c_double),target :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target :: C integer(c_int) :: ldc ! rocsparse_dcsrmm_rank_0 = rocsparse_dcsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocsparse_dcsrmm_rank_1(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrmm_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocsparse_dcsrmm_rank_1 = rocsparse_dcsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocsparse_dcsrmm_full_rank(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrmm_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsparse_dcsrmm_full_rank = rocsparse_dcsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsrmm_assumed_rank(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrmm_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsparse_ccsrmm_assumed_rank = rocsparse_ccsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocsparse_ccsrmm_rank_0(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrmm_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind complex(c_float_complex),target :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocsparse_ccsrmm_rank_0 = rocsparse_ccsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocsparse_ccsrmm_rank_1(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrmm_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsparse_ccsrmm_rank_1 = rocsparse_ccsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocsparse_ccsrmm_full_rank(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrmm_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsparse_ccsrmm_full_rank = rocsparse_ccsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsrmm_assumed_rank(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrmm_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsparse_zcsrmm_assumed_rank = rocsparse_zcsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocsparse_zcsrmm_rank_0(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrmm_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind complex(c_double_complex),target :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocsparse_zcsrmm_rank_0 = rocsparse_zcsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocsparse_zcsrmm_rank_1(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrmm_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsparse_zcsrmm_rank_1 = rocsparse_zcsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocsparse_zcsrmm_full_rank(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrmm_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsparse_zcsrmm_full_rank = rocsparse_zcsrmm_(handle,trans_A,trans_B,m,n,k,nnz,alpha,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsrsm_buffer_size_assumed_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha, & descr,csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsm_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy integer(c_size_t) :: buffer_size ! rocsparse_scsrsm_buffer_size_assumed_rank = rocsparse_scsrsm_buffer_size_(handle,trans_A, & trans_B,m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind), & c_loc(B),ldb,myInfo,policy,buffer_size) end function #else function rocsparse_scsrsm_buffer_size_rank_0(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsm_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind real(c_float),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy integer(c_size_t) :: buffer_size ! rocsparse_scsrsm_buffer_size_rank_0 = rocsparse_scsrsm_buffer_size_(handle,trans_A,trans_B, & m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb, & myInfo,policy,buffer_size) end function function rocsparse_scsrsm_buffer_size_rank_1(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsm_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_float),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy integer(c_size_t) :: buffer_size ! rocsparse_scsrsm_buffer_size_rank_1 = rocsparse_scsrsm_buffer_size_(handle,trans_A,trans_B, & m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb, & myInfo,policy,buffer_size) end function function rocsparse_scsrsm_buffer_size_full_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsm_buffer_size_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy integer(c_size_t) :: buffer_size ! rocsparse_scsrsm_buffer_size_full_rank = rocsparse_scsrsm_buffer_size_(handle,trans_A, & trans_B,m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind), & c_loc(B),ldb,myInfo,policy,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsrsm_buffer_size_assumed_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha, & descr,csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsm_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy integer(c_size_t) :: buffer_size ! rocsparse_dcsrsm_buffer_size_assumed_rank = rocsparse_dcsrsm_buffer_size_(handle,trans_A, & trans_B,m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind), & c_loc(B),ldb,myInfo,policy,buffer_size) end function #else function rocsparse_dcsrsm_buffer_size_rank_0(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsm_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind real(c_double),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy integer(c_size_t) :: buffer_size ! rocsparse_dcsrsm_buffer_size_rank_0 = rocsparse_dcsrsm_buffer_size_(handle,trans_A,trans_B, & m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb, & myInfo,policy,buffer_size) end function function rocsparse_dcsrsm_buffer_size_rank_1(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsm_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_double),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy integer(c_size_t) :: buffer_size ! rocsparse_dcsrsm_buffer_size_rank_1 = rocsparse_dcsrsm_buffer_size_(handle,trans_A,trans_B, & m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb, & myInfo,policy,buffer_size) end function function rocsparse_dcsrsm_buffer_size_full_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsm_buffer_size_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy integer(c_size_t) :: buffer_size ! rocsparse_dcsrsm_buffer_size_full_rank = rocsparse_dcsrsm_buffer_size_(handle,trans_A, & trans_B,m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind), & c_loc(B),ldb,myInfo,policy,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsrsm_buffer_size_assumed_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha, & descr,csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsm_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy integer(c_size_t) :: buffer_size ! rocsparse_ccsrsm_buffer_size_assumed_rank = rocsparse_ccsrsm_buffer_size_(handle,trans_A, & trans_B,m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind), & c_loc(B),ldb,myInfo,policy,buffer_size) end function #else function rocsparse_ccsrsm_buffer_size_rank_0(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsm_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind complex(c_float_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy integer(c_size_t) :: buffer_size ! rocsparse_ccsrsm_buffer_size_rank_0 = rocsparse_ccsrsm_buffer_size_(handle,trans_A,trans_B, & m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb, & myInfo,policy,buffer_size) end function function rocsparse_ccsrsm_buffer_size_rank_1(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsm_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy integer(c_size_t) :: buffer_size ! rocsparse_ccsrsm_buffer_size_rank_1 = rocsparse_ccsrsm_buffer_size_(handle,trans_A,trans_B, & m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb, & myInfo,policy,buffer_size) end function function rocsparse_ccsrsm_buffer_size_full_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsm_buffer_size_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy integer(c_size_t) :: buffer_size ! rocsparse_ccsrsm_buffer_size_full_rank = rocsparse_ccsrsm_buffer_size_(handle,trans_A, & trans_B,m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind), & c_loc(B),ldb,myInfo,policy,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsrsm_buffer_size_assumed_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha, & descr,csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsm_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy integer(c_size_t) :: buffer_size ! rocsparse_zcsrsm_buffer_size_assumed_rank = rocsparse_zcsrsm_buffer_size_(handle,trans_A, & trans_B,m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind), & c_loc(B),ldb,myInfo,policy,buffer_size) end function #else function rocsparse_zcsrsm_buffer_size_rank_0(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsm_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind complex(c_double_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy integer(c_size_t) :: buffer_size ! rocsparse_zcsrsm_buffer_size_rank_0 = rocsparse_zcsrsm_buffer_size_(handle,trans_A,trans_B, & m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb, & myInfo,policy,buffer_size) end function function rocsparse_zcsrsm_buffer_size_rank_1(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsm_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy integer(c_size_t) :: buffer_size ! rocsparse_zcsrsm_buffer_size_rank_1 = rocsparse_zcsrsm_buffer_size_(handle,trans_A,trans_B, & m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb, & myInfo,policy,buffer_size) end function function rocsparse_zcsrsm_buffer_size_full_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsm_buffer_size_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy integer(c_size_t) :: buffer_size ! rocsparse_zcsrsm_buffer_size_full_rank = rocsparse_zcsrsm_buffer_size_(handle,trans_A, & trans_B,m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind), & c_loc(B),ldb,myInfo,policy,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsrsm_analysis_assumed_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsm_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_scsrsm_analysis_assumed_rank = rocsparse_scsrsm_analysis_(handle,trans_A,trans_B, & m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb, & myInfo,analysis,solve,temp_buffer) end function #else function rocsparse_scsrsm_analysis_rank_0(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsm_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind real(c_float),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_scsrsm_analysis_rank_0 = rocsparse_scsrsm_analysis_(handle,trans_A,trans_B,m,nrhs, & nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & analysis,solve,temp_buffer) end function function rocsparse_scsrsm_analysis_rank_1(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsm_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_float),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_scsrsm_analysis_rank_1 = rocsparse_scsrsm_analysis_(handle,trans_A,trans_B,m,nrhs, & nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & analysis,solve,temp_buffer) end function function rocsparse_scsrsm_analysis_full_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsm_analysis_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_scsrsm_analysis_full_rank = rocsparse_scsrsm_analysis_(handle,trans_A,trans_B,m, & nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb, & myInfo,analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsrsm_analysis_assumed_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsm_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dcsrsm_analysis_assumed_rank = rocsparse_dcsrsm_analysis_(handle,trans_A,trans_B, & m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb, & myInfo,analysis,solve,temp_buffer) end function #else function rocsparse_dcsrsm_analysis_rank_0(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsm_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind real(c_double),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dcsrsm_analysis_rank_0 = rocsparse_dcsrsm_analysis_(handle,trans_A,trans_B,m,nrhs, & nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & analysis,solve,temp_buffer) end function function rocsparse_dcsrsm_analysis_rank_1(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsm_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_double),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dcsrsm_analysis_rank_1 = rocsparse_dcsrsm_analysis_(handle,trans_A,trans_B,m,nrhs, & nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & analysis,solve,temp_buffer) end function function rocsparse_dcsrsm_analysis_full_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsm_analysis_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dcsrsm_analysis_full_rank = rocsparse_dcsrsm_analysis_(handle,trans_A,trans_B,m, & nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb, & myInfo,analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsrsm_analysis_assumed_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsm_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_ccsrsm_analysis_assumed_rank = rocsparse_ccsrsm_analysis_(handle,trans_A,trans_B, & m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb, & myInfo,analysis,solve,temp_buffer) end function #else function rocsparse_ccsrsm_analysis_rank_0(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsm_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind complex(c_float_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_ccsrsm_analysis_rank_0 = rocsparse_ccsrsm_analysis_(handle,trans_A,trans_B,m,nrhs, & nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & analysis,solve,temp_buffer) end function function rocsparse_ccsrsm_analysis_rank_1(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsm_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_ccsrsm_analysis_rank_1 = rocsparse_ccsrsm_analysis_(handle,trans_A,trans_B,m,nrhs, & nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & analysis,solve,temp_buffer) end function function rocsparse_ccsrsm_analysis_full_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsm_analysis_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_ccsrsm_analysis_full_rank = rocsparse_ccsrsm_analysis_(handle,trans_A,trans_B,m, & nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb, & myInfo,analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsrsm_analysis_assumed_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsm_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zcsrsm_analysis_assumed_rank = rocsparse_zcsrsm_analysis_(handle,trans_A,trans_B, & m,nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb, & myInfo,analysis,solve,temp_buffer) end function #else function rocsparse_zcsrsm_analysis_rank_0(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsm_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind complex(c_double_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zcsrsm_analysis_rank_0 = rocsparse_zcsrsm_analysis_(handle,trans_A,trans_B,m,nrhs, & nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & analysis,solve,temp_buffer) end function function rocsparse_zcsrsm_analysis_rank_1(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsm_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zcsrsm_analysis_rank_1 = rocsparse_zcsrsm_analysis_(handle,trans_A,trans_B,m,nrhs, & nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & analysis,solve,temp_buffer) end function function rocsparse_zcsrsm_analysis_full_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsm_analysis_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zcsrsm_analysis_full_rank = rocsparse_zcsrsm_analysis_(handle,trans_A,trans_B,m, & nrhs,nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb, & myInfo,analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsrsm_solve_assumed_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsm_solve_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_scsrsm_solve_assumed_rank = rocsparse_scsrsm_solve_(handle,trans_A,trans_B,m,nrhs, & nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & policy,temp_buffer) end function #else function rocsparse_scsrsm_solve_rank_0(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsm_solve_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind real(c_float),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_scsrsm_solve_rank_0 = rocsparse_scsrsm_solve_(handle,trans_A,trans_B,m,nrhs,nnz, & alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & policy,temp_buffer) end function function rocsparse_scsrsm_solve_rank_1(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsm_solve_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_float),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_scsrsm_solve_rank_1 = rocsparse_scsrsm_solve_(handle,trans_A,trans_B,m,nrhs,nnz, & alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & policy,temp_buffer) end function function rocsparse_scsrsm_solve_full_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrsm_solve_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_scsrsm_solve_full_rank = rocsparse_scsrsm_solve_(handle,trans_A,trans_B,m,nrhs, & nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsrsm_solve_assumed_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsm_solve_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dcsrsm_solve_assumed_rank = rocsparse_dcsrsm_solve_(handle,trans_A,trans_B,m,nrhs, & nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & policy,temp_buffer) end function #else function rocsparse_dcsrsm_solve_rank_0(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsm_solve_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind real(c_double),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dcsrsm_solve_rank_0 = rocsparse_dcsrsm_solve_(handle,trans_A,trans_B,m,nrhs,nnz, & alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & policy,temp_buffer) end function function rocsparse_dcsrsm_solve_rank_1(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsm_solve_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_double),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dcsrsm_solve_rank_1 = rocsparse_dcsrsm_solve_(handle,trans_A,trans_B,m,nrhs,nnz, & alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & policy,temp_buffer) end function function rocsparse_dcsrsm_solve_full_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrsm_solve_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dcsrsm_solve_full_rank = rocsparse_dcsrsm_solve_(handle,trans_A,trans_B,m,nrhs, & nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsrsm_solve_assumed_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsm_solve_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_ccsrsm_solve_assumed_rank = rocsparse_ccsrsm_solve_(handle,trans_A,trans_B,m,nrhs, & nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & policy,temp_buffer) end function #else function rocsparse_ccsrsm_solve_rank_0(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsm_solve_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind complex(c_float_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_ccsrsm_solve_rank_0 = rocsparse_ccsrsm_solve_(handle,trans_A,trans_B,m,nrhs,nnz, & alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & policy,temp_buffer) end function function rocsparse_ccsrsm_solve_rank_1(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsm_solve_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_ccsrsm_solve_rank_1 = rocsparse_ccsrsm_solve_(handle,trans_A,trans_B,m,nrhs,nnz, & alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & policy,temp_buffer) end function function rocsparse_ccsrsm_solve_full_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrsm_solve_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_ccsrsm_solve_full_rank = rocsparse_ccsrsm_solve_(handle,trans_A,trans_B,m,nrhs, & nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsrsm_solve_assumed_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsm_solve_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zcsrsm_solve_assumed_rank = rocsparse_zcsrsm_solve_(handle,trans_A,trans_B,m,nrhs, & nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & policy,temp_buffer) end function #else function rocsparse_zcsrsm_solve_rank_0(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsm_solve_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind complex(c_double_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zcsrsm_solve_rank_0 = rocsparse_zcsrsm_solve_(handle,trans_A,trans_B,m,nrhs,nnz, & alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & policy,temp_buffer) end function function rocsparse_zcsrsm_solve_rank_1(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr,csr_val, & csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsm_solve_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zcsrsm_solve_rank_1 = rocsparse_zcsrsm_solve_(handle,trans_A,trans_B,m,nrhs,nnz, & alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & policy,temp_buffer) end function function rocsparse_zcsrsm_solve_full_rank(handle,trans_A,trans_B,m,nrhs,nnz,alpha,descr, & csr_val,csr_row_ptr,csr_col_ind,B,ldb,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrsm_solve_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: nrhs integer(c_int) :: nnz complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zcsrsm_solve_full_rank = rocsparse_zcsrsm_solve_(handle,trans_A,trans_B,m,nrhs, & nnz,alpha,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),c_loc(B),ldb,myInfo, & policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sgebsrmm_assumed_rank(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsrmm_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsparse_sgebsrmm_assumed_rank = rocsparse_sgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb, & nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocsparse_sgebsrmm_rank_0(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsrmm_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_float),target :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target :: C integer(c_int) :: ldc ! rocsparse_sgebsrmm_rank_0 = rocsparse_sgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocsparse_sgebsrmm_rank_1(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsrmm_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_float),target,dimension(:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocsparse_sgebsrmm_rank_1 = rocsparse_sgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocsparse_sgebsrmm_full_rank(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgebsrmm_full_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_float) :: alpha type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_float) :: beta real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsparse_sgebsrmm_full_rank = rocsparse_sgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dgebsrmm_assumed_rank(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsrmm_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsparse_dgebsrmm_assumed_rank = rocsparse_dgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb, & nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocsparse_dgebsrmm_rank_0(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsrmm_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_double),target :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target :: C integer(c_int) :: ldc ! rocsparse_dgebsrmm_rank_0 = rocsparse_dgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocsparse_dgebsrmm_rank_1(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsrmm_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_double),target,dimension(:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocsparse_dgebsrmm_rank_1 = rocsparse_dgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocsparse_dgebsrmm_full_rank(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgebsrmm_full_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb real(c_double) :: alpha type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb real(c_double) :: beta real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsparse_dgebsrmm_full_rank = rocsparse_dgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cgebsrmm_assumed_rank(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsrmm_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsparse_cgebsrmm_assumed_rank = rocsparse_cgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb, & nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocsparse_cgebsrmm_rank_0(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsrmm_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_float_complex),target :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocsparse_cgebsrmm_rank_0 = rocsparse_cgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocsparse_cgebsrmm_rank_1(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsrmm_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsparse_cgebsrmm_rank_1 = rocsparse_cgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocsparse_cgebsrmm_full_rank(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgebsrmm_full_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_float_complex) :: alpha type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsparse_cgebsrmm_full_rank = rocsparse_cgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zgebsrmm_assumed_rank(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsrmm_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsparse_zgebsrmm_assumed_rank = rocsparse_zgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb, & nnzb,alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,c_loc(B),ldb,beta,c_loc(C),ldc) end function #else function rocsparse_zgebsrmm_rank_0(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsrmm_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_double_complex),target :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocsparse_zgebsrmm_rank_0 = rocsparse_zgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocsparse_zgebsrmm_rank_1(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsrmm_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsparse_zgebsrmm_rank_1 = rocsparse_zgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,c_loc(B),ldb,beta,c_loc(C),ldc) end function function rocsparse_zgebsrmm_full_rank(handle,dir,trans_A,trans_B,mb,n,kb,nnzb,alpha,descr, & bsr_val,bsr_row_ptr,bsr_col_ind,row_block_dim,col_block_dim,B,ldb,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgebsrmm_full_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: mb integer(c_int) :: n integer(c_int) :: kb integer(c_int) :: nnzb complex(c_double_complex) :: alpha type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: row_block_dim integer(c_int) :: col_block_dim complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsparse_zgebsrmm_full_rank = rocsparse_zgebsrmm_(handle,dir,trans_A,trans_B,mb,n,kb,nnzb, & alpha,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),row_block_dim, & col_block_dim,c_loc(B),ldb,beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sgemmi_assumed_rank(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr, & csr_val,csr_row_ptr,csr_col_ind,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgemmi_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha real(c_float),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind real(c_float) :: beta real(c_float),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsparse_sgemmi_assumed_rank = rocsparse_sgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha, & c_loc(A),lda,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),beta,c_loc(C),ldc) end function #else function rocsparse_sgemmi_rank_0(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr,csr_val, & csr_row_ptr,csr_col_ind,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgemmi_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha real(c_float),target :: A integer(c_int) :: lda type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind real(c_float) :: beta real(c_float),target :: C integer(c_int) :: ldc ! rocsparse_sgemmi_rank_0 = rocsparse_sgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha,c_loc(A), & lda,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),beta,c_loc(C),ldc) end function function rocsparse_sgemmi_rank_1(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr,csr_val, & csr_row_ptr,csr_col_ind,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgemmi_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha real(c_float),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_float) :: beta real(c_float),target,dimension(:) :: C integer(c_int) :: ldc ! rocsparse_sgemmi_rank_1 = rocsparse_sgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha,c_loc(A), & lda,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),beta,c_loc(C),ldc) end function function rocsparse_sgemmi_full_rank(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr, & csr_val,csr_row_ptr,csr_col_ind,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgemmi_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_float) :: alpha real(c_float),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_float) :: beta real(c_float),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsparse_sgemmi_full_rank = rocsparse_sgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha, & c_loc(A),lda,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dgemmi_assumed_rank(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr, & csr_val,csr_row_ptr,csr_col_ind,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgemmi_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha real(c_double),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind real(c_double) :: beta real(c_double),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsparse_dgemmi_assumed_rank = rocsparse_dgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha, & c_loc(A),lda,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),beta,c_loc(C),ldc) end function #else function rocsparse_dgemmi_rank_0(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr,csr_val, & csr_row_ptr,csr_col_ind,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgemmi_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha real(c_double),target :: A integer(c_int) :: lda type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind real(c_double) :: beta real(c_double),target :: C integer(c_int) :: ldc ! rocsparse_dgemmi_rank_0 = rocsparse_dgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha,c_loc(A), & lda,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),beta,c_loc(C),ldc) end function function rocsparse_dgemmi_rank_1(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr,csr_val, & csr_row_ptr,csr_col_ind,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgemmi_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha real(c_double),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_double) :: beta real(c_double),target,dimension(:) :: C integer(c_int) :: ldc ! rocsparse_dgemmi_rank_1 = rocsparse_dgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha,c_loc(A), & lda,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),beta,c_loc(C),ldc) end function function rocsparse_dgemmi_full_rank(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr, & csr_val,csr_row_ptr,csr_col_ind,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgemmi_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz real(c_double) :: alpha real(c_double),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_double) :: beta real(c_double),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsparse_dgemmi_full_rank = rocsparse_dgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha, & c_loc(A),lda,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cgemmi_assumed_rank(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr, & csr_val,csr_row_ptr,csr_col_ind,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgemmi_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha complex(c_float_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind complex(c_float_complex) :: beta complex(c_float_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsparse_cgemmi_assumed_rank = rocsparse_cgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha, & c_loc(A),lda,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),beta,c_loc(C),ldc) end function #else function rocsparse_cgemmi_rank_0(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr,csr_val, & csr_row_ptr,csr_col_ind,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgemmi_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha complex(c_float_complex),target :: A integer(c_int) :: lda type(c_ptr) :: descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind complex(c_float_complex) :: beta complex(c_float_complex),target :: C integer(c_int) :: ldc ! rocsparse_cgemmi_rank_0 = rocsparse_cgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha,c_loc(A), & lda,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),beta,c_loc(C),ldc) end function function rocsparse_cgemmi_rank_1(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr,csr_val, & csr_row_ptr,csr_col_ind,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgemmi_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsparse_cgemmi_rank_1 = rocsparse_cgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha,c_loc(A), & lda,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),beta,c_loc(C),ldc) end function function rocsparse_cgemmi_full_rank(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr, & csr_val,csr_row_ptr,csr_col_ind,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgemmi_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_float_complex) :: alpha complex(c_float_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_float_complex) :: beta complex(c_float_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsparse_cgemmi_full_rank = rocsparse_cgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha, & c_loc(A),lda,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zgemmi_assumed_rank(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr, & csr_val,csr_row_ptr,csr_col_ind,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgemmi_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha complex(c_double_complex),target,contiguous,dimension(..) :: A integer(c_int) :: lda type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind complex(c_double_complex) :: beta complex(c_double_complex),target,contiguous,dimension(..) :: C integer(c_int) :: ldc ! rocsparse_zgemmi_assumed_rank = rocsparse_zgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha, & c_loc(A),lda,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),beta,c_loc(C),ldc) end function #else function rocsparse_zgemmi_rank_0(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr,csr_val, & csr_row_ptr,csr_col_ind,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgemmi_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha complex(c_double_complex),target :: A integer(c_int) :: lda type(c_ptr) :: descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind complex(c_double_complex) :: beta complex(c_double_complex),target :: C integer(c_int) :: ldc ! rocsparse_zgemmi_rank_0 = rocsparse_zgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha,c_loc(A), & lda,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),beta,c_loc(C),ldc) end function function rocsparse_zgemmi_rank_1(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr,csr_val, & csr_row_ptr,csr_col_ind,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgemmi_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:) :: A integer(c_int) :: lda type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:) :: C integer(c_int) :: ldc ! rocsparse_zgemmi_rank_1 = rocsparse_zgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha,c_loc(A), & lda,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),beta,c_loc(C),ldc) end function function rocsparse_zgemmi_full_rank(handle,trans_A,trans_B,m,n,k,nnz,alpha,A,lda,descr, & csr_val,csr_row_ptr,csr_col_ind,beta,C,ldc) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgemmi_full_rank type(c_ptr) :: handle integer(kind(rocsparse_operation_none)) :: trans_A integer(kind(rocsparse_operation_none)) :: trans_B integer(c_int) :: m integer(c_int) :: n integer(c_int) :: k integer(c_int) :: nnz complex(c_double_complex) :: alpha complex(c_double_complex),target,dimension(:,:) :: A integer(c_int) :: lda type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind complex(c_double_complex) :: beta complex(c_double_complex),target,dimension(:,:) :: C integer(c_int) :: ldc ! rocsparse_zgemmi_full_rank = rocsparse_zgemmi_(handle,trans_A,trans_B,m,n,k,nnz,alpha, & c_loc(A),lda,descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),beta,c_loc(C),ldc) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sbsric0_buffer_size_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsric0_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_sbsric0_buffer_size_assumed_rank = rocsparse_sbsric0_buffer_size_(handle,dir,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function #else function rocsparse_sbsric0_buffer_size_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsric0_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_sbsric0_buffer_size_rank_0 = rocsparse_sbsric0_buffer_size_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,buffer_size) end function function rocsparse_sbsric0_buffer_size_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsric0_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_sbsric0_buffer_size_rank_1 = rocsparse_sbsric0_buffer_size_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dbsric0_buffer_size_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsric0_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dbsric0_buffer_size_assumed_rank = rocsparse_dbsric0_buffer_size_(handle,dir,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function #else function rocsparse_dbsric0_buffer_size_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsric0_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dbsric0_buffer_size_rank_0 = rocsparse_dbsric0_buffer_size_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,buffer_size) end function function rocsparse_dbsric0_buffer_size_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsric0_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dbsric0_buffer_size_rank_1 = rocsparse_dbsric0_buffer_size_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cbsric0_buffer_size_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsric0_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_cbsric0_buffer_size_assumed_rank = rocsparse_cbsric0_buffer_size_(handle,dir,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function #else function rocsparse_cbsric0_buffer_size_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsric0_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_cbsric0_buffer_size_rank_0 = rocsparse_cbsric0_buffer_size_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,buffer_size) end function function rocsparse_cbsric0_buffer_size_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsric0_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_cbsric0_buffer_size_rank_1 = rocsparse_cbsric0_buffer_size_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zbsric0_buffer_size_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsric0_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zbsric0_buffer_size_assumed_rank = rocsparse_zbsric0_buffer_size_(handle,dir,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function #else function rocsparse_zbsric0_buffer_size_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsric0_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zbsric0_buffer_size_rank_0 = rocsparse_zbsric0_buffer_size_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,buffer_size) end function function rocsparse_zbsric0_buffer_size_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsric0_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zbsric0_buffer_size_rank_1 = rocsparse_zbsric0_buffer_size_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sbsric0_analysis_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsric0_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_sbsric0_analysis_assumed_rank = rocsparse_sbsric0_analysis_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function #else function rocsparse_sbsric0_analysis_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsric0_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_sbsric0_analysis_rank_0 = rocsparse_sbsric0_analysis_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis,solve, & temp_buffer) end function function rocsparse_sbsric0_analysis_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsric0_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_sbsric0_analysis_rank_1 = rocsparse_sbsric0_analysis_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis,solve, & temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dbsric0_analysis_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsric0_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dbsric0_analysis_assumed_rank = rocsparse_dbsric0_analysis_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function #else function rocsparse_dbsric0_analysis_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsric0_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dbsric0_analysis_rank_0 = rocsparse_dbsric0_analysis_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis,solve, & temp_buffer) end function function rocsparse_dbsric0_analysis_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsric0_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dbsric0_analysis_rank_1 = rocsparse_dbsric0_analysis_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis,solve, & temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cbsric0_analysis_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsric0_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_cbsric0_analysis_assumed_rank = rocsparse_cbsric0_analysis_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function #else function rocsparse_cbsric0_analysis_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsric0_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_cbsric0_analysis_rank_0 = rocsparse_cbsric0_analysis_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis,solve, & temp_buffer) end function function rocsparse_cbsric0_analysis_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsric0_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_cbsric0_analysis_rank_1 = rocsparse_cbsric0_analysis_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis,solve, & temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zbsric0_analysis_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsric0_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zbsric0_analysis_assumed_rank = rocsparse_zbsric0_analysis_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function #else function rocsparse_zbsric0_analysis_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsric0_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zbsric0_analysis_rank_0 = rocsparse_zbsric0_analysis_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis,solve, & temp_buffer) end function function rocsparse_zbsric0_analysis_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsric0_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zbsric0_analysis_rank_1 = rocsparse_zbsric0_analysis_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis,solve, & temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sbsric0_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsric0_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_sbsric0_assumed_rank = rocsparse_sbsric0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function #else function rocsparse_sbsric0_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsric0_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_sbsric0_rank_0 = rocsparse_sbsric0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function function rocsparse_sbsric0_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsric0_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_sbsric0_rank_1 = rocsparse_sbsric0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dbsric0_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsric0_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dbsric0_assumed_rank = rocsparse_dbsric0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function #else function rocsparse_dbsric0_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsric0_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dbsric0_rank_0 = rocsparse_dbsric0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function function rocsparse_dbsric0_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsric0_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dbsric0_rank_1 = rocsparse_dbsric0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cbsric0_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsric0_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_cbsric0_assumed_rank = rocsparse_cbsric0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function #else function rocsparse_cbsric0_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsric0_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_cbsric0_rank_0 = rocsparse_cbsric0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function function rocsparse_cbsric0_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsric0_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_cbsric0_rank_1 = rocsparse_cbsric0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zbsric0_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsric0_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zbsric0_assumed_rank = rocsparse_zbsric0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function #else function rocsparse_zbsric0_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsric0_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zbsric0_rank_0 = rocsparse_zbsric0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function function rocsparse_zbsric0_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsric0_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zbsric0_rank_1 = rocsparse_zbsric0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sbsrilu0_buffer_size_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrilu0_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_sbsrilu0_buffer_size_assumed_rank = rocsparse_sbsrilu0_buffer_size_(handle,dir,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function #else function rocsparse_sbsrilu0_buffer_size_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrilu0_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_sbsrilu0_buffer_size_rank_0 = rocsparse_sbsrilu0_buffer_size_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,buffer_size) end function function rocsparse_sbsrilu0_buffer_size_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrilu0_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_sbsrilu0_buffer_size_rank_1 = rocsparse_sbsrilu0_buffer_size_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dbsrilu0_buffer_size_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrilu0_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dbsrilu0_buffer_size_assumed_rank = rocsparse_dbsrilu0_buffer_size_(handle,dir,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function #else function rocsparse_dbsrilu0_buffer_size_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrilu0_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dbsrilu0_buffer_size_rank_0 = rocsparse_dbsrilu0_buffer_size_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,buffer_size) end function function rocsparse_dbsrilu0_buffer_size_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrilu0_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dbsrilu0_buffer_size_rank_1 = rocsparse_dbsrilu0_buffer_size_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cbsrilu0_buffer_size_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrilu0_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_cbsrilu0_buffer_size_assumed_rank = rocsparse_cbsrilu0_buffer_size_(handle,dir,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function #else function rocsparse_cbsrilu0_buffer_size_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrilu0_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_cbsrilu0_buffer_size_rank_0 = rocsparse_cbsrilu0_buffer_size_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,buffer_size) end function function rocsparse_cbsrilu0_buffer_size_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrilu0_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_cbsrilu0_buffer_size_rank_1 = rocsparse_cbsrilu0_buffer_size_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zbsrilu0_buffer_size_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrilu0_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zbsrilu0_buffer_size_assumed_rank = rocsparse_zbsrilu0_buffer_size_(handle,dir,mb, & nnzb,descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo, & buffer_size) end function #else function rocsparse_zbsrilu0_buffer_size_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrilu0_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zbsrilu0_buffer_size_rank_0 = rocsparse_zbsrilu0_buffer_size_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,buffer_size) end function function rocsparse_zbsrilu0_buffer_size_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrilu0_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zbsrilu0_buffer_size_rank_1 = rocsparse_zbsrilu0_buffer_size_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sbsrilu0_analysis_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrilu0_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_sbsrilu0_analysis_assumed_rank = rocsparse_sbsrilu0_analysis_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function #else function rocsparse_sbsrilu0_analysis_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrilu0_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_sbsrilu0_analysis_rank_0 = rocsparse_sbsrilu0_analysis_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis,solve, & temp_buffer) end function function rocsparse_sbsrilu0_analysis_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrilu0_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_sbsrilu0_analysis_rank_1 = rocsparse_sbsrilu0_analysis_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis,solve, & temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dbsrilu0_analysis_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrilu0_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dbsrilu0_analysis_assumed_rank = rocsparse_dbsrilu0_analysis_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function #else function rocsparse_dbsrilu0_analysis_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrilu0_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dbsrilu0_analysis_rank_0 = rocsparse_dbsrilu0_analysis_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis,solve, & temp_buffer) end function function rocsparse_dbsrilu0_analysis_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrilu0_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dbsrilu0_analysis_rank_1 = rocsparse_dbsrilu0_analysis_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis,solve, & temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cbsrilu0_analysis_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrilu0_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_cbsrilu0_analysis_assumed_rank = rocsparse_cbsrilu0_analysis_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function #else function rocsparse_cbsrilu0_analysis_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrilu0_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_cbsrilu0_analysis_rank_0 = rocsparse_cbsrilu0_analysis_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis,solve, & temp_buffer) end function function rocsparse_cbsrilu0_analysis_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrilu0_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_cbsrilu0_analysis_rank_1 = rocsparse_cbsrilu0_analysis_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis,solve, & temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zbsrilu0_analysis_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val, & bsr_row_ptr,bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrilu0_analysis_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zbsrilu0_analysis_assumed_rank = rocsparse_zbsrilu0_analysis_(handle,dir,mb,nnzb, & descr,c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis, & solve,temp_buffer) end function #else function rocsparse_zbsrilu0_analysis_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrilu0_analysis_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zbsrilu0_analysis_rank_0 = rocsparse_zbsrilu0_analysis_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis,solve, & temp_buffer) end function function rocsparse_zbsrilu0_analysis_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrilu0_analysis_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zbsrilu0_analysis_rank_1 = rocsparse_zbsrilu0_analysis_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,analysis,solve, & temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sbsrilu0_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrilu0_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_sbsrilu0_assumed_rank = rocsparse_sbsrilu0_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function #else function rocsparse_sbsrilu0_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrilu0_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_sbsrilu0_rank_0 = rocsparse_sbsrilu0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function function rocsparse_sbsrilu0_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sbsrilu0_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_float),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_sbsrilu0_rank_1 = rocsparse_sbsrilu0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dbsrilu0_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrilu0_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dbsrilu0_assumed_rank = rocsparse_dbsrilu0_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function #else function rocsparse_dbsrilu0_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrilu0_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dbsrilu0_rank_0 = rocsparse_dbsrilu0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function function rocsparse_dbsrilu0_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dbsrilu0_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr real(c_double),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dbsrilu0_rank_1 = rocsparse_dbsrilu0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cbsrilu0_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrilu0_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_cbsrilu0_assumed_rank = rocsparse_cbsrilu0_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function #else function rocsparse_cbsrilu0_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrilu0_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_cbsrilu0_rank_0 = rocsparse_cbsrilu0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function function rocsparse_cbsrilu0_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cbsrilu0_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_cbsrilu0_rank_1 = rocsparse_cbsrilu0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zbsrilu0_assumed_rank(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr, & bsr_col_ind,block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrilu0_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: bsr_val integer(c_int),target,contiguous,dimension(..) :: bsr_row_ptr integer(c_int),target,contiguous,dimension(..) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zbsrilu0_assumed_rank = rocsparse_zbsrilu0_(handle,dir,mb,nnzb,descr, & c_loc(bsr_val),c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function #else function rocsparse_zbsrilu0_rank_0(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrilu0_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target :: bsr_val integer(c_int),target :: bsr_row_ptr integer(c_int),target :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zbsrilu0_rank_0 = rocsparse_zbsrilu0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function function rocsparse_zbsrilu0_rank_1(handle,dir,mb,nnzb,descr,bsr_val,bsr_row_ptr,bsr_col_ind, & block_dim,myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zbsrilu0_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_direction_row)) :: dir integer(c_int) :: mb integer(c_int) :: nnzb type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: bsr_val integer(c_int),target,dimension(:) :: bsr_row_ptr integer(c_int),target,dimension(:) :: bsr_col_ind integer(c_int) :: block_dim type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zbsrilu0_rank_1 = rocsparse_zbsrilu0_(handle,dir,mb,nnzb,descr,c_loc(bsr_val), & c_loc(bsr_row_ptr),c_loc(bsr_col_ind),block_dim,myInfo,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsric0_buffer_size_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsric0_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_scsric0_buffer_size_assumed_rank = rocsparse_scsric0_buffer_size_(handle,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #else function rocsparse_scsric0_buffer_size_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsric0_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_scsric0_buffer_size_rank_0 = rocsparse_scsric0_buffer_size_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function function rocsparse_scsric0_buffer_size_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsric0_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_scsric0_buffer_size_rank_1 = rocsparse_scsric0_buffer_size_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsric0_buffer_size_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsric0_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dcsric0_buffer_size_assumed_rank = rocsparse_dcsric0_buffer_size_(handle,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #else function rocsparse_dcsric0_buffer_size_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsric0_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dcsric0_buffer_size_rank_0 = rocsparse_dcsric0_buffer_size_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function function rocsparse_dcsric0_buffer_size_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsric0_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dcsric0_buffer_size_rank_1 = rocsparse_dcsric0_buffer_size_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsric0_buffer_size_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsric0_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_ccsric0_buffer_size_assumed_rank = rocsparse_ccsric0_buffer_size_(handle,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #else function rocsparse_ccsric0_buffer_size_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsric0_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_ccsric0_buffer_size_rank_0 = rocsparse_ccsric0_buffer_size_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function function rocsparse_ccsric0_buffer_size_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsric0_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_ccsric0_buffer_size_rank_1 = rocsparse_ccsric0_buffer_size_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsric0_buffer_size_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsric0_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zcsric0_buffer_size_assumed_rank = rocsparse_zcsric0_buffer_size_(handle,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #else function rocsparse_zcsric0_buffer_size_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsric0_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zcsric0_buffer_size_rank_0 = rocsparse_zcsric0_buffer_size_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function function rocsparse_zcsric0_buffer_size_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsric0_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zcsric0_buffer_size_rank_1 = rocsparse_zcsric0_buffer_size_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsric0_analysis_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsric0_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_scsric0_analysis_assumed_rank = rocsparse_scsric0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #else function rocsparse_scsric0_analysis_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsric0_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_scsric0_analysis_rank_0 = rocsparse_scsric0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function function rocsparse_scsric0_analysis_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsric0_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_scsric0_analysis_rank_1 = rocsparse_scsric0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsric0_analysis_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsric0_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dcsric0_analysis_assumed_rank = rocsparse_dcsric0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #else function rocsparse_dcsric0_analysis_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsric0_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dcsric0_analysis_rank_0 = rocsparse_dcsric0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function function rocsparse_dcsric0_analysis_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsric0_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dcsric0_analysis_rank_1 = rocsparse_dcsric0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsric0_analysis_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsric0_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_ccsric0_analysis_assumed_rank = rocsparse_ccsric0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #else function rocsparse_ccsric0_analysis_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsric0_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_ccsric0_analysis_rank_0 = rocsparse_ccsric0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function function rocsparse_ccsric0_analysis_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsric0_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_ccsric0_analysis_rank_1 = rocsparse_ccsric0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsric0_analysis_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsric0_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zcsric0_analysis_assumed_rank = rocsparse_zcsric0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #else function rocsparse_zcsric0_analysis_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsric0_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zcsric0_analysis_rank_0 = rocsparse_zcsric0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function function rocsparse_zcsric0_analysis_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsric0_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zcsric0_analysis_rank_1 = rocsparse_zcsric0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsric0_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsric0_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_scsric0_assumed_rank = rocsparse_scsric0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function #else function rocsparse_scsric0_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo, & policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsric0_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_scsric0_rank_0 = rocsparse_scsric0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function function rocsparse_scsric0_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo, & policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsric0_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_scsric0_rank_1 = rocsparse_scsric0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsric0_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsric0_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dcsric0_assumed_rank = rocsparse_dcsric0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function #else function rocsparse_dcsric0_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo, & policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsric0_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dcsric0_rank_0 = rocsparse_dcsric0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function function rocsparse_dcsric0_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo, & policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsric0_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dcsric0_rank_1 = rocsparse_dcsric0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsric0_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsric0_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_ccsric0_assumed_rank = rocsparse_ccsric0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function #else function rocsparse_ccsric0_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo, & policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsric0_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_ccsric0_rank_0 = rocsparse_ccsric0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function function rocsparse_ccsric0_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo, & policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsric0_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_ccsric0_rank_1 = rocsparse_ccsric0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsric0_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsric0_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zcsric0_assumed_rank = rocsparse_zcsric0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function #else function rocsparse_zcsric0_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo, & policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsric0_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zcsric0_rank_0 = rocsparse_zcsric0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function function rocsparse_zcsric0_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo, & policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsric0_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zcsric0_rank_1 = rocsparse_zcsric0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsrilu0_buffer_size_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrilu0_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_scsrilu0_buffer_size_assumed_rank = rocsparse_scsrilu0_buffer_size_(handle,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #else function rocsparse_scsrilu0_buffer_size_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrilu0_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_scsrilu0_buffer_size_rank_0 = rocsparse_scsrilu0_buffer_size_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function function rocsparse_scsrilu0_buffer_size_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrilu0_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_scsrilu0_buffer_size_rank_1 = rocsparse_scsrilu0_buffer_size_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsrilu0_buffer_size_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrilu0_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dcsrilu0_buffer_size_assumed_rank = rocsparse_dcsrilu0_buffer_size_(handle,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #else function rocsparse_dcsrilu0_buffer_size_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrilu0_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dcsrilu0_buffer_size_rank_0 = rocsparse_dcsrilu0_buffer_size_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function function rocsparse_dcsrilu0_buffer_size_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrilu0_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_dcsrilu0_buffer_size_rank_1 = rocsparse_dcsrilu0_buffer_size_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsrilu0_buffer_size_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrilu0_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_ccsrilu0_buffer_size_assumed_rank = rocsparse_ccsrilu0_buffer_size_(handle,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #else function rocsparse_ccsrilu0_buffer_size_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrilu0_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_ccsrilu0_buffer_size_rank_0 = rocsparse_ccsrilu0_buffer_size_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function function rocsparse_ccsrilu0_buffer_size_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrilu0_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_ccsrilu0_buffer_size_rank_1 = rocsparse_ccsrilu0_buffer_size_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsrilu0_buffer_size_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrilu0_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zcsrilu0_buffer_size_assumed_rank = rocsparse_zcsrilu0_buffer_size_(handle,m,nnz, & descr,c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #else function rocsparse_zcsrilu0_buffer_size_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrilu0_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zcsrilu0_buffer_size_rank_0 = rocsparse_zcsrilu0_buffer_size_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function function rocsparse_zcsrilu0_buffer_size_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrilu0_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(c_size_t) :: buffer_size ! rocsparse_zcsrilu0_buffer_size_rank_1 = rocsparse_zcsrilu0_buffer_size_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsrilu0_analysis_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrilu0_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_scsrilu0_analysis_assumed_rank = rocsparse_scsrilu0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #else function rocsparse_scsrilu0_analysis_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrilu0_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_scsrilu0_analysis_rank_0 = rocsparse_scsrilu0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function function rocsparse_scsrilu0_analysis_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrilu0_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_scsrilu0_analysis_rank_1 = rocsparse_scsrilu0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsrilu0_analysis_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrilu0_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dcsrilu0_analysis_assumed_rank = rocsparse_dcsrilu0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #else function rocsparse_dcsrilu0_analysis_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrilu0_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dcsrilu0_analysis_rank_0 = rocsparse_dcsrilu0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function function rocsparse_dcsrilu0_analysis_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrilu0_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_dcsrilu0_analysis_rank_1 = rocsparse_dcsrilu0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsrilu0_analysis_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrilu0_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_ccsrilu0_analysis_assumed_rank = rocsparse_ccsrilu0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #else function rocsparse_ccsrilu0_analysis_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrilu0_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_ccsrilu0_analysis_rank_0 = rocsparse_ccsrilu0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function function rocsparse_ccsrilu0_analysis_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrilu0_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_ccsrilu0_analysis_rank_1 = rocsparse_ccsrilu0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsrilu0_analysis_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrilu0_analysis_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zcsrilu0_analysis_assumed_rank = rocsparse_zcsrilu0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #else function rocsparse_zcsrilu0_analysis_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrilu0_analysis_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zcsrilu0_analysis_rank_0 = rocsparse_zcsrilu0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function function rocsparse_zcsrilu0_analysis_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr, & csr_col_ind,myInfo,analysis,solve,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrilu0_analysis_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_analysis_policy_reuse)) :: analysis integer(kind(rocsparse_solve_policy_auto)) :: solve type(c_ptr) :: temp_buffer ! rocsparse_zcsrilu0_analysis_rank_1 = rocsparse_zcsrilu0_analysis_(handle,m,nnz,descr, & c_loc(csr_val),c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,analysis,solve,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsrilu0_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrilu0_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_scsrilu0_assumed_rank = rocsparse_scsrilu0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function #else function rocsparse_scsrilu0_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo, & policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrilu0_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_scsrilu0_rank_0 = rocsparse_scsrilu0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function function rocsparse_scsrilu0_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo, & policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrilu0_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_scsrilu0_rank_1 = rocsparse_scsrilu0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsrilu0_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrilu0_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dcsrilu0_assumed_rank = rocsparse_dcsrilu0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function #else function rocsparse_dcsrilu0_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo, & policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrilu0_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dcsrilu0_rank_0 = rocsparse_dcsrilu0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function function rocsparse_dcsrilu0_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo, & policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrilu0_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_dcsrilu0_rank_1 = rocsparse_dcsrilu0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsrilu0_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrilu0_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_ccsrilu0_assumed_rank = rocsparse_ccsrilu0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function #else function rocsparse_ccsrilu0_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo, & policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrilu0_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_ccsrilu0_rank_0 = rocsparse_ccsrilu0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function function rocsparse_ccsrilu0_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo, & policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrilu0_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_ccsrilu0_rank_1 = rocsparse_ccsrilu0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsrilu0_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & myInfo,policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrilu0_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zcsrilu0_assumed_rank = rocsparse_zcsrilu0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function #else function rocsparse_zcsrilu0_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo, & policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrilu0_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zcsrilu0_rank_0 = rocsparse_zcsrilu0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function function rocsparse_zcsrilu0_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind,myInfo, & policy,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrilu0_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind type(c_ptr) :: myInfo integer(kind(rocsparse_solve_policy_auto)) :: policy type(c_ptr) :: temp_buffer ! rocsparse_zcsrilu0_rank_1 = rocsparse_zcsrilu0_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),myInfo,policy,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sgpsv_interleaved_batch_buffer_size_assumed_rank(handle,alg,m,ds,dl,d,du, & dw,x,batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgpsv_interleaved_batch_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m real(c_float),target,contiguous,dimension(..) :: ds real(c_float),target,contiguous,dimension(..) :: dl real(c_float),target,contiguous,dimension(..) :: d real(c_float),target,contiguous,dimension(..) :: du real(c_float),target,contiguous,dimension(..) :: dw real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_sgpsv_interleaved_batch_buffer_size_assumed_rank = & rocsparse_sgpsv_interleaved_batch_buffer_size_(handle,alg,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride,buffer_size) end function #else function rocsparse_sgpsv_interleaved_batch_buffer_size_rank_0(handle,alg,m,ds,dl,d,du,dw,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgpsv_interleaved_batch_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m real(c_float),target :: ds real(c_float),target :: dl real(c_float),target :: d real(c_float),target :: du real(c_float),target :: dw real(c_float),target :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_sgpsv_interleaved_batch_buffer_size_rank_0 = & rocsparse_sgpsv_interleaved_batch_buffer_size_(handle,alg,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride,buffer_size) end function function rocsparse_sgpsv_interleaved_batch_buffer_size_rank_1(handle,alg,m,ds,dl,d,du,dw,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgpsv_interleaved_batch_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m real(c_float),target,dimension(:) :: ds real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:) :: dw real(c_float),target,dimension(:) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_sgpsv_interleaved_batch_buffer_size_rank_1 = & rocsparse_sgpsv_interleaved_batch_buffer_size_(handle,alg,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dgpsv_interleaved_batch_buffer_size_assumed_rank(handle,alg,m,ds,dl,d,du, & dw,x,batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgpsv_interleaved_batch_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m real(c_double),target,contiguous,dimension(..) :: ds real(c_double),target,contiguous,dimension(..) :: dl real(c_double),target,contiguous,dimension(..) :: d real(c_double),target,contiguous,dimension(..) :: du real(c_double),target,contiguous,dimension(..) :: dw real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_dgpsv_interleaved_batch_buffer_size_assumed_rank = & rocsparse_dgpsv_interleaved_batch_buffer_size_(handle,alg,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride,buffer_size) end function #else function rocsparse_dgpsv_interleaved_batch_buffer_size_rank_0(handle,alg,m,ds,dl,d,du,dw,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgpsv_interleaved_batch_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m real(c_double),target :: ds real(c_double),target :: dl real(c_double),target :: d real(c_double),target :: du real(c_double),target :: dw real(c_double),target :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_dgpsv_interleaved_batch_buffer_size_rank_0 = & rocsparse_dgpsv_interleaved_batch_buffer_size_(handle,alg,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride,buffer_size) end function function rocsparse_dgpsv_interleaved_batch_buffer_size_rank_1(handle,alg,m,ds,dl,d,du,dw,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgpsv_interleaved_batch_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m real(c_double),target,dimension(:) :: ds real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:) :: dw real(c_double),target,dimension(:) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_dgpsv_interleaved_batch_buffer_size_rank_1 = & rocsparse_dgpsv_interleaved_batch_buffer_size_(handle,alg,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cgpsv_interleaved_batch_buffer_size_assumed_rank(handle,alg,m,ds,dl,d,du, & dw,x,batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgpsv_interleaved_batch_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m complex(c_float_complex),target,contiguous,dimension(..) :: ds complex(c_float_complex),target,contiguous,dimension(..) :: dl complex(c_float_complex),target,contiguous,dimension(..) :: d complex(c_float_complex),target,contiguous,dimension(..) :: du complex(c_float_complex),target,contiguous,dimension(..) :: dw complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_cgpsv_interleaved_batch_buffer_size_assumed_rank = & rocsparse_cgpsv_interleaved_batch_buffer_size_(handle,alg,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride,buffer_size) end function #else function rocsparse_cgpsv_interleaved_batch_buffer_size_rank_0(handle,alg,m,ds,dl,d,du,dw,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgpsv_interleaved_batch_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m complex(c_float_complex),target :: ds complex(c_float_complex),target :: dl complex(c_float_complex),target :: d complex(c_float_complex),target :: du complex(c_float_complex),target :: dw complex(c_float_complex),target :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_cgpsv_interleaved_batch_buffer_size_rank_0 = & rocsparse_cgpsv_interleaved_batch_buffer_size_(handle,alg,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride,buffer_size) end function function rocsparse_cgpsv_interleaved_batch_buffer_size_rank_1(handle,alg,m,ds,dl,d,du,dw,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgpsv_interleaved_batch_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m complex(c_float_complex),target,dimension(:) :: ds complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:) :: dw complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_cgpsv_interleaved_batch_buffer_size_rank_1 = & rocsparse_cgpsv_interleaved_batch_buffer_size_(handle,alg,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zgpsv_interleaved_batch_buffer_size_assumed_rank(handle,alg,m,ds,dl,d,du, & dw,x,batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgpsv_interleaved_batch_buffer_size_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m complex(c_double_complex),target,contiguous,dimension(..) :: ds complex(c_double_complex),target,contiguous,dimension(..) :: dl complex(c_double_complex),target,contiguous,dimension(..) :: d complex(c_double_complex),target,contiguous,dimension(..) :: du complex(c_double_complex),target,contiguous,dimension(..) :: dw complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_zgpsv_interleaved_batch_buffer_size_assumed_rank = & rocsparse_zgpsv_interleaved_batch_buffer_size_(handle,alg,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride,buffer_size) end function #else function rocsparse_zgpsv_interleaved_batch_buffer_size_rank_0(handle,alg,m,ds,dl,d,du,dw,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgpsv_interleaved_batch_buffer_size_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m complex(c_double_complex),target :: ds complex(c_double_complex),target :: dl complex(c_double_complex),target :: d complex(c_double_complex),target :: du complex(c_double_complex),target :: dw complex(c_double_complex),target :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_zgpsv_interleaved_batch_buffer_size_rank_0 = & rocsparse_zgpsv_interleaved_batch_buffer_size_(handle,alg,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride,buffer_size) end function function rocsparse_zgpsv_interleaved_batch_buffer_size_rank_1(handle,alg,m,ds,dl,d,du,dw,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgpsv_interleaved_batch_buffer_size_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m complex(c_double_complex),target,dimension(:) :: ds complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:) :: dw complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_zgpsv_interleaved_batch_buffer_size_rank_1 = & rocsparse_zgpsv_interleaved_batch_buffer_size_(handle,alg,m,c_loc(ds),c_loc(dl),c_loc(d), & c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sgpsv_interleaved_batch_assumed_rank(handle,alg,m,ds,dl,d,du,dw,x, & batch_count,batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgpsv_interleaved_batch_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m real(c_float),target,contiguous,dimension(..) :: ds real(c_float),target,contiguous,dimension(..) :: dl real(c_float),target,contiguous,dimension(..) :: d real(c_float),target,contiguous,dimension(..) :: du real(c_float),target,contiguous,dimension(..) :: dw real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_sgpsv_interleaved_batch_assumed_rank = rocsparse_sgpsv_interleaved_batch_(handle, & alg,m,c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride, & temp_buffer) end function #else function rocsparse_sgpsv_interleaved_batch_rank_0(handle,alg,m,ds,dl,d,du,dw,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgpsv_interleaved_batch_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m real(c_float),target :: ds real(c_float),target :: dl real(c_float),target :: d real(c_float),target :: du real(c_float),target :: dw real(c_float),target :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_sgpsv_interleaved_batch_rank_0 = rocsparse_sgpsv_interleaved_batch_(handle,alg,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride, & temp_buffer) end function function rocsparse_sgpsv_interleaved_batch_rank_1(handle,alg,m,ds,dl,d,du,dw,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgpsv_interleaved_batch_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m real(c_float),target,dimension(:) :: ds real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:) :: dw real(c_float),target,dimension(:) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_sgpsv_interleaved_batch_rank_1 = rocsparse_sgpsv_interleaved_batch_(handle,alg,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride, & temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dgpsv_interleaved_batch_assumed_rank(handle,alg,m,ds,dl,d,du,dw,x, & batch_count,batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgpsv_interleaved_batch_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m real(c_double),target,contiguous,dimension(..) :: ds real(c_double),target,contiguous,dimension(..) :: dl real(c_double),target,contiguous,dimension(..) :: d real(c_double),target,contiguous,dimension(..) :: du real(c_double),target,contiguous,dimension(..) :: dw real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_dgpsv_interleaved_batch_assumed_rank = rocsparse_dgpsv_interleaved_batch_(handle, & alg,m,c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride, & temp_buffer) end function #else function rocsparse_dgpsv_interleaved_batch_rank_0(handle,alg,m,ds,dl,d,du,dw,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgpsv_interleaved_batch_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m real(c_double),target :: ds real(c_double),target :: dl real(c_double),target :: d real(c_double),target :: du real(c_double),target :: dw real(c_double),target :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_dgpsv_interleaved_batch_rank_0 = rocsparse_dgpsv_interleaved_batch_(handle,alg,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride, & temp_buffer) end function function rocsparse_dgpsv_interleaved_batch_rank_1(handle,alg,m,ds,dl,d,du,dw,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgpsv_interleaved_batch_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m real(c_double),target,dimension(:) :: ds real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:) :: dw real(c_double),target,dimension(:) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_dgpsv_interleaved_batch_rank_1 = rocsparse_dgpsv_interleaved_batch_(handle,alg,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride, & temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cgpsv_interleaved_batch_assumed_rank(handle,alg,m,ds,dl,d,du,dw,x, & batch_count,batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgpsv_interleaved_batch_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m complex(c_float_complex),target,contiguous,dimension(..) :: ds complex(c_float_complex),target,contiguous,dimension(..) :: dl complex(c_float_complex),target,contiguous,dimension(..) :: d complex(c_float_complex),target,contiguous,dimension(..) :: du complex(c_float_complex),target,contiguous,dimension(..) :: dw complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_cgpsv_interleaved_batch_assumed_rank = rocsparse_cgpsv_interleaved_batch_(handle, & alg,m,c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride, & temp_buffer) end function #else function rocsparse_cgpsv_interleaved_batch_rank_0(handle,alg,m,ds,dl,d,du,dw,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgpsv_interleaved_batch_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m complex(c_float_complex),target :: ds complex(c_float_complex),target :: dl complex(c_float_complex),target :: d complex(c_float_complex),target :: du complex(c_float_complex),target :: dw complex(c_float_complex),target :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_cgpsv_interleaved_batch_rank_0 = rocsparse_cgpsv_interleaved_batch_(handle,alg,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride, & temp_buffer) end function function rocsparse_cgpsv_interleaved_batch_rank_1(handle,alg,m,ds,dl,d,du,dw,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgpsv_interleaved_batch_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m complex(c_float_complex),target,dimension(:) :: ds complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:) :: dw complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_cgpsv_interleaved_batch_rank_1 = rocsparse_cgpsv_interleaved_batch_(handle,alg,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride, & temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zgpsv_interleaved_batch_assumed_rank(handle,alg,m,ds,dl,d,du,dw,x, & batch_count,batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgpsv_interleaved_batch_assumed_rank type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m complex(c_double_complex),target,contiguous,dimension(..) :: ds complex(c_double_complex),target,contiguous,dimension(..) :: dl complex(c_double_complex),target,contiguous,dimension(..) :: d complex(c_double_complex),target,contiguous,dimension(..) :: du complex(c_double_complex),target,contiguous,dimension(..) :: dw complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_zgpsv_interleaved_batch_assumed_rank = rocsparse_zgpsv_interleaved_batch_(handle, & alg,m,c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride, & temp_buffer) end function #else function rocsparse_zgpsv_interleaved_batch_rank_0(handle,alg,m,ds,dl,d,du,dw,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgpsv_interleaved_batch_rank_0 type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m complex(c_double_complex),target :: ds complex(c_double_complex),target :: dl complex(c_double_complex),target :: d complex(c_double_complex),target :: du complex(c_double_complex),target :: dw complex(c_double_complex),target :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_zgpsv_interleaved_batch_rank_0 = rocsparse_zgpsv_interleaved_batch_(handle,alg,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride, & temp_buffer) end function function rocsparse_zgpsv_interleaved_batch_rank_1(handle,alg,m,ds,dl,d,du,dw,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgpsv_interleaved_batch_rank_1 type(c_ptr) :: handle integer(kind(rocsparse_gpsv_interleaved_alg_default)) :: alg integer(c_int) :: m complex(c_double_complex),target,dimension(:) :: ds complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:) :: dw complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_zgpsv_interleaved_batch_rank_1 = rocsparse_zgpsv_interleaved_batch_(handle,alg,m, & c_loc(ds),c_loc(dl),c_loc(d),c_loc(du),c_loc(dw),c_loc(x),batch_count,batch_stride, & temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sgtsv_buffer_size_assumed_rank(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: dl real(c_float),target,contiguous,dimension(..) :: d real(c_float),target,contiguous,dimension(..) :: du real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_sgtsv_buffer_size_assumed_rank = rocsparse_sgtsv_buffer_size_(handle,m,n, & c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function #else function rocsparse_sgtsv_buffer_size_rank_0(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: dl real(c_float),target :: d real(c_float),target :: du real(c_float),target :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_sgtsv_buffer_size_rank_0 = rocsparse_sgtsv_buffer_size_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function function rocsparse_sgtsv_buffer_size_rank_1(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_sgtsv_buffer_size_rank_1 = rocsparse_sgtsv_buffer_size_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function function rocsparse_sgtsv_buffer_size_full_rank(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_buffer_size_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_sgtsv_buffer_size_full_rank = rocsparse_sgtsv_buffer_size_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dgtsv_buffer_size_assumed_rank(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: dl real(c_double),target,contiguous,dimension(..) :: d real(c_double),target,contiguous,dimension(..) :: du real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_dgtsv_buffer_size_assumed_rank = rocsparse_dgtsv_buffer_size_(handle,m,n, & c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function #else function rocsparse_dgtsv_buffer_size_rank_0(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: dl real(c_double),target :: d real(c_double),target :: du real(c_double),target :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_dgtsv_buffer_size_rank_0 = rocsparse_dgtsv_buffer_size_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function function rocsparse_dgtsv_buffer_size_rank_1(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_dgtsv_buffer_size_rank_1 = rocsparse_dgtsv_buffer_size_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function function rocsparse_dgtsv_buffer_size_full_rank(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_buffer_size_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_dgtsv_buffer_size_full_rank = rocsparse_dgtsv_buffer_size_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cgtsv_buffer_size_assumed_rank(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: dl complex(c_float_complex),target,contiguous,dimension(..) :: d complex(c_float_complex),target,contiguous,dimension(..) :: du complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_cgtsv_buffer_size_assumed_rank = rocsparse_cgtsv_buffer_size_(handle,m,n, & c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function #else function rocsparse_cgtsv_buffer_size_rank_0(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: dl complex(c_float_complex),target :: d complex(c_float_complex),target :: du complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_cgtsv_buffer_size_rank_0 = rocsparse_cgtsv_buffer_size_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function function rocsparse_cgtsv_buffer_size_rank_1(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_cgtsv_buffer_size_rank_1 = rocsparse_cgtsv_buffer_size_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function function rocsparse_cgtsv_buffer_size_full_rank(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_buffer_size_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_cgtsv_buffer_size_full_rank = rocsparse_cgtsv_buffer_size_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zgtsv_buffer_size_assumed_rank(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: dl complex(c_double_complex),target,contiguous,dimension(..) :: d complex(c_double_complex),target,contiguous,dimension(..) :: du complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_zgtsv_buffer_size_assumed_rank = rocsparse_zgtsv_buffer_size_(handle,m,n, & c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function #else function rocsparse_zgtsv_buffer_size_rank_0(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: dl complex(c_double_complex),target :: d complex(c_double_complex),target :: du complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_zgtsv_buffer_size_rank_0 = rocsparse_zgtsv_buffer_size_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function function rocsparse_zgtsv_buffer_size_rank_1(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_zgtsv_buffer_size_rank_1 = rocsparse_zgtsv_buffer_size_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function function rocsparse_zgtsv_buffer_size_full_rank(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_buffer_size_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_zgtsv_buffer_size_full_rank = rocsparse_zgtsv_buffer_size_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sgtsv_assumed_rank(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: dl real(c_float),target,contiguous,dimension(..) :: d real(c_float),target,contiguous,dimension(..) :: du real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_sgtsv_assumed_rank = rocsparse_sgtsv_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du), & c_loc(B),ldb,temp_buffer) end function #else function rocsparse_sgtsv_rank_0(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: dl real(c_float),target :: d real(c_float),target :: du real(c_float),target :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_sgtsv_rank_0 = rocsparse_sgtsv_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B), & ldb,temp_buffer) end function function rocsparse_sgtsv_rank_1(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_sgtsv_rank_1 = rocsparse_sgtsv_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B), & ldb,temp_buffer) end function function rocsparse_sgtsv_full_rank(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_sgtsv_full_rank = rocsparse_sgtsv_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du), & c_loc(B),ldb,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dgtsv_assumed_rank(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: dl real(c_double),target,contiguous,dimension(..) :: d real(c_double),target,contiguous,dimension(..) :: du real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_dgtsv_assumed_rank = rocsparse_dgtsv_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du), & c_loc(B),ldb,temp_buffer) end function #else function rocsparse_dgtsv_rank_0(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: dl real(c_double),target :: d real(c_double),target :: du real(c_double),target :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_dgtsv_rank_0 = rocsparse_dgtsv_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B), & ldb,temp_buffer) end function function rocsparse_dgtsv_rank_1(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_dgtsv_rank_1 = rocsparse_dgtsv_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B), & ldb,temp_buffer) end function function rocsparse_dgtsv_full_rank(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_dgtsv_full_rank = rocsparse_dgtsv_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du), & c_loc(B),ldb,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cgtsv_assumed_rank(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: dl complex(c_float_complex),target,contiguous,dimension(..) :: d complex(c_float_complex),target,contiguous,dimension(..) :: du complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_cgtsv_assumed_rank = rocsparse_cgtsv_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du), & c_loc(B),ldb,temp_buffer) end function #else function rocsparse_cgtsv_rank_0(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: dl complex(c_float_complex),target :: d complex(c_float_complex),target :: du complex(c_float_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_cgtsv_rank_0 = rocsparse_cgtsv_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B), & ldb,temp_buffer) end function function rocsparse_cgtsv_rank_1(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_cgtsv_rank_1 = rocsparse_cgtsv_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B), & ldb,temp_buffer) end function function rocsparse_cgtsv_full_rank(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_cgtsv_full_rank = rocsparse_cgtsv_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du), & c_loc(B),ldb,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zgtsv_assumed_rank(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: dl complex(c_double_complex),target,contiguous,dimension(..) :: d complex(c_double_complex),target,contiguous,dimension(..) :: du complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_zgtsv_assumed_rank = rocsparse_zgtsv_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du), & c_loc(B),ldb,temp_buffer) end function #else function rocsparse_zgtsv_rank_0(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: dl complex(c_double_complex),target :: d complex(c_double_complex),target :: du complex(c_double_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_zgtsv_rank_0 = rocsparse_zgtsv_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B), & ldb,temp_buffer) end function function rocsparse_zgtsv_rank_1(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_zgtsv_rank_1 = rocsparse_zgtsv_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B), & ldb,temp_buffer) end function function rocsparse_zgtsv_full_rank(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_zgtsv_full_rank = rocsparse_zgtsv_(handle,m,n,c_loc(dl),c_loc(d),c_loc(du), & c_loc(B),ldb,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sgtsv_no_pivot_buffer_size_assumed_rank(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_no_pivot_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: dl real(c_float),target,contiguous,dimension(..) :: d real(c_float),target,contiguous,dimension(..) :: du real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_sgtsv_no_pivot_buffer_size_assumed_rank = rocsparse_sgtsv_no_pivot_buffer_size_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function #else function rocsparse_sgtsv_no_pivot_buffer_size_rank_0(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_no_pivot_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: dl real(c_float),target :: d real(c_float),target :: du real(c_float),target :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_sgtsv_no_pivot_buffer_size_rank_0 = rocsparse_sgtsv_no_pivot_buffer_size_(handle, & m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function function rocsparse_sgtsv_no_pivot_buffer_size_rank_1(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_no_pivot_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_sgtsv_no_pivot_buffer_size_rank_1 = rocsparse_sgtsv_no_pivot_buffer_size_(handle, & m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function function rocsparse_sgtsv_no_pivot_buffer_size_full_rank(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_no_pivot_buffer_size_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_sgtsv_no_pivot_buffer_size_full_rank = rocsparse_sgtsv_no_pivot_buffer_size_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dgtsv_no_pivot_buffer_size_assumed_rank(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_no_pivot_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: dl real(c_double),target,contiguous,dimension(..) :: d real(c_double),target,contiguous,dimension(..) :: du real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_dgtsv_no_pivot_buffer_size_assumed_rank = rocsparse_dgtsv_no_pivot_buffer_size_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function #else function rocsparse_dgtsv_no_pivot_buffer_size_rank_0(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_no_pivot_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: dl real(c_double),target :: d real(c_double),target :: du real(c_double),target :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_dgtsv_no_pivot_buffer_size_rank_0 = rocsparse_dgtsv_no_pivot_buffer_size_(handle, & m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function function rocsparse_dgtsv_no_pivot_buffer_size_rank_1(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_no_pivot_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_dgtsv_no_pivot_buffer_size_rank_1 = rocsparse_dgtsv_no_pivot_buffer_size_(handle, & m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function function rocsparse_dgtsv_no_pivot_buffer_size_full_rank(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_no_pivot_buffer_size_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_dgtsv_no_pivot_buffer_size_full_rank = rocsparse_dgtsv_no_pivot_buffer_size_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cgtsv_no_pivot_buffer_size_assumed_rank(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_no_pivot_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: dl complex(c_float_complex),target,contiguous,dimension(..) :: d complex(c_float_complex),target,contiguous,dimension(..) :: du complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_cgtsv_no_pivot_buffer_size_assumed_rank = rocsparse_cgtsv_no_pivot_buffer_size_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function #else function rocsparse_cgtsv_no_pivot_buffer_size_rank_0(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_no_pivot_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: dl complex(c_float_complex),target :: d complex(c_float_complex),target :: du complex(c_float_complex),target :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_cgtsv_no_pivot_buffer_size_rank_0 = rocsparse_cgtsv_no_pivot_buffer_size_(handle, & m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function function rocsparse_cgtsv_no_pivot_buffer_size_rank_1(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_no_pivot_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_cgtsv_no_pivot_buffer_size_rank_1 = rocsparse_cgtsv_no_pivot_buffer_size_(handle, & m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function function rocsparse_cgtsv_no_pivot_buffer_size_full_rank(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_no_pivot_buffer_size_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_cgtsv_no_pivot_buffer_size_full_rank = rocsparse_cgtsv_no_pivot_buffer_size_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zgtsv_no_pivot_buffer_size_assumed_rank(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_no_pivot_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: dl complex(c_double_complex),target,contiguous,dimension(..) :: d complex(c_double_complex),target,contiguous,dimension(..) :: du complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_zgtsv_no_pivot_buffer_size_assumed_rank = rocsparse_zgtsv_no_pivot_buffer_size_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function #else function rocsparse_zgtsv_no_pivot_buffer_size_rank_0(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_no_pivot_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: dl complex(c_double_complex),target :: d complex(c_double_complex),target :: du complex(c_double_complex),target :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_zgtsv_no_pivot_buffer_size_rank_0 = rocsparse_zgtsv_no_pivot_buffer_size_(handle, & m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function function rocsparse_zgtsv_no_pivot_buffer_size_rank_1(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_no_pivot_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_zgtsv_no_pivot_buffer_size_rank_1 = rocsparse_zgtsv_no_pivot_buffer_size_(handle, & m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function function rocsparse_zgtsv_no_pivot_buffer_size_full_rank(handle,m,n,dl,d,du,B,ldb,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_no_pivot_buffer_size_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb integer(c_size_t) :: buffer_size ! rocsparse_zgtsv_no_pivot_buffer_size_full_rank = rocsparse_zgtsv_no_pivot_buffer_size_( & handle,m,n,c_loc(dl),c_loc(d),c_loc(du),c_loc(B),ldb,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sgtsv_no_pivot_assumed_rank(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_no_pivot_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,contiguous,dimension(..) :: dl real(c_float),target,contiguous,dimension(..) :: d real(c_float),target,contiguous,dimension(..) :: du real(c_float),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_sgtsv_no_pivot_assumed_rank = rocsparse_sgtsv_no_pivot_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,temp_buffer) end function #else function rocsparse_sgtsv_no_pivot_rank_0(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_no_pivot_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target :: dl real(c_float),target :: d real(c_float),target :: du real(c_float),target :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_sgtsv_no_pivot_rank_0 = rocsparse_sgtsv_no_pivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,temp_buffer) end function function rocsparse_sgtsv_no_pivot_rank_1(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_no_pivot_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_sgtsv_no_pivot_rank_1 = rocsparse_sgtsv_no_pivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,temp_buffer) end function function rocsparse_sgtsv_no_pivot_full_rank(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_no_pivot_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_sgtsv_no_pivot_full_rank = rocsparse_sgtsv_no_pivot_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dgtsv_no_pivot_assumed_rank(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_no_pivot_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,contiguous,dimension(..) :: dl real(c_double),target,contiguous,dimension(..) :: d real(c_double),target,contiguous,dimension(..) :: du real(c_double),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_dgtsv_no_pivot_assumed_rank = rocsparse_dgtsv_no_pivot_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,temp_buffer) end function #else function rocsparse_dgtsv_no_pivot_rank_0(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_no_pivot_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target :: dl real(c_double),target :: d real(c_double),target :: du real(c_double),target :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_dgtsv_no_pivot_rank_0 = rocsparse_dgtsv_no_pivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,temp_buffer) end function function rocsparse_dgtsv_no_pivot_rank_1(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_no_pivot_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_dgtsv_no_pivot_rank_1 = rocsparse_dgtsv_no_pivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,temp_buffer) end function function rocsparse_dgtsv_no_pivot_full_rank(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_no_pivot_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_dgtsv_no_pivot_full_rank = rocsparse_dgtsv_no_pivot_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cgtsv_no_pivot_assumed_rank(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_no_pivot_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,contiguous,dimension(..) :: dl complex(c_float_complex),target,contiguous,dimension(..) :: d complex(c_float_complex),target,contiguous,dimension(..) :: du complex(c_float_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_cgtsv_no_pivot_assumed_rank = rocsparse_cgtsv_no_pivot_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,temp_buffer) end function #else function rocsparse_cgtsv_no_pivot_rank_0(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_no_pivot_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target :: dl complex(c_float_complex),target :: d complex(c_float_complex),target :: du complex(c_float_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_cgtsv_no_pivot_rank_0 = rocsparse_cgtsv_no_pivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,temp_buffer) end function function rocsparse_cgtsv_no_pivot_rank_1(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_no_pivot_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_cgtsv_no_pivot_rank_1 = rocsparse_cgtsv_no_pivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,temp_buffer) end function function rocsparse_cgtsv_no_pivot_full_rank(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_no_pivot_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_cgtsv_no_pivot_full_rank = rocsparse_cgtsv_no_pivot_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zgtsv_no_pivot_assumed_rank(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_no_pivot_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,contiguous,dimension(..) :: dl complex(c_double_complex),target,contiguous,dimension(..) :: d complex(c_double_complex),target,contiguous,dimension(..) :: du complex(c_double_complex),target,contiguous,dimension(..) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_zgtsv_no_pivot_assumed_rank = rocsparse_zgtsv_no_pivot_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,temp_buffer) end function #else function rocsparse_zgtsv_no_pivot_rank_0(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_no_pivot_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target :: dl complex(c_double_complex),target :: d complex(c_double_complex),target :: du complex(c_double_complex),target :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_zgtsv_no_pivot_rank_0 = rocsparse_zgtsv_no_pivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,temp_buffer) end function function rocsparse_zgtsv_no_pivot_rank_1(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_no_pivot_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_zgtsv_no_pivot_rank_1 = rocsparse_zgtsv_no_pivot_(handle,m,n,c_loc(dl),c_loc(d), & c_loc(du),c_loc(B),ldb,temp_buffer) end function function rocsparse_zgtsv_no_pivot_full_rank(handle,m,n,dl,d,du,B,ldb,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_no_pivot_full_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: n complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:,:) :: B integer(c_int) :: ldb type(c_ptr) :: temp_buffer ! rocsparse_zgtsv_no_pivot_full_rank = rocsparse_zgtsv_no_pivot_(handle,m,n,c_loc(dl), & c_loc(d),c_loc(du),c_loc(B),ldb,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sgtsv_no_pivot_strided_batch_buffer_size_assumed_rank(handle,m,dl,d,du,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_no_pivot_strided_batch_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m real(c_float),target,contiguous,dimension(..) :: dl real(c_float),target,contiguous,dimension(..) :: d real(c_float),target,contiguous,dimension(..) :: du real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_sgtsv_no_pivot_strided_batch_buffer_size_assumed_rank = & rocsparse_sgtsv_no_pivot_strided_batch_buffer_size_(handle,m,c_loc(dl),c_loc(d),c_loc(du), & c_loc(x),batch_count,batch_stride,buffer_size) end function #else function rocsparse_sgtsv_no_pivot_strided_batch_buffer_size_rank_0(handle,m,dl,d,du,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_no_pivot_strided_batch_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m real(c_float),target :: dl real(c_float),target :: d real(c_float),target :: du real(c_float),target :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_sgtsv_no_pivot_strided_batch_buffer_size_rank_0 = & rocsparse_sgtsv_no_pivot_strided_batch_buffer_size_(handle,m,c_loc(dl),c_loc(d),c_loc(du), & c_loc(x),batch_count,batch_stride,buffer_size) end function function rocsparse_sgtsv_no_pivot_strided_batch_buffer_size_rank_1(handle,m,dl,d,du,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_no_pivot_strided_batch_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_sgtsv_no_pivot_strided_batch_buffer_size_rank_1 = & rocsparse_sgtsv_no_pivot_strided_batch_buffer_size_(handle,m,c_loc(dl),c_loc(d),c_loc(du), & c_loc(x),batch_count,batch_stride,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dgtsv_no_pivot_strided_batch_buffer_size_assumed_rank(handle,m,dl,d,du,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_no_pivot_strided_batch_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m real(c_double),target,contiguous,dimension(..) :: dl real(c_double),target,contiguous,dimension(..) :: d real(c_double),target,contiguous,dimension(..) :: du real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_dgtsv_no_pivot_strided_batch_buffer_size_assumed_rank = & rocsparse_dgtsv_no_pivot_strided_batch_buffer_size_(handle,m,c_loc(dl),c_loc(d),c_loc(du), & c_loc(x),batch_count,batch_stride,buffer_size) end function #else function rocsparse_dgtsv_no_pivot_strided_batch_buffer_size_rank_0(handle,m,dl,d,du,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_no_pivot_strided_batch_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m real(c_double),target :: dl real(c_double),target :: d real(c_double),target :: du real(c_double),target :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_dgtsv_no_pivot_strided_batch_buffer_size_rank_0 = & rocsparse_dgtsv_no_pivot_strided_batch_buffer_size_(handle,m,c_loc(dl),c_loc(d),c_loc(du), & c_loc(x),batch_count,batch_stride,buffer_size) end function function rocsparse_dgtsv_no_pivot_strided_batch_buffer_size_rank_1(handle,m,dl,d,du,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_no_pivot_strided_batch_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_dgtsv_no_pivot_strided_batch_buffer_size_rank_1 = & rocsparse_dgtsv_no_pivot_strided_batch_buffer_size_(handle,m,c_loc(dl),c_loc(d),c_loc(du), & c_loc(x),batch_count,batch_stride,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cgtsv_no_pivot_strided_batch_buffer_size_assumed_rank(handle,m,dl,d,du,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_no_pivot_strided_batch_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m complex(c_float_complex),target,contiguous,dimension(..) :: dl complex(c_float_complex),target,contiguous,dimension(..) :: d complex(c_float_complex),target,contiguous,dimension(..) :: du complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_cgtsv_no_pivot_strided_batch_buffer_size_assumed_rank = & rocsparse_cgtsv_no_pivot_strided_batch_buffer_size_(handle,m,c_loc(dl),c_loc(d),c_loc(du), & c_loc(x),batch_count,batch_stride,buffer_size) end function #else function rocsparse_cgtsv_no_pivot_strided_batch_buffer_size_rank_0(handle,m,dl,d,du,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_no_pivot_strided_batch_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m complex(c_float_complex),target :: dl complex(c_float_complex),target :: d complex(c_float_complex),target :: du complex(c_float_complex),target :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_cgtsv_no_pivot_strided_batch_buffer_size_rank_0 = & rocsparse_cgtsv_no_pivot_strided_batch_buffer_size_(handle,m,c_loc(dl),c_loc(d),c_loc(du), & c_loc(x),batch_count,batch_stride,buffer_size) end function function rocsparse_cgtsv_no_pivot_strided_batch_buffer_size_rank_1(handle,m,dl,d,du,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_no_pivot_strided_batch_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_cgtsv_no_pivot_strided_batch_buffer_size_rank_1 = & rocsparse_cgtsv_no_pivot_strided_batch_buffer_size_(handle,m,c_loc(dl),c_loc(d),c_loc(du), & c_loc(x),batch_count,batch_stride,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zgtsv_no_pivot_strided_batch_buffer_size_assumed_rank(handle,m,dl,d,du,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_no_pivot_strided_batch_buffer_size_assumed_rank type(c_ptr) :: handle integer(c_int) :: m complex(c_double_complex),target,contiguous,dimension(..) :: dl complex(c_double_complex),target,contiguous,dimension(..) :: d complex(c_double_complex),target,contiguous,dimension(..) :: du complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_zgtsv_no_pivot_strided_batch_buffer_size_assumed_rank = & rocsparse_zgtsv_no_pivot_strided_batch_buffer_size_(handle,m,c_loc(dl),c_loc(d),c_loc(du), & c_loc(x),batch_count,batch_stride,buffer_size) end function #else function rocsparse_zgtsv_no_pivot_strided_batch_buffer_size_rank_0(handle,m,dl,d,du,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_no_pivot_strided_batch_buffer_size_rank_0 type(c_ptr) :: handle integer(c_int) :: m complex(c_double_complex),target :: dl complex(c_double_complex),target :: d complex(c_double_complex),target :: du complex(c_double_complex),target :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_zgtsv_no_pivot_strided_batch_buffer_size_rank_0 = & rocsparse_zgtsv_no_pivot_strided_batch_buffer_size_(handle,m,c_loc(dl),c_loc(d),c_loc(du), & c_loc(x),batch_count,batch_stride,buffer_size) end function function rocsparse_zgtsv_no_pivot_strided_batch_buffer_size_rank_1(handle,m,dl,d,du,x, & batch_count,batch_stride,buffer_size) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_no_pivot_strided_batch_buffer_size_rank_1 type(c_ptr) :: handle integer(c_int) :: m complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride integer(c_size_t) :: buffer_size ! rocsparse_zgtsv_no_pivot_strided_batch_buffer_size_rank_1 = & rocsparse_zgtsv_no_pivot_strided_batch_buffer_size_(handle,m,c_loc(dl),c_loc(d),c_loc(du), & c_loc(x),batch_count,batch_stride,buffer_size) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_sgtsv_no_pivot_strided_batch_assumed_rank(handle,m,dl,d,du,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_no_pivot_strided_batch_assumed_rank type(c_ptr) :: handle integer(c_int) :: m real(c_float),target,contiguous,dimension(..) :: dl real(c_float),target,contiguous,dimension(..) :: d real(c_float),target,contiguous,dimension(..) :: du real(c_float),target,contiguous,dimension(..) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_sgtsv_no_pivot_strided_batch_assumed_rank = & rocsparse_sgtsv_no_pivot_strided_batch_(handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x), & batch_count,batch_stride,temp_buffer) end function #else function rocsparse_sgtsv_no_pivot_strided_batch_rank_0(handle,m,dl,d,du,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_no_pivot_strided_batch_rank_0 type(c_ptr) :: handle integer(c_int) :: m real(c_float),target :: dl real(c_float),target :: d real(c_float),target :: du real(c_float),target :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_sgtsv_no_pivot_strided_batch_rank_0 = rocsparse_sgtsv_no_pivot_strided_batch_( & handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x),batch_count,batch_stride,temp_buffer) end function function rocsparse_sgtsv_no_pivot_strided_batch_rank_1(handle,m,dl,d,du,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_sgtsv_no_pivot_strided_batch_rank_1 type(c_ptr) :: handle integer(c_int) :: m real(c_float),target,dimension(:) :: dl real(c_float),target,dimension(:) :: d real(c_float),target,dimension(:) :: du real(c_float),target,dimension(:) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_sgtsv_no_pivot_strided_batch_rank_1 = rocsparse_sgtsv_no_pivot_strided_batch_( & handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x),batch_count,batch_stride,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dgtsv_no_pivot_strided_batch_assumed_rank(handle,m,dl,d,du,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_no_pivot_strided_batch_assumed_rank type(c_ptr) :: handle integer(c_int) :: m real(c_double),target,contiguous,dimension(..) :: dl real(c_double),target,contiguous,dimension(..) :: d real(c_double),target,contiguous,dimension(..) :: du real(c_double),target,contiguous,dimension(..) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_dgtsv_no_pivot_strided_batch_assumed_rank = & rocsparse_dgtsv_no_pivot_strided_batch_(handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x), & batch_count,batch_stride,temp_buffer) end function #else function rocsparse_dgtsv_no_pivot_strided_batch_rank_0(handle,m,dl,d,du,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_no_pivot_strided_batch_rank_0 type(c_ptr) :: handle integer(c_int) :: m real(c_double),target :: dl real(c_double),target :: d real(c_double),target :: du real(c_double),target :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_dgtsv_no_pivot_strided_batch_rank_0 = rocsparse_dgtsv_no_pivot_strided_batch_( & handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x),batch_count,batch_stride,temp_buffer) end function function rocsparse_dgtsv_no_pivot_strided_batch_rank_1(handle,m,dl,d,du,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dgtsv_no_pivot_strided_batch_rank_1 type(c_ptr) :: handle integer(c_int) :: m real(c_double),target,dimension(:) :: dl real(c_double),target,dimension(:) :: d real(c_double),target,dimension(:) :: du real(c_double),target,dimension(:) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_dgtsv_no_pivot_strided_batch_rank_1 = rocsparse_dgtsv_no_pivot_strided_batch_( & handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x),batch_count,batch_stride,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_cgtsv_no_pivot_strided_batch_assumed_rank(handle,m,dl,d,du,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_no_pivot_strided_batch_assumed_rank type(c_ptr) :: handle integer(c_int) :: m complex(c_float_complex),target,contiguous,dimension(..) :: dl complex(c_float_complex),target,contiguous,dimension(..) :: d complex(c_float_complex),target,contiguous,dimension(..) :: du complex(c_float_complex),target,contiguous,dimension(..) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_cgtsv_no_pivot_strided_batch_assumed_rank = & rocsparse_cgtsv_no_pivot_strided_batch_(handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x), & batch_count,batch_stride,temp_buffer) end function #else function rocsparse_cgtsv_no_pivot_strided_batch_rank_0(handle,m,dl,d,du,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_no_pivot_strided_batch_rank_0 type(c_ptr) :: handle integer(c_int) :: m complex(c_float_complex),target :: dl complex(c_float_complex),target :: d complex(c_float_complex),target :: du complex(c_float_complex),target :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_cgtsv_no_pivot_strided_batch_rank_0 = rocsparse_cgtsv_no_pivot_strided_batch_( & handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x),batch_count,batch_stride,temp_buffer) end function function rocsparse_cgtsv_no_pivot_strided_batch_rank_1(handle,m,dl,d,du,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_cgtsv_no_pivot_strided_batch_rank_1 type(c_ptr) :: handle integer(c_int) :: m complex(c_float_complex),target,dimension(:) :: dl complex(c_float_complex),target,dimension(:) :: d complex(c_float_complex),target,dimension(:) :: du complex(c_float_complex),target,dimension(:) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_cgtsv_no_pivot_strided_batch_rank_1 = rocsparse_cgtsv_no_pivot_strided_batch_( & handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x),batch_count,batch_stride,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zgtsv_no_pivot_strided_batch_assumed_rank(handle,m,dl,d,du,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_no_pivot_strided_batch_assumed_rank type(c_ptr) :: handle integer(c_int) :: m complex(c_double_complex),target,contiguous,dimension(..) :: dl complex(c_double_complex),target,contiguous,dimension(..) :: d complex(c_double_complex),target,contiguous,dimension(..) :: du complex(c_double_complex),target,contiguous,dimension(..) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_zgtsv_no_pivot_strided_batch_assumed_rank = & rocsparse_zgtsv_no_pivot_strided_batch_(handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x), & batch_count,batch_stride,temp_buffer) end function #else function rocsparse_zgtsv_no_pivot_strided_batch_rank_0(handle,m,dl,d,du,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_no_pivot_strided_batch_rank_0 type(c_ptr) :: handle integer(c_int) :: m complex(c_double_complex),target :: dl complex(c_double_complex),target :: d complex(c_double_complex),target :: du complex(c_double_complex),target :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_zgtsv_no_pivot_strided_batch_rank_0 = rocsparse_zgtsv_no_pivot_strided_batch_( & handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x),batch_count,batch_stride,temp_buffer) end function function rocsparse_zgtsv_no_pivot_strided_batch_rank_1(handle,m,dl,d,du,x,batch_count, & batch_stride,temp_buffer) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zgtsv_no_pivot_strided_batch_rank_1 type(c_ptr) :: handle integer(c_int) :: m complex(c_double_complex),target,dimension(:) :: dl complex(c_double_complex),target,dimension(:) :: d complex(c_double_complex),target,dimension(:) :: du complex(c_double_complex),target,dimension(:) :: x integer(c_int) :: batch_count integer(c_int) :: batch_stride type(c_ptr) :: temp_buffer ! rocsparse_zgtsv_no_pivot_strided_batch_rank_1 = rocsparse_zgtsv_no_pivot_strided_batch_( & handle,m,c_loc(dl),c_loc(d),c_loc(du),c_loc(x),batch_count,batch_stride,temp_buffer) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_scsrcolor_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & fraction_to_color,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrcolor_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind real(c_float) :: fraction_to_color integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! rocsparse_scsrcolor_assumed_rank = rocsparse_scsrcolor_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),fraction_to_color,ncolors,coloring,reordering,myInfo) end function #else function rocsparse_scsrcolor_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & fraction_to_color,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrcolor_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind real(c_float) :: fraction_to_color integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! rocsparse_scsrcolor_rank_0 = rocsparse_scsrcolor_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),fraction_to_color,ncolors,coloring,reordering,myInfo) end function function rocsparse_scsrcolor_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & fraction_to_color,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_scsrcolor_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_float),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_float) :: fraction_to_color integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! rocsparse_scsrcolor_rank_1 = rocsparse_scsrcolor_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),fraction_to_color,ncolors,coloring,reordering,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_dcsrcolor_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & fraction_to_color,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrcolor_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind real(c_double) :: fraction_to_color integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! rocsparse_dcsrcolor_assumed_rank = rocsparse_dcsrcolor_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),fraction_to_color,ncolors,coloring,reordering,myInfo) end function #else function rocsparse_dcsrcolor_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & fraction_to_color,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrcolor_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind real(c_double) :: fraction_to_color integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! rocsparse_dcsrcolor_rank_0 = rocsparse_dcsrcolor_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),fraction_to_color,ncolors,coloring,reordering,myInfo) end function function rocsparse_dcsrcolor_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & fraction_to_color,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_dcsrcolor_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr real(c_double),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_double) :: fraction_to_color integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! rocsparse_dcsrcolor_rank_1 = rocsparse_dcsrcolor_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),fraction_to_color,ncolors,coloring,reordering,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_ccsrcolor_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & fraction_to_color,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrcolor_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind real(c_float) :: fraction_to_color integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! rocsparse_ccsrcolor_assumed_rank = rocsparse_ccsrcolor_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),fraction_to_color,ncolors,coloring,reordering,myInfo) end function #else function rocsparse_ccsrcolor_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & fraction_to_color,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrcolor_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind real(c_float) :: fraction_to_color integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! rocsparse_ccsrcolor_rank_0 = rocsparse_ccsrcolor_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),fraction_to_color,ncolors,coloring,reordering,myInfo) end function function rocsparse_ccsrcolor_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & fraction_to_color,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_ccsrcolor_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_float_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_float) :: fraction_to_color integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! rocsparse_ccsrcolor_rank_1 = rocsparse_ccsrcolor_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),fraction_to_color,ncolors,coloring,reordering,myInfo) end function #endif #ifdef USE_ASSUMED_RANK_INTERFACES function rocsparse_zcsrcolor_assumed_rank(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & fraction_to_color,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrcolor_assumed_rank type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,contiguous,dimension(..) :: csr_val integer(c_int),target,contiguous,dimension(..) :: csr_row_ptr integer(c_int),target,contiguous,dimension(..) :: csr_col_ind real(c_double) :: fraction_to_color integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! rocsparse_zcsrcolor_assumed_rank = rocsparse_zcsrcolor_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),fraction_to_color,ncolors,coloring,reordering,myInfo) end function #else function rocsparse_zcsrcolor_rank_0(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & fraction_to_color,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrcolor_rank_0 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target :: csr_val integer(c_int),target :: csr_row_ptr integer(c_int),target :: csr_col_ind real(c_double) :: fraction_to_color integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! rocsparse_zcsrcolor_rank_0 = rocsparse_zcsrcolor_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),fraction_to_color,ncolors,coloring,reordering,myInfo) end function function rocsparse_zcsrcolor_rank_1(handle,m,nnz,descr,csr_val,csr_row_ptr,csr_col_ind, & fraction_to_color,ncolors,coloring,reordering,myInfo) use iso_c_binding use hipfort_rocsparse_enums implicit none integer(kind(rocsparse_status_success)) :: rocsparse_zcsrcolor_rank_1 type(c_ptr) :: handle integer(c_int) :: m integer(c_int) :: nnz type(c_ptr) :: descr complex(c_double_complex),target,dimension(:) :: csr_val integer(c_int),target,dimension(:) :: csr_row_ptr integer(c_int),target,dimension(:) :: csr_col_ind real(c_double) :: fraction_to_color integer(c_int) :: ncolors integer(c_int) :: coloring integer(c_int) :: reordering type(c_ptr) :: myInfo ! rocsparse_zcsrcolor_rank_1 = rocsparse_zcsrcolor_(handle,m,nnz,descr,c_loc(csr_val), & c_loc(csr_row_ptr),c_loc(csr_col_ind),fraction_to_color,ncolors,coloring,reordering,myInfo) end function #endif #endif end module hipfort_rocsparse hipfort-rocm-10.0.0/lib/hipfort/hipfort_rocsparse_enums.F90000066400000000000000000000447361524740623400236720ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_rocsparse_enums use, intrinsic :: iso_c_binding implicit none ! rocsparse_operation_ enum, bind(c) enumerator :: rocsparse_operation_none = 111 enumerator :: rocsparse_operation_transpose = 112 enumerator :: rocsparse_operation_conjugate_transpose = 113 end enum ! rocsparse_index_base_ enum, bind(c) enumerator :: rocsparse_index_base_zero = 0 enumerator :: rocsparse_index_base_one = 1 end enum ! rocsparse_matrix_type_ enum, bind(c) enumerator :: rocsparse_matrix_type_general = 0 enumerator :: rocsparse_matrix_type_symmetric = 1 enumerator :: rocsparse_matrix_type_hermitian = 2 enumerator :: rocsparse_matrix_type_triangular = 3 end enum ! rocsparse_diag_type_ enum, bind(c) enumerator :: rocsparse_diag_type_non_unit = 0 enumerator :: rocsparse_diag_type_unit = 1 end enum ! rocsparse_fill_mode_ enum, bind(c) enumerator :: rocsparse_fill_mode_lower = 0 enumerator :: rocsparse_fill_mode_upper = 1 end enum ! rocsparse_storage_mode_ enum, bind(c) enumerator :: rocsparse_storage_mode_sorted = 0 enumerator :: rocsparse_storage_mode_unsorted = 1 end enum ! rocsparse_action_ enum, bind(c) enumerator :: rocsparse_action_symbolic = 0 enumerator :: rocsparse_action_numeric = 1 end enum ! rocsparse_direction_ enum, bind(c) enumerator :: rocsparse_direction_row = 0 enumerator :: rocsparse_direction_column = 1 end enum ! rocsparse_hyb_partition_ enum, bind(c) enumerator :: rocsparse_hyb_partition_auto = 0 enumerator :: rocsparse_hyb_partition_user = 1 enumerator :: rocsparse_hyb_partition_max = 2 end enum ! rocsparse_analysis_policy_ enum, bind(c) enumerator :: rocsparse_analysis_policy_reuse = 0 enumerator :: rocsparse_analysis_policy_force = 1 end enum ! rocsparse_solve_policy_ enum, bind(c) enumerator :: rocsparse_solve_policy_auto = 0 end enum ! rocsparse_pointer_mode_ enum, bind(c) enumerator :: rocsparse_pointer_mode_host = 0 enumerator :: rocsparse_pointer_mode_device = 1 end enum ! rocsparse_layer_mode enum, bind(c) enumerator :: rocsparse_layer_mode_none = 0 enumerator :: rocsparse_layer_mode_log_trace = 1 enumerator :: rocsparse_layer_mode_log_bench = 2 enumerator :: rocsparse_layer_mode_log_debug = 4 end enum ! rocsparse_status_ enum, bind(c) enumerator :: rocsparse_status_success = 0 enumerator :: rocsparse_status_invalid_handle = 1 enumerator :: rocsparse_status_not_implemented = 2 enumerator :: rocsparse_status_invalid_pointer = 3 enumerator :: rocsparse_status_invalid_size = 4 enumerator :: rocsparse_status_memory_error = 5 enumerator :: rocsparse_status_internal_error = 6 enumerator :: rocsparse_status_invalid_value = 7 enumerator :: rocsparse_status_arch_mismatch = 8 enumerator :: rocsparse_status_zero_pivot = 9 enumerator :: rocsparse_status_not_initialized = 10 enumerator :: rocsparse_status_type_mismatch = 11 enumerator :: rocsparse_status_requires_sorted_storage = 12 enumerator :: rocsparse_status_thrown_exception = 13 enumerator :: rocsparse_status_continue = 14 end enum ! rocsparse_data_status_ enum, bind(c) enumerator :: rocsparse_data_status_success = 0 enumerator :: rocsparse_data_status_inf = 1 enumerator :: rocsparse_data_status_nan = 2 enumerator :: rocsparse_data_status_invalid_offset_ptr = 3 enumerator :: rocsparse_data_status_invalid_index = 4 enumerator :: rocsparse_data_status_duplicate_entry = 5 enumerator :: rocsparse_data_status_invalid_sorting = 6 enumerator :: rocsparse_data_status_invalid_fill = 7 end enum ! rocsparse_indextype_ enum, bind(c) enumerator :: rocsparse_indextype_i32 = 2 enumerator :: rocsparse_indextype_i64 = 3 end enum ! rocsparse_datatype_ enum, bind(c) enumerator :: rocsparse_datatype_f16_r = 150 enumerator :: rocsparse_datatype_f32_r = 151 enumerator :: rocsparse_datatype_f64_r = 152 enumerator :: rocsparse_datatype_f32_c = 154 enumerator :: rocsparse_datatype_f64_c = 155 enumerator :: rocsparse_datatype_i8_r = 160 enumerator :: rocsparse_datatype_u8_r = 161 enumerator :: rocsparse_datatype_i32_r = 162 enumerator :: rocsparse_datatype_u32_r = 163 enumerator :: rocsparse_datatype_bf16_r = 168 end enum ! rocsparse_format_ enum, bind(c) enumerator :: rocsparse_format_coo = 0 enumerator :: rocsparse_format_coo_aos = 1 enumerator :: rocsparse_format_csr = 2 enumerator :: rocsparse_format_csc = 3 enumerator :: rocsparse_format_ell = 4 enumerator :: rocsparse_format_bell = 5 enumerator :: rocsparse_format_bsr = 6 enumerator :: rocsparse_format_sell = 7 end enum ! rocsparse_order_ enum, bind(c) enumerator :: rocsparse_order_row = 0 enumerator :: rocsparse_order_column = 1 end enum ! rocsparse_spmat_attribute_ enum, bind(c) enumerator :: rocsparse_spmat_fill_mode = 0 enumerator :: rocsparse_spmat_diag_type = 1 enumerator :: rocsparse_spmat_matrix_type = 2 enumerator :: rocsparse_spmat_storage_mode = 3 end enum ! rocsparse_sparse_to_sparse_alg_ enum, bind(c) enumerator :: rocsparse_sparse_to_sparse_alg_default = 0 end enum ! rocsparse_sparse_to_sparse_stage_ enum, bind(c) enumerator :: rocsparse_sparse_to_sparse_stage_analysis = 0 enumerator :: rocsparse_sparse_to_sparse_stage_compute = 1 end enum ! rocsparse_extract_alg_ enum, bind(c) enumerator :: rocsparse_extract_alg_default = 0 end enum ! rocsparse_extract_stage_ enum, bind(c) enumerator :: rocsparse_extract_stage_analysis = 0 enumerator :: rocsparse_extract_stage_compute = 1 end enum ! rocsparse_itilu0_alg_ enum, bind(c) enumerator :: rocsparse_itilu0_alg_default = 0 enumerator :: rocsparse_itilu0_alg_async_inplace = 1 enumerator :: rocsparse_itilu0_alg_async_split = 2 enumerator :: rocsparse_itilu0_alg_sync_split = 3 enumerator :: rocsparse_itilu0_alg_sync_split_fusion = 4 end enum ! rocsparse_itilu0_option_ enum, bind(c) enumerator :: rocsparse_itilu0_option_verbose = 1 enumerator :: rocsparse_itilu0_option_stopping_criteria = 2 enumerator :: rocsparse_itilu0_option_compute_nrm_correction = 4 enumerator :: rocsparse_itilu0_option_compute_nrm_residual = 8 enumerator :: rocsparse_itilu0_option_convergence_history = 16 enumerator :: rocsparse_itilu0_option_coo_format = 32 end enum ! rocsparse_gtsv_interleaved_alg_ enum, bind(c) enumerator :: rocsparse_gtsv_interleaved_alg_default = 0 enumerator :: rocsparse_gtsv_interleaved_alg_thomas = 1 enumerator :: rocsparse_gtsv_interleaved_alg_lu = 2 enumerator :: rocsparse_gtsv_interleaved_alg_qr = 3 end enum ! rocsparse_check_spmat_stage_ enum, bind(c) enumerator :: rocsparse_check_spmat_stage_buffer_size = 0 enumerator :: rocsparse_check_spmat_stage_compute = 1 end enum ! rocsparse_spmv_input_ enum, bind(c) enumerator :: rocsparse_spmv_input_alg = 0 enumerator :: rocsparse_spmv_input_operation = 1 enumerator :: rocsparse_spmv_input_scalar_datatype = 2 enumerator :: rocsparse_spmv_input_compute_datatype = 3 enumerator :: rocsparse_spmv_input_nnz_use_starting_block_ids = 4 enumerator :: rocsparse_spmv_input_enable_extra = 5 end enum ! rocsparse_v2_spmv_stage_ enum, bind(c) enumerator :: rocsparse_v2_spmv_stage_analysis = 0 enumerator :: rocsparse_v2_spmv_stage_compute = 1 end enum ! rocsparse_spmv_stage_ enum, bind(c) enumerator :: rocsparse_spmv_stage_buffer_size = 1 enumerator :: rocsparse_spmv_stage_preprocess = 2 enumerator :: rocsparse_spmv_stage_compute = 3 end enum ! rocsparse_spmv_alg_ enum, bind(c) enumerator :: rocsparse_spmv_alg_default = 0 enumerator :: rocsparse_spmv_alg_coo = 1 enumerator :: rocsparse_spmv_alg_csr_adaptive = 2 enumerator :: rocsparse_spmv_alg_csr_rowsplit = 3 enumerator :: rocsparse_spmv_alg_ell = 4 enumerator :: rocsparse_spmv_alg_coo_atomic = 5 enumerator :: rocsparse_spmv_alg_bsr = 6 enumerator :: rocsparse_spmv_alg_csr_lrb = 7 enumerator :: rocsparse_spmv_alg_csr_nnzsplit = 8 enumerator :: rocsparse_spmv_alg_sell = 9 enumerator :: rocsparse_spmv_alg_csr_stream = 3 end enum ! rocsparse_spsv_alg_ enum, bind(c) enumerator :: rocsparse_spsv_alg_default = 0 end enum ! rocsparse_spsv_stage_ enum, bind(c) enumerator :: rocsparse_spsv_stage_buffer_size = 1 enumerator :: rocsparse_spsv_stage_preprocess = 2 enumerator :: rocsparse_spsv_stage_compute = 3 end enum ! rocsparse_spitsv_alg_ enum, bind(c) enumerator :: rocsparse_spitsv_alg_default = 0 end enum ! rocsparse_spitsv_stage_ enum, bind(c) enumerator :: rocsparse_spitsv_stage_buffer_size = 1 enumerator :: rocsparse_spitsv_stage_preprocess = 2 enumerator :: rocsparse_spitsv_stage_compute = 3 end enum ! rocsparse_spsm_alg_ enum, bind(c) enumerator :: rocsparse_spsm_alg_default = 0 end enum ! rocsparse_spsm_stage_ enum, bind(c) enumerator :: rocsparse_spsm_stage_buffer_size = 1 enumerator :: rocsparse_spsm_stage_preprocess = 2 enumerator :: rocsparse_spsm_stage_compute = 3 end enum ! rocsparse_spmm_alg_ enum, bind(c) enumerator :: rocsparse_spmm_alg_default = 0 enumerator :: rocsparse_spmm_alg_csr = 1 enumerator :: rocsparse_spmm_alg_coo_segmented = 2 enumerator :: rocsparse_spmm_alg_coo_atomic = 3 enumerator :: rocsparse_spmm_alg_csr_row_split = 4 enumerator :: rocsparse_spmm_alg_csr_merge = 5 enumerator :: rocsparse_spmm_alg_coo_segmented_atomic = 6 enumerator :: rocsparse_spmm_alg_bell = 7 enumerator :: rocsparse_spmm_alg_bsr = 8 enumerator :: rocsparse_spmm_alg_csr_merge_path = 9 enumerator :: rocsparse_spmm_alg_csr_nnz_split = 5 end enum ! rocsparse_sddmm_alg_ enum, bind(c) enumerator :: rocsparse_sddmm_alg_default = 0 enumerator :: rocsparse_sddmm_alg_dense = 1 end enum ! rocsparse_sparse_to_dense_alg_ enum, bind(c) enumerator :: rocsparse_sparse_to_dense_alg_default = 0 end enum ! rocsparse_dense_to_sparse_alg_ enum, bind(c) enumerator :: rocsparse_dense_to_sparse_alg_default = 0 end enum ! rocsparse_spmm_stage_ enum, bind(c) enumerator :: rocsparse_spmm_stage_buffer_size = 1 enumerator :: rocsparse_spmm_stage_preprocess = 2 enumerator :: rocsparse_spmm_stage_compute = 3 end enum ! rocsparse_spgemm_stage_ enum, bind(c) enumerator :: rocsparse_spgemm_stage_buffer_size = 1 enumerator :: rocsparse_spgemm_stage_nnz = 2 enumerator :: rocsparse_spgemm_stage_compute = 3 enumerator :: rocsparse_spgemm_stage_symbolic = 4 enumerator :: rocsparse_spgemm_stage_numeric = 5 end enum ! rocsparse_spgemm_alg_ enum, bind(c) enumerator :: rocsparse_spgemm_alg_default = 0 end enum ! rocsparse_singularity_ enum, bind(c) enumerator :: rocsparse_singularity_none = 0 enumerator :: rocsparse_singularity_symbolic = 1 enumerator :: rocsparse_singularity_numeric_exact = 2 enumerator :: rocsparse_singularity_numeric_near = 3 end enum ! rocsparse_sptrsv_alg_ enum, bind(c) enumerator :: rocsparse_sptrsv_alg_default = 0 end enum ! rocsparse_sptrsv_stage_ enum, bind(c) enumerator :: rocsparse_sptrsv_stage_analysis = 0 enumerator :: rocsparse_sptrsv_stage_compute = 1 end enum ! rocsparse_sptrsv_input_ enum, bind(c) enumerator :: rocsparse_sptrsv_input_alg = 0 enumerator :: rocsparse_sptrsv_input_operation = 1 enumerator :: rocsparse_sptrsv_input_scalar_datatype = 2 enumerator :: rocsparse_sptrsv_input_compute_datatype = 3 enumerator :: rocsparse_sptrsv_input_scalar_alpha = 4 enumerator :: rocsparse_sptrsv_input_analysis_policy = 5 end enum ! rocsparse_sptrsv_output_ enum, bind(c) enumerator :: rocsparse_sptrsv_output_zero_pivot_position = 0 enumerator :: rocsparse_sptrsv_output_singularity = 1 enumerator :: rocsparse_sptrsv_output_singularity_position = 2 end enum ! rocsparse_sptrsm_alg_ enum, bind(c) enumerator :: rocsparse_sptrsm_alg_default = 0 end enum ! rocsparse_sptrsm_stage_ enum, bind(c) enumerator :: rocsparse_sptrsm_stage_analysis = 0 enumerator :: rocsparse_sptrsm_stage_compute = 1 end enum ! rocsparse_sptrsm_input_ enum, bind(c) enumerator :: rocsparse_sptrsm_input_alg = 0 enumerator :: rocsparse_sptrsm_input_operation_A = 1 enumerator :: rocsparse_sptrsm_input_operation_X = 2 enumerator :: rocsparse_sptrsm_input_compute_datatype = 3 enumerator :: rocsparse_sptrsm_input_scalar_datatype = 4 enumerator :: rocsparse_sptrsm_input_scalar_alpha = 5 enumerator :: rocsparse_sptrsm_input_analysis_policy = 6 end enum ! rocsparse_sptrsm_output_ enum, bind(c) enumerator :: rocsparse_sptrsm_output_zero_pivot_position = 0 end enum ! rocsparse_spic0_alg_ enum, bind(c) enumerator :: rocsparse_spic0_alg_default = 0 end enum ! rocsparse_spic0_stage_ enum, bind(c) enumerator :: rocsparse_spic0_stage_analysis = 0 enumerator :: rocsparse_spic0_stage_compute = 1 end enum ! rocsparse_spic0_input_ enum, bind(c) enumerator :: rocsparse_spic0_input_alg = 0 enumerator :: rocsparse_spic0_input_analysis_policy = 1 enumerator :: rocsparse_spic0_input_compute_datatype = 2 enumerator :: rocsparse_spic0_input_boost_enable = 3 enumerator :: rocsparse_spic0_input_boost_tolerance = 4 enumerator :: rocsparse_spic0_input_boost_value = 5 enumerator :: rocsparse_spic0_input_singularity_tolerance = 6 end enum ! rocsparse_spic0_output_ enum, bind(c) enumerator :: rocsparse_spic0_output_singularity = 0 enumerator :: rocsparse_spic0_output_singularity_position = 1 end enum ! rocsparse_spilu0_alg_ enum, bind(c) enumerator :: rocsparse_spilu0_alg_default = 0 end enum ! rocsparse_spilu0_stage_ enum, bind(c) enumerator :: rocsparse_spilu0_stage_analysis = 0 enumerator :: rocsparse_spilu0_stage_compute = 1 end enum ! rocsparse_spilu0_input_ enum, bind(c) enumerator :: rocsparse_spilu0_input_alg = 0 enumerator :: rocsparse_spilu0_input_analysis_policy = 1 enumerator :: rocsparse_spilu0_input_compute_datatype = 2 enumerator :: rocsparse_spilu0_input_boost_enable = 3 enumerator :: rocsparse_spilu0_input_boost_tolerance = 4 enumerator :: rocsparse_spilu0_input_boost_value = 5 enumerator :: rocsparse_spilu0_input_singularity_tolerance = 6 end enum ! rocsparse_spilu0_output_ enum, bind(c) enumerator :: rocsparse_spilu0_output_singularity = 0 enumerator :: rocsparse_spilu0_output_singularity_position = 1 end enum ! rocsparse_spildlt0_alg_ enum, bind(c) enumerator :: rocsparse_spildlt0_alg_default = 0 end enum ! rocsparse_spildlt0_stage_ enum, bind(c) enumerator :: rocsparse_spildlt0_stage_analysis = 0 enumerator :: rocsparse_spildlt0_stage_compute = 1 end enum ! rocsparse_spildlt0_input_ enum, bind(c) enumerator :: rocsparse_spildlt0_input_alg = 0 enumerator :: rocsparse_spildlt0_input_analysis_policy = 1 enumerator :: rocsparse_spildlt0_input_compute_datatype = 2 enumerator :: rocsparse_spildlt0_input_boost_enable = 3 enumerator :: rocsparse_spildlt0_input_boost_tolerance = 4 enumerator :: rocsparse_spildlt0_input_boost_value = 5 enumerator :: rocsparse_spildlt0_input_singularity_tolerance = 6 enumerator :: rocsparse_spildlt0_input_diag = 7 end enum ! rocsparse_spildlt0_output_ enum, bind(c) enumerator :: rocsparse_spildlt0_output_singularity = 0 enumerator :: rocsparse_spildlt0_output_singularity_position = 1 end enum ! rocsparse_spgeam_stage_ enum, bind(c) enumerator :: rocsparse_spgeam_stage_analysis = 1 enumerator :: rocsparse_spgeam_stage_compute = 2 enumerator :: rocsparse_spgeam_stage_symbolic_analysis = 3 enumerator :: rocsparse_spgeam_stage_symbolic_compute = 4 enumerator :: rocsparse_spgeam_stage_numeric_analysis = 5 enumerator :: rocsparse_spgeam_stage_numeric_compute = 6 end enum ! rocsparse_spgeam_input_ enum, bind(c) enumerator :: rocsparse_spgeam_input_alg = 0 enumerator :: rocsparse_spgeam_input_scalar_datatype = 1 enumerator :: rocsparse_spgeam_input_compute_datatype = 2 enumerator :: rocsparse_spgeam_input_operation_A = 3 enumerator :: rocsparse_spgeam_input_operation_B = 4 enumerator :: rocsparse_spgeam_input_scalar_alpha = 5 enumerator :: rocsparse_spgeam_input_scalar_beta = 6 end enum ! rocsparse_spgeam_output_ enum, bind(c) enumerator :: rocsparse_spgeam_output_nnz = 0 end enum ! rocsparse_spgeam_alg_ enum, bind(c) enumerator :: rocsparse_spgeam_alg_default = 0 end enum ! rocsparse_gpsv_interleaved_alg_ enum, bind(c) enumerator :: rocsparse_gpsv_interleaved_alg_default = 0 enumerator :: rocsparse_gpsv_interleaved_alg_qr = 1 end enum integer(c_int), parameter :: ROCSPARSE_VERSION_MAJOR = 5 integer(c_int), parameter :: ROCSPARSE_VERSION_MINOR = 0 integer(c_int), parameter :: ROCSPARSE_VERSION_PATCH = 0 end module hipfort_rocsparse_enums hipfort-rocm-10.0.0/lib/hipfort/hipfort_roctx.f90000066400000000000000000000052041524740623400216440ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2024-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_roctx interface subroutine roctxMark(message) bind(c, name="roctxMarkA") use iso_c_binding, only: c_char implicit none character(kind=c_char) :: message(*) end subroutine roctxMark function roctxRangePush(message) bind(c, name="roctxRangePushA") use iso_c_binding, only: c_int, c_char implicit none integer(c_int) :: roctxRangePush character(kind=c_char) :: message(*) end function roctxRangePush function roctxRangePop() bind(c, name="roctxRangePop") use iso_c_binding, only: c_int implicit none integer(c_int) :: roctxRangePop end function roctxRangePop function roctxRangeStart(message) bind(c, name="roctxRangeStartA") use iso_c_binding, only: c_size_t, c_char implicit none integer(c_size_t) :: roctxRangeStart character(kind=c_char) :: message(*) end function roctxRangeStart subroutine roctxRangeStop(range_id) bind(c, name="roctxRangeStop") use iso_c_binding, only: c_size_t implicit none integer(c_size_t), value :: range_id end subroutine roctxRangeStop end interface end module hipfort_roctx hipfort-rocm-10.0.0/lib/hipfort/hipfort_types.F90000066400000000000000000001162561524740623400216230ustar00rootroot00000000000000!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ============================================================================== ! hipfort: FORTRAN Interfaces for GPU kernels ! ============================================================================== ! Copyright (c) 2020-2026 Advanced Micro Devices, Inc. All rights reserved. ! [MITx11 License] ! ! 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. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! module hipfort_types use, intrinsic :: iso_c_binding implicit none type, bind(c) :: hipDeviceArch_t integer(c_int32_t) :: opaque(1) end type hipDeviceArch_t type, bind(c) :: hipUUID character(c_char) :: bytes(16) end type hipUUID #ifdef USE_CUDA_NAMES type,bind(c) :: hipDeviceProp_t ! as of cuda 13.3 (CUDART 13030); ABI-stable across 13.3 updates character(kind=c_char) :: name(256) character(kind=c_char) :: uuid(16) character(kind=c_char) :: luid(8) integer(c_int) :: luidDeviceNodeMask integer(c_size_t) :: totalGlobalMem integer(c_size_t) :: sharedMemPerBlock integer(c_int) :: regsPerBlock integer(c_int) :: warpSize integer(c_size_t) :: memPitch integer(c_int) :: maxThreadsPerBlock integer(c_int) :: maxThreadsDim(3) integer(c_int) :: maxGridSize(3) integer(c_size_t) :: totalConstMem integer(c_int) :: major integer(c_int) :: minor integer(c_size_t) :: textureAlignment integer(c_size_t) :: texturePitchAlignment integer(c_int) :: multiProcessorCount integer(c_int) :: integrated integer(c_int) :: canMapHostMemory integer(c_int) :: maxTexture1D integer(c_int) :: maxTexture1DMipmap integer(c_int) :: maxTexture2D(2) integer(c_int) :: maxTexture2DMipmap(2) integer(c_int) :: maxTexture2DLinear(3) integer(c_int) :: maxTexture2DGather(2) integer(c_int) :: maxTexture3D(3) integer(c_int) :: maxTexture3DAlt(3) integer(c_int) :: maxTextureCubemap integer(c_int) :: maxTexture1DLayered(2) integer(c_int) :: maxTexture2DLayered(3) integer(c_int) :: maxTextureCubemapLayered(2) integer(c_int) :: maxSurface1D integer(c_int) :: maxSurface2D(2) integer(c_int) :: maxSurface3D(3) integer(c_int) :: maxSurface1DLayered(2) integer(c_int) :: maxSurface2DLayered(3) integer(c_int) :: maxSurfaceCubemap integer(c_int) :: maxSurfaceCubemapLayered(2) integer(c_size_t) :: surfaceAlignment integer(c_int) :: concurrentKernels integer(c_int) :: ECCEnabled integer(c_int) :: pciBusID integer(c_int) :: pciDeviceID integer(c_int) :: pciDomainID integer(c_int) :: tccDriver integer(c_int) :: asyncEngineCount integer(c_int) :: unifiedAddressing integer(c_int) :: memoryBusWidth integer(c_int) :: l2CacheSize integer(c_int) :: persistingL2CacheMaxSize integer(c_int) :: maxThreadsPerMultiProcessor integer(c_int) :: streamPrioritiesSupported integer(c_int) :: globalL1CacheSupported integer(c_int) :: localL1CacheSupported integer(c_size_t) :: sharedMemPerMultiprocessor integer(c_int) :: regsPerMultiprocessor integer(c_int) :: managedMemory integer(c_int) :: isMultiGpuBoard integer(c_int) :: multiGpuBoardGroupID integer(c_int) :: hostNativeAtomicSupported integer(c_int) :: pageableMemoryAccess integer(c_int) :: concurrentManagedAccess integer(c_int) :: computePreemptionSupported integer(c_int) :: canUseHostPointerForRegisteredMem integer(c_int) :: cooperativeLaunch integer(c_size_t) :: sharedMemPerBlockOptin integer(c_int) :: pageableMemoryAccessUsesHostPageTables integer(c_int) :: directManagedMemAccessFromHost integer(c_int) :: maxBlocksPerMultiProcessor integer(c_int) :: accessPolicyMaxWindowSize integer(c_size_t) :: reservedSharedMemPerBlock integer(c_int) :: hostRegisterSupported integer(c_int) :: sparseCudaArraySupported integer(c_int) :: hostRegisterReadOnlySupported integer(c_int) :: timelineSemaphoreInteropSupported integer(c_int) :: memoryPoolsSupported integer(c_int) :: gpuDirectRDMASupported integer(c_int) :: gpuDirectRDMAFlushWritesOptions integer(c_int) :: gpuDirectRDMAWritesOrdering integer(c_int) :: memoryPoolSupportedHandleTypes integer(c_int) :: deferredMappingCudaArraySupported integer(c_int) :: ipcEventSupported integer(c_int) :: clusterLaunch integer(c_int) :: unifiedFunctionPointers integer(c_int) :: deviceNumaConfig integer(c_int) :: deviceNumaId integer(c_int) :: mpsEnabled integer(c_int) :: hostNumaId integer(c_int) :: gpuPciDeviceID integer(c_int) :: gpuPciSubsystemID integer(c_int) :: hostNumaMultinodeIpcSupported integer(c_int) :: reserved(56) end type hipDeviceProp_t #else type, bind(c) :: hipDeviceProp_t character(c_char) :: name(256) !< Device name. type(hipUUID) :: uuid !< UUID of a device character(c_char) :: luid(8) !< 8-byte unique identifier. Only valid on windows integer(c_int) :: luidDeviceNodeMask !< LUID node mask integer(c_size_t) :: totalGlobalMem !< Size of global memory region (in bytes). integer(c_size_t) :: sharedMemPerBlock !< Size of shared memory per block (in bytes). integer(c_int) :: regsPerBlock !< Registers per block. integer(c_int) :: warpSize !< Warp size. integer(c_size_t) :: memPitch !< Maximum pitch in bytes allowed by memory copies pitched memory integer(c_int) :: maxThreadsPerBlock !< Max work items per work group or workgroup max size. integer(c_int) :: maxThreadsDim(3) !< Max number of threads in each dimension (XYZ) of a block. integer(c_int) :: maxGridSize(3) !< Max grid dimensions (XYZ). integer(c_int) :: clockRate !< Max clock frequency of the multiProcessors in khz. integer(c_size_t) :: totalConstMem !< Size of shared constant memory region on the device (in bytes). integer(c_int) :: major !< Major compute capability version. This indicates the core instruction set of the GPU architect... integer(c_int) :: minor !< Minor compute capability version. This indicates a particular configuration, feature set, or v... integer(c_size_t) :: textureAlignment !< Alignment requirement for textures integer(c_size_t) :: texturePitchAlignment !< Pitch alignment requirement for texture references bound to integer(c_int) :: deviceOverlap !< Deprecated. Use asyncEngineCount instead integer(c_int) :: multiProcessorCount !< Number of multi-processors. When the GPU works in Compute Unit (CU) mode, this v... integer(c_int) :: kernelExecTimeoutEnabled !< Run time limit for kernels executed on the device integer(c_int) :: integrated !< APU vs dGPU integer(c_int) :: canMapHostMemory !< Check whether HIP can map host memory integer(c_int) :: computeMode !< Compute mode. integer(c_int) :: maxTexture1D !< Maximum number of elements in 1D images integer(c_int) :: maxTexture1DMipmap !< Maximum 1D mipmap texture size integer(c_int) :: maxTexture1DLinear !< Maximum size for 1D textures bound to linear memory integer(c_int) :: maxTexture2D(2) !< Maximum dimensions (width, height) of 2D images, in image elements integer(c_int) :: maxTexture2DMipmap(2) !< Maximum number of elements in 2D array mipmap of images integer(c_int) :: maxTexture2DLinear(3) !< Maximum 2D tex dimensions if tex are bound to pitched memory integer(c_int) :: maxTexture2DGather(2) !< Maximum 2D tex dimensions if gather has to be performed integer(c_int) :: maxTexture3D(3) !< Maximum dimensions (width, height, depth) of 3D images, in image elements integer(c_int) :: maxTexture3DAlt(3) !< Maximum alternate 3D texture dims integer(c_int) :: maxTextureCubemap !< Maximum cubemap texture dims integer(c_int) :: maxTexture1DLayered(2) !< Maximum number of elements in 1D array images integer(c_int) :: maxTexture2DLayered(3) !< Maximum number of elements in 2D array images integer(c_int) :: maxTextureCubemapLayered(2) !< Maximum cubemaps layered texture dims integer(c_int) :: maxSurface1D !< Maximum 1D surface size integer(c_int) :: maxSurface2D(2) !< Maximum 2D surface size integer(c_int) :: maxSurface3D(3) !< Maximum 3D surface size integer(c_int) :: maxSurface1DLayered(2) !< Maximum 1D layered surface size integer(c_int) :: maxSurface2DLayered(3) !< Maximum 2D layared surface size integer(c_int) :: maxSurfaceCubemap !< Maximum cubemap surface size integer(c_int) :: maxSurfaceCubemapLayered(2) !< Maximum cubemap layered surface size integer(c_size_t) :: surfaceAlignment !< Alignment requirement for surface integer(c_int) :: concurrentKernels !< Device can possibly execute multiple kernels concurrently. integer(c_int) :: ECCEnabled !< Device has ECC support enabled integer(c_int) :: pciBusID !< PCI Bus ID. integer(c_int) :: pciDeviceID !< PCI Device ID integer(c_int) :: pciDomainID !< PCI Domain ID integer(c_int) :: tccDriver !< 1:If device is Tesla device using TCC driver, else 0 integer(c_int) :: asyncEngineCount !< Number of async engines integer(c_int) :: unifiedAddressing !< Does device and host share unified address space integer(c_int) :: memoryClockRate !< Max global memory clock frequency in khz. integer(c_int) :: memoryBusWidth !< Global memory bus width in bits. integer(c_int) :: l2CacheSize !< L2 cache size. integer(c_int) :: persistingL2CacheMaxSize !< Device's max L2 persisting lines in bytes integer(c_int) :: maxThreadsPerMultiProcessor !< Maximum resident threads per multi-processor. integer(c_int) :: streamPrioritiesSupported !< Device supports stream priority integer(c_int) :: globalL1CacheSupported !< Indicates globals are cached in L1 integer(c_int) :: localL1CacheSupported !< Locals are cahced in L1 integer(c_size_t) :: sharedMemPerMultiprocessor !< Amount of shared memory available per multiprocessor. integer(c_int) :: regsPerMultiprocessor !< registers available per multiprocessor integer(c_int) :: managedMemory !< Device supports allocating managed memory on this system integer(c_int) :: isMultiGpuBoard !< 1 if device is on a multi-GPU board, 0 if not. integer(c_int) :: multiGpuBoardGroupID !< Unique identifier for a group of devices on same multiboard GPU integer(c_int) :: hostNativeAtomicSupported !< Link between host and device supports native atomics integer(c_int) :: singleToDoublePrecisionPerfRatio !< Deprecated. CUDA only. integer(c_int) :: pageableMemoryAccess !< Device supports coherently accessing pageable memory without calling hipHostReg... integer(c_int) :: concurrentManagedAccess !< Device can coherently access managed memory concurrently with the CPU integer(c_int) :: computePreemptionSupported !< Is compute preemption supported on the device integer(c_int) :: canUseHostPointerForRegisteredMem !< Device can access host registered memory with same address as the ... integer(c_int) :: cooperativeLaunch !< HIP device supports cooperative launch integer(c_int) :: cooperativeMultiDeviceLaunch !< HIP device supports cooperative launch on multiple devices integer(c_size_t) :: sharedMemPerBlockOptin !< Per device m ax shared mem per block usable by special opt in integer(c_int) :: pageableMemoryAccessUsesHostPageTables !< Device accesses pageable memory via the host's page tables integer(c_int) :: directManagedMemAccessFromHost !< Host can directly access managed memory on the device without migration integer(c_int) :: maxBlocksPerMultiProcessor !< Max number of blocks on CU integer(c_int) :: accessPolicyMaxWindowSize !< Max value of access policy window integer(c_size_t) :: reservedSharedMemPerBlock !< Shared memory reserved by driver per block integer(c_int) :: hostRegisterSupported !< Device supports hipHostRegister integer(c_int) :: sparseHipArraySupported !< Indicates if device supports sparse hip arrays integer(c_int) :: hostRegisterReadOnlySupported !< Device supports using the hipHostRegisterReadOnly flag with hipHostReg... integer(c_int) :: timelineSemaphoreInteropSupported !< Indicates external timeline semaphore support integer(c_int) :: memoryPoolsSupported !< Indicates if device supports hipMallocAsync and hipMemPool APIs integer(c_int) :: gpuDirectRDMASupported !< Indicates device support of RDMA APIs integer(c_int) :: gpuDirectRDMAFlushWritesOptions !< Bitmask to be interpreted according to hipFlushGPUDirectRDMAWritesOp... integer(c_int) :: gpuDirectRDMAWritesOrdering !< value of hipGPUDirectRDMAWritesOrdering integer(c_int) :: memoryPoolSupportedHandleTypes !< Bitmask of handle types support with mempool based IPC integer(c_int) :: deferredMappingHipArraySupported !< Device supports deferred mapping HIP arrays and HIP mipmapped arrays integer(c_int) :: ipcEventSupported !< Device supports IPC events integer(c_int) :: clusterLaunch !< Device supports cluster launch integer(c_int) :: unifiedFunctionPointers !< Indicates device supports unified function pointers integer(c_int) :: reserved(63) !< CUDA Reserved. integer(c_int) :: hipReserved(32) !< Reserved for adding new entries for HIP/CUDA. character(c_char) :: gcnArchName(256) !< AMD GCN Arch Name. HIP Only. integer(c_size_t) :: maxSharedMemoryPerMultiProcessor !< Maximum Shared Memory Per CU. HIP Only. integer(c_int) :: clockInstructionRate !< Frequency in khz of the timer used by the device-side "clock*" instructions. Ne... type(hipDeviceArch_t) :: arch !< Architectural feature flags. New for HIP. type(c_ptr) :: hdpMemFlushCntl !< Addres of HDP_MEM_COHERENCY_FLUSH_CNTL register type(c_ptr) :: hdpRegFlushCntl !< Addres of HDP_REG_COHERENCY_FLUSH_CNTL register integer(c_int) :: cooperativeMultiDeviceUnmatchedFunc !< HIP device supports cooperative launch on multiple integer(c_int) :: cooperativeMultiDeviceUnmatchedGridDim !< HIP device supports cooperative launch on multiple integer(c_int) :: cooperativeMultiDeviceUnmatchedBlockDim !< HIP device supports cooperative launch on multiple integer(c_int) :: cooperativeMultiDeviceUnmatchedSharedMem !< HIP device supports cooperative launch on multiple integer(c_int) :: isLargeBar !< 1: if it is a large PCI bar device, else 0 integer(c_int) :: asicRevision !< Revision of the GPU in this device end type hipDeviceProp_t #endif #ifdef USE_CUDA_NAMES type,bind(c) :: hipPointerAttribute_t ! cudaPointerAttributes as of cuda 13.3 integer(c_int) :: type integer(c_int) :: device type(c_ptr) :: devicePointer type(c_ptr) :: hostPointer integer(c_long) :: reserved(8) end type hipPointerAttribute_t #else type, bind(c) :: hipPointerAttribute_t integer(c_int) :: type integer(c_int) :: device type(c_ptr) :: devicePointer type(c_ptr) :: hostPointer integer(c_int) :: isManaged integer(c_int) :: allocationFlags end type hipPointerAttribute_t #endif type, bind(c) :: hipChannelFormatDesc integer(c_int) :: x integer(c_int) :: y integer(c_int) :: z integer(c_int) :: w integer(c_int) :: f !< Channel format kind end type hipChannelFormatDesc type, bind(c) :: HIP_ARRAY_DESCRIPTOR integer(c_size_t) :: Width !< Width of the array integer(c_size_t) :: Height !< Height of the array integer(c_int) :: Format !< Format of the array integer(c_int) :: NumChannels !< Number of channels of the array end type HIP_ARRAY_DESCRIPTOR type, bind(c) :: HIP_ARRAY3D_DESCRIPTOR integer(c_size_t) :: Width !< Width of the array integer(c_size_t) :: Height !< Height of the array integer(c_size_t) :: Depth !< Depth of the array integer(c_int) :: Format !< Format of the array integer(c_int) :: NumChannels !< Number of channels of the array integer(c_int) :: Flags !< Flags of the array end type HIP_ARRAY3D_DESCRIPTOR type, bind(c) :: hip_Memcpy2D integer(c_size_t) :: srcXInBytes !< Source width in bytes integer(c_size_t) :: srcY !< Source height integer(c_int) :: srcMemoryType !< Source memory type type(c_ptr) :: srcHost !< Source pointer type(c_ptr) :: srcDevice !< Source device type(c_ptr) :: srcArray !< Source array integer(c_size_t) :: srcPitch !< Source pitch integer(c_size_t) :: dstXInBytes !< Destination width in bytes integer(c_size_t) :: dstY !< Destination height integer(c_int) :: dstMemoryType !< Destination memory type type(c_ptr) :: dstHost !< Destination pointer type(c_ptr) :: dstDevice !< Destination device type(c_ptr) :: dstArray !< Destination array integer(c_size_t) :: dstPitch !< Destination pitch integer(c_size_t) :: WidthInBytes !< Width in bytes of the 2D memory copy integer(c_size_t) :: Height !< Height of the 2D memory copy end type hip_Memcpy2D type, bind(c) :: hipMipmappedArray type(c_ptr) :: data !< Data pointer of the mipmapped array type(hipChannelFormatDesc) :: desc !< Description of the mipmapped array integer(c_int) :: type !< Type of the mipmapped array integer(c_int) :: width !< Width of the mipmapped array integer(c_int) :: height !< Height of the mipmapped array integer(c_int) :: depth !< Depth of the mipmapped array integer(c_int) :: min_mipmap_level !< Minimum level of the mipmapped array integer(c_int) :: max_mipmap_level !< Maximum level of the mipmapped array integer(c_int) :: flags !< Flags of the mipmapped array integer(c_int) :: format !< Format of the mipmapped array integer(c_int) :: num_channels !< Number of channels of the mipmapped array end type hipMipmappedArray type, bind(c) :: HIP_TEXTURE_DESC integer(c_int) :: addressMode(3) !< Address modes integer(c_int) :: filterMode !< Filter mode integer(c_int) :: flags !< Flags integer(c_int) :: maxAnisotropy !< Maximum anisotropy ratio integer(c_int) :: mipmapFilterMode !< Mipmap filter mode real(c_float) :: mipmapLevelBias !< Mipmap level bias real(c_float) :: minMipmapLevelClamp !< Mipmap minimum level clamp real(c_float) :: maxMipmapLevelClamp !< Mipmap maximum level clamp real(c_float) :: borderColor(4) !< Border Color integer(c_int) :: reserved(12) end type HIP_TEXTURE_DESC type, bind(c) :: hipResourceDesc integer(c_int) :: resType !< Resource type integer(c_int64_t) :: res(7) !< 56-byte C union: keeps the layout exact, members not individually accessible end type hipResourceDesc type, bind(c) :: HIP_RESOURCE_DESC integer(c_int) :: resType !< Resource type integer(c_int64_t) :: res(16) !< 128-byte C union: keeps the layout exact, members not individually accessible integer(c_int) :: flags !< Flags (must be zero) end type HIP_RESOURCE_DESC type, bind(c) :: hipResourceViewDesc integer(c_int) :: format !< Resource view format integer(c_size_t) :: width !< Width of the resource view integer(c_size_t) :: height !< Height of the resource view integer(c_size_t) :: depth !< Depth of the resource view integer(c_int) :: firstMipmapLevel !< First defined mipmap level integer(c_int) :: lastMipmapLevel !< Last defined mipmap level integer(c_int) :: firstLayer !< First layer index integer(c_int) :: lastLayer !< Last layer index end type hipResourceViewDesc type, bind(c) :: HIP_RESOURCE_VIEW_DESC integer(c_int) :: format !< Resource view format integer(c_size_t) :: width !< Width of the resource view integer(c_size_t) :: height !< Height of the resource view integer(c_size_t) :: depth !< Depth of the resource view integer(c_int) :: firstMipmapLevel !< First defined mipmap level integer(c_int) :: lastMipmapLevel !< Last defined mipmap level integer(c_int) :: firstLayer !< First layer index integer(c_int) :: lastLayer !< Last layer index integer(c_int) :: reserved(16) end type HIP_RESOURCE_VIEW_DESC type, bind(c) :: hipPitchedPtr type(c_ptr) :: ptr !< Pointer to the allocated memory integer(c_size_t) :: pitch !< Pitch in bytes integer(c_size_t) :: xsize !< Logical size of the first dimension of allocation in elements integer(c_size_t) :: ysize !< Logical size of the second dimension of allocation in elements end type hipPitchedPtr type, bind(c) :: hipExtent integer(c_size_t) :: width integer(c_size_t) :: height integer(c_size_t) :: depth end type hipExtent type, bind(c) :: hipPos integer(c_size_t) :: x !< X coordinate integer(c_size_t) :: y !< Y coordinate integer(c_size_t) :: z !< Z coordinate end type hipPos type, bind(c) :: hipMemcpy3DParms type(c_ptr) :: srcArray !< Source array type(hipPos) :: srcPos !< Source position type(hipPitchedPtr) :: srcPtr !< Source pointer type(c_ptr) :: dstArray !< Destination array type(hipPos) :: dstPos !< Destination position type(hipPitchedPtr) :: dstPtr !< Destination pointer type(hipExtent) :: extent !< Extent of 3D memory copy integer(c_int) :: kind !< Kind of 3D memory copy end type hipMemcpy3DParms type, bind(c) :: HIP_MEMCPY3D integer(c_size_t) :: srcXInBytes !< Source X in bytes integer(c_size_t) :: srcY !< Source Y integer(c_size_t) :: srcZ !< Source Z integer(c_size_t) :: srcLOD !< Source LOD integer(c_int) :: srcMemoryType !< Source memory type type(c_ptr) :: srcHost !< Source host pointer type(c_ptr) :: srcDevice !< Source device type(c_ptr) :: srcArray !< Source array integer(c_size_t) :: srcPitch !< Source pitch integer(c_size_t) :: srcHeight !< Source height integer(c_size_t) :: dstXInBytes !< Destination X in bytes integer(c_size_t) :: dstY !< Destination Y integer(c_size_t) :: dstZ !< Destination Z integer(c_size_t) :: dstLOD !< Destination LOD integer(c_int) :: dstMemoryType !< Destination memory type type(c_ptr) :: dstHost !< Destination host pointer type(c_ptr) :: dstDevice !< Destination device type(c_ptr) :: dstArray !< Destination array integer(c_size_t) :: dstPitch !< Destination pitch integer(c_size_t) :: dstHeight !< Destination height integer(c_size_t) :: WidthInBytes !< Width in bytes of 3D memory copy integer(c_size_t) :: Height !< Height in bytes of 3D memory copy integer(c_size_t) :: Depth !< Depth in bytes of 3D memory copy end type HIP_MEMCPY3D type, bind(c) :: hipMemLocation integer(c_int) :: type !< Specifies the location type, which describes the meaning of id integer(c_int) :: id !< Identifier for the provided location type @p hipMemLocationType end type hipMemLocation type, bind(c) :: hipMemcpyAttributes integer(c_int) :: srcAccessOrder !< Source access ordering to be observed for copies with this attribute. type(hipMemLocation) :: srcLocHint !< Location hint for src operand. type(hipMemLocation) :: dstLocHint !< Location hint for destination operand. integer(c_int) :: flags !< Additional Flags for copies. See hipMemcpyFlags. end type hipMemcpyAttributes type, bind(c) :: hipOffset3D integer(c_size_t) :: x integer(c_size_t) :: y integer(c_size_t) :: z end type hipOffset3D type, bind(c) :: hipMemcpy3DOperand integer(c_int) :: type integer(c_int64_t) :: op(4) !< 32-byte C union: keeps the layout exact, members not individually accessible end type hipMemcpy3DOperand type, bind(c) :: hipMemcpy3DBatchOp type(hipMemcpy3DOperand) :: src type(hipMemcpy3DOperand) :: dst type(hipExtent) :: extent integer(c_int) :: srcAccessOrder integer(c_int) :: flags end type hipMemcpy3DBatchOp type, bind(c) :: hipMemcpy3DPeerParms type(c_ptr) :: srcArray !< Source memory address type(hipPos) :: srcPos !< Source position offset type(hipPitchedPtr) :: srcPtr !< Pitched source memory address integer(c_int) :: srcDevice !< Source device type(c_ptr) :: dstArray !< Destination memory address type(hipPos) :: dstPos !< Destination position offset type(hipPitchedPtr) :: dstPtr !< Pitched destination memory address integer(c_int) :: dstDevice !< Destination device type(hipExtent) :: extent !< Requested memory copy size end type hipMemcpy3DPeerParms type, bind(c) :: textureReference integer(c_int) :: normalized integer(c_int) :: readMode integer(c_int) :: filterMode integer(c_int) :: addressMode(3) type(hipChannelFormatDesc) :: channelDesc integer(c_int) :: sRGB integer(c_int) :: maxAnisotropy integer(c_int) :: mipmapFilterMode real(c_float) :: mipmapLevelBias real(c_float) :: minMipmapLevelClamp real(c_float) :: maxMipmapLevelClamp type(c_ptr) :: textureObject integer(c_int) :: numChannels integer(c_int) :: format end type textureReference type, bind(c) :: hipTextureDesc integer(c_int) :: addressMode(3) integer(c_int) :: filterMode integer(c_int) :: readMode integer(c_int) :: sRGB real(c_float) :: borderColor(4) integer(c_int) :: normalizedCoords integer(c_int) :: maxAnisotropy integer(c_int) :: mipmapFilterMode real(c_float) :: mipmapLevelBias real(c_float) :: minMipmapLevelClamp real(c_float) :: maxMipmapLevelClamp end type hipTextureDesc type, bind(c) :: surfaceReference type(c_ptr) :: surfaceObject end type surfaceReference type, bind(c) :: hipDevSmResource integer(c_int) :: smCount integer(c_int) :: minSmPartitionSize integer(c_int) :: smCoscheduledAlignment integer(c_int) :: flags end type hipDevSmResource type, bind(c) :: hipDevWorkqueueConfigResource integer(c_int) :: device integer(c_int) :: wqConcurrencyLimit integer(c_int) :: sharingScope end type hipDevWorkqueueConfigResource type, bind(c) :: hipDevWorkqueueResource character(c_char) :: reserved(40) end type hipDevWorkqueueResource type, bind(c) :: hipDevResource integer(c_int) :: type character(c_char) :: internal_padding(92) integer(c_int32_t) :: anonymous_union(10) !< 40-byte C union: keeps the layout exact, members not individually accessible type(c_ptr) :: nextResource end type hipDevResource type, bind(c) :: hipDevSmResourceGroupParams integer(c_int) :: smCount integer(c_int) :: coscheduledSmCount integer(c_int) :: preferredCoscheduledSmCount integer(c_int) :: flags integer(c_int) :: reserved(12) end type hipDevSmResourceGroupParams type, bind(c) :: hipIpcMemHandle_t character(c_char) :: reserved(64) end type hipIpcMemHandle_t type, bind(c) :: hipIpcEventHandle_t character(c_char) :: reserved(64) end type hipIpcEventHandle_t type, bind(c) :: hipMemFabricHandle_t character(c_char) :: data(64) end type hipMemFabricHandle_t type, bind(c) :: hipFuncAttributes integer(c_int) :: binaryVersion integer(c_int) :: cacheModeCA integer(c_size_t) :: constSizeBytes integer(c_size_t) :: localSizeBytes integer(c_int) :: maxDynamicSharedSizeBytes integer(c_int) :: maxThreadsPerBlock integer(c_int) :: numRegs integer(c_int) :: preferredShmemCarveout integer(c_int) :: ptxVersion integer(c_size_t) :: sharedSizeBytes end type hipFuncAttributes type, bind(c) :: hipBatchMemOpNodeParams type(c_ptr) :: ctx integer(c_int) :: count type(c_ptr) :: paramArray integer(c_int) :: flags end type hipBatchMemOpNodeParams type, bind(c) :: hipMemAccessDesc type(hipMemLocation) :: location !< Location on which the accessibility has to change integer(c_int) :: flags !< Accessibility flags to set end type hipMemAccessDesc type, bind(c) :: hipMemPoolProps integer(c_int) :: allocType !< Allocation type. Currently must be specified as @p hipMemAllocationTypePinned integer(c_int) :: handleTypes !< Handle types that will be supported by allocations from the pool type(hipMemLocation) :: location !< Location where allocations should reside type(c_ptr) :: win32SecurityAttributes !< Windows-specific LPSECURITYATTRIBUTES required when @p hipMemHandleTypeWin32 is... integer(c_size_t) :: maxSize !< Maximum pool size. When set to 0, defaults to a system dependent value character(c_char) :: reserved(56) !< Reserved for future use, must be 0 end type hipMemPoolProps type, bind(c) :: hipMemPoolPtrExportData character(c_char) :: reserved(64) end type hipMemPoolPtrExportData type, bind(c) :: dim3 integer(c_int32_t) :: x = 1 !< x integer(c_int32_t) :: y = 1 !< y integer(c_int32_t) :: z = 1 !< z end type dim3 type, bind(c) :: hipLaunchParams type(c_ptr) :: func !< Device function symbol type(dim3) :: gridDim !< Grid dimensions type(dim3) :: blockDim !< Block dimensions type(c_ptr) :: args !< Arguments integer(c_size_t) :: sharedMem !< Shared memory type(c_ptr) :: stream !< Stream identifier end type hipLaunchParams type, bind(c) :: hipFunctionLaunchParams type(c_ptr) :: function !< Kernel to launch integer(c_int) :: gridDimX !< Width(X) of grid in blocks integer(c_int) :: gridDimY !< Height(Y) of grid in blocks integer(c_int) :: gridDimZ !< Depth(Z) of grid in blocks integer(c_int) :: blockDimX !< X dimension of each thread block integer(c_int) :: blockDimY !< Y dimension of each thread block integer(c_int) :: blockDimZ !< Z dimension of each thread block integer(c_int) :: sharedMemBytes !< Shared memory type(c_ptr) :: hStream !< Stream identifier type(c_ptr) :: kernelParams !< Kernel parameters end type hipFunctionLaunchParams type, bind(c) :: hipExternalMemoryHandleDesc integer(c_int) :: type integer(c_int64_t) :: handle(2) !< 16-byte C union: keeps the layout exact, members not individually accessible integer(c_int64_t) :: size integer(c_int) :: flags integer(c_int) :: reserved(16) end type hipExternalMemoryHandleDesc type, bind(c) :: hipExternalMemoryBufferDesc integer(c_int64_t) :: offset integer(c_int64_t) :: size integer(c_int) :: flags integer(c_int) :: reserved(16) end type hipExternalMemoryBufferDesc type, bind(c) :: hipExternalMemoryMipmappedArrayDesc integer(c_int64_t) :: offset type(hipChannelFormatDesc) :: formatDesc type(hipExtent) :: extent integer(c_int) :: flags integer(c_int) :: numLevels end type hipExternalMemoryMipmappedArrayDesc type, bind(c) :: hipExternalSemaphoreHandleDesc integer(c_int) :: type integer(c_int64_t) :: handle(2) !< 16-byte C union: keeps the layout exact, members not individually accessible integer(c_int) :: flags integer(c_int) :: reserved(16) end type hipExternalSemaphoreHandleDesc type, bind(c) :: hipExternalSemaphoreSignalParams integer(c_int64_t) :: params(9) !< 72-byte unnamed C struct: keeps the layout exact, fields not individually accessible integer(c_int) :: flags integer(c_int) :: reserved(16) end type hipExternalSemaphoreSignalParams type, bind(c) :: hipExternalSemaphoreWaitParams integer(c_int64_t) :: params(9) !< 72-byte unnamed C struct: keeps the layout exact, fields not individually accessible integer(c_int) :: flags integer(c_int) :: reserved(16) end type hipExternalSemaphoreWaitParams type, bind(c) :: hipHostNodeParams type(c_funptr) :: fn type(c_ptr) :: userData end type hipHostNodeParams type, bind(c) :: hipKernelNodeParams type(dim3) :: blockDim type(c_ptr) :: extra type(c_ptr) :: func type(dim3) :: gridDim type(c_ptr) :: kernelParams integer(c_int) :: sharedMemBytes end type hipKernelNodeParams type, bind(c) :: hipMemsetParams type(c_ptr) :: dst integer(c_int) :: elementSize integer(c_size_t) :: height integer(c_size_t) :: pitch integer(c_int) :: value integer(c_size_t) :: width end type hipMemsetParams type, bind(c) :: hipMemAllocNodeParams type(hipMemPoolProps) :: poolProps !< Pool properties, which contain where the location should reside type(c_ptr) :: accessDescs !< The number of memory access descriptors. integer(c_size_t) :: accessDescCount !< The number of access descriptors. Must not be bigger than the number of GPUs integer(c_size_t) :: bytesize !< The size of the requested allocation in bytes type(c_ptr) :: dptr !< Returned device address of the allocation end type hipMemAllocNodeParams type, bind(c) :: hipAccessPolicyWindow type(c_ptr) :: base_ptr !< Starting address of the access policy window integer(c_int) :: hitProp !< hipAccessProperty set for hit real(c_float) :: hitRatio !< hitRatio specifies percentage of lines assigned hitProp integer(c_int) :: missProp !< hipAccessProperty set for miss integer(c_size_t) :: num_bytes !< Size in bytes of the window policy. end type hipAccessPolicyWindow type, bind(c) :: hipLaunchMemSyncDomainMap character(c_char) :: default_ !< The default domain ID to use for designated kernels character(c_char) :: remote !< The remote domain ID to use for designated kernels end type hipLaunchMemSyncDomainMap type, bind(c) :: hipExtDynDataPrefetchRegion type(c_ptr) :: address !< Base address (must be cache-line aligned) integer(c_size_t) :: stride !< Stride between row starts in bytes integer(c_size_t) :: width !< Width of each row in bytes (must be a multiple of cache line size) integer(c_size_t) :: height !< Number of rows to prefetch end type hipExtDynDataPrefetchRegion type, bind(c) :: hipExtDynDataPrefetchConfig integer(c_int) :: numRegions !< Number of valid regions (1-max) integer(c_int) :: temporal !< Cache retention policy for prefetched data type(hipExtDynDataPrefetchRegion) :: regions(2) !< Prefetch regions end type hipExtDynDataPrefetchConfig type, bind(c) :: hipGraphInstantiateParams type(c_ptr) :: errNode_out !< The node which caused instantiation to fail, if any integer(c_int64_t) :: flags !< Instantiation flags integer(c_int) :: result_out !< Whether instantiation was successful. If it failed, the reason why type(c_ptr) :: uploadStream !< Upload stream end type hipGraphInstantiateParams type, bind(c) :: hipMemAllocationProp integer(c_int) :: type !< Memory allocation type integer(c_int) :: requestedHandleType !< C union; also spelled requestedHandleTypes type(hipMemLocation) :: location !< Memory location type(c_ptr) :: win32HandleMetaData !< Metadata for Win32 handles integer(c_int16_t) :: allocFlags(2) !< 4-byte unnamed C struct: keeps the layout exact, fields not individually accessible end type hipMemAllocationProp type, bind(c) :: hipExternalSemaphoreSignalNodeParams type(c_ptr) :: extSemArray type(c_ptr) :: paramsArray integer(c_int) :: numExtSems end type hipExternalSemaphoreSignalNodeParams type, bind(c) :: hipExternalSemaphoreWaitNodeParams type(c_ptr) :: extSemArray type(c_ptr) :: paramsArray integer(c_int) :: numExtSems end type hipExternalSemaphoreWaitNodeParams type, bind(c) :: hipArrayMapInfo integer(c_int) :: resourceType !< Resource type integer(c_int64_t) :: resource(8) !< 64-byte C union: keeps the layout exact, members not individually accessible integer(c_int) :: subresourceType !< Sparse subresource type integer(c_int64_t) :: subresource(4) !< 32-byte C union: keeps the layout exact, members not individually accessible integer(c_int) :: memOperationType !< Memory operation type integer(c_int) :: memHandleType !< Memory handle type type(c_ptr) :: memHandle integer(c_int64_t) :: offset !< Offset within the memory integer(c_int) :: deviceBitMask !< Device ordinal bit mask integer(c_int) :: flags !< flags for future use, must be zero now. integer(c_int) :: reserved(2) !< Reserved for future use, must be zero now. end type hipArrayMapInfo type, bind(c) :: hipMemcpyNodeParams integer(c_int) :: flags !< Must be zero. integer(c_int) :: reserved(3) !< Must be zero. type(hipMemcpy3DParms) :: copyParams !< Params set for the memory copy. end type hipMemcpyNodeParams type, bind(c) :: hipChildGraphNodeParams type(c_ptr) :: graph !< Either the child graph to clone into the node, or a handle to the graph possesed by the node used... end type hipChildGraphNodeParams type, bind(c) :: hipEventWaitNodeParams type(c_ptr) :: event !< Event to wait on end type hipEventWaitNodeParams type, bind(c) :: hipEventRecordNodeParams type(c_ptr) :: event !< The event to be recorded when node executes end type hipEventRecordNodeParams type, bind(c) :: hipMemFreeNodeParams type(c_ptr) :: dptr !< the pointer to be freed end type hipMemFreeNodeParams type, bind(c) :: hipGraphNodeParams integer(c_int) :: type integer(c_int) :: reserved0(3) integer(c_int64_t) :: anonymous_union(29) !< 232-byte C union: keeps the layout exact, members not individually accessible integer(c_int64_t) :: reserved2 end type hipGraphNodeParams type, bind(c) :: hipGraphEdgeData character(c_char) :: from_port !< This indicates when the dependency is triggered from the upstream node on the edge. The... character(c_char) :: reserved(5) !< These bytes are unused and must be zeroed character(c_char) :: to_port !< Currently no node types define non-zero ports. This field must be set to zero. character(c_char) :: type !< This should be populated with a value from hipGraphDependencyType end type hipGraphEdgeData type, bind(c) :: hipLaunchAttribute integer(c_int) :: id !< Identifier of the launch attribute character(c_char) :: pad(4) !< Padding to align the structure to 8 bytes integer(c_int64_t) :: anonymous_union(8) !< 64-byte C union: keeps the layout exact, members not individually accessible end type hipLaunchAttribute type, bind(c) :: hipLaunchConfig_t type(dim3) :: gridDim !< Grid dimensions type(dim3) :: blockDim !< Block dimensions integer(c_size_t) :: dynamicSmemBytes !< Dynamic shared-memory size per thread block type(c_ptr) :: stream !< Stream identifier type(c_ptr) :: attrs !< Attributes list integer(c_int) :: numAttrs !< Number of attributes end type hipLaunchConfig_t type, bind(c) :: HIP_LAUNCH_CONFIG integer(c_int) :: gridDimX !< Grid width in blocks integer(c_int) :: gridDimY !< Grid height in blocks integer(c_int) :: gridDimZ !< Grid depth in blocks integer(c_int) :: blockDimX !< Thread block dimension in X integer(c_int) :: blockDimY !< Thread block dimension in Y integer(c_int) :: blockDimZ !< Thread block dimension in Z integer(c_int) :: sharedMemBytes !< Dynamic shared-memory size in bytes per block type(c_ptr) :: hStream !< HIP stream identifier type(c_ptr) :: attrs !< Attribute list integer(c_int) :: numAttrs !< Number of attributes end type HIP_LAUNCH_CONFIG type, bind(c) :: hipArrayMemoryRequirements integer(c_size_t) :: alignment integer(c_size_t) :: size end type hipArrayMemoryRequirements end module hipfort_types hipfort-rocm-10.0.0/test/000077500000000000000000000000001524740623400151675ustar00rootroot00000000000000hipfort-rocm-10.0.0/test/CMakeLists.txt000066400000000000000000001636541524740623400177460ustar00rootroot00000000000000# # File: test/CMakeLists.txt # Each test is contained in its own subdirectory of this test directory. # The tests are driven by CTest; build the test suite with -DBUILD_TESTING=ON # and run it with `ctest`. cmake_minimum_required(VERSION 3.18..4.0 FATAL_ERROR) if ("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}") project(test-hipfort) endif() # cmake-based test infrastructure if(BUILD_TESTING) # The Intel compilers (ifx/ifort) do not recognize the .f03/.f08 source # extensions and skip such files ("no action performed"). Force Fortran # compilation by inserting -Tf immediately before the source in the compile # rule (set_source_files_properties(LANGUAGE Fortran) alone is not enough). if(CMAKE_Fortran_COMPILER_ID MATCHES "Intel") string(REPLACE "" "-Tf " CMAKE_Fortran_COMPILE_OBJECT "${CMAKE_Fortran_COMPILE_OBJECT}") endif() function(hipfort_add_test lib func dir) # The f2008 tests exercise the array overloads (USE_FPOINTER_INTERFACES) and # the f2018 tests the assumed-rank overloads; skip each when its interface # level is disabled so a plain C-binding build still tests cleanly. if(dir STREQUAL "f2008" AND NOT HIPFORT_USE_FPOINTER_INTERFACES) return() endif() if(dir STREQUAL "f2018" AND NOT HIPFORT_ASSUMED_RANK) return() endif() if(dir STREQUAL "f2008") set(ext "f08") elseif(dir STREQUAL "f2018") # F2018 sources use .f90; .f18 would require compiler-dependent flags. set(ext "f90") else() set(ext "f03") endif() # Build absolute source path and fail early if checkout is incomplete. set(src "${CMAKE_CURRENT_SOURCE_DIR}/${dir}/${lib}/${func}.${ext}") if(NOT EXISTS "${src}") message(FATAL_ERROR "Missing test source: ${src}") endif() # Force language detection for .f03/.f08 in toolchains where CMake misses it. set_source_files_properties("${src}" PROPERTIES LANGUAGE Fortran) add_executable(hipfort_test_${dir}_${lib}_${func} "${src}") set_target_properties(hipfort_test_${dir}_${lib}_${func} PROPERTIES LINKER_LANGUAGE Fortran) target_link_libraries(hipfort_test_${dir}_${lib}_${func} PRIVATE hipfort::${lib} hipfort::hip) # the tests call EXIT, which is a GNU extension in gfortran target_compile_options(hipfort_test_${dir}_${lib}_${func} PRIVATE $<$:-std=gnu>) add_test( NAME hipfort_test_${dir}_${lib}_${func} COMMAND hipfort_test_${dir}_${lib}_${func} ) endfunction() # Extended, exhaustive per-library "symbol" tests (test_.F03), # auto-generated by the rocm-fortran generator # (src/tools/gen_symbol_tests.jl, run with LAYOUT=hipfort). Each references # *every* bind(c) routine of a library through its generic name, guarded # so nothing executes: the point is purely to prove each interface compiles # and each C symbol links. Because they reference every symbol, enabling them # turns an undefined-symbol (missing in the installed ROCm) into a build error # -- handy to audit a specific ROCm version, but off by default so a # partial/older ROCm does not break the normal test build. Reuses the # HIPFORT_EXTENDED_TESTS option declared in the top-level CMakeLists.txt: # like the undefined-symbol shared-link test it gates, this needs a recent, # complete ROCm/CUDA install to be certain it passes. # # The sources are preprocessed .F03: routines with no CUDA counterpart are # wrapped in #ifndef USE_CUDA_NAMES, so the same file also builds on the NVIDIA # backend, where the interfaces bind to cu* symbols. On that backend the test # must be compiled with -DUSE_CUDA_NAMES to match the nvptx library it links. # # Detect the active backend the way lib/CMakeLists.txt does: this test/ tree is # a sibling add_subdirectory and cannot see lib/'s HIP_PLATFORM, so re-run the # same detection here. The symbol tests build whenever HIPFORT_EXTENDED_TESTS is # on and the backend's runtime libraries are found (the per-test if(TARGET # hipfort::) guards handle that); this only decides the symbol naming. # NB: CUDAToolkit is often found on an AMD box too, so it alone is not the # discriminator -- HIP_PLATFORM is. set(_hipfort_cuda_backend FALSE) if(HIPFORT_EXTENDED_TESTS) find_package(hip QUIET PATHS ${ROCM_PATH}) find_package(CUDAToolkit QUIET) if(NOT HIP_PLATFORM STREQUAL "amd" AND CUDAToolkit_FOUND) set(_hipfort_cuda_backend TRUE) endif() endif() function(hipfort_add_symbol_test lib) if(NOT HIPFORT_EXTENDED_TESTS) return() endif() set(src "${CMAKE_CURRENT_SOURCE_DIR}/f2003/${lib}/test_${lib}.F03") if(NOT EXISTS "${src}") message(FATAL_ERROR "Missing symbol test source: ${src}") endif() set(tgt hipfort_test_f2003_${lib}_test_${lib}) set_source_files_properties("${src}" PROPERTIES LANGUAGE Fortran Fortran_PREPROCESS ON) add_executable(${tgt} "${src}") set_target_properties(${tgt} PROPERTIES LINKER_LANGUAGE Fortran) target_link_libraries(${tgt} PRIVATE hipfort::${lib} hipfort::hip) if(_hipfort_cuda_backend) target_compile_definitions(${tgt} PRIVATE USE_CUDA_NAMES) # The HIP runtime maps ~50 routines to the CUDA *driver* API (cu*), which # live in libcuda, not libcudart (hipfort::hip -> CUDA::cudart). Link the # driver stub so the exhaustive runtime symbol test resolves them. if(lib STREQUAL "hip" AND TARGET CUDA::cuda_driver) target_link_libraries(${tgt} PRIVATE CUDA::cuda_driver) endif() endif() add_test(NAME ${tgt} COMMAND ${tgt}) endfunction() if(TARGET hipfort::hipblas) hipfort_add_symbol_test(hipblas) hipfort_add_test(hipblas cgemm f2003) hipfort_add_test(hipblas dgemm f2003) hipfort_add_test(hipblas sgemm f2003) hipfort_add_test(hipblas zgemm f2003) hipfort_add_test(hipblas sgemm_batched f2003) hipfort_add_test(hipblas dgemm_batched f2003) hipfort_add_test(hipblas cgemm_batched f2003) hipfort_add_test(hipblas zgemm_batched f2003) hipfort_add_test(hipblas sgemm_strided_batched f2003) hipfort_add_test(hipblas dgemm_strided_batched f2003) hipfort_add_test(hipblas cgemm_strided_batched f2003) hipfort_add_test(hipblas zgemm_strided_batched f2003) hipfort_add_test(hipblas dger f2003) hipfort_add_test(hipblas dscal f2003) hipfort_add_test(hipblas saxpy f2003) hipfort_add_test(hipblas daxpy f2003) hipfort_add_test(hipblas caxpy f2003) hipfort_add_test(hipblas zaxpy f2003) hipfort_add_test(hipblas scopy f2003) hipfort_add_test(hipblas sgemv f2003) hipfort_add_test(hipblas dgemv f2003) hipfort_add_test(hipblas cgemv f2003) hipfort_add_test(hipblas zgemv f2003) hipfort_add_test(hipblas strsv f2003) hipfort_add_test(hipblas dtrsv f2003) hipfort_add_test(hipblas ctrsv f2003) hipfort_add_test(hipblas ztrsv f2003) hipfort_add_test(hipblas strsm f2003) hipfort_add_test(hipblas dtrsm f2003) hipfort_add_test(hipblas ctrsm f2003) hipfort_add_test(hipblas ztrsm f2003) hipfort_add_test(hipblas sdot f2003) hipfort_add_test(hipblas ddot f2003) hipfort_add_test(hipblas cdotu f2003) hipfort_add_test(hipblas cdotc f2003) hipfort_add_test(hipblas zdotu f2003) hipfort_add_test(hipblas zdotc f2003) hipfort_add_test(hipblas sger f2003) hipfort_add_test(hipblas sswap f2003) hipfort_add_test(hipblas cgemm f2008) hipfort_add_test(hipblas dgemm f2008) hipfort_add_test(hipblas sgemm f2008) hipfort_add_test(hipblas zgemm f2008) hipfort_add_test(hipblas sgemm_batched f2008) hipfort_add_test(hipblas dgemm_batched f2008) hipfort_add_test(hipblas cgemm_batched f2008) hipfort_add_test(hipblas zgemm_batched f2008) hipfort_add_test(hipblas sgemm_strided_batched f2008) hipfort_add_test(hipblas dgemm_strided_batched f2008) hipfort_add_test(hipblas cgemm_strided_batched f2008) hipfort_add_test(hipblas zgemm_strided_batched f2008) hipfort_add_test(hipblas dger f2008) hipfort_add_test(hipblas dscal f2008) hipfort_add_test(hipblas saxpy f2008) hipfort_add_test(hipblas daxpy f2008) hipfort_add_test(hipblas caxpy f2008) hipfort_add_test(hipblas zaxpy f2008) hipfort_add_test(hipblas scopy f2008) hipfort_add_test(hipblas sgemv f2008) hipfort_add_test(hipblas dgemv f2008) hipfort_add_test(hipblas cgemv f2008) hipfort_add_test(hipblas zgemv f2008) hipfort_add_test(hipblas strsv f2008) hipfort_add_test(hipblas dtrsv f2008) hipfort_add_test(hipblas ctrsv f2008) hipfort_add_test(hipblas ztrsv f2008) hipfort_add_test(hipblas strsm f2008) hipfort_add_test(hipblas dtrsm f2008) hipfort_add_test(hipblas ctrsm f2008) hipfort_add_test(hipblas ztrsm f2008) hipfort_add_test(hipblas sdot f2008) hipfort_add_test(hipblas ddot f2008) hipfort_add_test(hipblas cdotu f2008) hipfort_add_test(hipblas cdotc f2008) hipfort_add_test(hipblas zdotu f2008) hipfort_add_test(hipblas zdotc f2008) hipfort_add_test(hipblas sger f2008) hipfort_add_test(hipblas sswap f2008) hipfort_add_test(hipblas stpsv f2008) endif() if(TARGET hipfort::hipfft) hipfort_add_symbol_test(hipfft) hipfort_add_test(hipfft hipfft f2003) hipfort_add_test(hipfft hipfft f2008) hipfort_add_test(hipfft hipfft_c2c_1d_z f2003) hipfort_add_test(hipfft hipfft_c2c_1d_z f2008) hipfort_add_test(hipfft hipfft_c2c_1d_c f2003) hipfort_add_test(hipfft hipfft_c2c_1d_c f2008) hipfort_add_test(hipfft hipfft_r2c_c2r_1d_d f2003) hipfort_add_test(hipfft hipfft_r2c_c2r_1d_d f2008) hipfort_add_test(hipfft hipfft_r2c_c2r_1d_s f2003) hipfort_add_test(hipfft hipfft_r2c_c2r_1d_s f2008) hipfort_add_test(hipfft hipfft_c2c_2d_z f2003) hipfort_add_test(hipfft hipfft_c2c_2d_z f2008) hipfort_add_test(hipfft hipfft_c2c_3d_z f2003) hipfort_add_test(hipfft hipfft_c2c_3d_z f2008) hipfort_add_test(hipfft hipfft_c2c_1d_batched_z f2003) hipfort_add_test(hipfft hipfft_c2c_1d_batched_z f2008) hipfort_add_test(hipfft hipfft_planmany_2d_z2z f2003) hipfort_add_test(hipfft hipfft_planmany_2d_z2z f2008) hipfort_add_test(hipfft hipfft_makeplanmany_z f2003) hipfort_add_test(hipfft hipfft_makeplanmany_z f2008) hipfort_add_test(hipfft hipfft_estimate_getsize_d f2003) hipfort_add_test(hipfft hipfft_estimate_getsize_d f2008) hipfort_add_test(hipfft hipfft_setstream_z f2003) hipfort_add_test(hipfft hipfft_setstream_z f2008) endif() if(TARGET hipfort::hipfftw) hipfort_add_symbol_test(hipfftw) # Detect hipfftw API features based on hipfft version. # Version-to-feature mapping (based on ROCm releases): # hipfft < 1.0.21: no hipfftw library # hipfft 1.0.21: hipfftw exists but no fftw_execute_dft (ROCm 7.1) # hipfft 1.0.22: adds fftw_execute_dft (ROCm 7.2) # hipfft 1.0.23+: adds fftw_plan_many_dft and fftw_plan_guru_dft # (therock/ROCm 7.3+) set(HIPFFTW_HAS_EXECUTE_DFT FALSE) set(HIPFFTW_HAS_PLAN_MANY_DFT FALSE) # hipfft's config doesn't export hipfft_VERSION, so extract it from the version file set(_hipfft_version_file "${hipfft_DIR}/hipfft-config-version.cmake") if(EXISTS "${_hipfft_version_file}") file(STRINGS "${_hipfft_version_file}" _hipfft_version_line REGEX "^set\\(PACKAGE_VERSION \"[0-9]+\\.[0-9]+\\.[0-9]+\"\\)") if(_hipfft_version_line) string(REGEX REPLACE ".*\"([0-9]+\\.[0-9]+\\.[0-9]+)\".*" "\\1" _hipfft_version "${_hipfft_version_line}") message(STATUS "Detected hipfft version: ${_hipfft_version}") if(_hipfft_version VERSION_GREATER_EQUAL "1.0.22") set(HIPFFTW_HAS_EXECUTE_DFT TRUE) endif() if(_hipfft_version VERSION_GREATER_EQUAL "1.0.23") set(HIPFFTW_HAS_PLAN_MANY_DFT TRUE) endif() endif() else() message(STATUS "hipfft version file not found, cannot detect hipfftw features") endif() if(HIPFFTW_HAS_EXECUTE_DFT) hipfort_add_test(hipfftw hipfftw_c2c f2003) hipfort_add_test(hipfftw hipfftw_r2c_c2r f2003) hipfort_add_test(hipfftw hipfftw_dft_2d f2003) hipfort_add_test(hipfftw hipfftw_dft_3d f2003) hipfort_add_test(hipfftw hipfftw_alloc f2003) else() message(STATUS "Skipping hipfftw c2c/r2c_c2r/dft_2d/dft_3d tests (requires hipfft >= 1.0.22)") endif() if(HIPFFTW_HAS_PLAN_MANY_DFT) hipfort_add_test(hipfftw hipfftw_many f2003) hipfort_add_test(hipfftw hipfftw_guru f2003) else() message(STATUS "Skipping hipfftw_many/hipfftw_guru tests (requires hipfft >= 1.0.23)") endif() endif() if(TARGET hipfort::hipsolver) hipfort_add_symbol_test(hipsolver) hipfort_add_test(hipsolver hipsolver_sgetrf f2003) hipfort_add_test(hipsolver hipsolver_dgetrf f2003) hipfort_add_test(hipsolver hipsolver_cgetrf f2003) hipfort_add_test(hipsolver hipsolver_zgetrf f2003) hipfort_add_test(hipsolver hipsolver_sgetrf f2008) hipfort_add_test(hipsolver hipsolver_dgetrf f2008) hipfort_add_test(hipsolver hipsolver_cgetrf f2008) hipfort_add_test(hipsolver hipsolver_zgetrf f2008) hipfort_add_test(hipsolver hipsolver_dpotrf f2008) hipfort_add_test(hipsolver hipsolver_spotrfbatched f2003) hipfort_add_test(hipsolver hipsolver_spotrfbatched f2008) hipfort_add_test(hipsolver hipsolver_dpotrfbatched f2003) hipfort_add_test(hipsolver hipsolver_dpotrfbatched f2008) hipfort_add_test(hipsolver hipsolver_cpotrfbatched f2003) hipfort_add_test(hipsolver hipsolver_cpotrfbatched f2008) hipfort_add_test(hipsolver hipsolver_zpotrfbatched f2003) hipfort_add_test(hipsolver hipsolver_zpotrfbatched f2008) hipfort_add_test(hipsolver hipsolver_dsyevd f2008) hipfort_add_test(hipsolver hipsolver_ssyevd f2008) hipfort_add_test(hipsolver hipsolver_cheevd f2008) hipfort_add_test(hipsolver hipsolver_zheevd f2008) hipfort_add_test(hipsolver hipsolver_ssyevd f2003) hipfort_add_test(hipsolver hipsolver_cheevd f2003) hipfort_add_test(hipsolver hipsolver_zheevd f2003) hipfort_add_test(hipsolver hipsolver_sgesvd f2008) hipfort_add_test(hipsolver hipsolver_cgesvd f2008) hipfort_add_test(hipsolver hipsolver_zgesvd f2008) hipfort_add_test(hipsolver hipsolver_sgesvd f2003) hipfort_add_test(hipsolver hipsolver_cgesvd f2003) hipfort_add_test(hipsolver hipsolver_zgesvd f2003) hipfort_add_test(hipsolver hipsolver_ssyevdx f2008) hipfort_add_test(hipsolver hipsolver_dsyevdx f2008) hipfort_add_test(hipsolver hipsolver_cheevdx f2008) hipfort_add_test(hipsolver hipsolver_zheevdx f2008) hipfort_add_test(hipsolver hipsolver_ssygvd f2008) hipfort_add_test(hipsolver hipsolver_dsygvd f2008) hipfort_add_test(hipsolver hipsolver_chegvd f2008) hipfort_add_test(hipsolver hipsolver_zhegvd f2008) hipfort_add_test(hipsolver hipsolver_ssygvdx f2008) hipfort_add_test(hipsolver hipsolver_dsygvdx f2008) hipfort_add_test(hipsolver hipsolver_chegvdx f2008) hipfort_add_test(hipsolver hipsolver_zhegvdx f2008) hipfort_add_test(hipsolver hipsolver_ssyevdx f2003) hipfort_add_test(hipsolver hipsolver_dsyevdx f2003) hipfort_add_test(hipsolver hipsolver_cheevdx f2003) hipfort_add_test(hipsolver hipsolver_zheevdx f2003) hipfort_add_test(hipsolver hipsolver_ssygvd f2003) hipfort_add_test(hipsolver hipsolver_dsygvd f2003) hipfort_add_test(hipsolver hipsolver_chegvd f2003) hipfort_add_test(hipsolver hipsolver_zhegvd f2003) hipfort_add_test(hipsolver hipsolver_ssygvdx f2003) hipfort_add_test(hipsolver hipsolver_dsygvdx f2003) hipfort_add_test(hipsolver hipsolver_chegvdx f2003) hipfort_add_test(hipsolver hipsolver_zhegvdx f2003) hipfort_add_test(hipsolver hipsolver_dgetrs f2008) hipfort_add_test(hipsolver hipsolver_dgesvd f2008) hipfort_add_test(hipsolver hipsolver_sgeqrf f2003) hipfort_add_test(hipsolver hipsolver_sgeqrf f2008) hipfort_add_test(hipsolver hipsolver_dgeqrf f2003) hipfort_add_test(hipsolver hipsolver_dgeqrf f2008) hipfort_add_test(hipsolver hipsolver_cgeqrf f2003) hipfort_add_test(hipsolver hipsolver_cgeqrf f2008) hipfort_add_test(hipsolver hipsolver_zgeqrf f2003) hipfort_add_test(hipsolver hipsolver_zgeqrf f2008) hipfort_add_test(hipsolver hipsolver_sorgqr f2003) hipfort_add_test(hipsolver hipsolver_sorgqr f2008) hipfort_add_test(hipsolver hipsolver_dorgqr f2003) hipfort_add_test(hipsolver hipsolver_dorgqr f2008) hipfort_add_test(hipsolver hipsolver_cungqr f2003) hipfort_add_test(hipsolver hipsolver_cungqr f2008) hipfort_add_test(hipsolver hipsolver_zungqr f2003) hipfort_add_test(hipsolver hipsolver_zungqr f2008) hipfort_add_test(hipsolver hipsolver_spotrs f2003) hipfort_add_test(hipsolver hipsolver_spotrs f2008) hipfort_add_test(hipsolver hipsolver_dpotrs f2003) hipfort_add_test(hipsolver hipsolver_dpotrs f2008) hipfort_add_test(hipsolver hipsolver_cpotrs f2003) hipfort_add_test(hipsolver hipsolver_cpotrs f2008) hipfort_add_test(hipsolver hipsolver_zpotrs f2003) hipfort_add_test(hipsolver hipsolver_zpotrs f2008) hipfort_add_test(hipsolver hipsolver_ssyevj f2003) hipfort_add_test(hipsolver hipsolver_ssyevj f2008) hipfort_add_test(hipsolver hipsolver_dsyevj f2003) hipfort_add_test(hipsolver hipsolver_dsyevj f2008) hipfort_add_test(hipsolver hipsolver_sgesvdj f2003) hipfort_add_test(hipsolver hipsolver_sgesvdj f2008) hipfort_add_test(hipsolver hipsolver_dgesvdj f2003) hipfort_add_test(hipsolver hipsolver_dgesvdj f2008) hipfort_add_test(hipsolver hipsolver_cgesvdj f2003) hipfort_add_test(hipsolver hipsolver_cgesvdj f2008) hipfort_add_test(hipsolver hipsolver_zgesvdj f2003) hipfort_add_test(hipsolver hipsolver_zgesvdj f2008) hipfort_add_test(hipsolver hipsolver_dormqr f2003) hipfort_add_test(hipsolver hipsolver_dormqr f2008) hipfort_add_test(hipsolver hipsolver_sormqr f2003) hipfort_add_test(hipsolver hipsolver_sormqr f2008) hipfort_add_test(hipsolver hipsolver_cunmqr f2003) hipfort_add_test(hipsolver hipsolver_cunmqr f2008) hipfort_add_test(hipsolver hipsolver_zunmqr f2003) hipfort_add_test(hipsolver hipsolver_zunmqr f2008) endif() if(TARGET hipfort::hipsparse) hipfort_add_symbol_test(hipsparse) hipfort_add_test(hipsparse hipsparse_sgtsv f2008) hipfort_add_test(hipsparse hipsparse_scsr2csc f2008) hipfort_add_test(hipsparse hipsparse_xcsr2coo f2008) hipfort_add_test(hipsparse hipsparse_xcsr2coo f2003) hipfort_add_test(hipsparse hipsparse_xcoo2csr f2003) hipfort_add_test(hipsparse hipsparse_xcoo2csr f2008) hipfort_add_test(hipsparse hipsparse_sgthr f2003) hipfort_add_test(hipsparse hipsparse_sgthr f2008) hipfort_add_test(hipsparse hipsparse_dgthr f2003) hipfort_add_test(hipsparse hipsparse_dgthr f2008) hipfort_add_test(hipsparse hipsparse_cgthr f2003) hipfort_add_test(hipsparse hipsparse_cgthr f2008) hipfort_add_test(hipsparse hipsparse_zgthr f2003) hipfort_add_test(hipsparse hipsparse_zgthr f2008) hipfort_add_test(hipsparse hipsparse_ssctr f2003) hipfort_add_test(hipsparse hipsparse_ssctr f2008) hipfort_add_test(hipsparse hipsparse_dsctr f2003) hipfort_add_test(hipsparse hipsparse_dsctr f2008) hipfort_add_test(hipsparse hipsparse_csctr f2003) hipfort_add_test(hipsparse hipsparse_csctr f2008) hipfort_add_test(hipsparse hipsparse_zsctr f2003) hipfort_add_test(hipsparse hipsparse_zsctr f2008) hipfort_add_test(hipsparse hipsparse_sgemvi f2003) hipfort_add_test(hipsparse hipsparse_sgemvi f2008) hipfort_add_test(hipsparse hipsparse_dgemvi f2003) hipfort_add_test(hipsparse hipsparse_dgemvi f2008) hipfort_add_test(hipsparse hipsparse_cgemvi f2003) hipfort_add_test(hipsparse hipsparse_cgemvi f2008) hipfort_add_test(hipsparse hipsparse_zgemvi f2003) hipfort_add_test(hipsparse hipsparse_zgemvi f2008) hipfort_add_test(hipsparse hipsparse_scsrsv2 f2003) hipfort_add_test(hipsparse hipsparse_scsrsv2 f2008) hipfort_add_test(hipsparse hipsparse_dcsrsv2 f2003) hipfort_add_test(hipsparse hipsparse_dcsrsv2 f2008) hipfort_add_test(hipsparse hipsparse_ccsrsv2 f2003) hipfort_add_test(hipsparse hipsparse_ccsrsv2 f2008) hipfort_add_test(hipsparse hipsparse_zcsrsv2 f2003) hipfort_add_test(hipsparse hipsparse_zcsrsv2 f2008) hipfort_add_test(hipsparse hipsparse_scsrilu02 f2003) hipfort_add_test(hipsparse hipsparse_scsrilu02 f2008) hipfort_add_test(hipsparse hipsparse_dcsrilu02 f2003) hipfort_add_test(hipsparse hipsparse_dcsrilu02 f2008) hipfort_add_test(hipsparse hipsparse_ccsrilu02 f2003) hipfort_add_test(hipsparse hipsparse_ccsrilu02 f2008) hipfort_add_test(hipsparse hipsparse_zcsrilu02 f2003) hipfort_add_test(hipsparse hipsparse_zcsrilu02 f2008) hipfort_add_test(hipsparse hipsparse_sspmv f2003) hipfort_add_test(hipsparse hipsparse_sspmv f2008) hipfort_add_test(hipsparse hipsparse_dspmv f2003) hipfort_add_test(hipsparse hipsparse_dspmv f2008) hipfort_add_test(hipsparse hipsparse_cspmv f2003) hipfort_add_test(hipsparse hipsparse_cspmv f2008) hipfort_add_test(hipsparse hipsparse_zspmv f2003) hipfort_add_test(hipsparse hipsparse_zspmv f2008) hipfort_add_test(hipsparse hipsparse_sspmm f2003) hipfort_add_test(hipsparse hipsparse_sspmm f2008) hipfort_add_test(hipsparse hipsparse_dspmm f2003) hipfort_add_test(hipsparse hipsparse_dspmm f2008) hipfort_add_test(hipsparse hipsparse_cspmm f2003) hipfort_add_test(hipsparse hipsparse_cspmm f2008) hipfort_add_test(hipsparse hipsparse_zspmm f2003) hipfort_add_test(hipsparse hipsparse_zspmm f2008) hipfort_add_test(hipsparse hipsparse_ssddmm f2003) hipfort_add_test(hipsparse hipsparse_ssddmm f2008) hipfort_add_test(hipsparse hipsparse_dsddmm f2003) hipfort_add_test(hipsparse hipsparse_dsddmm f2008) hipfort_add_test(hipsparse hipsparse_csddmm f2003) hipfort_add_test(hipsparse hipsparse_csddmm f2008) hipfort_add_test(hipsparse hipsparse_zsddmm f2003) hipfort_add_test(hipsparse hipsparse_zsddmm f2008) hipfort_add_test(hipsparse hipsparse_scsrgemm f2003) hipfort_add_test(hipsparse hipsparse_scsrgemm f2008) hipfort_add_test(hipsparse hipsparse_dcsrgemm f2003) hipfort_add_test(hipsparse hipsparse_dcsrgemm f2008) hipfort_add_test(hipsparse hipsparse_ccsrgemm f2003) hipfort_add_test(hipsparse hipsparse_ccsrgemm f2008) hipfort_add_test(hipsparse hipsparse_zcsrgemm f2003) hipfort_add_test(hipsparse hipsparse_zcsrgemm f2008) hipfort_add_test(hipsparse hipsparse_ssptrsv f2003) hipfort_add_test(hipsparse hipsparse_ssptrsv f2008) hipfort_add_test(hipsparse hipsparse_dsptrsv f2003) hipfort_add_test(hipsparse hipsparse_dsptrsv f2008) hipfort_add_test(hipsparse hipsparse_csptrsv f2003) hipfort_add_test(hipsparse hipsparse_csptrsv f2008) hipfort_add_test(hipsparse hipsparse_zsptrsv f2003) hipfort_add_test(hipsparse hipsparse_zsptrsv f2008) hipfort_add_test(hipsparse hipsparse_ssptrsm f2003) hipfort_add_test(hipsparse hipsparse_ssptrsm f2008) hipfort_add_test(hipsparse hipsparse_dsptrsm f2003) hipfort_add_test(hipsparse hipsparse_dsptrsm f2008) hipfort_add_test(hipsparse hipsparse_csptrsm f2003) hipfort_add_test(hipsparse hipsparse_csptrsm f2008) hipfort_add_test(hipsparse hipsparse_zsptrsm f2003) hipfort_add_test(hipsparse hipsparse_zsptrsm f2008) hipfort_add_test(hipsparse hipsparse_dcsr2csc f2003) hipfort_add_test(hipsparse hipsparse_dcsr2csc f2008) hipfort_add_test(hipsparse hipsparse_ccsr2csc f2003) hipfort_add_test(hipsparse hipsparse_ccsr2csc f2008) hipfort_add_test(hipsparse hipsparse_zcsr2csc f2003) hipfort_add_test(hipsparse hipsparse_zcsr2csc f2008) endif() if(TARGET hipfort::rocblas) hipfort_add_symbol_test(rocblas) hipfort_add_test(rocblas saxpy f2003) hipfort_add_test(rocblas daxpy f2003) hipfort_add_test(rocblas caxpy f2003) hipfort_add_test(rocblas zaxpy f2003) hipfort_add_test(rocblas dtrmm f2003) hipfort_add_test(rocblas saxpy f2008) hipfort_add_test(rocblas daxpy f2008) hipfort_add_test(rocblas saxpy f2018) hipfort_add_test(rocblas caxpy f2008) hipfort_add_test(rocblas zaxpy f2008) hipfort_add_test(rocblas dtrmm f2008) hipfort_add_test(rocblas sgemm f2003) hipfort_add_test(rocblas dgemm f2003) hipfort_add_test(rocblas cgemm f2003) hipfort_add_test(rocblas zgemm f2003) hipfort_add_test(rocblas sgemm f2008) hipfort_add_test(rocblas dgemm f2008) hipfort_add_test(rocblas cgemm f2008) hipfort_add_test(rocblas zgemm f2008) hipfort_add_test(rocblas sgemm_batched f2003) hipfort_add_test(rocblas dgemm_batched f2003) hipfort_add_test(rocblas cgemm_batched f2003) hipfort_add_test(rocblas zgemm_batched f2003) hipfort_add_test(rocblas sgemm_strided_batched f2003) hipfort_add_test(rocblas dgemm_strided_batched f2003) hipfort_add_test(rocblas cgemm_strided_batched f2003) hipfort_add_test(rocblas zgemm_strided_batched f2003) hipfort_add_test(rocblas sgemm_batched f2008) hipfort_add_test(rocblas dgemm_batched f2008) hipfort_add_test(rocblas cgemm_batched f2008) hipfort_add_test(rocblas zgemm_batched f2008) hipfort_add_test(rocblas sgemm_strided_batched f2008) hipfort_add_test(rocblas dgemm_strided_batched f2008) hipfort_add_test(rocblas cgemm_strided_batched f2008) hipfort_add_test(rocblas zgemm_strided_batched f2008) hipfort_add_test(rocblas sgemv f2003) hipfort_add_test(rocblas dgemv f2003) hipfort_add_test(rocblas cgemv f2003) hipfort_add_test(rocblas zgemv f2003) hipfort_add_test(rocblas sgemv f2008) hipfort_add_test(rocblas dgemv f2008) hipfort_add_test(rocblas cgemv f2008) hipfort_add_test(rocblas zgemv f2008) hipfort_add_test(rocblas strsv f2003) hipfort_add_test(rocblas dtrsv f2003) hipfort_add_test(rocblas ctrsv f2003) hipfort_add_test(rocblas ztrsv f2003) hipfort_add_test(rocblas strsv f2008) hipfort_add_test(rocblas dtrsv f2008) hipfort_add_test(rocblas ctrsv f2008) hipfort_add_test(rocblas ztrsv f2008) hipfort_add_test(rocblas stpsv f2008) hipfort_add_test(rocblas strsm f2003) hipfort_add_test(rocblas dtrsm f2003) hipfort_add_test(rocblas ctrsm f2003) hipfort_add_test(rocblas ztrsm f2003) hipfort_add_test(rocblas strsm f2008) hipfort_add_test(rocblas dtrsm f2008) hipfort_add_test(rocblas ctrsm f2008) hipfort_add_test(rocblas ztrsm f2008) hipfort_add_test(rocblas sdot f2003) hipfort_add_test(rocblas ddot f2003) hipfort_add_test(rocblas cdotu f2003) hipfort_add_test(rocblas cdotc f2003) hipfort_add_test(rocblas zdotu f2003) hipfort_add_test(rocblas zdotc f2003) hipfort_add_test(rocblas sdot f2008) hipfort_add_test(rocblas ddot f2008) hipfort_add_test(rocblas cdotu f2008) hipfort_add_test(rocblas cdotc f2008) hipfort_add_test(rocblas zdotu f2008) hipfort_add_test(rocblas zdotc f2008) hipfort_add_test(rocblas sscal f2003) hipfort_add_test(rocblas dscal f2003) hipfort_add_test(rocblas cscal f2003) hipfort_add_test(rocblas zscal f2003) hipfort_add_test(rocblas csscal f2003) hipfort_add_test(rocblas zdscal f2003) hipfort_add_test(rocblas sscal f2008) hipfort_add_test(rocblas dscal f2008) hipfort_add_test(rocblas cscal f2008) hipfort_add_test(rocblas zscal f2008) hipfort_add_test(rocblas csscal f2008) hipfort_add_test(rocblas zdscal f2008) hipfort_add_test(rocblas dgemv_batched f2008) endif() if(TARGET hipfort::rocrand) hipfort_add_symbol_test(rocrand) hipfort_add_test(rocrand xorwow_uniform f2003) hipfort_add_test(rocrand xorwow_normal f2003) hipfort_add_test(rocrand philox_uniform f2003) hipfort_add_test(rocrand philox_normal f2003) hipfort_add_test(rocrand xorwow_uniform f2008) hipfort_add_test(rocrand xorwow_normal f2008) hipfort_add_test(rocrand philox_uniform f2008) hipfort_add_test(rocrand philox_normal f2008) hipfort_add_test(rocrand xorwow_uniform_double f2003) hipfort_add_test(rocrand xorwow_normal_double f2003) hipfort_add_test(rocrand philox_uniform_double f2003) hipfort_add_test(rocrand philox_normal_double f2003) hipfort_add_test(rocrand xorwow_uniform_double f2008) hipfort_add_test(rocrand xorwow_normal_double f2008) hipfort_add_test(rocrand philox_uniform_double f2008) hipfort_add_test(rocrand philox_normal_double f2008) endif() if(TARGET hipfort::hiprand) hipfort_add_symbol_test(hiprand) hipfort_add_test(hiprand xorwow_uniform f2003) hipfort_add_test(hiprand xorwow_normal f2003) hipfort_add_test(hiprand philox_uniform f2003) hipfort_add_test(hiprand philox_normal f2003) hipfort_add_test(hiprand xorwow_uniform f2008) hipfort_add_test(hiprand xorwow_normal f2008) hipfort_add_test(hiprand philox_uniform f2008) hipfort_add_test(hiprand philox_normal f2008) hipfort_add_test(hiprand xorwow_uniform_double f2003) hipfort_add_test(hiprand xorwow_normal_double f2003) hipfort_add_test(hiprand philox_uniform_double f2003) hipfort_add_test(hiprand philox_normal_double f2003) hipfort_add_test(hiprand xorwow_uniform_double f2008) hipfort_add_test(hiprand xorwow_normal_double f2008) hipfort_add_test(hiprand philox_uniform_double f2008) hipfort_add_test(hiprand philox_normal_double f2008) endif() if(TARGET hipfort::rocfft) hipfort_add_symbol_test(rocfft) hipfort_add_test(rocfft rocfft f2003) hipfort_add_test(rocfft rocfft f2008) hipfort_add_test(rocfft rocfft_c2c_1d_z f2003) hipfort_add_test(rocfft rocfft_c2c_1d_z f2008) hipfort_add_test(rocfft rocfft_c2c_1d_c f2003) hipfort_add_test(rocfft rocfft_c2c_1d_c f2008) hipfort_add_test(rocfft rocfft_r2c_c2r_1d_d f2003) hipfort_add_test(rocfft rocfft_r2c_c2r_1d_d f2008) hipfort_add_test(rocfft rocfft_r2c_c2r_1d_s f2003) hipfort_add_test(rocfft rocfft_r2c_c2r_1d_s f2008) hipfort_add_test(rocfft rocfft_r2c_c2r_1d_inplace_d f2003) hipfort_add_test(rocfft rocfft_r2c_c2r_1d_inplace_d f2008) hipfort_add_test(rocfft rocfft_c2c_2d_z f2003) hipfort_add_test(rocfft rocfft_c2c_2d_z f2008) hipfort_add_test(rocfft rocfft_c2c_3d_z f2003) hipfort_add_test(rocfft rocfft_c2c_3d_z f2008) hipfort_add_test(rocfft rocfft_c2c_1d_batched_z f2003) hipfort_add_test(rocfft rocfft_c2c_1d_batched_z f2008) hipfort_add_test(rocfft rocfft_c2c_1d_notinplace_z f2003) hipfort_add_test(rocfft rocfft_c2c_1d_notinplace_z f2008) hipfort_add_test(rocfft rocfft_scale_factor_z f2003) hipfort_add_test(rocfft rocfft_scale_factor_z f2008) hipfort_add_test(rocfft rocfft_work_buffer_z f2003) hipfort_add_test(rocfft rocfft_work_buffer_z f2008) hipfort_add_test(rocfft rocfft_stream_z f2003) hipfort_add_test(rocfft rocfft_stream_z f2008) hipfort_add_test(rocfft rocfft_version f2003) hipfort_add_test(rocfft rocfft_version f2008) hipfort_add_test(rocfft rocfft_plan_print_z f2003) hipfort_add_test(rocfft rocfft_plan_print_z f2008) hipfort_add_test(rocfft rocfft_cache_z f2003) hipfort_add_test(rocfft rocfft_cache_z f2008) hipfort_add_test(rocfft rocfft_callback_z f2003) hipfort_add_test(rocfft rocfft_callback_z f2008) # Single-process multi-GPU field/brick decomposition; skips on < 2 GPUs. hipfort_add_test(rocfft rocfft_field_brick_z f2003) hipfort_add_test(rocfft rocfft_field_brick_z f2008) endif() if(TARGET hipfort::rocsolver) hipfort_add_symbol_test(rocsolver) hipfort_add_test(rocsolver rocsolver_dgeqrf f2003) hipfort_add_test(rocsolver rocsolver_dgeqrf f2008) hipfort_add_test(rocsolver rocsolver_dsterf f2003) hipfort_add_test(rocsolver rocsolver_dsterf f2008) hipfort_add_test(rocsolver rocsolver_dgetrf_strided_batched f2003) hipfort_add_test(rocsolver rocsolver_dgetrf f2003) hipfort_add_test(rocsolver rocsolver_sgeqrf f2003) hipfort_add_test(rocsolver rocsolver_cgeqrf f2003) hipfort_add_test(rocsolver rocsolver_zgeqrf f2003) hipfort_add_test(rocsolver rocsolver_sgetrf f2003) hipfort_add_test(rocsolver rocsolver_cgetrf f2003) hipfort_add_test(rocsolver rocsolver_zgetrf f2003) hipfort_add_test(rocsolver rocsolver_spotrf f2003) hipfort_add_test(rocsolver rocsolver_dpotrf f2003) hipfort_add_test(rocsolver rocsolver_cpotrf f2003) hipfort_add_test(rocsolver rocsolver_zpotrf f2003) hipfort_add_test(rocsolver rocsolver_sgetrs f2003) hipfort_add_test(rocsolver rocsolver_dgetrs f2003) hipfort_add_test(rocsolver rocsolver_cgetrs f2003) hipfort_add_test(rocsolver rocsolver_zgetrs f2003) hipfort_add_test(rocsolver rocsolver_spotrs f2003) hipfort_add_test(rocsolver rocsolver_dpotrs f2003) hipfort_add_test(rocsolver rocsolver_cpotrs f2003) hipfort_add_test(rocsolver rocsolver_zpotrs f2003) hipfort_add_test(rocsolver rocsolver_sgesvd f2003) hipfort_add_test(rocsolver rocsolver_dgesvd f2003) hipfort_add_test(rocsolver rocsolver_cgesvd f2003) hipfort_add_test(rocsolver rocsolver_zgesvd f2003) hipfort_add_test(rocsolver rocsolver_ssyevd f2003) hipfort_add_test(rocsolver rocsolver_dsyevd f2003) hipfort_add_test(rocsolver rocsolver_cheevd f2003) hipfort_add_test(rocsolver rocsolver_zheevd f2003) hipfort_add_test(rocsolver rocsolver_dgetrf_strided_batched f2008) hipfort_add_test(rocsolver rocsolver_sgeqrf f2008) hipfort_add_test(rocsolver rocsolver_cgeqrf f2008) hipfort_add_test(rocsolver rocsolver_zgeqrf f2008) hipfort_add_test(rocsolver rocsolver_sgetrf f2008) hipfort_add_test(rocsolver rocsolver_dgetrf f2008) hipfort_add_test(rocsolver rocsolver_cgetrf f2008) hipfort_add_test(rocsolver rocsolver_zgetrf f2008) hipfort_add_test(rocsolver rocsolver_spotrf f2008) hipfort_add_test(rocsolver rocsolver_dpotrf f2008) hipfort_add_test(rocsolver rocsolver_cpotrf f2008) hipfort_add_test(rocsolver rocsolver_zpotrf f2008) hipfort_add_test(rocsolver rocsolver_sgetrs f2008) hipfort_add_test(rocsolver rocsolver_dgetrs f2008) hipfort_add_test(rocsolver rocsolver_cgetrs f2008) hipfort_add_test(rocsolver rocsolver_zgetrs f2008) hipfort_add_test(rocsolver rocsolver_spotrs f2008) hipfort_add_test(rocsolver rocsolver_dpotrs f2008) hipfort_add_test(rocsolver rocsolver_cpotrs f2008) hipfort_add_test(rocsolver rocsolver_zpotrs f2008) hipfort_add_test(rocsolver rocsolver_sgesvd f2008) hipfort_add_test(rocsolver rocsolver_dgesvd f2008) hipfort_add_test(rocsolver rocsolver_cgesvd f2008) hipfort_add_test(rocsolver rocsolver_zgesvd f2008) hipfort_add_test(rocsolver rocsolver_ssyevd f2008) hipfort_add_test(rocsolver rocsolver_dsyevd f2008) hipfort_add_test(rocsolver rocsolver_cheevd f2008) hipfort_add_test(rocsolver rocsolver_zheevd f2008) hipfort_add_test(rocsolver rocsolver_ssyevdx f2008) hipfort_add_test(rocsolver rocsolver_dsyevdx f2008) hipfort_add_test(rocsolver rocsolver_cheevdx f2008) hipfort_add_test(rocsolver rocsolver_zheevdx f2008) hipfort_add_test(rocsolver rocsolver_ssygvd f2008) hipfort_add_test(rocsolver rocsolver_dsygvd f2008) hipfort_add_test(rocsolver rocsolver_chegvd f2008) hipfort_add_test(rocsolver rocsolver_zhegvd f2008) hipfort_add_test(rocsolver rocsolver_ssygvdx f2008) hipfort_add_test(rocsolver rocsolver_dsygvdx f2008) hipfort_add_test(rocsolver rocsolver_chegvdx f2008) hipfort_add_test(rocsolver rocsolver_zhegvdx f2008) hipfort_add_test(rocsolver rocsolver_ssyevdx f2003) hipfort_add_test(rocsolver rocsolver_dsyevdx f2003) hipfort_add_test(rocsolver rocsolver_cheevdx f2003) hipfort_add_test(rocsolver rocsolver_zheevdx f2003) hipfort_add_test(rocsolver rocsolver_ssygvd f2003) hipfort_add_test(rocsolver rocsolver_dsygvd f2003) hipfort_add_test(rocsolver rocsolver_chegvd f2003) hipfort_add_test(rocsolver rocsolver_zhegvd f2003) hipfort_add_test(rocsolver rocsolver_ssygvdx f2003) hipfort_add_test(rocsolver rocsolver_dsygvdx f2003) hipfort_add_test(rocsolver rocsolver_chegvdx f2003) hipfort_add_test(rocsolver rocsolver_zhegvdx f2003) hipfort_add_test(rocsolver rocsolver_dgesv f2003) hipfort_add_test(rocsolver rocsolver_dgesv f2008) hipfort_add_test(rocsolver rocsolver_dgetri f2003) hipfort_add_test(rocsolver rocsolver_dgetri f2008) hipfort_add_test(rocsolver rocsolver_dlatrd f2003) hipfort_add_test(rocsolver rocsolver_dlatrd f2008) hipfort_add_test(rocsolver rocsolver_dsytrd f2003) hipfort_add_test(rocsolver rocsolver_dsytrd f2008) hipfort_add_test(rocsolver rocsolver_dlarft f2003) hipfort_add_test(rocsolver rocsolver_dlarft f2008) hipfort_add_test(rocsolver rocsolver_dtrtri f2003) hipfort_add_test(rocsolver rocsolver_dtrtri f2008) hipfort_add_test(rocsolver rocsolver_dposv f2003) hipfort_add_test(rocsolver rocsolver_dposv f2008) hipfort_add_test(rocsolver rocsolver_dsyev f2003) hipfort_add_test(rocsolver rocsolver_dsyev f2008) hipfort_add_test(rocsolver rocsolver_dgetrf_batched f2008) hipfort_add_test(rocsolver rocsolver_dgetrf_npvt f2008) hipfort_add_test(rocsolver rocsolver_dgetf2_npvt f2008) hipfort_add_test(rocsolver rocsolver_dgetri_npvt f2008) hipfort_add_test(rocsolver rocsolver_dsytrf f2003) hipfort_add_test(rocsolver rocsolver_dsytrf f2008) hipfort_add_test(rocsolver rocsolver_ssytrf f2003) hipfort_add_test(rocsolver rocsolver_ssytrf f2008) hipfort_add_test(rocsolver rocsolver_csytrf f2003) hipfort_add_test(rocsolver rocsolver_csytrf f2008) hipfort_add_test(rocsolver rocsolver_zsytrf f2003) hipfort_add_test(rocsolver rocsolver_zsytrf f2008) hipfort_add_test(rocsolver rocsolver_dsytrs f2003) hipfort_add_test(rocsolver rocsolver_dsytrs f2008) hipfort_add_test(rocsolver rocsolver_ssytrs f2003) hipfort_add_test(rocsolver rocsolver_ssytrs f2008) hipfort_add_test(rocsolver rocsolver_csytrs f2003) hipfort_add_test(rocsolver rocsolver_csytrs f2008) hipfort_add_test(rocsolver rocsolver_zsytrs f2003) hipfort_add_test(rocsolver rocsolver_zsytrs f2008) hipfort_add_test(rocsolver rocsolver_dsytf2 f2008) hipfort_add_test(rocsolver rocsolver_dsteqr f2008) hipfort_add_test(rocsolver rocsolver_dstedc f2008) hipfort_add_test(rocsolver rocsolver_dgetrf_64 f2008) hipfort_add_test(rocsolver rocsolver_dgetf2_64 f2008) hipfort_add_test(rocsolver rocsolver_dpotrf_64 f2008) hipfort_add_test(rocsolver rocsolver_dpotf2_64 f2008) hipfort_add_test(rocsolver rocsolver_dgetf2 f2008) hipfort_add_test(rocsolver rocsolver_dpotf2 f2008) hipfort_add_test(rocsolver rocsolver_dpotri f2008) hipfort_add_test(rocsolver rocsolver_zheev f2008) # #411 checklist: gels, syevj/heevj, gesvdj, gebrd, orgqr/ungqr, ormqr/unmqr hipfort_add_test(rocsolver rocsolver_sgels f2003) hipfort_add_test(rocsolver rocsolver_sgels f2008) hipfort_add_test(rocsolver rocsolver_dgels f2003) hipfort_add_test(rocsolver rocsolver_dgels f2008) hipfort_add_test(rocsolver rocsolver_cgels f2003) hipfort_add_test(rocsolver rocsolver_cgels f2008) hipfort_add_test(rocsolver rocsolver_zgels f2003) hipfort_add_test(rocsolver rocsolver_zgels f2008) hipfort_add_test(rocsolver rocsolver_dsyevj f2003) hipfort_add_test(rocsolver rocsolver_dsyevj f2008) hipfort_add_test(rocsolver rocsolver_ssyevj f2003) hipfort_add_test(rocsolver rocsolver_ssyevj f2008) hipfort_add_test(rocsolver rocsolver_cheevj f2003) hipfort_add_test(rocsolver rocsolver_cheevj f2008) hipfort_add_test(rocsolver rocsolver_zheevj f2003) hipfort_add_test(rocsolver rocsolver_zheevj f2008) hipfort_add_test(rocsolver rocsolver_sgesvdj f2003) hipfort_add_test(rocsolver rocsolver_sgesvdj f2008) hipfort_add_test(rocsolver rocsolver_dgesvdj f2003) hipfort_add_test(rocsolver rocsolver_dgesvdj f2008) hipfort_add_test(rocsolver rocsolver_cgesvdj f2003) hipfort_add_test(rocsolver rocsolver_cgesvdj f2008) hipfort_add_test(rocsolver rocsolver_zgesvdj f2003) hipfort_add_test(rocsolver rocsolver_zgesvdj f2008) hipfort_add_test(rocsolver rocsolver_sgebrd f2003) hipfort_add_test(rocsolver rocsolver_sgebrd f2008) hipfort_add_test(rocsolver rocsolver_dgebrd f2003) hipfort_add_test(rocsolver rocsolver_dgebrd f2008) hipfort_add_test(rocsolver rocsolver_cgebrd f2003) hipfort_add_test(rocsolver rocsolver_cgebrd f2008) hipfort_add_test(rocsolver rocsolver_zgebrd f2003) hipfort_add_test(rocsolver rocsolver_zgebrd f2008) hipfort_add_test(rocsolver rocsolver_sorgqr f2003) hipfort_add_test(rocsolver rocsolver_sorgqr f2008) hipfort_add_test(rocsolver rocsolver_dorgqr f2003) hipfort_add_test(rocsolver rocsolver_dorgqr f2008) hipfort_add_test(rocsolver rocsolver_cungqr f2003) hipfort_add_test(rocsolver rocsolver_cungqr f2008) hipfort_add_test(rocsolver rocsolver_zungqr f2003) hipfort_add_test(rocsolver rocsolver_zungqr f2008) hipfort_add_test(rocsolver rocsolver_sormqr f2003) hipfort_add_test(rocsolver rocsolver_sormqr f2008) hipfort_add_test(rocsolver rocsolver_dormqr f2003) hipfort_add_test(rocsolver rocsolver_dormqr f2008) hipfort_add_test(rocsolver rocsolver_cunmqr f2003) hipfort_add_test(rocsolver rocsolver_cunmqr f2008) hipfort_add_test(rocsolver rocsolver_zunmqr f2003) hipfort_add_test(rocsolver rocsolver_zunmqr f2008) endif() if(TARGET hipfort::rocsparse) hipfort_add_symbol_test(rocsparse) hipfort_add_test(rocsparse ddoti f2003) hipfort_add_test(rocsparse ddoti f2008) hipfort_add_test(rocsparse rocsparse_sgthr f2003) hipfort_add_test(rocsparse rocsparse_sgthr f2008) hipfort_add_test(rocsparse rocsparse_dgthr f2003) hipfort_add_test(rocsparse rocsparse_dgthr f2008) hipfort_add_test(rocsparse rocsparse_cgthr f2003) hipfort_add_test(rocsparse rocsparse_cgthr f2008) hipfort_add_test(rocsparse rocsparse_zgthr f2003) hipfort_add_test(rocsparse rocsparse_zgthr f2008) hipfort_add_test(rocsparse rocsparse_ssctr f2003) hipfort_add_test(rocsparse rocsparse_ssctr f2008) hipfort_add_test(rocsparse rocsparse_dsctr f2003) hipfort_add_test(rocsparse rocsparse_dsctr f2008) hipfort_add_test(rocsparse rocsparse_csctr f2003) hipfort_add_test(rocsparse rocsparse_csctr f2008) hipfort_add_test(rocsparse rocsparse_zsctr f2003) hipfort_add_test(rocsparse rocsparse_zsctr f2008) hipfort_add_test(rocsparse rocsparse_coo2csr f2003) hipfort_add_test(rocsparse rocsparse_coo2csr f2008) hipfort_add_test(rocsparse rocsparse_sgemvi f2003) hipfort_add_test(rocsparse rocsparse_sgemvi f2008) hipfort_add_test(rocsparse rocsparse_dgemvi f2003) hipfort_add_test(rocsparse rocsparse_dgemvi f2008) hipfort_add_test(rocsparse rocsparse_cgemvi f2003) hipfort_add_test(rocsparse rocsparse_cgemvi f2008) hipfort_add_test(rocsparse rocsparse_zgemvi f2003) hipfort_add_test(rocsparse rocsparse_zgemvi f2008) hipfort_add_test(rocsparse rocsparse_sbsrmv f2003) hipfort_add_test(rocsparse rocsparse_sbsrmv f2008) hipfort_add_test(rocsparse rocsparse_dbsrmv f2003) hipfort_add_test(rocsparse rocsparse_dbsrmv f2008) hipfort_add_test(rocsparse rocsparse_cbsrmv f2003) hipfort_add_test(rocsparse rocsparse_cbsrmv f2008) hipfort_add_test(rocsparse rocsparse_zbsrmv f2003) hipfort_add_test(rocsparse rocsparse_zbsrmv f2008) hipfort_add_test(rocsparse rocsparse_sgebsrmv f2003) hipfort_add_test(rocsparse rocsparse_sgebsrmv f2008) hipfort_add_test(rocsparse rocsparse_dgebsrmv f2003) hipfort_add_test(rocsparse rocsparse_dgebsrmv f2008) hipfort_add_test(rocsparse rocsparse_cgebsrmv f2003) hipfort_add_test(rocsparse rocsparse_cgebsrmv f2008) hipfort_add_test(rocsparse rocsparse_zgebsrmv f2003) hipfort_add_test(rocsparse rocsparse_zgebsrmv f2008) hipfort_add_test(rocsparse rocsparse_scsrilu0 f2003) hipfort_add_test(rocsparse rocsparse_scsrilu0 f2008) hipfort_add_test(rocsparse rocsparse_scsric0 f2003) hipfort_add_test(rocsparse rocsparse_scsric0 f2008) hipfort_add_test(rocsparse rocsparse_dcsrilu0 f2003) hipfort_add_test(rocsparse rocsparse_dcsrilu0 f2008) hipfort_add_test(rocsparse rocsparse_ccsrilu0 f2003) hipfort_add_test(rocsparse rocsparse_ccsrilu0 f2008) hipfort_add_test(rocsparse rocsparse_zcsrilu0 f2003) hipfort_add_test(rocsparse rocsparse_zcsrilu0 f2008) hipfort_add_test(rocsparse rocsparse_dcsric0 f2003) hipfort_add_test(rocsparse rocsparse_dcsric0 f2008) hipfort_add_test(rocsparse rocsparse_ccsric0 f2003) hipfort_add_test(rocsparse rocsparse_ccsric0 f2008) hipfort_add_test(rocsparse rocsparse_zcsric0 f2003) hipfort_add_test(rocsparse rocsparse_zcsric0 f2008) hipfort_add_test(rocsparse rocsparse_spildlt0 f2003) hipfort_add_test(rocsparse rocsparse_spildlt0 f2008) hipfort_add_test(rocsparse rocsparse_csr2coo f2008) hipfort_add_test(rocsparse rocsparse_sgtsv f2008) hipfort_add_test(rocsparse rocsparse_scsr2csc f2008) hipfort_add_test(rocsparse rocsparse_dcsr2csc f2008) hipfort_add_test(rocsparse rocsparse_ccsr2csc f2008) hipfort_add_test(rocsparse rocsparse_zcsr2csc f2008) hipfort_add_test(rocsparse rocsparse_sspmm f2008) hipfort_add_test(rocsparse rocsparse_dspmm f2008) hipfort_add_test(rocsparse rocsparse_cspmm f2008) hipfort_add_test(rocsparse rocsparse_zspmm f2008) hipfort_add_test(rocsparse rocsparse_sspmv f2008) hipfort_add_test(rocsparse rocsparse_dspmv f2008) hipfort_add_test(rocsparse rocsparse_cspmv f2008) hipfort_add_test(rocsparse rocsparse_zspmv f2008) hipfort_add_test(rocsparse rocsparse_ssddmm f2008) hipfort_add_test(rocsparse rocsparse_dsddmm f2008) hipfort_add_test(rocsparse rocsparse_csddmm f2008) hipfort_add_test(rocsparse rocsparse_zsddmm f2008) hipfort_add_test(rocsparse rocsparse_dsddmm_batched f2008) hipfort_add_test(rocsparse rocsparse_scsrgemm f2008) hipfort_add_test(rocsparse rocsparse_dcsrgemm f2008) hipfort_add_test(rocsparse rocsparse_ccsrgemm f2008) hipfort_add_test(rocsparse rocsparse_zcsrgemm f2008) hipfort_add_test(rocsparse rocsparse_scsrgeam f2008) hipfort_add_test(rocsparse rocsparse_dcsrgeam f2008) hipfort_add_test(rocsparse rocsparse_ccsrgeam f2008) hipfort_add_test(rocsparse rocsparse_zcsrgeam f2008) hipfort_add_test(rocsparse rocsparse_scsrgeam f2003) hipfort_add_test(rocsparse rocsparse_dcsrgeam f2003) hipfort_add_test(rocsparse rocsparse_ccsrgeam f2003) hipfort_add_test(rocsparse rocsparse_zcsrgeam f2003) hipfort_add_test(rocsparse rocsparse_ssptrsv f2008) hipfort_add_test(rocsparse rocsparse_dsptrsv f2008) hipfort_add_test(rocsparse rocsparse_csptrsv f2008) hipfort_add_test(rocsparse rocsparse_zsptrsv f2008) hipfort_add_test(rocsparse rocsparse_ssptrsm f2008) hipfort_add_test(rocsparse rocsparse_dsptrsm f2008) hipfort_add_test(rocsparse rocsparse_csptrsm f2008) hipfort_add_test(rocsparse rocsparse_zsptrsm f2008) hipfort_add_test(rocsparse zgpsv_interleaved_batch f2008) hipfort_add_test(rocsparse rocsparse_csr2coo f2003) hipfort_add_test(rocsparse rocsparse_scsr2csc f2003) hipfort_add_test(rocsparse rocsparse_dcsr2csc f2003) hipfort_add_test(rocsparse rocsparse_ccsr2csc f2003) hipfort_add_test(rocsparse rocsparse_zcsr2csc f2003) hipfort_add_test(rocsparse rocsparse_sspmm f2003) hipfort_add_test(rocsparse rocsparse_dspmm f2003) hipfort_add_test(rocsparse rocsparse_cspmm f2003) hipfort_add_test(rocsparse rocsparse_zspmm f2003) hipfort_add_test(rocsparse rocsparse_ssddmm f2003) hipfort_add_test(rocsparse rocsparse_dsddmm f2003) hipfort_add_test(rocsparse rocsparse_csddmm f2003) hipfort_add_test(rocsparse rocsparse_zsddmm f2003) hipfort_add_test(rocsparse rocsparse_sspmv f2003) hipfort_add_test(rocsparse rocsparse_dspmv f2003) hipfort_add_test(rocsparse rocsparse_cspmv f2003) hipfort_add_test(rocsparse rocsparse_zspmv f2003) hipfort_add_test(rocsparse rocsparse_scsrgemm f2003) hipfort_add_test(rocsparse rocsparse_dcsrgemm f2003) hipfort_add_test(rocsparse rocsparse_ccsrgemm f2003) hipfort_add_test(rocsparse rocsparse_zcsrgemm f2003) hipfort_add_test(rocsparse rocsparse_ssptrsv f2003) hipfort_add_test(rocsparse rocsparse_dsptrsv f2003) hipfort_add_test(rocsparse rocsparse_csptrsv f2003) hipfort_add_test(rocsparse rocsparse_zsptrsv f2003) hipfort_add_test(rocsparse rocsparse_ssptrsm f2003) hipfort_add_test(rocsparse rocsparse_dsptrsm f2003) hipfort_add_test(rocsparse rocsparse_csptrsm f2003) hipfort_add_test(rocsparse rocsparse_zsptrsm f2003) endif() # HIP runtime API tests: device management, streams, events, memset, # asynchronous copies, unified-memory hints and the module/kernel API. if(TARGET hipfort::hip) hipfort_add_symbol_test(hip) hipfort_add_test(hip device_management f2003) hipfort_add_test(hip stream f2003) hipfort_add_test(hip event f2003) hipfort_add_test(hip memset f2003) hipfort_add_test(hip memcpy_async f2003) hipfort_add_test(hip memcpy2d f2003) hipfort_add_test(hip memcpy2d f2008) hipfort_add_test(hip malloc_managed f2003) hipfort_add_test(hip malloc_managed f2008) hipfort_add_test(hip host_malloc f2003) hipfort_add_test(hip host_malloc f2008) hipfort_add_test(hip host_register f2003) hipfort_add_test(hip graph f2003) hipfort_add_test(hip graph_nodes f2003) hipfort_add_test(hip graph_memset_node f2003) hipfort_add_test(hip peer_access f2003) hipfort_add_test(hip graph_empty_node f2003) hipfort_add_test(hip stream_flags f2003) hipfort_add_test(hip stream_callback f2003) hipfort_add_test(hip event_timing f2003) hipfort_add_test(hip memory_ops f2003) hipfort_add_test(hip device_properties f2003) hipfort_add_test(hip error_version f2003) hipfort_add_test(hip pointer_attributes f2003) hipfort_add_test(hip mem_advise f2003) hipfort_add_test(hip virtual_memory f2003) hipfort_add_test(hip pointer_attributes f2008) hipfort_add_test(hip mem_advise f2008) # The hipModule* entry points need a real GPU kernel, so this test loads a # standalone code object built from the existing vecadd source. They have no # CUDA-driver counterpart in the generated bindings, hence the AMD-only guard. find_package(hip QUIET PATHS ${ROCM_PATH}) find_program(HIPFORT_HIPCC hipcc HINTS ${ROCM_PATH}/bin) if(HIPFORT_HIPCC AND HIP_PLATFORM STREQUAL "amd") # --offload-arch=native and `rocm_agent_enumerator -name` both append the # :xnack suffix, which pins the code object to one XNACK mode and makes # hipModuleLoad fail in the other. The bare gfxNNN loads under both. set(_hipfort_arch "native") find_program(HIPFORT_AGENT_ENUM rocm_agent_enumerator HINTS ${ROCM_PATH}/bin) if(HIPFORT_AGENT_ENUM) execute_process(COMMAND ${HIPFORT_AGENT_ENUM} OUTPUT_VARIABLE _hipfort_agents OUTPUT_STRIP_TRAILING_WHITESPACE) string(REPLACE "\n" ";" _hipfort_agents "${_hipfort_agents}") list(REMOVE_ITEM _hipfort_agents "gfx000") if(_hipfort_agents) list(GET _hipfort_agents 0 _hipfort_arch) endif() endif() set(_hipfort_code_object "${CMAKE_CURRENT_BINARY_DIR}/vecadd_kernel.co") add_custom_command( OUTPUT "${_hipfort_code_object}" COMMAND ${HIPFORT_HIPCC} --genco --offload-arch=${_hipfort_arch} "${CMAKE_CURRENT_SOURCE_DIR}/f2003/vecadd/hip_implementation.cpp" -o "${_hipfort_code_object}" DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/f2003/vecadd/hip_implementation.cpp" COMMENT "Building the HIP code object used by the module_kernel test") add_custom_target(hipfort_test_code_object DEPENDS "${_hipfort_code_object}") hipfort_add_test(hip module_kernel f2003) add_dependencies(hipfort_test_f2003_hip_module_kernel hipfort_test_code_object) set_tests_properties(hipfort_test_f2003_hip_module_kernel PROPERTIES ENVIRONMENT "HIPFORT_TEST_CODE_OBJECT=${_hipfort_code_object}") endif() endif() # vecadd mixes a Fortran driver with a HIP C++ kernel, so it needs the HIP # language enabled rather than the plain hipfort_add_test() helper. include(CheckLanguage) check_language(HIP) if(CMAKE_HIP_COMPILER) enable_language(HIP) foreach(std IN ITEMS f2003 f2008) # The f2008 interfaces are disabled on the Intel compilers, so skip the # f2008 vecadd test there (see USE_FPOINTER_INTERFACES in lib/CMakeLists.txt). if(std STREQUAL "f2008" AND CMAKE_Fortran_COMPILER_ID MATCHES "Intel") continue() endif() # f2003 tests use .f03, f2008 tests use .f08 to match the target standard. if(std STREQUAL "f2008") set(ext "f08") else() set(ext "f03") endif() set(vecadd_target hipfort_test_${std}_vecadd_main) add_executable(${vecadd_target} ${std}/vecadd/main.${ext} ${std}/vecadd/hip_implementation.cpp) set_source_files_properties(${std}/vecadd/main.${ext} PROPERTIES LANGUAGE Fortran) set_source_files_properties(${std}/vecadd/hip_implementation.cpp PROPERTIES LANGUAGE HIP) target_link_libraries(${vecadd_target} PRIVATE hipfort::hip) set_target_properties(${vecadd_target} PROPERTIES LINKER_LANGUAGE Fortran POSITION_INDEPENDENT_CODE ON) # the tests call EXIT, which is a GNU extension in gfortran target_compile_options(${vecadd_target} PRIVATE $<$:-std=gnu>) add_test(NAME ${vecadd_target} COMMAND ${vecadd_target}) endforeach() endif() # hipOccupancy* and hipLaunchCooperativeKernel take the host stub of a kernel. if(CMAKE_HIP_COMPILER AND TARGET hipfort::hip AND HIP_PLATFORM STREQUAL "amd") foreach(kernel_test IN ITEMS occupancy cooperative_launch) hipfort_add_test(hip ${kernel_test} f2003) target_sources(hipfort_test_f2003_hip_${kernel_test} PRIVATE f2003/vecadd/hip_implementation.cpp) set_source_files_properties(f2003/vecadd/hip_implementation.cpp PROPERTIES LANGUAGE HIP) set_target_properties(hipfort_test_f2003_hip_${kernel_test} PROPERTIES LINKER_LANGUAGE Fortran POSITION_INDEPENDENT_CODE ON) endforeach() endif() if(TARGET hipfort::roctx) hipfort_add_symbol_test(roctx) include(CheckLanguage) check_language(HIP) if(CMAKE_HIP_COMPILER) enable_language(HIP) hipfort_add_test(roctx main f2003) target_sources(hipfort_test_f2003_roctx_main PRIVATE f2003/roctx/hip_implementation.cpp) set_source_files_properties(f2003/roctx/hip_implementation.cpp PROPERTIES LANGUAGE HIP ) set_target_properties(hipfort_test_f2003_roctx_main PROPERTIES LINKER_LANGUAGE Fortran POSITION_INDEPENDENT_CODE ON ) endif() endif() # Regression test for SWDEV-427498: installing hipfort and calling # find_package(hipfort) from the install prefix must succeed. This guards the # multitoolchain-layout shim (lib/cmake/hipfort forwarding to # lib/fortran//cmake/hipfort) and the flat-layout config alike. add_test(NAME hipfort_find_package_install COMMAND ${CMAKE_COMMAND} -DHIPFORT_BUILD_DIR=${CMAKE_BINARY_DIR} -DCONSUMER_SRC=${CMAKE_CURRENT_SOURCE_DIR}/find_package -DWORK_DIR=${CMAKE_CURRENT_BINARY_DIR}/find_package_work -DFORTRAN_COMPILER=${CMAKE_Fortran_COMPILER} -P ${CMAKE_CURRENT_SOURCE_DIR}/find_package/run_find_package_test.cmake) # test/openmp needs offload (LLVM Flang) and a host LAPACK for the reference, # so every other toolchain skips with a reason instead of failing. if(CMAKE_Fortran_COMPILER_ID MATCHES "LLVMFlang") # "native" stays xnack-agnostic; an arch pinned to one HSA_XNACK mode will # not load in the other. set(HIPFORT_OFFLOAD_ARCH "native" CACHE STRING "AMD GPU architecture for the OpenMP offload tests (gfxNNN, or native)") set(_offload_flags -fopenmp -fopenmp-version=51 -fopenmp-offload-mandatory --offload-arch=${HIPFORT_OFFLOAD_ARCH}) # Also the GPU-less guard: --offload-arch=native cannot compile without a GPU. include(CheckFortranSourceCompiles) set(CMAKE_REQUIRED_FLAGS "-fopenmp --offload-arch=${HIPFORT_OFFLOAD_ARCH}") check_fortran_source_compiles(" program p integer :: i(1) !$omp target map(tofrom: i) i(1) = 1 !$omp end target end program" HIPFORT_HAVE_OMP_OFFLOAD) unset(CMAKE_REQUIRED_FLAGS) find_package(LAPACK QUIET) # zhegvd, the reference for rocsolver_zhegvdx if(NOT HIPFORT_HAVE_OMP_OFFLOAD) message(STATUS "Skipping OpenMP offload tests: ${CMAKE_Fortran_COMPILER} cannot offload to ${HIPFORT_OFFLOAD_ARCH}") elseif(NOT LAPACK_FOUND) message(STATUS "Skipping OpenMP offload tests: no host LAPACK for the reference result") else() # openmp//test_.f90 builds against hipfort::, so a # new file is picked up on the next configure with no edit here. file(GLOB _omp_sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/openmp/*/test_*.f90") foreach(_src IN LISTS _omp_sources) get_filename_component(_lib "${_src}" DIRECTORY) get_filename_component(_lib "${_lib}" NAME) get_filename_component(_name "${_src}" NAME_WE) string(REGEX REPLACE "^test_" "" _name "${_name}") if(NOT TARGET hipfort::${_lib}) message(STATUS "Skipping OpenMP offload test ${_name}: no hipfort::${_lib}") continue() endif() add_executable(hipfort_test_openmp_${_name} "${_src}") target_compile_options(hipfort_test_openmp_${_name} PRIVATE ${_offload_flags}) target_link_options(hipfort_test_openmp_${_name} PRIVATE ${_offload_flags}) target_link_libraries(hipfort_test_openmp_${_name} PRIVATE hipfort::${_lib} ${LAPACK_LIBRARIES}) set_target_properties(hipfort_test_openmp_${_name} PROPERTIES LINKER_LANGUAGE Fortran) add_test(NAME hipfort_test_openmp_${_name} COMMAND hipfort_test_openmp_${_name}) endforeach() endif() endif() # Source-only lint. Needs bash, so not on Windows. if(NOT CMAKE_HOST_WIN32) add_test(NAME hipfort_fortran_line_length COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/check_line_length.sh) endif() endif() hipfort-rocm-10.0.0/test/README.md000066400000000000000000000032301524740623400164440ustar00rootroot00000000000000# hipfort tests The test programs are grouped by Fortran standard: `f2003/`, `f2008/`, `f2018/`, plus `openmp/`. Each subdirectory holds one directory per ROCm library. Tests are registered in `CMakeLists.txt` and run through CTest. Sources use the extension matching their standard, `.f03` and `.f08`, except `f2018/`, which uses `.f90`. No Fortran driver recognizes a `.f18` suffix without compiler-dependent flags. Build and run them the usual way: ```bash cmake -S . -B build -DBUILD_TESTING=ON cmake --build build -j cd build && ctest --output-on-failure ``` The `f2018/` tests are only registered when the experimental assumed-rank interfaces are enabled with `-DHIPFORT_ASSUMED_RANK=ON`. ## check_compilers.sh Fortran `.mod` files are not portable between compilers, and `HIPFORT_ASSUMED_RANK` changes which interfaces are compiled, so each combination needs its own build. `check_compilers.sh` does that for every compiler it finds, using the toolchain files in `cmake/toolchains`: ```bash bash test/check_compilers.sh # every compiler found, both variants bash test/check_compilers.sh gnu amdflang # only these toolchains bash test/check_compilers.sh --build-only # skip ctest, no GPU needed bash test/check_compilers.sh --no-assumed-rank BUILD_ROOT=/tmp/hf bash test/check_compilers.sh ``` Compilers that are not installed are skipped, and the run degrades to build-only when no GPU is visible. It exits non-zero if any available configuration fails. Builds land in `build/compilers/